Merge ~bullwinkle-team/ubuntu/+source/hipblas:bullwinkle/llvm-21/ubuntu/devel into ubuntu/+source/hipblas:ubuntu/devel

[Bruno Bernardo de Moura]

New upstream version 7.1.0

[Bruno Bernardo de Moura (bruno-bdmoura)]

Build in ppa: https://launchpad.net/~bruno-bdmoura/+archive/ubuntu/lp-2139242-hipblas

(~proposed and target archs)

[Igor Luppi (igorluppi)]

Rebasing with ubuntu/devel

[Igor Luppi (igorluppi)]

Rebase done. New ppa build with version 7.1.0-0ubuntu4 here: https://launchpad.net/~igorluppi/+archive/ubuntu/hipblas-lp2139242

(-proposed and all archs)

[Igor Luppi (igorluppi)]

$ reverse-depends --arch ppc64el src:hipblas -x
Reverse-Depends
===============
* libggml-hip (for libhipblas0)

But it only actually requires: libhipblas-dev [amd64 arm64] <!pkg.ggml.nohip>,

I have done ggml builds in ppa for ppc64el without having any ppc64el rocm pkg. So safe to drop ppc64el for hipblas.

[Andreas Hasenack (ahasenack)]

What's this about in d/rules:

+LIB=libhipblas3
+LIBV=7.1.0
+REV=1
+gensymbols:
+ dpkg-deb -x ../$(LIB)_$(LIBV)-$(REV)_amd64.deb /tmp/$(LIB)
+ dpkg-gensymbols -v$(LIBV) -p$(LIB) -P/tmp/$(LIB) -Odebian/$(LIB).symbols

You are opening a built deb (amd64 only), and then doing what?

review: Needs Information

[Igor Luppi (igorluppi)]

I think this is outdated, we could just use

override_dh_makeshlibs:
    dh_makeshlibs -V

[Andreas Hasenack (ahasenack)]

Why even override it?

[Igor Luppi (igorluppi)]

Yeah, I actually deleted that temp. piece of code. Please take a look.

[Andreas Hasenack (ahasenack)]

Please also trigger a new build

[Igor Luppi (igorluppi)]

Here the recipe build with 3 child builds (amd64, amd64v3 and arm64):

https://code.launchpad.net/~bullwinkle-team/+archive/ubuntu/rocm-devel-21/+recipebuild/4006949

[Andreas Hasenack (ahasenack)]

- delta: OK
- upstream changes: OK
- debian packaging changes: OK

Debian could benefit from the fixes in the smartcard tests that you made, that will allow them to re-enable those tests (currently disabled in d/t/control in debian/sid).

+1

review: Approve

[Andreas Hasenack (ahasenack)]

Bah, that was the wrong MP, sorry. I'll put it back to "needs fixing" to reset the approve state, sorry again.

Doing too many reviews in parallel :\

review: Needs Fixing

[Andreas Hasenack (ahasenack)]

> Here the recipe build with 3 child builds (amd64, amd64v3 and arm64):

Does that have the updated d/rules?

[Igor Luppi (igorluppi)]

I removed the section:

+LIB=libhipblas3
+LIBV=7.1.0
+REV=1
+gensymbols:
+ dpkg-deb -x ../$(LIB)_$(LIBV)-$(REV)_amd64.deb /tmp/$(LIB)
+ dpkg-gensymbols -v$(LIBV) -p$(LIB) -P/tmp/$(LIB) -Odebian/$(LIB).symbols

for those builds

[Igor Luppi (igorluppi)]

Here the diff log: https://launchpadlibrarian.net/847057093/hipblas_7.1.0-0ubuntu4~git202602061415.c8430b6~ubuntu26.04.1_7.1.0-0ubuntu4~git202602101821.fffc9a7~ubuntu26.04.1.diff.gz

(Removed also annoying extra whitespaces from *.links files)

[Igor Luppi (igorluppi)]

Builds done successfully, please take a look.

[Andreas Hasenack (ahasenack)]

This depends on rocsolver 7, so it will say in the build queue until that other upload finishes building.

+1

review: Approve

[Andreas Hasenack (ahasenack)]

Sponsored:

Uploading hipblas_7.1.0-0ubuntu4.dsc
Uploading hipblas_7.1.0.orig.tar.gz
Uploading hipblas_7.1.0-0ubuntu4.debian.tar.xz
Uploading hipblas_7.1.0-0ubuntu4_source.buildinfo
Uploading hipblas_7.1.0-0ubuntu4_source.changes

[Igor Luppi (igorluppi)]

Indeed, it ll be waiting for build-depends. Let's hope rocsolver will be published soon! Thanks a lot Andreas!!

diff --git a/.githooks/install b/.githooks/install
index cbb0569..685ea28 100755
--- a/.githooks/install
+++ b/.githooks/install
@@ -3,6 +3,6 @@
 cd $(git rev-parse --git-dir)
 cd hooks
 
-echo "Installing hooks..." 
+echo "Installing hooks..."
 ln -s ../../.githooks/pre-commit pre-commit
 echo "Done!"
diff --git a/.jenkins/codecov.groovy b/.jenkins/codecov.groovy
new file mode 100644
index 0000000..dc11b47
--- /dev/null
+++ b/.jenkins/codecov.groovy
@@ -0,0 +1,119 @@
+#!/usr/bin/env groovy
+// This shared library is available at https://github.com/ROCmSoftwarePlatform/rocJENKINS/
+@Library('rocJenkins@pong') _
+
+// This is file for internal AMD use.
+// If you are interested in running your own Jenkins, please raise a github issue for assistance.
+
+import com.amd.project.*
+import com.amd.docker.*
+import java.nio.file.Path
+
+def runCI =
+{
+    nodeDetails, jobName, buildCommand, label->
+
+    def prj  = new rocProject('hipBLAS', 'CodeCov')
+
+    if (env.BRANCH_NAME ==~ /PR-\d+/ && pullRequest.labels.contains("noSolver"))
+    {
+        prj.libraryDependencies = ['hipBLAS-common', 'hipBLASLt', 'rocBLAS']
+    }
+    else
+    {
+        prj.libraryDependencies = ['rocPRIM', 'hipBLAS-common', 'hipBLASLt', 'rocBLAS', 'rocSPARSE', 'rocSOLVER']
+    }
+
+    if (env.BRANCH_NAME ==~ /PR-\d+/ && pullRequest.labels.contains('g++'))
+    {
+        buildCommand += ' --compiler=g++'
+    }
+    else if (env.BRANCH_NAME ==~ /PR-\d+/ && pullRequest.labels.contains('clang'))
+    {
+        buildCommand += ' --compiler=clang++'
+    }
+    else
+    {
+        // buildCommand += ' --compiler=amdclang++' # leave as default
+    }
+
+    //customize for project
+    prj.paths.build_command = buildCommand
+
+    // Define test architectures, optional rocm version argument is available
+    def nodes = new dockerNodes(nodeDetails, jobName, prj)
+
+    boolean formatCheck = false
+
+    def commonGroovy
+
+    def compileCommand =
+    {
+        platform, project->
+
+        commonGroovy = load "${project.paths.project_src_prefix}/.jenkins/common.groovy"
+        commonGroovy.runCompileCommand(platform, project, jobName)
+    }
+
+    def testCommand =
+    {
+        platform, project->
+
+        commonGroovy.runCoverageCommand(platform, project, "release-debug")
+    }
+
+    def packageCommand =
+    {
+        platform, project->
+
+        commonGroovy.runPackageCommand(platform, project, jobName, label, "release-debug")
+    }
+
+    buildProject(prj, formatCheck, nodes.dockerArray, compileCommand, testCommand, null)
+}
+
+def setupCI(urlJobName, jobNameList, buildCommand, runCI, label)
+{
+    jobNameList = auxiliary.appendJobNameList(jobNameList)
+
+    jobNameList.each
+    {
+        jobName, nodeDetails->
+        if (urlJobName == jobName)
+            stage(label + ' ' + jobName) {
+                runCI(nodeDetails, jobName, buildCommand, label)
+            }
+    }
+
+    // For url job names that are not listed by the jobNameList i.e. compute-rocm-dkms-no-npi-1901
+    if(!jobNameList.keySet().contains(urlJobName))
+    {
+        properties(auxiliary.addCommonProperties([pipelineTriggers([cron('0 1 * * *')])]))
+        stage(label + ' ' + urlJobName) {
+            runCI([ubuntu18:['gfx906']], urlJobName, buildCommand, label)
+        }
+    }
+
+}
+
+ci: {
+    String urlJobName = auxiliary.getTopJobName(env.BUILD_URL)
+
+    def propertyList = ["compute-rocm-dkms-no-npi-hipclang":[pipelineTriggers([cron('0 1 * * 0')])],
+                        "rocm-docker":[]]
+    propertyList = auxiliary.appendPropertyList(propertyList)
+
+    def jobNameList = ["compute-rocm-dkms-no-npi-hipclang":([ubuntu18:['gfx900'],centos7:['gfx906'],sles15sp1:['gfx908']]),
+                       "rocm-docker":([ubuntu18:['gfx900'],centos7:['gfx906'],sles15sp1:['gfx906']])]
+    jobNameList = auxiliary.appendJobNameList(jobNameList)
+
+    propertyList.each
+    {
+        jobName, property->
+        if (urlJobName == jobName)
+            properties(auxiliary.addCommonProperties(property))
+    }
+
+    String hostBuildCommand = './install.sh -k --codecoverage -c'
+    setupCI(urlJobName, jobNameList, hostBuildCommand, runCI, 'g++')
+}
diff --git a/.jenkins/common.groovy b/.jenkins/common.groovy
index 987c1c4..f959eef 100644
--- a/.jenkins/common.groovy
+++ b/.jenkins/common.groovy
@@ -3,8 +3,6 @@
 
 def runCompileCommand(platform, project, jobName, boolean sameOrg=false)
 {
-    project.paths.construct_build_prefix()
-
     def getDependenciesCommand = ""
     if (project.installLibraryDependenciesFromCI)
     {
@@ -33,7 +31,7 @@ def runCompileCommand(platform, project, jobName, boolean sameOrg=false)
                 cd ${project.paths.project_build_prefix}
                 ${getDependenciesCommand}
                 ${centos}
-                LD_LIBRARY_PATH=/opt/rocm/lib ${project.paths.build_command}
+                ${project.paths.build_command}
                 """
     platform.runCommand(this, command)
 }
@@ -51,42 +49,60 @@ def runTestCommand (platform, project)
         }
     }
 
-    String gtestCommonEnv = "HIPBLAS_CLIENT_RAM_GB_LIMIT=95"
+    String gtestCommonEnv = "HIPBLAS_CLIENT_RAM_GB_LIMIT=95 GTEST_LISTENER=NO_PASS_LINE_IN_LOG"
+
     def command = """#!/usr/bin/env bash
                     set -x
-                    cd ${stagingDir}
-                    ${sudo} LD_LIBRARY_PATH=/opt/rocm/lib ${gtestCommonEnv} GTEST_LISTENER=NO_PASS_LINE_IN_LOG ./hipblas-test --gtest_output=xml --gtest_color=yes
+                    pushd ${stagingDir}
+                    ${gtestCommonEnv} ./hipblas-test --gtest_output=xml --gtest_color=yes
+                    popd
                 """
 
     platform.runCommand(this, command)
 
-    // In an upcoming release, we are replacing hipblasDatatype_t with hipDataType. We have created hipblas_v2-test to test the new
-    // interfaces while hipblasDatatype_t is deprecated. Thus, hipblas-test will be testing the old, deprecated, functions
-    // using hipblasDatatype_t, and hipblas_v2-test will be testing the upcoming interfaces.
-    def v2TestCommand = """#!/usr/bin/env bash
-                    set -x
-                    cd ${stagingDir}
-                    ${sudo} LD_LIBRARY_PATH=/opt/rocm/lib ${gtestCommonEnv} GTEST_LISTENER=NO_PASS_LINE_IN_LOG ./hipblas_v2-test --gtest_output=xml --gtest_color=yes
-                """
-
-    platform.runCommand(this, v2TestCommand)
-
     def yamlTestCommand = """#!/usr/bin/env bash
                     set -x
-                    cd ${stagingDir}
-                    ${sudo} LD_LIBRARY_PATH=/opt/rocm/lib ${gtestCommonEnv} GTEST_LISTENER=NO_PASS_LINE_IN_LOG ./hipblas-test --gtest_output=xml --gtest_color=yes --yaml hipblas_smoke.yaml
+                    pushd ${stagingDir}
+                    ${gtestCommonEnv} ./hipblas-test --gtest_output=xml --gtest_color=yes --yaml hipblas_smoke.yaml
+                    popd
                 """
     platform.runCommand(this, yamlTestCommand)
-    junit "${stagingDir}/*.xml"
 }
 
-def runPackageCommand(platform, project, jobName, label='')
+def runCoverageCommand (platform, project, String cmdDir = "release-debug")
+{
+    //Temporary workaround due to bug in container
+    String centos7Workaround = platform.jenkinsLabel.contains('centos7') ? 'export LD_LIBRARY_PATH=\$LD_LIBRARY_PATH:/opt/rocm/lib64/' : ''
+
+    String gtestCommonEnv = "HIPBLAS_CLIENT_RAM_GB_LIMIT=95 GTEST_LISTENER=NO_PASS_LINE_IN_LOG"
+
+    def command = """#!/usr/bin/env bash
+                set -x
+                cd ${project.paths.project_build_prefix}/build/${cmdDir}
+                export LD_LIBRARY_PATH=/opt/rocm/lib/
+                ${centos7Workaround}
+                ${gtestCommonEnv} make coverage_cleanup coverage GTEST_FILTER=-*known_bug*
+            """
+
+    platform.runCommand(this, command)
+
+    publishHTML([allowMissing: false,
+                alwaysLinkToLastBuild: false,
+                keepAll: false,
+                reportDir: "${project.paths.project_build_prefix}/build/${cmdDir}/coverage-report",
+                reportFiles: "index.html",
+                reportName: "Code coverage report",
+                reportTitles: "Code coverage report"])
+}
+
+def runPackageCommand(platform, project, jobName, label='', buildDir='')
 {
     def command
 
     label = label != '' ? '-' + label.toLowerCase() : ''
     String ext = platform.jenkinsLabel.contains('ubuntu') ? "deb" : "rpm"
     String dir = jobName.contains('Debug') ? "debug" : "release"
+
     if (env.BRANCH_NAME ==~ /PR-\d+/)
     {
         if (pullRequest.labels.contains("debug"))
@@ -94,6 +110,10 @@ def runPackageCommand(platform, project, jobName, label='')
             dir = "debug"
         }
     }
+    if (buildDir != '')
+    {
+        dir = buildDir
+    }
 
     command = """
             set -x
diff --git a/.jenkins/precheckin-cuda.groovy b/.jenkins/precheckin-cuda.groovy
index 771c0a0..8378953 100644
--- a/.jenkins/precheckin-cuda.groovy
+++ b/.jenkins/precheckin-cuda.groovy
@@ -58,18 +58,14 @@ def setupCI(urlJobName, jobNameList, buildCommand, runCI, label)
     {
         jobName, nodeDetails->
         if (urlJobName == jobName)
-            stage(label + ' ' + jobName) {
-                runCI(nodeDetails, jobName, buildCommand, label)
-            }
+            runCI(nodeDetails, jobName, buildCommand, label)
     }
 
     // For url job names that are not listed by the jobNameList i.e. compute-rocm-dkms-no-npi-1901
     if(!jobNameList.keySet().contains(urlJobName))
     {
         properties(auxiliary.addCommonProperties([pipelineTriggers([cron('0 1 * * *')])]))
-        stage(label + ' ' + urlJobName) {
-            runCI(['ubuntu20-cuda11':['anycuda']], urlJobName, buildCommand, label)
-        }
+        runCI(['ubuntu20-cuda11':['anycuda']], urlJobName, buildCommand, label)
     }
 
 }
diff --git a/.jenkins/precheckin.groovy b/.jenkins/precheckin.groovy
index 06aa474..8f5362f 100644
--- a/.jenkins/precheckin.groovy
+++ b/.jenkins/precheckin.groovy
@@ -80,18 +80,14 @@ def setupCI(urlJobName, jobNameList, buildCommand, runCI, label)
     {
         jobName, nodeDetails->
         if (urlJobName == jobName)
-            stage(label + ' ' + jobName) {
-                runCI(nodeDetails, jobName, buildCommand, label)
-            }
+            runCI(nodeDetails, jobName, buildCommand, label)
     }
 
     // For url job names that are not listed by the jobNameList i.e. compute-rocm-dkms-no-npi-1901
     if(!jobNameList.keySet().contains(urlJobName))
     {
         properties(auxiliary.addCommonProperties([pipelineTriggers([cron('0 1 * * *')])]))
-        stage(label + ' ' + urlJobName) {
-            runCI([ubuntu18:['gfx906']], urlJobName, buildCommand, label)
-        }
+        runCI([ubuntu18:['gfx906']], urlJobName, buildCommand, label)
     }
 
 }
diff --git a/.jenkins/static.groovy b/.jenkins/static.groovy
index e7899e8..11e0e03 100644
--- a/.jenkins/static.groovy
+++ b/.jenkins/static.groovy
@@ -18,10 +18,10 @@ def runCI =
 
     if (env.BRANCH_NAME ==~ /PR-\d+/ && pullRequest.labels.contains("noSolver"))
     {
-        prj.libraryDependencies = ['hipBLAS-common', 'hipBLASLt', 'rocBLAS']    }
+        prj.libraryDependencies = ['hipBLAS-common', 'rocBLAS']    }
     else
     {
-        prj.libraryDependencies = ['rocPRIM', 'hipBLAS-common', 'hipBLASLt', 'rocBLAS', 'rocSPARSE', 'rocSOLVER']
+        prj.libraryDependencies = ['rocPRIM', 'hipBLAS-common', 'rocBLAS', 'rocSPARSE', 'rocSOLVER']
     }
 
     // Define test architectures, optional rocm version argument is available
@@ -76,17 +76,13 @@ ci: {
     {
         jobName, nodeDetails->
         if (urlJobName == jobName)
-            stage(jobName) {
-                runCI(nodeDetails, jobName)
-            }
+            runCI(nodeDetails, jobName)
     }
 
     // For url job names that are not listed by the jobNameList i.e. compute-rocm-dkms-no-npi-1901
     if(!jobNameList.keySet().contains(urlJobName))
     {
         properties(auxiliary.addCommonProperties([pipelineTriggers([cron('0 1 * * *')])]))
-        stage(urlJobName) {
-            runCI([ubuntu18:['gfx906']], urlJobName)
-        }
+        runCI([ubuntu18:['gfx906']], urlJobName)
     }
 }
diff --git a/.jenkins/staticanalysis.groovy b/.jenkins/staticanalysis.groovy
index 096e8c5..36d76d6 100644
--- a/.jenkins/staticanalysis.groovy
+++ b/.jenkins/staticanalysis.groovy
@@ -45,8 +45,6 @@ ci: {
     {
         jobName, nodeDetails->
         if (urlJobName == jobName)
-            stage(jobName) {
-                runCI(nodeDetails, jobName)
-            }
+            runCI(nodeDetails, jobName)
     }
 }
diff --git a/CHANGELOG.md b/CHANGELOG.md
index 5e8395f..4501829 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -3,7 +3,44 @@
 Documentation for hipBLAS is available at
 [https://rocm.docs.amd.com/projects/hipBLAS/en/latest/](https://rocm.docs.amd.com/projects/hipBLAS/en/latest/).
 
-## hipBLAS 2.4.0 for ROCm 6.4.0
+## hipBLAS 3.1.0 for ROCm 7.1
+
+### Added
+
+* `--clients-only` build option to only build clients against a prebuilt library.
+* gfx1103, gfx1150, gfx1151, gfx1200, and gfx1201 support to clients.
+* FORTRAN enabled for the Microsoft Windows build and tests.
+* Additional reference library fallback options added.
+
+### Changed
+
+* Improve the build time for clients by removing `clients_common.cpp` from the hipblas-test build.
+
+## hipBLAS 3.0.0 for ROCm 7.0
+
+### Added
+
+* Added the `hipblasSetWorkspace()` API
+* Support for codecoverage tests
+
+### Changed
+
+* HIPBLAS_V2 API is now the only available API using `hipComplex` and `hipDatatype` types
+* Documentation updates
+* Verbose compilation for `hipblas.cpp`
+
+### Removed
+
+* `hipblasDatatype_t` type
+* `hipComplex` and `hipDoubleComplex` types
+* Support code for non-production gfx targets
+
+### Resolved issues
+
+* The build time `CMake` configuration for the dependency on `hipBLAS-common` is fixed
+* Compiler warnings for unhandled enums have been resolved
+
+##  hipBLAS 2.4.0 for ROCm 6.4.0
 
 ### Changed
 
diff --git a/CMakeLists.txt b/CMakeLists.txt
index c63dfe1..6b3d0b0 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -1,5 +1,5 @@
 # ########################################################################
-# Copyright (C) 2016-2024 Advanced Micro Devices, Inc. All rights reserved.
+# Copyright (C) 2016-2025 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
@@ -42,12 +42,11 @@ if( NOT DEFINED CMAKE_CONFIGURATION_TYPES AND NOT DEFINED CMAKE_BUILD_TYPE )
   set( CMAKE_BUILD_TYPE Release CACHE STRING "Choose the type of build, options are: None Debug Release RelWithDebInfo MinSizeRel." )
 endif()
 
-if (NOT WIN32)
-    if ( NOT DEFINED CMAKE_Fortran_COMPILER AND NOT DEFINED ENV{FC} )
-      set( CMAKE_Fortran_COMPILER  "gfortran" )
-    endif()
-    set( fortran_language "Fortran" )
-endif( )
+if ( NOT DEFINED CMAKE_Fortran_COMPILER AND NOT DEFINED ENV{FC} )
+  set( CMAKE_Fortran_COMPILER  "gfortran" )
+endif()
+
+set( fortran_language "Fortran" )
 
 project( hipblas LANGUAGES CXX ${fortran_language} )
 
@@ -66,7 +65,7 @@ list( APPEND CMAKE_PREFIX_PATH ${ROCM_PATH}/lib/cmake/hip /opt/rocm /opt/rocm/ll
 # rocm-cmake contains common cmake code for rocm projects to help setup and install
 include(dependencies)
 
-set ( VERSION_STRING "2.4.0" )
+set ( VERSION_STRING "3.1.0" )
 rocm_setup_version( VERSION ${VERSION_STRING} )
 
 option( BUILD_VERBOSE "Output additional build information" OFF )
@@ -114,10 +113,6 @@ if(HIP_PLATFORM STREQUAL nvidia)
 endif()
 
 option(BUILD_CODE_COVERAGE "Build with code coverage enabled" OFF)
-if(BUILD_CODE_COVERAGE)
-  add_compile_options(-fprofile-arcs -ftest-coverage)
-  add_link_options(--coverage)
-endif()
 
 option(BUILD_ADDRESS_SANITIZER "Build with address sanitizer enabled" OFF)
 if(BUILD_ADDRESS_SANITIZER)
@@ -125,20 +120,10 @@ if(BUILD_ADDRESS_SANITIZER)
     set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -fsanitize=address -shared-libasan")
 endif()
 
-
-# FOR HANDLING ENABLE/DISABLE OPTIONAL BACKWARD COMPATIBILITY for FILE/FOLDER REORG
-option(BUILD_FILE_REORG_BACKWARD_COMPATIBILITY "Build with file/folder reorg with backward compatibility enabled" OFF)
-if(BUILD_FILE_REORG_BACKWARD_COMPATIBILITY AND NOT WIN32)
-  rocm_wrap_header_dir(
-    ${CMAKE_SOURCE_DIR}/library/include
-    PATTERNS "*.h"
-    GUARDS SYMLINK WRAPPER
-    WRAPPER_LOCATIONS ${CMAKE_INSTALL_INCLUDEDIR}
-  )
+if(NOT SKIP_LIBRARY)
+  add_subdirectory(library)
 endif()
 
-add_subdirectory( library )
-
 include( clients/cmake/build-options.cmake )
 
 # Build clients of the library
@@ -151,7 +136,7 @@ if( BUILD_CLIENTS_SAMPLES OR BUILD_CLIENTS_TESTS OR BUILD_CLIENTS_BENCHMARKS )
   message(STATUS "OS: ${CLIENTS_OS} ${CLIENTS_OS_VERSION}")
   set(GFORTRAN_RPM "libgfortran4")
   set(GFORTRAN_DEB "libgfortran4")
-  if(CLIENTS_OS STREQUAL "centos" OR CLIENTS_OS STREQUAL "rhel")
+  if(CLIENTS_OS STREQUAL "centos" OR CLIENTS_OS STREQUAL "rhel" OR CLIENTS_OS STREQUAL "almalinux")
     if(CLIENTS_OS_VERSION VERSION_GREATER_EQUAL "8")
       set(GFORTRAN_RPM "libgfortran")
     endif()
@@ -204,22 +189,30 @@ endif( )
 
 # Package specific CPACK vars
 if(HIP_PLATFORM STREQUAL amd)
-  set(rocblas_minimum 4.4.0)
-  set(rocsolver_minimum 3.28.0)
+  set(rocblas_minimum 5.1.0)
+  set(rocsolver_minimum 3.31.0)
   rocm_package_add_dependencies(SHARED_DEPENDS "rocblas >= ${rocblas_minimum}" "rocsolver >= ${rocsolver_minimum}")
   rocm_package_add_rpm_dependencies(STATIC_DEPENDS "rocblas-static-devel >= ${rocblas_minimum}" "rocsolver-static-devel >= ${rocsolver_minimum}")
   rocm_package_add_deb_dependencies(STATIC_DEPENDS "rocblas-static-dev >= ${rocblas_minimum}" "rocsolver-static-dev >= ${rocsolver_minimum}")
 endif( )
 
-set(hipblas_common_minimum 1.0.0)
-rocm_package_add_deb_dependencies(COMPONENT devel DEPENDS "hipblas-common-dev >= ${hipblas_common_minimum}") 
-rocm_package_add_rpm_dependencies(COMPONENT devel DEPENDS "hipblas-common-devel >= ${hipblas_common_minimum}")
+set(hipblas_common_minimum 1.3.0)
+
+if(BUILD_SHARED_LIBS)
+  rocm_package_add_deb_dependencies(COMPONENT devel DEPENDS "hipblas-common-dev >= ${hipblas_common_minimum}")
+  rocm_package_add_rpm_dependencies(COMPONENT devel DEPENDS "hipblas-common-devel >= ${hipblas_common_minimum}")
+else()
+  rocm_package_add_deb_dependencies(COMPONENT devel DEPENDS "hipblas-common-static-dev >= ${hipblas_common_minimum}")
+  rocm_package_add_rpm_dependencies(COMPONENT devel DEPENDS "hipblas-common-static-devel >= ${hipblas_common_minimum}")
+endif()
 
 set( CPACK_RESOURCE_FILE_LICENSE "${CMAKE_CURRENT_SOURCE_DIR}/LICENSE.md" )
 set( CPACK_RPM_PACKAGE_LICENSE "MIT")
 
 if (WIN32)
-  SET( CMAKE_INSTALL_PREFIX "C:/hipSDK" CACHE PATH "Install path" FORCE )
+  if( CMAKE_INSTALL_PREFIX_INITIALIZED_TO_DEFAULT )
+    SET( CMAKE_INSTALL_PREFIX "C:/hipSDK" CACHE PATH "Install path" FORCE )
+  endif()
   SET( INSTALL_PREFIX "C:/hipSDK" )
   SET( CPACK_SET_DESTDIR FALSE )
   SET( CPACK_PACKAGE_INSTALL_DIRECTORY "C:/hipSDK" )
@@ -273,35 +266,37 @@ if(BUILD_CODE_COVERAGE)
 
   add_custom_target(coverage_analysis
     COMMAND echo Coverage GTEST_FILTER=\${GTEST_FILTER}
-    COMMAND ${coverage_test} --gtest_filter=\"\${GTEST_FILTER}\"
+    COMMAND ${CMAKE_COMMAND} -E make_directory ./coverage/profraw
+    COMMAND ${CMAKE_COMMAND} -E env LLVM_PROFILE_FILE="./coverage-report/profraw/hipblas-coverage_%m.profraw" ${coverage_test} --gtest_filter=\"\${GTEST_FILTER}\"
     WORKING_DIRECTORY ${CMAKE_BINARY_DIR}
     )
 
   add_dependencies(coverage_analysis hipblas)
 
-  #
-  # Prepare coverage output
-  # This little script is generated because the option '--gcov-tool <program name>' of lcov cannot take arguments.
-  #
-  add_custom_target(coverage_output
-    DEPENDS coverage_analysis
-    COMMAND mkdir -p lcoverage
-    COMMAND echo "\\#!/bin/bash" > llvm-gcov.sh
-    COMMAND echo "\\# THIS FILE HAS BEEN GENERATED" >> llvm-gcov.sh
-    COMMAND printf "exec /opt/rocm/llvm/bin/llvm-cov gcov $$\\@" >> llvm-gcov.sh
-    COMMAND chmod +x llvm-gcov.sh
-    )
+  find_program(
+    LLVM_PROFDATA
+    llvm-profdata
+    REQUIRED
+    HINTS ${ROCM_PATH}/llvm/bin
+    PATHS /opt/rocm/llvm/bin
+  )
 
-  #
-  # Generate coverage output.
-  #
-  add_custom_command(TARGET coverage_output
-    COMMAND lcov --directory . --base-directory . --gcov-tool ${CMAKE_BINARY_DIR}/llvm-gcov.sh --capture -o lcoverage/raw_main_coverage.info
-    COMMAND lcov --remove lcoverage/raw_main_coverage.info "'/opt/*'" "'/usr/*'" -o lcoverage/main_coverage.info
-    COMMAND genhtml lcoverage/main_coverage.info --output-directory lcoverage
-    )
+  find_program(
+    LLVM_COV
+    llvm-cov
+    REQUIRED
+    HINTS ${ROCM_PATH}/llvm/bin
+    PATHS /opt/rocm/llvm/bin
+  )
 
-  add_custom_target(coverage DEPENDS coverage_output)
+  add_custom_target(
+    coverage
+    DEPENDS coverage_analysis
+    COMMAND ${LLVM_PROFDATA} merge -sparse ./coverage-report/profraw/hipblas-coverage_*.profraw -o ./coverage-report/hipblas.profdata
+    COMMAND ${LLVM_COV} report -object ./library/src/libhipblas.so -instr-profile=./coverage-report/hipblas.profdata
+    COMMAND ${LLVM_COV} show -object ./library/src/libhipblas.so -instr-profile=./coverage-report/hipblas.profdata -format=html -output-dir=coverage-report
+    WORKING_DIRECTORY ${CMAKE_BINARY_DIR}
+  )
 
   #
   # Coverage cleanup
diff --git a/LICENSE.md b/LICENSE.md
index 588320c..1461bfb 100644
--- a/LICENSE.md
+++ b/LICENSE.md
@@ -1,12 +1,26 @@
 MIT License
 
-Copyright (C) 2017-2025 Advanced Micro Devices, Inc. All rights reserved.
+Copyright (C) Advanced Micro Devices, Inc.
 
-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:
+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 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.
+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.
+
+---
 
 This product includes software from copyright holders as shown below, and distributed under their license terms as specified.
 
diff --git a/README.md b/README.md
index bce3811..5990bae 100644
--- a/README.md
+++ b/README.md
@@ -33,22 +33,43 @@ cmake -DBUILD_DOCS=ON ...
 
 ## Build and install
 
-1. Download the hipBLAS source code (clone this repository):
+1. Checkout the hipBLAS code using either a sparse checkout or a full clone of the rocm-libraries repository.
+
+   To limit your local checkout to only the hipBLAS project, configure ``sparse-checkout`` before cloning.
+   This uses the Git partial clone feature (``--filter=blob:none``) to reduce how much data is downloaded.
+   Use the following commands for a sparse checkout:
+
+    ```bash
+
+    git clone --no-checkout --filter=blob:none https://github.com/ROCm/rocm-libraries.git
+    cd rocm-libraries
+    git sparse-checkout init --cone
+    git sparse-checkout set projects/hipblas # add projects/rocsolver projects/rocblas projects/hipblas-common to include dependencies
+    git checkout develop # or use the branch you want to work with
+    ```
+
+   To clone the entire rocm-libraries repository, use the following commands. This process takes more time,
+   but is recommended if you want to work with a large number of libraries.
 
     ```bash
-        git clone https://github.com/ROCmSoftwarePlatform/hipBLAS.git
+
+    # Clone rocm-libraries, including hipBLAS, using Git
+    git clone https://github.com/ROCm/rocm-libraries.git
+
+    # Go to hipBLAS directory
+    cd rocm-libraries/projects/hipblas
     ```
 
     ```note
         hipBLAS requires specific versions of rocBLAS and rocSOLVER. Refer to
-        [CMakeLists.txt](https://github.com/ROCmSoftwarePlatform/hipBLAS/blob/develop/library/CMakeLists.txt)
+        [CMakeLists.txt](https://github.com/ROCm/rocm-libraries/blob/develop/projects/hipblas/library/CMakeLists.txt)
         for details.
     ```
 
-2. Build hipBLAS and install it into `/opt/rocm/hipblas`:
+2. Build hipBLAS using the `install.sh` script and install it into `/opt/rocm/hipblas`:
 
     ```bash
-        cd hipblas
+        cd rocm-libraries/projects/hipblas
         ./install.sh -i
     ```
 
diff --git a/bump_develop_version.sh b/bump_develop_version.sh
index cdfcdad..b83ca98 100755
--- a/bump_develop_version.sh
+++ b/bump_develop_version.sh
@@ -2,19 +2,23 @@
 
 # For the develop branch, bump hipblas version and rocblas/rocsolver dependency versions
 
-OLD_HIPBLAS_VERSION="2.3.0"
-NEW_HIPBLAS_VERSION="2.4.0"
+OLD_HIPBLAS_VERSION="3.0.0"
+NEW_HIPBLAS_VERSION="3.1.0"
 
-OLD_MINIMUM_ROCBLAS_VERSION="4.3.0"
-NEW_MINIMUM_ROCBLAS_VERSION="4.4.0"
+OLD_MINIMUM_ROCBLAS_VERSION="5.0.0"
+NEW_MINIMUM_ROCBLAS_VERSION="5.1.0"
 
-OLD_MINIMUM_ROCSOLVER_VERSION="3.27.0"
-NEW_MINIMUM_ROCSOLVER_VERSION="3.28.0"
+OLD_MINIMUM_ROCSOLVER_VERSION="3.30.0"
+NEW_MINIMUM_ROCSOLVER_VERSION="3.31.0"
 
-OLD_SO_VERSION="hipblas_SOVERSION 2.3"
-NEW_SO_VERSION="hipblas_SOVERSION 2.4"
+OLD_MINIMUM_HIPBLAS_COMMON_VERSION="1.1.0"
+NEW_MINIMUM_HIPBLAS_COMMON_VERSION="1.3.0"
+
+OLD_SO_VERSION="hipblas_SOVERSION 3.0"
+NEW_SO_VERSION="hipblas_SOVERSION 3.1"
 
 sed -i "s/${OLD_HIPBLAS_VERSION}/${NEW_HIPBLAS_VERSION}/g" CMakeLists.txt
 sed -i "s/${OLD_MINIMUM_ROCBLAS_VERSION}/${NEW_MINIMUM_ROCBLAS_VERSION}/g" CMakeLists.txt
 sed -i "s/${OLD_MINIMUM_ROCSOLVER_VERSION}/${NEW_MINIMUM_ROCSOLVER_VERSION}/g" CMakeLists.txt
+sed -i "s/${OLD_MINIMUM_HIPBLAS_COMMON_VERSION}/${NEW_MINIMUM_HIPBLAS_COMMON_VERSION}/g" CMakeLists.txt
 sed -i "s/${OLD_SO_VERSION}/${NEW_SO_VERSION}/g" library/CMakeLists.txt
diff --git a/clients/CMakeLists.txt b/clients/CMakeLists.txt
index 7cad5e1..f67828e 100644
--- a/clients/CMakeLists.txt
+++ b/clients/CMakeLists.txt
@@ -1,5 +1,5 @@
 # ########################################################################
-# Copyright (C) 2016-2024 Advanced Micro Devices, Inc. All rights reserved.
+# Copyright (C) 2016-2025 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
@@ -28,8 +28,8 @@ function( get_lapack lapack_lib lapack_inc )
     set( inc "${BUILD_DIR}/deps/deps-install/include" )
     set( ${cblas_inc} ${inc} PARENT_SCOPE )
   else()
-    find_package( lapack REQUIRED CONFIG )
-    set( lib "lapack" )
+    find_package( LAPACK REQUIRED )
+    set( lib "${LAPACK_LIBRARIES}" )
   endif()
   set( ${lapack_lib} ${lib} PARENT_SCOPE )
 endfunction( )
@@ -52,12 +52,31 @@ function( get_cblas cblas_libs cblas_inc )
       set( ${cblas_inc} ${inc} PARENT_SCOPE )
     else()
       find_package( cblas REQUIRED CONFIG )
-      set( libs cblas blas )
+      set( libs ${CBLAS_LIBRARIES} )
     endif()
   endif()
   set( ${cblas_libs} ${libs} PARENT_SCOPE )
 endfunction( )
 
+function( apply_omp_settings lib_target_ )
+  if (CMAKE_CXX_COMPILER_ID MATCHES "Clang" AND TARGET OpenMP::OpenMP_CXX)
+    set_target_properties( ${lib_target_} PROPERTIES
+      BUILD_RPATH "${HIP_CLANG_ROOT}/lib"
+    )
+    set_target_properties( ${lib_target_} PROPERTIES
+      INSTALL_RPATH "$ORIGIN/../llvm/lib"
+    )
+  elseif(CMAKE_CXX_COMPILER_ID MATCHES "Clang" AND TARGET OpenMP::omp)
+    set_target_properties( ${lib_target_} PROPERTIES
+      BUILD_RPATH "${HIP_CLANG_ROOT}/${openmp_LIB_DIR}"
+    )
+    set_target_properties( ${lib_target_} PROPERTIES
+      INSTALL_RPATH "$ORIGIN/../llvm/${openmp_LIB_DIR}"
+    )
+  endif()
+endfunction()
+
+
 # Consider removing this in the future
 # This should appear before the project command, because it does not use FORCE
 if( WIN32 )
@@ -90,19 +109,34 @@ if( NOT WIN32 )
     set(hipblas_f90_source_clients_solver
       include/hipblas_fortran_module.f90
     )
+
+    set (hipblas_f90_source
+      ../library/src/hipblas_module.f90
+    )
 endif()
 
 if( BUILD_CLIENTS_TESTS OR BUILD_CLIENTS_BENCHMARKS OR BUILD_CLIENTS_SAMPLES )
+  # Create hipBLAS Fortran module
+  if(NOT WIN32)
+      # Set Fortran module output directory
+      set(CMAKE_Fortran_MODULE_DIRECTORY ${PROJECT_BINARY_DIR}/include/hipblas)
+      add_library(hipblas_fortran OBJECT ${hipblas_f90_source})
+  endif()
+
   if( NOT WIN32 )
     if( BUILD_WITH_SOLVER )
-      add_library(hipblas_fortran_client STATIC ${hipblas_f90_source_clients_solver})
+      add_library(hipblas_fortran_client STATIC ${hipblas_f90_source_clients_solver} $<TARGET_OBJECTS:hipblas_fortran>)
     else()
-      add_library(hipblas_fortran_client STATIC ${hipblas_f90_source_clients_no_solver})
+      add_library(hipblas_fortran_client STATIC ${hipblas_f90_source_clients_no_solver} $<TARGET_OBJECTS:hipblas_fortran>)
     endif()
-    add_dependencies(hipblas_fortran_client hipblas_fortran)
   endif()
-  include_directories(${CMAKE_BINARY_DIR}/include/hipblas)
-  include_directories(${CMAKE_BINARY_DIR}/include)
+
+  if(SKIP_LIBRARY)
+    include_directories(${HIPBLAS_LIBRARY_DIR}/include/hipblas)
+  else()
+    include_directories(${CMAKE_BINARY_DIR}/include/hipblas)
+    include_directories(${CMAKE_BINARY_DIR}/include)
+  endif()
 endif( )
 
 if( BUILD_CLIENTS_SAMPLES )
@@ -114,19 +148,20 @@ if( BUILD_CLIENTS_BENCHMARKS OR BUILD_CLIENTS_TESTS)
   set(THREADS_PREFER_PTHREAD_FLAG ON)
   find_package(Threads REQUIRED)
 
-  # if it fails to find OpenMP compile and link flags in strange configurations it can just use non-parallel reference computation
-  # if there is no omp.h to find the client compilation will fail and this should be obvious, used to be REQUIRED
-  find_package(OpenMP)
+  if (CMAKE_CXX_COMPILER_ID MATCHES "Clang")
+    # Look for openmp config in ROCm install to populate openmp_LIB_DIR and openmp_LIB_INSTALL_DIR
+    find_package(OpenMP CONFIG PATHS "${HIP_CLANG_ROOT}/lib/cmake")
+  endif()
 
-  if (TARGET OpenMP::OpenMP_CXX)
-    set( COMMON_LINK_LIBS "OpenMP::OpenMP_CXX")
-    if(HIP_PLATFORM STREQUAL amd)
-      list( APPEND COMMON_LINK_LIBS "-L\"${HIP_CLANG_ROOT}/lib\"")
-      if (NOT WIN32)
-        list( APPEND COMMON_LINK_LIBS "-Wl,-rpath=${HIP_CLANG_ROOT}/lib -lomp")
-      else()
-        list( APPEND COMMON_LINK_LIBS "libomp")
-      endif()
+  if (CMAKE_CXX_COMPILER_ID MATCHES "Clang" AND TARGET OpenMP::omp)
+    set( COMMON_LINK_LIBS "OpenMP::omp")
+    message(STATUS "Found openmp-config.cmake at ${OpenMP_DIR}")
+  else()
+    # if it fails to find OpenMP compile and link flags in strange configurations it can just use non-parallel reference computation
+    # if there is no omp.h to find the client compilation will fail and this should be obvious, used to be REQUIRED
+    find_package(OpenMP)
+    if (TARGET OpenMP::OpenMP_CXX)
+      set( COMMON_LINK_LIBS "OpenMP::OpenMP_CXX")
     endif()
   endif()
 
@@ -184,7 +219,7 @@ if( BUILD_CLIENTS_BENCHMARKS OR BUILD_CLIENTS_TESTS)
                     NO_DEFAULT_PATH
                   )
       if (NOT BLAS_LIBRARY)
-        find_package( OPENBLAS CONFIG REQUIRED )
+        find_package( OpenBLAS CONFIG REQUIRED )
         set( BLAS_LIBRARY OpenBLAS::OpenBLAS )
         set( BLAS_INCLUDE_DIR "" )
       endif()
@@ -195,8 +230,17 @@ if( BUILD_CLIENTS_BENCHMARKS OR BUILD_CLIENTS_TESTS)
     set( BLIS_CPP ../common/blis_interface.cpp )
   endif()
 
+  if(EXISTS  "${BUILD_DIR}/deps/deps-install/lib/libgtest.a")
+    set( GTEST_ROOT "${BUILD_DIR}/deps/deps-install")
+  endif()
+  find_package( GTest REQUIRED )
+
   message(STATUS "Build Dir: ${BUILD_DIR}")
-  message(STATUS "Linking Ref. Libs: ${BLAS_LIBRARY}")
+  message(STATUS "Linking Libs: ${BLAS_LIBRARY}")
+
+  if( NOT TARGET hipblas )
+    find_package( hipblas REQUIRED CONFIG PATHS ${HIPBLAS_LIBRARY_DIR} )
+  endif( )
 
   if( BUILD_CLIENTS_TESTS )
     add_subdirectory( gtest )
@@ -232,8 +276,14 @@ add_custom_command( OUTPUT "${HIPBLAS_GENTEST}"
                     DEPENDS common/hipblas_gentest.py
                     WORKING_DIRECTORY "${CMAKE_CURRENT_SOURCE_DIR}" )
 
+set( HIPBLAS_CLIENTS_README "${PROJECT_BINARY_DIR}/staging/hipblas_clients_readme.txt")
+add_custom_command( OUTPUT "${HIPBLAS_CLIENTS_README}"
+                    COMMAND ${CMAKE_COMMAND} -E copy hipblas_clients_readme.txt "${HIPBLAS_CLIENTS_README}"
+                    DEPENDS hipblas_clients_readme.txt
+                    WORKING_DIRECTORY "${CMAKE_CURRENT_SOURCE_DIR}" )
+
 
-add_custom_target( hipblas-common DEPENDS "${HIPBLAS_COMMON}" "${HIPBLAS_TEMPLATE}" "${HIPBLAS_SMOKE}" "${HIPBLAS_GENTEST}" )
+add_custom_target( hipblas-clients-common DEPENDS "${HIPBLAS_COMMON}" "${HIPBLAS_TEMPLATE}" "${HIPBLAS_SMOKE}" "${HIPBLAS_GENTEST}" "${HIPBLAS_CLIENTS_README}" )
 
 if( BUILD_CLIENTS_TESTS OR BUILD_CLIENTS_BENCHMARKS )
   rocm_install(
@@ -246,4 +296,10 @@ if( BUILD_CLIENTS_TESTS OR BUILD_CLIENTS_BENCHMARKS )
     DESTINATION "${CMAKE_INSTALL_BINDIR}"
     COMPONENT clients-common
   )
+  # this readme also serves to prevent an empty package hipblas-clients which dpkg may auto-remove entire hipblas-clients and non empty children
+  rocm_install(
+    FILES ${HIPBLAS_CLIENTS_README}
+    DESTINATION "${CMAKE_INSTALL_BINDIR}"
+    COMPONENT clients
+  )
 endif()
diff --git a/clients/benchmarks/CMakeLists.txt b/clients/benchmarks/CMakeLists.txt
index d04d28e..5ed28e2 100644
--- a/clients/benchmarks/CMakeLists.txt
+++ b/clients/benchmarks/CMakeLists.txt
@@ -1,5 +1,5 @@
 # ########################################################################
-# Copyright (C) 2016-2024 Advanced Micro Devices, Inc. All rights reserved.
+# Copyright (C) 2016-2025 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
@@ -27,10 +27,6 @@ enable_language( Fortran )
 
 set(hipblas_bench_source client.cpp)
 
-if( NOT TARGET hipblas )
-  find_package( hipblas REQUIRED CONFIG PATHS /opt/rocm/hipblas )
-endif( )
-
 set( hipblas_benchmark_common
       ../common/utility.cpp
       ../common/cblas_interface.cpp
@@ -43,26 +39,22 @@ set( hipblas_benchmark_common
       ../common/near.cpp
       ../common/arg_check.cpp
       ../common/argument_model.cpp
-      ../common/hipblas_template_specialization.cpp
       ../common/host_alloc.cpp
       ${BLIS_CPP}
     )
 
-add_executable( hipblas-bench ${hipblas_bench_source} ${hipblas_benchmark_common} )
-add_executable( hipblas_v2-bench ${hipblas_bench_source} ${hipblas_benchmark_common} )
+if(NOT WIN32)
+  add_executable( hipblas-bench ${hipblas_bench_source} ${hipblas_benchmark_common} $<TARGET_OBJECTS:hipblas_fortran_client>)
+else()
+  add_executable( hipblas-bench ${hipblas_bench_source} ${hipblas_benchmark_common} )
+endif()
 
 target_compile_features( hipblas-bench PRIVATE cxx_static_assert cxx_nullptr cxx_auto_type )
-target_compile_features( hipblas_v2-bench PRIVATE cxx_static_assert cxx_nullptr cxx_auto_type )
-
 # Internal header includes
 target_include_directories( hipblas-bench
   PRIVATE
     $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/../include>
 )
-target_include_directories( hipblas_v2-bench
-  PRIVATE
-    $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/../include>
-)
 
 # External header includes included as system files
 target_include_directories( hipblas-bench
@@ -73,47 +65,28 @@ target_include_directories( hipblas-bench
     $<BUILD_INTERFACE:${BLIS_INCLUDE_DIR}>
     $<BUILD_INTERFACE:${FLAME_INCLUDE_DIR}>
 )
-target_include_directories( hipblas_v2-bench
-  SYSTEM PRIVATE
-    $<BUILD_INTERFACE:${HIP_INCLUDE_DIRS}>
-    $<BUILD_INTERFACE:${CBLAS_INCLUDE_DIRS}>
-    $<BUILD_INTERFACE:${BLAS_INCLUDE_DIR}>
-    $<BUILD_INTERFACE:${BLIS_INCLUDE_DIR}>
-    $<BUILD_INTERFACE:${FLAME_INCLUDE_DIR}>
-)
-
-target_link_libraries( hipblas-bench PRIVATE roc::hipblas )
-target_link_libraries( hipblas_v2-bench PRIVATE roc::hipblas )
 
-if (NOT WIN32)
-    target_link_libraries( hipblas-bench PRIVATE hipblas_fortran_client )
-    target_link_libraries( hipblas_v2-bench PRIVATE hipblas_fortran_client )
-endif()
+target_link_libraries( hipblas-bench PRIVATE roc::hipblas GTest::gtest GTest::gtest_main )
 
 # need mf16c flag for float->half convertion
 target_compile_options( hipblas-bench PRIVATE -mf16c ) # -Wno-deprecated-declarations )
-target_compile_options( hipblas_v2-bench PRIVATE -mf16c ) # -Wno-deprecated-declarations )
 
 target_compile_options(hipblas-bench PRIVATE $<$<COMPILE_LANGUAGE:CXX>:${COMMON_CXX_OPTIONS}>)
-target_compile_options(hipblas_v2-bench PRIVATE $<$<COMPILE_LANGUAGE:CXX>:${COMMON_CXX_OPTIONS}>)
 
 target_compile_definitions( hipblas-bench PRIVATE HIPBLAS_BENCH ${COMMON_DEFINES} ${BLIS_DEFINES} )
-target_compile_definitions( hipblas_v2-bench PRIVATE HIPBLAS_BENCH ${COMMON_DEFINES} ${BLIS_DEFINES} HIPBLAS_V2 )
 
 target_link_libraries( hipblas-bench PRIVATE ${BLAS_LIBRARY} ${COMMON_LINK_LIBS} )
-target_link_libraries( hipblas_v2-bench PRIVATE ${BLAS_LIBRARY} ${COMMON_LINK_LIBS} )
+apply_omp_settings( hipblas-bench )
+
 if (NOT WIN32)
     target_link_libraries( hipblas-bench PRIVATE stdc++fs )
-    target_link_libraries( hipblas_v2-bench PRIVATE stdc++fs )
 endif()
 
 if(HIP_PLATFORM STREQUAL amd)
   target_link_libraries( hipblas-bench PRIVATE hip::host )
-  target_link_libraries( hipblas_v2-bench PRIVATE hip::host )
 
   if( CUSTOM_TARGET )
     target_link_libraries( hipblas-bench PRIVATE hip::${CUSTOM_TARGET} )
-    target_link_libraries( hipblas_v2-bench PRIVATE hip::${CUSTOM_TARGET} )
   endif()
 
 else( )
@@ -121,26 +94,15 @@ else( )
     PRIVATE
       $<BUILD_INTERFACE:${CUDA_INCLUDE_DIRS}>
   )
-  target_include_directories( hipblas_v2-bench
-    PRIVATE
-      $<BUILD_INTERFACE:${CUDA_INCLUDE_DIRS}>
-  )
 
   target_link_libraries( hipblas-bench PRIVATE ${CUDA_LIBRARIES} )
-  target_link_libraries( hipblas_v2-bench PRIVATE ${CUDA_LIBRARIES} )
 endif( )
 
 set_target_properties( hipblas-bench PROPERTIES
   CXX_EXTENSIONS OFF
   RUNTIME_OUTPUT_DIRECTORY "${PROJECT_BINARY_DIR}/staging"
 )
-set_target_properties( hipblas_v2-bench PROPERTIES
-  CXX_EXTENSIONS OFF
-  RUNTIME_OUTPUT_DIRECTORY "${PROJECT_BINARY_DIR}/staging"
-)
 
-add_dependencies( hipblas-bench hipblas-common )
-add_dependencies( hipblas_v2-bench hipblas-common )
+add_dependencies( hipblas-bench hipblas-clients-common )
 
 rocm_install(TARGETS hipblas-bench COMPONENT benchmarks)
-rocm_install(TARGETS hipblas_v2-bench COMPONENT benchmarks)
diff --git a/clients/benchmarks/client.cpp b/clients/benchmarks/client.cpp
index 2aebc63..b412224 100644
--- a/clients/benchmarks/client.cpp
+++ b/clients/benchmarks/client.cpp
@@ -1,5 +1,5 @@
 /* ************************************************************************
- * Copyright (C) 2016-2023 Advanced Micro Devices, Inc. All rights reserved.
+ * Copyright (C) 2016-2025 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
@@ -277,7 +277,7 @@ try
          "Options: h,s,d,c,z,f16_r,f32_r,f64_r,bf16_r,f32_c,f64_c,i8_r,i32_r")
 
         ("compute_type_gemm",
-         value<std::string>(&compute_type_gemm), "Precision of computation for gemm_ex with HIPBLAS_V2 define"
+         value<std::string>(&compute_type_gemm), "Precision of computation for gemm_ex"
          "Options: c16f,c16f_pedantic,c32f,c32f_pedantic,c32f_fast_16f,c32f_fast_16bf,c32f_fast_tf32,c64f,c64f_pedantic,c32i,c32i_pedantic")
 
         ("initialization",
@@ -369,6 +369,10 @@ try
          value<int32_t>(&api)->default_value(0),
          "Use API, supercedes fortran flag (0==C, 1==C_64, ...)")
 
+        ("workspace",
+         value<size_t>(&arg.user_allocated_workspace)->default_value(0),
+         "Set workspace available in handle using xxblasSetWorkspace() API after handle creation")
+
         ("help,h", "produces this help message");
 
         //("version", "Prints the version number");
@@ -418,30 +422,13 @@ try
         return hipblas_bench_datafile();
 
     std::transform(precision.begin(), precision.end(), precision.begin(), ::tolower);
-    auto prec = string2hipblas_datatype(precision);
-    if(prec == HIPBLAS_DATATYPE_INVALID)
-        throw std::invalid_argument("Invalid value for --precision " + precision);
-
-    arg.a_type = a_type == "" ? prec : string2hipblas_datatype(a_type);
-    if(arg.a_type == HIPBLAS_DATATYPE_INVALID)
-        throw std::invalid_argument("Invalid value for --a_type " + a_type);
-
-    arg.b_type = b_type == "" ? prec : string2hipblas_datatype(b_type);
-    if(arg.b_type == HIPBLAS_DATATYPE_INVALID)
-        throw std::invalid_argument("Invalid value for --b_type " + b_type);
-
-    arg.c_type = c_type == "" ? prec : string2hipblas_datatype(c_type);
-    if(arg.c_type == HIPBLAS_DATATYPE_INVALID)
-        throw std::invalid_argument("Invalid value for --c_type " + c_type);
-
-    arg.d_type = d_type == "" ? prec : string2hipblas_datatype(d_type);
-    if(arg.d_type == HIPBLAS_DATATYPE_INVALID)
-        throw std::invalid_argument("Invalid value for --d_type " + d_type);
-
-    arg.compute_type = compute_type == "" ? prec : string2hipblas_datatype(compute_type);
-    if(arg.compute_type == HIPBLAS_DATATYPE_INVALID)
-        throw std::invalid_argument("Invalid value for --compute_type " + compute_type);
+    auto prec = string2hip_datatype(precision);
 
+    arg.a_type            = a_type == "" ? prec : string2hip_datatype(a_type);
+    arg.b_type            = b_type == "" ? prec : string2hip_datatype(b_type);
+    arg.c_type            = c_type == "" ? prec : string2hip_datatype(c_type);
+    arg.d_type            = d_type == "" ? prec : string2hip_datatype(d_type);
+    arg.compute_type      = compute_type == "" ? prec : string2hip_datatype(compute_type);
     arg.compute_type_gemm = string2hipblas_computetype(compute_type_gemm);
 
     arg.initialization = string2hipblas_initialization(initialization);
diff --git a/clients/cmake/build-options.cmake b/clients/cmake/build-options.cmake
index 25bb314..44e0b32 100644
--- a/clients/cmake/build-options.cmake
+++ b/clients/cmake/build-options.cmake
@@ -26,5 +26,3 @@ if( HIP_PLATFORM STREQUAL nvidia )
 else()
   option( LINK_BLIS "Link AOCL Blis reference library" ON )
 endif()
-
-
diff --git a/clients/common/cblas_interface.cpp b/clients/common/cblas_interface.cpp
index 2ccc666..f65b25c 100644
--- a/clients/common/cblas_interface.cpp
+++ b/clients/common/cblas_interface.cpp
@@ -1,5 +1,5 @@
 /* ************************************************************************
- * Copyright (C) 2016-2024 Advanced Micro Devices, Inc. All rights reserved.
+ * Copyright (C) 2016-2025 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
@@ -46,14 +46,15 @@ extern "C" {
 
 void spotrf_(char* uplo, int64_t* m, float* A, int64_t* lda, int64_t* info);
 void dpotrf_(char* uplo, int64_t* m, double* A, int64_t* lda, int64_t* info);
-void cpotrf_(char* uplo, int64_t* m, hipblasComplex* A, int64_t* lda, int64_t* info);
-void zpotrf_(char* uplo, int64_t* m, hipblasDoubleComplex* A, int64_t* lda, int64_t* info);
+void cpotrf_(char* uplo, int64_t* m, std::complex<float>* A, int64_t* lda, int64_t* info);
+void zpotrf_(char* uplo, int64_t* m, std::complex<double>* A, int64_t* lda, int64_t* info);
 
 void sgetrf_(int64_t* m, int64_t* n, float* A, int64_t* lda, int64_t* ipiv, int64_t* info);
 void dgetrf_(int64_t* m, int64_t* n, double* A, int64_t* lda, int64_t* ipiv, int64_t* info);
-void cgetrf_(int64_t* m, int64_t* n, hipblasComplex* A, int64_t* lda, int64_t* ipiv, int64_t* info);
+void cgetrf_(
+    int64_t* m, int64_t* n, std::complex<float>* A, int64_t* lda, int64_t* ipiv, int64_t* info);
 void zgetrf_(
-    int64_t* m, int64_t* n, hipblasDoubleComplex* A, int64_t* lda, int64_t* ipiv, int64_t* info);
+    int64_t* m, int64_t* n, std::complex<double>* A, int64_t* lda, int64_t* ipiv, int64_t* info);
 
 void sgetrs_(char*    trans,
              int64_t* n,
@@ -73,22 +74,22 @@ void dgetrs_(char*    trans,
              double*  B,
              int64_t* ldb,
              int64_t* info);
-void cgetrs_(char*           trans,
-             int64_t*        n,
-             int64_t*        nrhs,
-             hipblasComplex* A,
-             int64_t*        lda,
-             int64_t*        ipiv,
-             hipblasComplex* B,
-             int64_t*        ldb,
-             int64_t*        info);
+void cgetrs_(char*                trans,
+             int64_t*             n,
+             int64_t*             nrhs,
+             std::complex<float>* A,
+             int64_t*             lda,
+             int64_t*             ipiv,
+             std::complex<float>* B,
+             int64_t*             ldb,
+             int64_t*             info);
 void zgetrs_(char*                 trans,
              int64_t*              n,
              int64_t*              nrhs,
-             hipblasDoubleComplex* A,
+             std::complex<double>* A,
              int64_t*              lda,
              int64_t*              ipiv,
-             hipblasDoubleComplex* B,
+             std::complex<double>* B,
              int64_t*              ldb,
              int64_t*              info);
 
@@ -101,18 +102,18 @@ void dgetri_(int64_t* n,
              double*  work,
              int64_t* lwork,
              int64_t* info);
-void cgetri_(int64_t*        n,
-             hipblasComplex* A,
-             int64_t*        lda,
-             int64_t*        ipiv,
-             hipblasComplex* work,
-             int64_t*        lwork,
-             int64_t*        info);
+void cgetri_(int64_t*             n,
+             std::complex<float>* A,
+             int64_t*             lda,
+             int64_t*             ipiv,
+             std::complex<float>* work,
+             int64_t*             lwork,
+             int64_t*             info);
 void zgetri_(int64_t*              n,
-             hipblasDoubleComplex* A,
+             std::complex<double>* A,
              int64_t*              lda,
              int64_t*              ipiv,
-             hipblasDoubleComplex* work,
+             std::complex<double>* work,
              int64_t*              lwork,
              int64_t*              info);
 
@@ -132,20 +133,20 @@ void dgeqrf_(int64_t* m,
              double*  work,
              int64_t* lwork,
              int64_t* info);
-void cgeqrf_(int64_t*        m,
-             int64_t*        n,
-             hipblasComplex* A,
-             int64_t*        lda,
-             hipblasComplex* tau,
-             hipblasComplex* work,
-             int64_t*        lwork,
-             int64_t*        info);
+void cgeqrf_(int64_t*             m,
+             int64_t*             n,
+             std::complex<float>* A,
+             int64_t*             lda,
+             std::complex<float>* tau,
+             std::complex<float>* work,
+             int64_t*             lwork,
+             int64_t*             info);
 void zgeqrf_(int64_t*              m,
              int64_t*              n,
-             hipblasDoubleComplex* A,
+             std::complex<double>* A,
              int64_t*              lda,
-             hipblasDoubleComplex* tau,
-             hipblasDoubleComplex* work,
+             std::complex<double>* tau,
+             std::complex<double>* work,
              int64_t*              lwork,
              int64_t*              info);
 
@@ -171,80 +172,80 @@ void dgels_(char*    trans,
             double*  work,
             int64_t* lwork,
             int64_t* info);
-void cgels_(char*           trans,
-            int64_t*        m,
-            int64_t*        n,
-            int64_t*        nrhs,
-            hipblasComplex* A,
-            int64_t*        lda,
-            hipblasComplex* B,
-            int64_t*        ldb,
-            hipblasComplex* work,
-            int64_t*        lwork,
-            int64_t*        info);
+void cgels_(char*                trans,
+            int64_t*             m,
+            int64_t*             n,
+            int64_t*             nrhs,
+            std::complex<float>* A,
+            int64_t*             lda,
+            std::complex<float>* B,
+            int64_t*             ldb,
+            std::complex<float>* work,
+            int64_t*             lwork,
+            int64_t*             info);
 void zgels_(char*                 trans,
             int64_t*              m,
             int64_t*              n,
             int64_t*              nrhs,
-            hipblasDoubleComplex* A,
+            std::complex<double>* A,
             int64_t*              lda,
-            hipblasDoubleComplex* B,
+            std::complex<double>* B,
             int64_t*              ldb,
-            hipblasDoubleComplex* work,
+            std::complex<double>* work,
             int64_t*              lwork,
             int64_t*              info);
 
 /*
 void strtri_(char* uplo, char* diag, int64_t* n, float* A, int64_t* lda, int64_t* info);
 void dtrtri_(char* uplo, char* diag, int64_t* n, double* A, int64_t* lda, int64_t* info);
-void ctrtri_(char* uplo, char* diag, int64_t* n, hipblasComplex* A, int64_t* lda, int64_t* info);
-void ztrtri_(char* uplo, char* diag, int64_t* n, hipblasDoubleComplex* A, int64_t* lda, int64_t* info);
+void ctrtri_(char* uplo, char* diag, int64_t* n, std::complex<float>* A, int64_t* lda, int64_t* info);
+void ztrtri_(char* uplo, char* diag, int64_t* n, std::complex<double>* A, int64_t* lda, int64_t* info);
 
 void cspr_(
-    char* uplo, int64_t* n, hipblasComplex* alpha, hipblasComplex* x, int64_t* incx, hipblasComplex* A);
+    char* uplo, int64_t* n, std::complex<float>* alpha, std::complex<float>* x, int64_t* incx, std::complex<float>* A);
 
 void zspr_(char*                 uplo,
            int64_t*                  n,
-           hipblasDoubleComplex* alpha,
-           hipblasDoubleComplex* x,
+           std::complex<double>* alpha,
+           std::complex<double>* x,
            int64_t*                  incx,
-           hipblasDoubleComplex* A);
+           std::complex<double>* A);
 
 void csyr_(char*           uplo,
            int64_t*            n,
-           hipblasComplex* alpha,
-           hipblasComplex* x,
+           std::complex<float>* alpha,
+           std::complex<float>* x,
            int64_t*            incx,
-           hipblasComplex* a,
+           std::complex<float>* a,
            int64_t*            lda);
 void zsyr_(char*                 uplo,
            int64_t*                  n,
-           hipblasDoubleComplex* alpha,
-           hipblasDoubleComplex* x,
+           std::complex<double>* alpha,
+           std::complex<double>* x,
            int64_t*                  incx,
-           hipblasDoubleComplex* a,
+           std::complex<double>* a,
            int64_t*                  lda);
 
 void csymv_(char*           uplo,
             int64_t*            n,
-            hipblasComplex* alpha,
-            hipblasComplex* A,
+            std::complex<float>* alpha,
+            std::complex<float>* A,
             int64_t*            lda,
-            hipblasComplex* x,
+            std::complex<float>* x,
             int64_t*            incx,
-            hipblasComplex* beta,
-            hipblasComplex* y,
+            std::complex<float>* beta,
+            std::complex<float>* y,
             int64_t*            incy);
 
 void zsymv_(char*                 uplo,
             int64_t*                  n,
-            hipblasDoubleComplex* alpha,
-            hipblasDoubleComplex* A,
+            std::complex<double>* alpha,
+            std::complex<double>* A,
             int64_t*                  lda,
-            hipblasDoubleComplex* x,
+            std::complex<double>* x,
             int64_t*                  incx,
-            hipblasDoubleComplex* beta,
-            hipblasDoubleComplex* y,
+            std::complex<double>* beta,
+            std::complex<double>* y,
             int64_t*                  incy);
 */
 
@@ -380,22 +381,22 @@ void ref_axpy<double, double>(
 }
 
 template <>
-void ref_axpy<hipblasComplex, hipblasComplex>(int64_t               n,
-                                              const hipblasComplex  alpha,
-                                              const hipblasComplex* x,
-                                              int64_t               incx,
-                                              hipblasComplex*       y,
-                                              int64_t               incy)
+void ref_axpy<std::complex<float>, std::complex<float>>(int64_t                    n,
+                                                        const std::complex<float>  alpha,
+                                                        const std::complex<float>* x,
+                                                        int64_t                    incx,
+                                                        std::complex<float>*       y,
+                                                        int64_t                    incy)
 {
     cblas_caxpy(n, &alpha, x, incx, y, incy);
 }
 
 template <>
-void ref_axpy<hipblasDoubleComplex, hipblasDoubleComplex>(int64_t                     n,
-                                                          const hipblasDoubleComplex  alpha,
-                                                          const hipblasDoubleComplex* x,
+void ref_axpy<std::complex<double>, std::complex<double>>(int64_t                     n,
+                                                          const std::complex<double>  alpha,
+                                                          const std::complex<double>* x,
                                                           int64_t                     incx,
-                                                          hipblasDoubleComplex*       y,
+                                                          std::complex<double>*       y,
                                                           int64_t                     incy)
 {
     cblas_zaxpy(n, &alpha, x, incx, y, incy);
@@ -515,33 +516,36 @@ void ref_scal<double>(int64_t n, const double alpha, double* x, int64_t incx)
 }
 
 template <>
-void ref_scal<hipblasComplex>(int64_t              n,
-                              const hipblasComplex alpha,
-                              hipblasComplex*      x,
-                              int64_t              incx)
+void ref_scal<std::complex<float>>(int64_t                   n,
+                                   const std::complex<float> alpha,
+                                   std::complex<float>*      x,
+                                   int64_t                   incx)
 {
     cblas_cscal(n, &alpha, x, incx);
 }
 
 template <>
-void ref_scal<hipblasComplex, float>(int64_t n, const float alpha, hipblasComplex* x, int64_t incx)
+void ref_scal<std::complex<float>, float>(int64_t              n,
+                                          const float          alpha,
+                                          std::complex<float>* x,
+                                          int64_t              incx)
 {
     cblas_csscal(n, alpha, x, incx);
 }
 
 template <>
-void ref_scal<hipblasDoubleComplex>(int64_t                    n,
-                                    const hipblasDoubleComplex alpha,
-                                    hipblasDoubleComplex*      x,
+void ref_scal<std::complex<double>>(int64_t                    n,
+                                    const std::complex<double> alpha,
+                                    std::complex<double>*      x,
                                     int64_t                    incx)
 {
     cblas_zscal(n, &alpha, x, incx);
 }
 
 template <>
-void ref_scal<hipblasDoubleComplex, double>(int64_t               n,
+void ref_scal<std::complex<double>, double>(int64_t               n,
                                             const double          alpha,
-                                            hipblasDoubleComplex* x,
+                                            std::complex<double>* x,
                                             int64_t               incx)
 {
     cblas_zdscal(n, alpha, x, incx);
@@ -561,15 +565,15 @@ void ref_copy<double>(int64_t n, double* x, int64_t incx, double* y, int64_t inc
 }
 
 template <>
-void ref_copy<hipblasComplex>(
-    int64_t n, hipblasComplex* x, int64_t incx, hipblasComplex* y, int64_t incy)
+void ref_copy<std::complex<float>>(
+    int64_t n, std::complex<float>* x, int64_t incx, std::complex<float>* y, int64_t incy)
 {
     cblas_ccopy(n, x, incx, y, incy);
 }
 
 template <>
-void ref_copy<hipblasDoubleComplex>(
-    int64_t n, hipblasDoubleComplex* x, int64_t incx, hipblasDoubleComplex* y, int64_t incy)
+void ref_copy<std::complex<double>>(
+    int64_t n, std::complex<double>* x, int64_t incx, std::complex<double>* y, int64_t incy)
 {
     cblas_zcopy(n, x, incx, y, incy);
 }
@@ -588,15 +592,15 @@ void ref_swap<double>(int64_t n, double* x, int64_t incx, double* y, int64_t inc
 }
 
 template <>
-void ref_swap<hipblasComplex>(
-    int64_t n, hipblasComplex* x, int64_t incx, hipblasComplex* y, int64_t incy)
+void ref_swap<std::complex<float>>(
+    int64_t n, std::complex<float>* x, int64_t incx, std::complex<float>* y, int64_t incy)
 {
     cblas_cswap(n, x, incx, y, incy);
 }
 
 template <>
-void ref_swap<hipblasDoubleComplex>(
-    int64_t n, hipblasDoubleComplex* x, int64_t incx, hipblasDoubleComplex* y, int64_t incy)
+void ref_swap<std::complex<double>>(
+    int64_t n, std::complex<double>* x, int64_t incx, std::complex<double>* y, int64_t incy)
 {
     cblas_zswap(n, x, incx, y, incy);
 }
@@ -659,23 +663,23 @@ void ref_dot<double>(
 }
 
 template <>
-void ref_dot<hipblasComplex>(int64_t               n,
-                             const hipblasComplex* x,
-                             int64_t               incx,
-                             const hipblasComplex* y,
-                             int64_t               incy,
-                             hipblasComplex*       result)
+void ref_dot<std::complex<float>>(int64_t                    n,
+                                  const std::complex<float>* x,
+                                  int64_t                    incx,
+                                  const std::complex<float>* y,
+                                  int64_t                    incy,
+                                  std::complex<float>*       result)
 {
     cblas_cdotu_sub(n, x, incx, y, incy, result);
 }
 
 template <>
-void ref_dot<hipblasDoubleComplex>(int64_t                     n,
-                                   const hipblasDoubleComplex* x,
+void ref_dot<std::complex<double>>(int64_t                     n,
+                                   const std::complex<double>* x,
                                    int64_t                     incx,
-                                   const hipblasDoubleComplex* y,
+                                   const std::complex<double>* y,
                                    int64_t                     incy,
-                                   hipblasDoubleComplex*       result)
+                                   std::complex<double>*       result)
 {
     cblas_zdotu_sub(n, x, incx, y, incy, result);
 }
@@ -721,23 +725,23 @@ void ref_dotc<double>(
 }
 
 template <>
-void ref_dotc<hipblasComplex>(int64_t               n,
-                              const hipblasComplex* x,
-                              int64_t               incx,
-                              const hipblasComplex* y,
-                              int64_t               incy,
-                              hipblasComplex*       result)
+void ref_dotc<std::complex<float>>(int64_t                    n,
+                                   const std::complex<float>* x,
+                                   int64_t                    incx,
+                                   const std::complex<float>* y,
+                                   int64_t                    incy,
+                                   std::complex<float>*       result)
 {
     cblas_cdotc_sub(n, x, incx, y, incy, result);
 }
 
 template <>
-void ref_dotc<hipblasDoubleComplex>(int64_t                     n,
-                                    const hipblasDoubleComplex* x,
+void ref_dotc<std::complex<double>>(int64_t                     n,
+                                    const std::complex<double>* x,
                                     int64_t                     incx,
-                                    const hipblasDoubleComplex* y,
+                                    const std::complex<double>* y,
                                     int64_t                     incy,
-                                    hipblasDoubleComplex*       result)
+                                    std::complex<double>*       result)
 {
     cblas_zdotc_sub(n, x, incx, y, incy, result);
 }
@@ -790,17 +794,17 @@ void ref_nrm2<double, double>(int64_t n, const double* x, int64_t incx, double* 
 }
 
 template <>
-void ref_nrm2<hipblasComplex, float>(int64_t               n,
-                                     const hipblasComplex* x,
-                                     int64_t               incx,
-                                     float*                result)
+void ref_nrm2<std::complex<float>, float>(int64_t                    n,
+                                          const std::complex<float>* x,
+                                          int64_t                    incx,
+                                          float*                     result)
 {
     *result = cblas_scnrm2(n, x, incx);
 }
 
 template <>
-void ref_nrm2<hipblasDoubleComplex, double>(int64_t                     n,
-                                            const hipblasDoubleComplex* x,
+void ref_nrm2<std::complex<double>, double>(int64_t                     n,
+                                            const std::complex<double>* x,
                                             int64_t                     incx,
                                             double*                     result)
 {
@@ -812,37 +816,37 @@ void ref_nrm2<hipblasDoubleComplex, double>(int64_t                     n,
 ///////////////////
 // LAPACK fortran library functionality
 extern "C" {
-void crot_(const int64_t*        n,
-           hipblasComplex*       cx,
-           const int64_t*        incx,
-           hipblasComplex*       cy,
-           const int64_t*        incy,
-           const float*          c,
-           const hipblasComplex* s);
-void csrot_(const int64_t*  n,
-            hipblasComplex* cx,
-            const int64_t*  incx,
-            hipblasComplex* cy,
-            const int64_t*  incy,
-            const float*    c,
-            const float*    s);
+void crot_(const int64_t*             n,
+           std::complex<float>*       cx,
+           const int64_t*             incx,
+           std::complex<float>*       cy,
+           const int64_t*             incy,
+           const float*               c,
+           const std::complex<float>* s);
+void csrot_(const int64_t*       n,
+            std::complex<float>* cx,
+            const int64_t*       incx,
+            std::complex<float>* cy,
+            const int64_t*       incy,
+            const float*         c,
+            const float*         s);
 void zrot_(const int64_t*              n,
-           hipblasDoubleComplex*       cx,
+           std::complex<double>*       cx,
            const int64_t*              incx,
-           hipblasDoubleComplex*       cy,
+           std::complex<double>*       cy,
            const int64_t*              incy,
            const double*               c,
-           const hipblasDoubleComplex* s);
+           const std::complex<double>* s);
 void zdrot_(const int64_t*        n,
-            hipblasDoubleComplex* cx,
+            std::complex<double>* cx,
             const int64_t*        incx,
-            hipblasDoubleComplex* cy,
+            std::complex<double>* cy,
             const int64_t*        incy,
             const double*         c,
             const double*         s);
 
-void crotg_(hipblasComplex* a, hipblasComplex* b, float* c, hipblasComplex* s);
-void zrotg_(hipblasDoubleComplex* a, hipblasDoubleComplex* b, double* c, hipblasDoubleComplex* s);
+void crotg_(std::complex<float>* a, std::complex<float>* b, float* c, std::complex<float>* s);
+void zrotg_(std::complex<double>* a, std::complex<double>* b, double* c, std::complex<double>* s);
 }
 
 // rot
@@ -936,67 +940,72 @@ void ref_rot<double>(
 }
 
 template <>
-void ref_rot<hipblasComplex>(int64_t         n,
-                             hipblasComplex* x,
-                             int64_t         incx,
-                             hipblasComplex* y,
-                             int64_t         incy,
-                             hipblasComplex  c,
-                             hipblasComplex  s)
+void ref_rot<std::complex<float>>(int64_t              n,
+                                  std::complex<float>* x,
+                                  int64_t              incx,
+                                  std::complex<float>* y,
+                                  int64_t              incy,
+                                  std::complex<float>  c,
+                                  std::complex<float>  s)
 {
     float c_real = std::real(c);
     lapack_xrot(n, x, incx, y, incy, c_real, s);
 }
 
 template <>
-void ref_rot<hipblasComplex, float>(int64_t         n,
-                                    hipblasComplex* x,
-                                    int64_t         incx,
-                                    hipblasComplex* y,
-                                    int64_t         incy,
-                                    float           c,
-                                    hipblasComplex  s)
+void ref_rot<std::complex<float>, float>(int64_t              n,
+                                         std::complex<float>* x,
+                                         int64_t              incx,
+                                         std::complex<float>* y,
+                                         int64_t              incy,
+                                         float                c,
+                                         std::complex<float>  s)
 {
     lapack_xrot(n, x, incx, y, incy, c, s);
 }
 
 template <>
-void ref_rot<hipblasComplex, float, float>(
-    int64_t n, hipblasComplex* x, int64_t incx, hipblasComplex* y, int64_t incy, float c, float s)
+void ref_rot<std::complex<float>, float, float>(int64_t              n,
+                                                std::complex<float>* x,
+                                                int64_t              incx,
+                                                std::complex<float>* y,
+                                                int64_t              incy,
+                                                float                c,
+                                                float                s)
 {
     lapack_xrot(n, x, incx, y, incy, c, s);
 }
 
 template <>
-void ref_rot<hipblasDoubleComplex>(int64_t               n,
-                                   hipblasDoubleComplex* x,
+void ref_rot<std::complex<double>>(int64_t               n,
+                                   std::complex<double>* x,
                                    int64_t               incx,
-                                   hipblasDoubleComplex* y,
+                                   std::complex<double>* y,
                                    int64_t               incy,
-                                   hipblasDoubleComplex  c,
-                                   hipblasDoubleComplex  s)
+                                   std::complex<double>  c,
+                                   std::complex<double>  s)
 {
     double c_real = std::real(c);
     lapack_xrot(n, x, incx, y, incy, c_real, s);
 }
 
 template <>
-void ref_rot<hipblasDoubleComplex, double>(int64_t               n,
-                                           hipblasDoubleComplex* x,
+void ref_rot<std::complex<double>, double>(int64_t               n,
+                                           std::complex<double>* x,
                                            int64_t               incx,
-                                           hipblasDoubleComplex* y,
+                                           std::complex<double>* y,
                                            int64_t               incy,
                                            double                c,
-                                           hipblasDoubleComplex  s)
+                                           std::complex<double>  s)
 {
     lapack_xrot(n, x, incx, y, incy, c, s);
 }
 
 template <>
-void ref_rot<hipblasDoubleComplex, double, double>(int64_t               n,
-                                                   hipblasDoubleComplex* x,
+void ref_rot<std::complex<double>, double, double>(int64_t               n,
+                                                   std::complex<double>* x,
                                                    int64_t               incx,
-                                                   hipblasDoubleComplex* y,
+                                                   std::complex<double>* y,
                                                    int64_t               incy,
                                                    double                c,
                                                    double                s)
@@ -1018,19 +1027,19 @@ void ref_rotg<double>(double* a, double* b, double* c, double* s)
 }
 
 template <>
-void ref_rotg<hipblasComplex, float>(hipblasComplex* a,
-                                     hipblasComplex* b,
-                                     float*          c,
-                                     hipblasComplex* s)
+void ref_rotg<std::complex<float>, float>(std::complex<float>* a,
+                                          std::complex<float>* b,
+                                          float*               c,
+                                          std::complex<float>* s)
 {
     lapack_xrotg(*a, *b, *c, *s);
 }
 
 template <>
-void ref_rotg<hipblasDoubleComplex, double>(hipblasDoubleComplex* a,
-                                            hipblasDoubleComplex* b,
+void ref_rotg<std::complex<double>, double>(std::complex<double>* a,
+                                            std::complex<double>* b,
                                             double*               c,
-                                            hipblasDoubleComplex* s)
+                                            std::complex<double>* s)
 {
     lapack_xrotg(*a, *b, *c, *s);
 }
@@ -1050,8 +1059,8 @@ void ref_asum<double, double>(int64_t n, const double* x, int64_t incx, double* 
 }
 
 template <>
-void ref_asum<hipblasComplex, float>(int64_t               n,
-                                       const hipblasComplex* x,
+void ref_asum<std::complex<float>, float>(int64_t               n,
+                                       const std::complex<float>* x,
                                        int64_t               incx,
                                        float*                result)
 {
@@ -1059,8 +1068,8 @@ void ref_asum<hipblasComplex, float>(int64_t               n,
 }
 
 template <>
-void ref_asum<hipblasDoubleComplex, double>(int64_t                     n,
-                                              const hipblasDoubleComplex* x,
+void ref_asum<std::complex<double>, double>(int64_t                     n,
+                                              const std::complex<double>* x,
                                               int64_t                     incx,
                                               double*                     result)
 {
@@ -1086,14 +1095,14 @@ void ref_iamax<double>(int64_t n, const double* x, int64_t incx, int64_t* result
 }
 
 template <>
-void ref_iamax<hipblasComplex>(int64_t n, const hipblasComplex* x, int64_t incx, int64_t* result)
+void ref_iamax<std::complex<float>>(int64_t n, const std::complex<float>* x, int64_t incx, int64_t* result)
 {
     *result = (int64_t)cblas_icamax(n, x, incx);
 }
 
 template <>
-void ref_iamax<hipblasDoubleComplex>(int64_t                     n,
-                                     const hipblasDoubleComplex* x,
+void ref_iamax<std::complex<double>>(int64_t                     n,
+                                     const std::complex<double>* x,
                                      int64_t                     incx,
                                      int64_t*                    result)
 {
@@ -1110,13 +1119,13 @@ double hipblas_magnitude(T val)
 }
 
 template <>
-double hipblas_magnitude(hipblasComplex val)
+double hipblas_magnitude(std::complex<float> val)
 {
     return std::abs(val.real()) + std::abs(val.imag());
 }
 
 template <>
-double hipblas_magnitude(hipblasDoubleComplex val)
+double hipblas_magnitude(std::complex<double> val)
 {
     return std::abs(val.real()) + std::abs(val.imag());
 }
@@ -1155,14 +1164,14 @@ void ref_iamin<double>(int64_t n, const double* x, int64_t incx, int64_t* result
 }
 
 template <>
-void ref_iamin<hipblasComplex>(int64_t n, const hipblasComplex* x, int64_t incx, int64_t* result)
+void ref_iamin<std::complex<float>>(int64_t n, const std::complex<float>* x, int64_t incx, int64_t* result)
 {
     *result = (int64_t)ref_iamin_helper(n, x, incx);
 }
 
 template <>
-void ref_iamin<hipblasDoubleComplex>(int64_t                     n,
-                                     const hipblasDoubleComplex* x,
+void ref_iamin<std::complex<double>>(int64_t                     n,
+                                     const std::complex<double>* x,
                                      int64_t                     incx,
                                      int64_t*                    result)
 {
@@ -1240,19 +1249,19 @@ void ref_gbmv<double>(hipblasOperation_t transA,
 }
 
 template <>
-void ref_gbmv<hipblasComplex>(hipblasOperation_t transA,
-                              int64_t            m,
-                              int64_t            n,
-                              int64_t            kl,
-                              int64_t            ku,
-                              hipblasComplex     alpha,
-                              hipblasComplex*    A,
-                              int64_t            lda,
-                              hipblasComplex*    x,
-                              int64_t            incx,
-                              hipblasComplex     beta,
-                              hipblasComplex*    y,
-                              int64_t            incy)
+void ref_gbmv<std::complex<float>>(hipblasOperation_t   transA,
+                                   int64_t              m,
+                                   int64_t              n,
+                                   int64_t              kl,
+                                   int64_t              ku,
+                                   std::complex<float>  alpha,
+                                   std::complex<float>* A,
+                                   int64_t              lda,
+                                   std::complex<float>* x,
+                                   int64_t              incx,
+                                   std::complex<float>  beta,
+                                   std::complex<float>* y,
+                                   int64_t              incy)
 {
     cblas_cgbmv(CblasColMajor,
                 (CBLAS_TRANSPOSE)transA,
@@ -1271,18 +1280,18 @@ void ref_gbmv<hipblasComplex>(hipblasOperation_t transA,
 }
 
 template <>
-void ref_gbmv<hipblasDoubleComplex>(hipblasOperation_t    transA,
+void ref_gbmv<std::complex<double>>(hipblasOperation_t    transA,
                                     int64_t               m,
                                     int64_t               n,
                                     int64_t               kl,
                                     int64_t               ku,
-                                    hipblasDoubleComplex  alpha,
-                                    hipblasDoubleComplex* A,
+                                    std::complex<double>  alpha,
+                                    std::complex<double>* A,
                                     int64_t               lda,
-                                    hipblasDoubleComplex* x,
+                                    std::complex<double>* x,
                                     int64_t               incx,
-                                    hipblasDoubleComplex  beta,
-                                    hipblasDoubleComplex* y,
+                                    std::complex<double>  beta,
+                                    std::complex<double>* y,
                                     int64_t               incy)
 {
     cblas_zgbmv(CblasColMajor,
@@ -1337,33 +1346,33 @@ void ref_gemv<double>(hipblasOperation_t transA,
 }
 
 template <>
-void ref_gemv<hipblasComplex>(hipblasOperation_t transA,
-                              int64_t            m,
-                              int64_t            n,
-                              hipblasComplex     alpha,
-                              hipblasComplex*    A,
-                              int64_t            lda,
-                              hipblasComplex*    x,
-                              int64_t            incx,
-                              hipblasComplex     beta,
-                              hipblasComplex*    y,
-                              int64_t            incy)
+void ref_gemv<std::complex<float>>(hipblasOperation_t   transA,
+                                   int64_t              m,
+                                   int64_t              n,
+                                   std::complex<float>  alpha,
+                                   std::complex<float>* A,
+                                   int64_t              lda,
+                                   std::complex<float>* x,
+                                   int64_t              incx,
+                                   std::complex<float>  beta,
+                                   std::complex<float>* y,
+                                   int64_t              incy)
 {
     cblas_cgemv(
         CblasColMajor, (CBLAS_TRANSPOSE)transA, m, n, &alpha, A, lda, x, incx, &beta, y, incy);
 }
 
 template <>
-void ref_gemv<hipblasDoubleComplex>(hipblasOperation_t    transA,
+void ref_gemv<std::complex<double>>(hipblasOperation_t    transA,
                                     int64_t               m,
                                     int64_t               n,
-                                    hipblasDoubleComplex  alpha,
-                                    hipblasDoubleComplex* A,
+                                    std::complex<double>  alpha,
+                                    std::complex<double>* A,
                                     int64_t               lda,
-                                    hipblasDoubleComplex* x,
+                                    std::complex<double>* x,
                                     int64_t               incx,
-                                    hipblasDoubleComplex  beta,
-                                    hipblasDoubleComplex* y,
+                                    std::complex<double>  beta,
+                                    std::complex<double>* y,
                                     int64_t               incy)
 {
     cblas_zgemv(
@@ -1400,56 +1409,56 @@ void ref_ger<double, false>(int64_t m,
 }
 
 template <>
-void ref_ger<hipblasComplex, false>(int64_t         m,
-                                    int64_t         n,
-                                    hipblasComplex  alpha,
-                                    hipblasComplex* x,
-                                    int64_t         incx,
-                                    hipblasComplex* y,
-                                    int64_t         incy,
-                                    hipblasComplex* A,
-                                    int64_t         lda)
+void ref_ger<std::complex<float>, false>(int64_t              m,
+                                         int64_t              n,
+                                         std::complex<float>  alpha,
+                                         std::complex<float>* x,
+                                         int64_t              incx,
+                                         std::complex<float>* y,
+                                         int64_t              incy,
+                                         std::complex<float>* A,
+                                         int64_t              lda)
 {
     cblas_cgeru(CblasColMajor, m, n, &alpha, x, incx, y, incy, A, lda);
 }
 
 template <>
-void ref_ger<hipblasComplex, true>(int64_t         m,
-                                   int64_t         n,
-                                   hipblasComplex  alpha,
-                                   hipblasComplex* x,
-                                   int64_t         incx,
-                                   hipblasComplex* y,
-                                   int64_t         incy,
-                                   hipblasComplex* A,
-                                   int64_t         lda)
+void ref_ger<std::complex<float>, true>(int64_t              m,
+                                        int64_t              n,
+                                        std::complex<float>  alpha,
+                                        std::complex<float>* x,
+                                        int64_t              incx,
+                                        std::complex<float>* y,
+                                        int64_t              incy,
+                                        std::complex<float>* A,
+                                        int64_t              lda)
 {
     cblas_cgerc(CblasColMajor, m, n, &alpha, x, incx, y, incy, A, lda);
 }
 
 template <>
-void ref_ger<hipblasDoubleComplex, false>(int64_t               m,
+void ref_ger<std::complex<double>, false>(int64_t               m,
                                           int64_t               n,
-                                          hipblasDoubleComplex  alpha,
-                                          hipblasDoubleComplex* x,
+                                          std::complex<double>  alpha,
+                                          std::complex<double>* x,
                                           int64_t               incx,
-                                          hipblasDoubleComplex* y,
+                                          std::complex<double>* y,
                                           int64_t               incy,
-                                          hipblasDoubleComplex* A,
+                                          std::complex<double>* A,
                                           int64_t               lda)
 {
     cblas_zgeru(CblasColMajor, m, n, &alpha, x, incx, y, incy, A, lda);
 }
 
 template <>
-void ref_ger<hipblasDoubleComplex, true>(int64_t               m,
+void ref_ger<std::complex<double>, true>(int64_t               m,
                                          int64_t               n,
-                                         hipblasDoubleComplex  alpha,
-                                         hipblasDoubleComplex* x,
+                                         std::complex<double>  alpha,
+                                         std::complex<double>* x,
                                          int64_t               incx,
-                                         hipblasDoubleComplex* y,
+                                         std::complex<double>* y,
                                          int64_t               incy,
-                                         hipblasDoubleComplex* A,
+                                         std::complex<double>* A,
                                          int64_t               lda)
 {
     cblas_zgerc(CblasColMajor, m, n, &alpha, x, incx, y, incy, A, lda);
@@ -1457,32 +1466,32 @@ void ref_ger<hipblasDoubleComplex, true>(int64_t               m,
 
 // hbmv
 template <>
-void ref_hbmv<hipblasComplex>(hipblasFillMode_t uplo,
-                              int64_t           n,
-                              int64_t           k,
-                              hipblasComplex    alpha,
-                              hipblasComplex*   A,
-                              int64_t           lda,
-                              hipblasComplex*   x,
-                              int64_t           incx,
-                              hipblasComplex    beta,
-                              hipblasComplex*   y,
-                              int64_t           incy)
+void ref_hbmv<std::complex<float>>(hipblasFillMode_t    uplo,
+                                   int64_t              n,
+                                   int64_t              k,
+                                   std::complex<float>  alpha,
+                                   std::complex<float>* A,
+                                   int64_t              lda,
+                                   std::complex<float>* x,
+                                   int64_t              incx,
+                                   std::complex<float>  beta,
+                                   std::complex<float>* y,
+                                   int64_t              incy)
 {
     cblas_chbmv(CblasColMajor, (CBLAS_UPLO)uplo, n, k, &alpha, A, lda, x, incx, &beta, y, incy);
 }
 
 template <>
-void ref_hbmv<hipblasDoubleComplex>(hipblasFillMode_t     uplo,
+void ref_hbmv<std::complex<double>>(hipblasFillMode_t     uplo,
                                     int64_t               n,
                                     int64_t               k,
-                                    hipblasDoubleComplex  alpha,
-                                    hipblasDoubleComplex* A,
+                                    std::complex<double>  alpha,
+                                    std::complex<double>* A,
                                     int64_t               lda,
-                                    hipblasDoubleComplex* x,
+                                    std::complex<double>* x,
                                     int64_t               incx,
-                                    hipblasDoubleComplex  beta,
-                                    hipblasDoubleComplex* y,
+                                    std::complex<double>  beta,
+                                    std::complex<double>* y,
                                     int64_t               incy)
 {
     cblas_zhbmv(CblasColMajor, (CBLAS_UPLO)uplo, n, k, &alpha, A, lda, x, incx, &beta, y, incy);
@@ -1490,30 +1499,30 @@ void ref_hbmv<hipblasDoubleComplex>(hipblasFillMode_t     uplo,
 
 // hemv
 template <>
-void ref_hemv<hipblasComplex>(hipblasFillMode_t uplo,
-                              int64_t           n,
-                              hipblasComplex    alpha,
-                              hipblasComplex*   A,
-                              int64_t           lda,
-                              hipblasComplex*   x,
-                              int64_t           incx,
-                              hipblasComplex    beta,
-                              hipblasComplex*   y,
-                              int64_t           incy)
+void ref_hemv<std::complex<float>>(hipblasFillMode_t    uplo,
+                                   int64_t              n,
+                                   std::complex<float>  alpha,
+                                   std::complex<float>* A,
+                                   int64_t              lda,
+                                   std::complex<float>* x,
+                                   int64_t              incx,
+                                   std::complex<float>  beta,
+                                   std::complex<float>* y,
+                                   int64_t              incy)
 {
     cblas_chemv(CblasColMajor, (CBLAS_UPLO)uplo, n, &alpha, A, lda, x, incx, &beta, y, incy);
 }
 
 template <>
-void ref_hemv<hipblasDoubleComplex>(hipblasFillMode_t     uplo,
+void ref_hemv<std::complex<double>>(hipblasFillMode_t     uplo,
                                     int64_t               n,
-                                    hipblasDoubleComplex  alpha,
-                                    hipblasDoubleComplex* A,
+                                    std::complex<double>  alpha,
+                                    std::complex<double>* A,
                                     int64_t               lda,
-                                    hipblasDoubleComplex* x,
+                                    std::complex<double>* x,
                                     int64_t               incx,
-                                    hipblasDoubleComplex  beta,
-                                    hipblasDoubleComplex* y,
+                                    std::complex<double>  beta,
+                                    std::complex<double>* y,
                                     int64_t               incy)
 {
     cblas_zhemv(CblasColMajor, (CBLAS_UPLO)uplo, n, &alpha, A, lda, x, incx, &beta, y, incy);
@@ -1521,24 +1530,24 @@ void ref_hemv<hipblasDoubleComplex>(hipblasFillMode_t     uplo,
 
 // her
 template <>
-void ref_her<hipblasComplex, float>(hipblasFillMode_t uplo,
-                                    int64_t           n,
-                                    float             alpha,
-                                    hipblasComplex*   x,
-                                    int64_t           incx,
-                                    hipblasComplex*   A,
-                                    int64_t           lda)
+void ref_her<std::complex<float>, float>(hipblasFillMode_t    uplo,
+                                         int64_t              n,
+                                         float                alpha,
+                                         std::complex<float>* x,
+                                         int64_t              incx,
+                                         std::complex<float>* A,
+                                         int64_t              lda)
 {
     cblas_cher(CblasColMajor, (CBLAS_UPLO)uplo, n, alpha, x, incx, A, lda);
 }
 
 template <>
-void ref_her<hipblasDoubleComplex, double>(hipblasFillMode_t     uplo,
+void ref_her<std::complex<double>, double>(hipblasFillMode_t     uplo,
                                            int64_t               n,
                                            double                alpha,
-                                           hipblasDoubleComplex* x,
+                                           std::complex<double>* x,
                                            int64_t               incx,
-                                           hipblasDoubleComplex* A,
+                                           std::complex<double>* A,
                                            int64_t               lda)
 {
     cblas_zher(CblasColMajor, (CBLAS_UPLO)uplo, n, alpha, x, incx, A, lda);
@@ -1546,28 +1555,28 @@ void ref_her<hipblasDoubleComplex, double>(hipblasFillMode_t     uplo,
 
 // her2
 template <>
-void ref_her2<hipblasComplex>(hipblasFillMode_t uplo,
-                              int64_t           n,
-                              hipblasComplex    alpha,
-                              hipblasComplex*   x,
-                              int64_t           incx,
-                              hipblasComplex*   y,
-                              int64_t           incy,
-                              hipblasComplex*   A,
-                              int64_t           lda)
+void ref_her2<std::complex<float>>(hipblasFillMode_t    uplo,
+                                   int64_t              n,
+                                   std::complex<float>  alpha,
+                                   std::complex<float>* x,
+                                   int64_t              incx,
+                                   std::complex<float>* y,
+                                   int64_t              incy,
+                                   std::complex<float>* A,
+                                   int64_t              lda)
 {
     cblas_cher2(CblasColMajor, (CBLAS_UPLO)uplo, n, &alpha, x, incx, y, incy, A, lda);
 }
 
 template <>
-void ref_her2<hipblasDoubleComplex>(hipblasFillMode_t     uplo,
+void ref_her2<std::complex<double>>(hipblasFillMode_t     uplo,
                                     int64_t               n,
-                                    hipblasDoubleComplex  alpha,
-                                    hipblasDoubleComplex* x,
+                                    std::complex<double>  alpha,
+                                    std::complex<double>* x,
                                     int64_t               incx,
-                                    hipblasDoubleComplex* y,
+                                    std::complex<double>* y,
                                     int64_t               incy,
-                                    hipblasDoubleComplex* A,
+                                    std::complex<double>* A,
                                     int64_t               lda)
 {
     cblas_zher2(CblasColMajor, (CBLAS_UPLO)uplo, n, &alpha, x, incx, y, incy, A, lda);
@@ -1575,28 +1584,28 @@ void ref_her2<hipblasDoubleComplex>(hipblasFillMode_t     uplo,
 
 // hpmv
 template <>
-void ref_hpmv<hipblasComplex>(hipblasFillMode_t uplo,
-                              int64_t           n,
-                              hipblasComplex    alpha,
-                              hipblasComplex*   AP,
-                              hipblasComplex*   x,
-                              int64_t           incx,
-                              hipblasComplex    beta,
-                              hipblasComplex*   y,
-                              int64_t           incy)
+void ref_hpmv<std::complex<float>>(hipblasFillMode_t    uplo,
+                                   int64_t              n,
+                                   std::complex<float>  alpha,
+                                   std::complex<float>* AP,
+                                   std::complex<float>* x,
+                                   int64_t              incx,
+                                   std::complex<float>  beta,
+                                   std::complex<float>* y,
+                                   int64_t              incy)
 {
     cblas_chpmv(CblasColMajor, (CBLAS_UPLO)uplo, n, &alpha, AP, x, incx, &beta, y, incy);
 }
 
 template <>
-void ref_hpmv<hipblasDoubleComplex>(hipblasFillMode_t     uplo,
+void ref_hpmv<std::complex<double>>(hipblasFillMode_t     uplo,
                                     int64_t               n,
-                                    hipblasDoubleComplex  alpha,
-                                    hipblasDoubleComplex* AP,
-                                    hipblasDoubleComplex* x,
+                                    std::complex<double>  alpha,
+                                    std::complex<double>* AP,
+                                    std::complex<double>* x,
                                     int64_t               incx,
-                                    hipblasDoubleComplex  beta,
-                                    hipblasDoubleComplex* y,
+                                    std::complex<double>  beta,
+                                    std::complex<double>* y,
                                     int64_t               incy)
 {
     cblas_zhpmv(CblasColMajor, (CBLAS_UPLO)uplo, n, &alpha, AP, x, incx, &beta, y, incy);
@@ -1604,12 +1613,12 @@ void ref_hpmv<hipblasDoubleComplex>(hipblasFillMode_t     uplo,
 
 // hpr
 template <>
-void ref_hpr(hipblasFillMode_t uplo,
-             int64_t           n,
-             float             alpha,
-             hipblasComplex*   x,
-             int64_t           incx,
-             hipblasComplex*   AP)
+void ref_hpr(hipblasFillMode_t    uplo,
+             int64_t              n,
+             float                alpha,
+             std::complex<float>* x,
+             int64_t              incx,
+             std::complex<float>* AP)
 {
     cblas_chpr(CblasColMajor, (CBLAS_UPLO)uplo, n, alpha, x, incx, AP);
 }
@@ -1618,23 +1627,23 @@ template <>
 void ref_hpr(hipblasFillMode_t     uplo,
              int64_t               n,
              double                alpha,
-             hipblasDoubleComplex* x,
+             std::complex<double>* x,
              int64_t               incx,
-             hipblasDoubleComplex* AP)
+             std::complex<double>* AP)
 {
     cblas_zhpr(CblasColMajor, (CBLAS_UPLO)uplo, n, alpha, x, incx, AP);
 }
 
 // hpr2
 template <>
-void ref_hpr2(hipblasFillMode_t uplo,
-              int64_t           n,
-              hipblasComplex    alpha,
-              hipblasComplex*   x,
-              int64_t           incx,
-              hipblasComplex*   y,
-              int64_t           incy,
-              hipblasComplex*   AP)
+void ref_hpr2(hipblasFillMode_t    uplo,
+              int64_t              n,
+              std::complex<float>  alpha,
+              std::complex<float>* x,
+              int64_t              incx,
+              std::complex<float>* y,
+              int64_t              incy,
+              std::complex<float>* AP)
 {
     cblas_chpr2(CblasColMajor, (CBLAS_UPLO)uplo, n, &alpha, x, incx, y, incy, AP);
 }
@@ -1642,12 +1651,12 @@ void ref_hpr2(hipblasFillMode_t uplo,
 template <>
 void ref_hpr2(hipblasFillMode_t     uplo,
               int64_t               n,
-              hipblasDoubleComplex  alpha,
-              hipblasDoubleComplex* x,
+              std::complex<double>  alpha,
+              std::complex<double>* x,
               int64_t               incx,
-              hipblasDoubleComplex* y,
+              std::complex<double>* y,
               int64_t               incy,
-              hipblasDoubleComplex* AP)
+              std::complex<double>* AP)
 {
     cblas_zhpr2(CblasColMajor, (CBLAS_UPLO)uplo, n, &alpha, x, incx, y, incy, AP);
 }
@@ -1728,12 +1737,12 @@ void ref_spr(hipblasFillMode_t uplo, int64_t n, double alpha, double* x, int64_t
 }
 
 template <>
-void ref_spr(hipblasFillMode_t uplo,
-             int64_t           n,
-             hipblasComplex    alpha,
-             hipblasComplex*   x,
-             int64_t           incx,
-             hipblasComplex*   AP)
+void ref_spr(hipblasFillMode_t    uplo,
+             int64_t              n,
+             std::complex<float>  alpha,
+             std::complex<float>* x,
+             int64_t              incx,
+             std::complex<float>* AP)
 {
     lapack_xspr(uplo, n, alpha, x, incx, AP);
 }
@@ -1741,10 +1750,10 @@ void ref_spr(hipblasFillMode_t uplo,
 template <>
 void ref_spr(hipblasFillMode_t     uplo,
              int64_t               n,
-             hipblasDoubleComplex  alpha,
-             hipblasDoubleComplex* x,
+             std::complex<double>  alpha,
+             std::complex<double>* x,
              int64_t               incx,
-             hipblasDoubleComplex* AP)
+             std::complex<double>* AP)
 {
     lapack_xspr(uplo, n, alpha, x, incx, AP);
 }
@@ -1808,16 +1817,16 @@ void ref_symv(hipblasFillMode_t uplo,
 }
 
 template <>
-void ref_symv(hipblasFillMode_t uplo,
-              int64_t           n,
-              hipblasComplex    alpha,
-              hipblasComplex*   A,
-              int64_t           lda,
-              hipblasComplex*   x,
-              int64_t           incx,
-              hipblasComplex    beta,
-              hipblasComplex*   y,
-              int64_t           incy)
+void ref_symv(hipblasFillMode_t    uplo,
+              int64_t              n,
+              std::complex<float>  alpha,
+              std::complex<float>* A,
+              int64_t              lda,
+              std::complex<float>* x,
+              int64_t              incx,
+              std::complex<float>  beta,
+              std::complex<float>* y,
+              int64_t              incy)
 {
     lapack_xsymv(uplo, n, alpha, A, lda, x, incx, beta, y, incy);
 }
@@ -1825,13 +1834,13 @@ void ref_symv(hipblasFillMode_t uplo,
 template <>
 void ref_symv(hipblasFillMode_t     uplo,
               int64_t               n,
-              hipblasDoubleComplex  alpha,
-              hipblasDoubleComplex* A,
+              std::complex<double>  alpha,
+              std::complex<double>* A,
               int64_t               lda,
-              hipblasDoubleComplex* x,
+              std::complex<double>* x,
               int64_t               incx,
-              hipblasDoubleComplex  beta,
-              hipblasDoubleComplex* y,
+              std::complex<double>  beta,
+              std::complex<double>* y,
               int64_t               incy)
 {
     lapack_xsymv(uplo, n, alpha, A, lda, x, incx, beta, y, incy);
@@ -1858,13 +1867,13 @@ void ref_syr<double>(hipblasFillMode_t uplo,
 }
 
 template <>
-void ref_syr(hipblasFillMode_t uplo,
-             int64_t           n,
-             hipblasComplex    alpha,
-             hipblasComplex*   xa,
-             int64_t           incx,
-             hipblasComplex*   A,
-             int64_t           lda)
+void ref_syr(hipblasFillMode_t    uplo,
+             int64_t              n,
+             std::complex<float>  alpha,
+             std::complex<float>* xa,
+             int64_t              incx,
+             std::complex<float>* A,
+             int64_t              lda)
 {
     lapack_xsyr(uplo, n, alpha, xa, incx, A, lda);
 }
@@ -1872,10 +1881,10 @@ void ref_syr(hipblasFillMode_t uplo,
 template <>
 void ref_syr(hipblasFillMode_t     uplo,
              int64_t               n,
-             hipblasDoubleComplex  alpha,
-             hipblasDoubleComplex* xa,
+             std::complex<double>  alpha,
+             std::complex<double>* xa,
              int64_t               incx,
-             hipblasDoubleComplex* A,
+             std::complex<double>* A,
              int64_t               lda)
 {
     lapack_xsyr(uplo, n, alpha, xa, incx, A, lda);
@@ -1912,15 +1921,15 @@ void ref_syr2(hipblasFillMode_t uplo,
 }
 
 template <>
-void ref_syr2(hipblasFillMode_t uplo,
-              int64_t           n,
-              hipblasComplex    alpha,
-              hipblasComplex*   x,
-              int64_t           incx,
-              hipblasComplex*   y,
-              int64_t           incy,
-              hipblasComplex*   A,
-              int64_t           lda)
+void ref_syr2(hipblasFillMode_t    uplo,
+              int64_t              n,
+              std::complex<float>  alpha,
+              std::complex<float>* x,
+              int64_t              incx,
+              std::complex<float>* y,
+              int64_t              incy,
+              std::complex<float>* A,
+              int64_t              lda)
 {
     lapack_xsyr2(uplo, n, alpha, x, incx, y, incy, A, lda);
 }
@@ -1928,12 +1937,12 @@ void ref_syr2(hipblasFillMode_t uplo,
 template <>
 void ref_syr2(hipblasFillMode_t     uplo,
               int64_t               n,
-              hipblasDoubleComplex  alpha,
-              hipblasDoubleComplex* x,
+              std::complex<double>  alpha,
+              std::complex<double>* x,
               int64_t               incx,
-              hipblasDoubleComplex* y,
+              std::complex<double>* y,
               int64_t               incy,
-              hipblasDoubleComplex* A,
+              std::complex<double>* A,
               int64_t               lda)
 {
     lapack_xsyr2(uplo, n, alpha, x, incx, y, incy, A, lda);
@@ -1987,15 +1996,15 @@ void ref_tbmv<double>(hipblasFillMode_t  uplo,
 }
 
 template <>
-void ref_tbmv<hipblasComplex>(hipblasFillMode_t     uplo,
-                              hipblasOperation_t    transA,
-                              hipblasDiagType_t     diag,
-                              int64_t               m,
-                              int64_t               k,
-                              const hipblasComplex* A,
-                              int64_t               lda,
-                              hipblasComplex*       x,
-                              int64_t               incx)
+void ref_tbmv<std::complex<float>>(hipblasFillMode_t          uplo,
+                                   hipblasOperation_t         transA,
+                                   hipblasDiagType_t          diag,
+                                   int64_t                    m,
+                                   int64_t                    k,
+                                   const std::complex<float>* A,
+                                   int64_t                    lda,
+                                   std::complex<float>*       x,
+                                   int64_t                    incx)
 {
     cblas_ctbmv(CblasColMajor,
                 CBLAS_UPLO(uplo),
@@ -2010,14 +2019,14 @@ void ref_tbmv<hipblasComplex>(hipblasFillMode_t     uplo,
 }
 
 template <>
-void ref_tbmv<hipblasDoubleComplex>(hipblasFillMode_t           uplo,
+void ref_tbmv<std::complex<double>>(hipblasFillMode_t           uplo,
                                     hipblasOperation_t          transA,
                                     hipblasDiagType_t           diag,
                                     int64_t                     m,
                                     int64_t                     k,
-                                    const hipblasDoubleComplex* A,
+                                    const std::complex<double>* A,
                                     int64_t                     lda,
-                                    hipblasDoubleComplex*       x,
+                                    std::complex<double>*       x,
                                     int64_t                     incx)
 {
     cblas_ztbmv(CblasColMajor,
@@ -2080,15 +2089,15 @@ void ref_tbsv<double>(hipblasFillMode_t  uplo,
 }
 
 template <>
-void ref_tbsv<hipblasComplex>(hipblasFillMode_t     uplo,
-                              hipblasOperation_t    transA,
-                              hipblasDiagType_t     diag,
-                              int64_t               m,
-                              int64_t               k,
-                              const hipblasComplex* A,
-                              int64_t               lda,
-                              hipblasComplex*       x,
-                              int64_t               incx)
+void ref_tbsv<std::complex<float>>(hipblasFillMode_t          uplo,
+                                   hipblasOperation_t         transA,
+                                   hipblasDiagType_t          diag,
+                                   int64_t                    m,
+                                   int64_t                    k,
+                                   const std::complex<float>* A,
+                                   int64_t                    lda,
+                                   std::complex<float>*       x,
+                                   int64_t                    incx)
 {
     cblas_ctbsv(CblasColMajor,
                 CBLAS_UPLO(uplo),
@@ -2103,14 +2112,14 @@ void ref_tbsv<hipblasComplex>(hipblasFillMode_t     uplo,
 }
 
 template <>
-void ref_tbsv<hipblasDoubleComplex>(hipblasFillMode_t           uplo,
+void ref_tbsv<std::complex<double>>(hipblasFillMode_t           uplo,
                                     hipblasOperation_t          transA,
                                     hipblasDiagType_t           diag,
                                     int64_t                     m,
                                     int64_t                     k,
-                                    const hipblasDoubleComplex* A,
+                                    const std::complex<double>* A,
                                     int64_t                     lda,
-                                    hipblasDoubleComplex*       x,
+                                    std::complex<double>*       x,
                                     int64_t                     incx)
 {
     cblas_ztbsv(CblasColMajor,
@@ -2153,13 +2162,13 @@ void ref_tpmv(hipblasFillMode_t  uplo,
 }
 
 template <>
-void ref_tpmv(hipblasFillMode_t     uplo,
-              hipblasOperation_t    transA,
-              hipblasDiagType_t     diag,
-              int64_t               m,
-              const hipblasComplex* A,
-              hipblasComplex*       x,
-              int64_t               incx)
+void ref_tpmv(hipblasFillMode_t          uplo,
+              hipblasOperation_t         transA,
+              hipblasDiagType_t          diag,
+              int64_t                    m,
+              const std::complex<float>* A,
+              std::complex<float>*       x,
+              int64_t                    incx)
 {
     cblas_ctpmv(
         CblasColMajor, CBLAS_UPLO(uplo), CBLAS_TRANSPOSE(transA), CBLAS_DIAG(diag), m, A, x, incx);
@@ -2170,8 +2179,8 @@ void ref_tpmv(hipblasFillMode_t           uplo,
               hipblasOperation_t          transA,
               hipblasDiagType_t           diag,
               int64_t                     m,
-              const hipblasDoubleComplex* A,
-              hipblasDoubleComplex*       x,
+              const std::complex<double>* A,
+              std::complex<double>*       x,
               int64_t                     incx)
 {
     cblas_ztpmv(
@@ -2206,13 +2215,13 @@ void ref_tpsv(hipblasFillMode_t  uplo,
 }
 
 template <>
-void ref_tpsv(hipblasFillMode_t     uplo,
-              hipblasOperation_t    transA,
-              hipblasDiagType_t     diag,
-              int64_t               n,
-              const hipblasComplex* AP,
-              hipblasComplex*       x,
-              int64_t               incx)
+void ref_tpsv(hipblasFillMode_t          uplo,
+              hipblasOperation_t         transA,
+              hipblasDiagType_t          diag,
+              int64_t                    n,
+              const std::complex<float>* AP,
+              std::complex<float>*       x,
+              int64_t                    incx)
 {
     cblas_ctpsv(
         CblasColMajor, CBLAS_UPLO(uplo), CBLAS_TRANSPOSE(transA), CBLAS_DIAG(diag), n, AP, x, incx);
@@ -2223,8 +2232,8 @@ void ref_tpsv(hipblasFillMode_t           uplo,
               hipblasOperation_t          transA,
               hipblasDiagType_t           diag,
               int64_t                     n,
-              const hipblasDoubleComplex* AP,
-              hipblasDoubleComplex*       x,
+              const std::complex<double>* AP,
+              std::complex<double>*       x,
               int64_t                     incx)
 {
     cblas_ztpsv(
@@ -2275,14 +2284,14 @@ void ref_trmv<double>(hipblasFillMode_t  uplo,
 }
 
 template <>
-void ref_trmv<hipblasComplex>(hipblasFillMode_t     uplo,
-                              hipblasOperation_t    transA,
-                              hipblasDiagType_t     diag,
-                              int64_t               m,
-                              const hipblasComplex* A,
-                              int64_t               lda,
-                              hipblasComplex*       x,
-                              int64_t               incx)
+void ref_trmv<std::complex<float>>(hipblasFillMode_t          uplo,
+                                   hipblasOperation_t         transA,
+                                   hipblasDiagType_t          diag,
+                                   int64_t                    m,
+                                   const std::complex<float>* A,
+                                   int64_t                    lda,
+                                   std::complex<float>*       x,
+                                   int64_t                    incx)
 {
     cblas_ctrmv(CblasColMajor,
                 CBLAS_UPLO(uplo),
@@ -2296,13 +2305,13 @@ void ref_trmv<hipblasComplex>(hipblasFillMode_t     uplo,
 }
 
 template <>
-void ref_trmv<hipblasDoubleComplex>(hipblasFillMode_t           uplo,
+void ref_trmv<std::complex<double>>(hipblasFillMode_t           uplo,
                                     hipblasOperation_t          transA,
                                     hipblasDiagType_t           diag,
                                     int64_t                     m,
-                                    const hipblasDoubleComplex* A,
+                                    const std::complex<double>* A,
                                     int64_t                     lda,
-                                    hipblasDoubleComplex*       x,
+                                    std::complex<double>*       x,
                                     int64_t                     incx)
 {
     cblas_ztrmv(CblasColMajor,
@@ -2362,15 +2371,15 @@ void ref_trsv<double>(hipblasHandle_t    handle,
 }
 
 template <>
-void ref_trsv<hipblasComplex>(hipblasHandle_t       handle,
-                              hipblasFillMode_t     uplo,
-                              hipblasOperation_t    transA,
-                              hipblasDiagType_t     diag,
-                              int64_t               m,
-                              const hipblasComplex* A,
-                              int64_t               lda,
-                              hipblasComplex*       x,
-                              int64_t               incx)
+void ref_trsv<std::complex<float>>(hipblasHandle_t            handle,
+                                   hipblasFillMode_t          uplo,
+                                   hipblasOperation_t         transA,
+                                   hipblasDiagType_t          diag,
+                                   int64_t                    m,
+                                   const std::complex<float>* A,
+                                   int64_t                    lda,
+                                   std::complex<float>*       x,
+                                   int64_t                    incx)
 {
     cblas_ctrsv(CblasColMajor,
                 CBLAS_UPLO(uplo),
@@ -2384,14 +2393,14 @@ void ref_trsv<hipblasComplex>(hipblasHandle_t       handle,
 }
 
 template <>
-void ref_trsv<hipblasDoubleComplex>(hipblasHandle_t             handle,
+void ref_trsv<std::complex<double>>(hipblasHandle_t             handle,
                                     hipblasFillMode_t           uplo,
                                     hipblasOperation_t          transA,
                                     hipblasDiagType_t           diag,
                                     int64_t                     m,
-                                    const hipblasDoubleComplex* A,
+                                    const std::complex<double>* A,
                                     int64_t                     lda,
-                                    hipblasDoubleComplex*       x,
+                                    std::complex<double>*       x,
                                     int64_t                     incx)
 {
     cblas_ztrsv(CblasColMajor,
@@ -2436,10 +2445,13 @@ void ref_geam_helper(hipblasOperation_t transA,
         {
             T a_val = A[i * inc1_A + j * inc2_A];
             T b_val = B[i * inc1_B + j * inc2_B];
-            if(transA == HIPBLAS_OP_C)
-                a_val = std::conj(a_val);
-            if(transB == HIPBLAS_OP_C)
-                b_val = std::conj(b_val);
+            if constexpr(is_complex<T>)
+            {
+                if(transA == HIPBLAS_OP_C)
+                    a_val = std::conj(a_val);
+                if(transB == HIPBLAS_OP_C)
+                    b_val = std::conj(b_val);
+            }
             C[i + j * ldc] = alpha * a_val + beta * b_val;
         }
     }
@@ -2503,15 +2515,15 @@ void ref_dgmm(hipblasSideMode_t side,
 }
 
 template <>
-void ref_dgmm(hipblasSideMode_t     side,
-              int64_t               M,
-              int64_t               N,
-              const hipblasComplex* A,
-              int64_t               lda,
-              const hipblasComplex* x,
-              int64_t               incx,
-              hipblasComplex*       C,
-              int64_t               ldc)
+void ref_dgmm(hipblasSideMode_t          side,
+              int64_t                    M,
+              int64_t                    N,
+              const std::complex<float>* A,
+              int64_t                    lda,
+              const std::complex<float>* x,
+              int64_t                    incx,
+              std::complex<float>*       C,
+              int64_t                    ldc)
 {
     ref_dgmm_helper(side, M, N, A, lda, x, incx, C, ldc);
 }
@@ -2520,11 +2532,11 @@ template <>
 void ref_dgmm(hipblasSideMode_t           side,
               int64_t                     M,
               int64_t                     N,
-              const hipblasDoubleComplex* A,
+              const std::complex<double>* A,
               int64_t                     lda,
-              const hipblasDoubleComplex* x,
+              const std::complex<double>* x,
               int64_t                     incx,
-              hipblasDoubleComplex*       C,
+              std::complex<double>*       C,
               int64_t                     ldc)
 {
     ref_dgmm_helper(side, M, N, A, lda, x, incx, C, ldc);
@@ -2566,18 +2578,18 @@ void ref_geam(hipblasOperation_t transa,
 }
 
 template <>
-void ref_geam(hipblasOperation_t transa,
-              hipblasOperation_t transb,
-              int64_t            m,
-              int64_t            n,
-              hipblasComplex*    alpha,
-              hipblasComplex*    A,
-              int64_t            lda,
-              hipblasComplex*    beta,
-              hipblasComplex*    B,
-              int64_t            ldb,
-              hipblasComplex*    C,
-              int64_t            ldc)
+void ref_geam(hipblasOperation_t   transa,
+              hipblasOperation_t   transb,
+              int64_t              m,
+              int64_t              n,
+              std::complex<float>* alpha,
+              std::complex<float>* A,
+              int64_t              lda,
+              std::complex<float>* beta,
+              std::complex<float>* B,
+              int64_t              ldb,
+              std::complex<float>* C,
+              int64_t              ldc)
 {
     return ref_geam_helper(transa, transb, m, n, *alpha, A, lda, *beta, B, ldb, C, ldc);
 }
@@ -2587,13 +2599,13 @@ void ref_geam(hipblasOperation_t    transa,
               hipblasOperation_t    transb,
               int64_t               m,
               int64_t               n,
-              hipblasDoubleComplex* alpha,
-              hipblasDoubleComplex* A,
+              std::complex<double>* alpha,
+              std::complex<double>* A,
               int64_t               lda,
-              hipblasDoubleComplex* beta,
-              hipblasDoubleComplex* B,
+              std::complex<double>* beta,
+              std::complex<double>* B,
               int64_t               ldb,
-              hipblasDoubleComplex* C,
+              std::complex<double>* C,
               int64_t               ldc)
 {
     return ref_geam_helper(transa, transb, m, n, *alpha, A, lda, *beta, B, ldb, C, ldc);
@@ -2955,19 +2967,19 @@ void ref_gemm<double>(hipblasOperation_t transA,
 }
 
 template <>
-void ref_gemm<hipblasComplex>(hipblasOperation_t transA,
-                              hipblasOperation_t transB,
-                              int64_t            m,
-                              int64_t            n,
-                              int64_t            k,
-                              hipblasComplex     alpha,
-                              hipblasComplex*    A,
-                              int64_t            lda,
-                              hipblasComplex*    B,
-                              int64_t            ldb,
-                              hipblasComplex     beta,
-                              hipblasComplex*    C,
-                              int64_t            ldc)
+void ref_gemm<std::complex<float>>(hipblasOperation_t   transA,
+                                   hipblasOperation_t   transB,
+                                   int64_t              m,
+                                   int64_t              n,
+                                   int64_t              k,
+                                   std::complex<float>  alpha,
+                                   std::complex<float>* A,
+                                   int64_t              lda,
+                                   std::complex<float>* B,
+                                   int64_t              ldb,
+                                   std::complex<float>  beta,
+                                   std::complex<float>* C,
+                                   int64_t              ldc)
 {
     //just directly cast, since transA, transB are integers in the enum
     cblas_cgemm(CblasColMajor,
@@ -2987,18 +2999,18 @@ void ref_gemm<hipblasComplex>(hipblasOperation_t transA,
 }
 
 template <>
-void ref_gemm<hipblasDoubleComplex>(hipblasOperation_t    transA,
+void ref_gemm<std::complex<double>>(hipblasOperation_t    transA,
                                     hipblasOperation_t    transB,
                                     int64_t               m,
                                     int64_t               n,
                                     int64_t               k,
-                                    hipblasDoubleComplex  alpha,
-                                    hipblasDoubleComplex* A,
+                                    std::complex<double>  alpha,
+                                    std::complex<double>* A,
                                     int64_t               lda,
-                                    hipblasDoubleComplex* B,
+                                    std::complex<double>* B,
                                     int64_t               ldb,
-                                    hipblasDoubleComplex  beta,
-                                    hipblasDoubleComplex* C,
+                                    std::complex<double>  beta,
+                                    std::complex<double>* C,
                                     int64_t               ldc)
 {
     cblas_zgemm(CblasColMajor,
@@ -3077,18 +3089,18 @@ void ref_gemm<int8_t, int32_t, int32_t>(hipblasOperation_t transA,
 
 // hemm
 template <>
-void ref_hemm(hipblasSideMode_t side,
-              hipblasFillMode_t uplo,
-              int64_t           m,
-              int64_t           n,
-              hipblasComplex    alpha,
-              hipblasComplex*   A,
-              int64_t           lda,
-              hipblasComplex*   B,
-              int64_t           ldb,
-              hipblasComplex    beta,
-              hipblasComplex*   C,
-              int64_t           ldc)
+void ref_hemm(hipblasSideMode_t    side,
+              hipblasFillMode_t    uplo,
+              int64_t              m,
+              int64_t              n,
+              std::complex<float>  alpha,
+              std::complex<float>* A,
+              int64_t              lda,
+              std::complex<float>* B,
+              int64_t              ldb,
+              std::complex<float>  beta,
+              std::complex<float>* C,
+              int64_t              ldc)
 {
     cblas_chemm(CblasColMajor,
                 (CBLAS_SIDE)side,
@@ -3110,13 +3122,13 @@ void ref_hemm(hipblasSideMode_t     side,
               hipblasFillMode_t     uplo,
               int64_t               m,
               int64_t               n,
-              hipblasDoubleComplex  alpha,
-              hipblasDoubleComplex* A,
+              std::complex<double>  alpha,
+              std::complex<double>* A,
               int64_t               lda,
-              hipblasDoubleComplex* B,
+              std::complex<double>* B,
               int64_t               ldb,
-              hipblasDoubleComplex  beta,
-              hipblasDoubleComplex* C,
+              std::complex<double>  beta,
+              std::complex<double>* C,
               int64_t               ldc)
 {
     cblas_zhemm(CblasColMajor,
@@ -3136,16 +3148,16 @@ void ref_hemm(hipblasSideMode_t     side,
 
 // herk
 template <>
-void ref_herk(hipblasFillMode_t  uplo,
-              hipblasOperation_t transA,
-              int64_t            n,
-              int64_t            k,
-              float              alpha,
-              hipblasComplex*    A,
-              int64_t            lda,
-              float              beta,
-              hipblasComplex*    C,
-              int64_t            ldc)
+void ref_herk(hipblasFillMode_t    uplo,
+              hipblasOperation_t   transA,
+              int64_t              n,
+              int64_t              k,
+              float                alpha,
+              std::complex<float>* A,
+              int64_t              lda,
+              float                beta,
+              std::complex<float>* C,
+              int64_t              ldc)
 {
     cblas_cherk(CblasColMajor,
                 (CBLAS_UPLO)uplo,
@@ -3166,10 +3178,10 @@ void ref_herk(hipblasFillMode_t     uplo,
               int64_t               n,
               int64_t               k,
               double                alpha,
-              hipblasDoubleComplex* A,
+              std::complex<double>* A,
               int64_t               lda,
               double                beta,
-              hipblasDoubleComplex* C,
+              std::complex<double>* C,
               int64_t               ldc)
 {
     cblas_zherk(CblasColMajor,
@@ -3270,18 +3282,18 @@ void ref_herkx_local(hipblasFillMode_t  uplo,
 }
 
 template <>
-void ref_herkx(hipblasFillMode_t  uplo,
-               hipblasOperation_t transA,
-               int64_t            n,
-               int64_t            k,
-               hipblasComplex     alpha,
-               hipblasComplex*    A,
-               int64_t            lda,
-               hipblasComplex*    B,
-               int64_t            ldb,
-               float              beta,
-               hipblasComplex*    C,
-               int64_t            ldc)
+void ref_herkx(hipblasFillMode_t    uplo,
+               hipblasOperation_t   transA,
+               int64_t              n,
+               int64_t              k,
+               std::complex<float>  alpha,
+               std::complex<float>* A,
+               int64_t              lda,
+               std::complex<float>* B,
+               int64_t              ldb,
+               float                beta,
+               std::complex<float>* C,
+               int64_t              ldc)
 {
     ref_herkx_local(uplo, transA, n, k, alpha, A, lda, B, ldb, beta, C, ldc);
 }
@@ -3291,13 +3303,13 @@ void ref_herkx(hipblasFillMode_t     uplo,
                hipblasOperation_t    transA,
                int64_t               n,
                int64_t               k,
-               hipblasDoubleComplex  alpha,
-               hipblasDoubleComplex* A,
+               std::complex<double>  alpha,
+               std::complex<double>* A,
                int64_t               lda,
-               hipblasDoubleComplex* B,
+               std::complex<double>* B,
                int64_t               ldb,
                double                beta,
-               hipblasDoubleComplex* C,
+               std::complex<double>* C,
                int64_t               ldc)
 {
     ref_herkx_local(uplo, transA, n, k, alpha, A, lda, B, ldb, beta, C, ldc);
@@ -3305,18 +3317,18 @@ void ref_herkx(hipblasFillMode_t     uplo,
 
 // her2k
 template <>
-void ref_her2k(hipblasFillMode_t  uplo,
-               hipblasOperation_t transA,
-               int64_t            n,
-               int64_t            k,
-               hipblasComplex     alpha,
-               hipblasComplex*    A,
-               int64_t            lda,
-               hipblasComplex*    B,
-               int64_t            ldb,
-               float              beta,
-               hipblasComplex*    C,
-               int64_t            ldc)
+void ref_her2k(hipblasFillMode_t    uplo,
+               hipblasOperation_t   transA,
+               int64_t              n,
+               int64_t              k,
+               std::complex<float>  alpha,
+               std::complex<float>* A,
+               int64_t              lda,
+               std::complex<float>* B,
+               int64_t              ldb,
+               float                beta,
+               std::complex<float>* C,
+               int64_t              ldc)
 {
     cblas_cher2k(CblasColMajor,
                  (CBLAS_UPLO)uplo,
@@ -3338,13 +3350,13 @@ void ref_her2k(hipblasFillMode_t     uplo,
                hipblasOperation_t    transA,
                int64_t               n,
                int64_t               k,
-               hipblasDoubleComplex  alpha,
-               hipblasDoubleComplex* A,
+               std::complex<double>  alpha,
+               std::complex<double>* A,
                int64_t               lda,
-               hipblasDoubleComplex* B,
+               std::complex<double>* B,
                int64_t               ldb,
                double                beta,
-               hipblasDoubleComplex* C,
+               std::complex<double>* C,
                int64_t               ldc)
 {
     cblas_zher2k(CblasColMajor,
@@ -3422,18 +3434,18 @@ void ref_symm(hipblasSideMode_t side,
 }
 
 template <>
-void ref_symm(hipblasSideMode_t side,
-              hipblasFillMode_t uplo,
-              int64_t           m,
-              int64_t           n,
-              hipblasComplex    alpha,
-              hipblasComplex*   A,
-              int64_t           lda,
-              hipblasComplex*   B,
-              int64_t           ldb,
-              hipblasComplex    beta,
-              hipblasComplex*   C,
-              int64_t           ldc)
+void ref_symm(hipblasSideMode_t    side,
+              hipblasFillMode_t    uplo,
+              int64_t              m,
+              int64_t              n,
+              std::complex<float>  alpha,
+              std::complex<float>* A,
+              int64_t              lda,
+              std::complex<float>* B,
+              int64_t              ldb,
+              std::complex<float>  beta,
+              std::complex<float>* C,
+              int64_t              ldc)
 {
     cblas_csymm(CblasColMajor,
                 (CBLAS_SIDE)side,
@@ -3455,13 +3467,13 @@ void ref_symm(hipblasSideMode_t     side,
               hipblasFillMode_t     uplo,
               int64_t               m,
               int64_t               n,
-              hipblasDoubleComplex  alpha,
-              hipblasDoubleComplex* A,
+              std::complex<double>  alpha,
+              std::complex<double>* A,
               int64_t               lda,
-              hipblasDoubleComplex* B,
+              std::complex<double>* B,
               int64_t               ldb,
-              hipblasDoubleComplex  beta,
-              hipblasDoubleComplex* C,
+              std::complex<double>  beta,
+              std::complex<double>* C,
               int64_t               ldc)
 {
     cblas_zsymm(CblasColMajor,
@@ -3531,16 +3543,16 @@ void ref_syrk(hipblasFillMode_t  uplo,
 }
 
 template <>
-void ref_syrk(hipblasFillMode_t  uplo,
-              hipblasOperation_t transA,
-              int64_t            n,
-              int64_t            k,
-              hipblasComplex     alpha,
-              hipblasComplex*    A,
-              int64_t            lda,
-              hipblasComplex     beta,
-              hipblasComplex*    C,
-              int64_t            ldc)
+void ref_syrk(hipblasFillMode_t    uplo,
+              hipblasOperation_t   transA,
+              int64_t              n,
+              int64_t              k,
+              std::complex<float>  alpha,
+              std::complex<float>* A,
+              int64_t              lda,
+              std::complex<float>  beta,
+              std::complex<float>* C,
+              int64_t              ldc)
 {
     cblas_csyrk(CblasColMajor,
                 (CBLAS_UPLO)uplo,
@@ -3560,11 +3572,11 @@ void ref_syrk(hipblasFillMode_t     uplo,
               hipblasOperation_t    transA,
               int64_t               n,
               int64_t               k,
-              hipblasDoubleComplex  alpha,
-              hipblasDoubleComplex* A,
+              std::complex<double>  alpha,
+              std::complex<double>* A,
               int64_t               lda,
-              hipblasDoubleComplex  beta,
-              hipblasDoubleComplex* C,
+              std::complex<double>  beta,
+              std::complex<double>* C,
               int64_t               ldc)
 {
     cblas_zsyrk(CblasColMajor,
@@ -3640,18 +3652,18 @@ void ref_syr2k(hipblasFillMode_t  uplo,
 }
 
 template <>
-void ref_syr2k(hipblasFillMode_t  uplo,
-               hipblasOperation_t transA,
-               int64_t            n,
-               int64_t            k,
-               hipblasComplex     alpha,
-               hipblasComplex*    A,
-               int64_t            lda,
-               hipblasComplex*    B,
-               int64_t            ldb,
-               hipblasComplex     beta,
-               hipblasComplex*    C,
-               int64_t            ldc)
+void ref_syr2k(hipblasFillMode_t    uplo,
+               hipblasOperation_t   transA,
+               int64_t              n,
+               int64_t              k,
+               std::complex<float>  alpha,
+               std::complex<float>* A,
+               int64_t              lda,
+               std::complex<float>* B,
+               int64_t              ldb,
+               std::complex<float>  beta,
+               std::complex<float>* C,
+               int64_t              ldc)
 {
     cblas_csyr2k(CblasColMajor,
                  (CBLAS_UPLO)uplo,
@@ -3673,13 +3685,13 @@ void ref_syr2k(hipblasFillMode_t     uplo,
                hipblasOperation_t    transA,
                int64_t               n,
                int64_t               k,
-               hipblasDoubleComplex  alpha,
-               hipblasDoubleComplex* A,
+               std::complex<double>  alpha,
+               std::complex<double>* A,
                int64_t               lda,
-               hipblasDoubleComplex* B,
+               std::complex<double>* B,
                int64_t               ldb,
-               hipblasDoubleComplex  beta,
-               hipblasDoubleComplex* C,
+               std::complex<double>  beta,
+               std::complex<double>* C,
                int64_t               ldc)
 {
     cblas_zsyr2k(CblasColMajor,
@@ -3759,16 +3771,16 @@ void ref_trsm<double>(hipblasSideMode_t  side,
 }
 
 template <>
-void ref_trsm<hipblasComplex>(hipblasSideMode_t     side,
+void ref_trsm<std::complex<float>>(hipblasSideMode_t     side,
                               hipblasFillMode_t     uplo,
                               hipblasOperation_t    transA,
                               hipblasDiagType_t     diag,
                               int64_t               m,
                               int64_t               n,
-                              hipblasComplex        alpha,
-                              const hipblasComplex* A,
+                              std::complex<float>        alpha,
+                              const std::complex<float>* A,
                               int64_t               lda,
-                              hipblasComplex*       B,
+                              std::complex<float>*       B,
                               int64_t               ldb)
 {
     cblas_ctrsm(CblasColMajor,
@@ -3786,16 +3798,16 @@ void ref_trsm<hipblasComplex>(hipblasSideMode_t     side,
 }
 
 template <>
-void ref_trsm<hipblasDoubleComplex>(hipblasSideMode_t           side,
+void ref_trsm<std::complex<double>>(hipblasSideMode_t           side,
                                     hipblasFillMode_t           uplo,
                                     hipblasOperation_t          transA,
                                     hipblasDiagType_t           diag,
                                     int64_t                     m,
                                     int64_t                     n,
-                                    hipblasDoubleComplex        alpha,
-                                    const hipblasDoubleComplex* A,
+                                    std::complex<double>        alpha,
+                                    const std::complex<double>* A,
                                     int64_t                     lda,
-                                    hipblasDoubleComplex*       B,
+                                    std::complex<double>*       B,
                                     int64_t                     ldb)
 {
     cblas_ztrsm(CblasColMajor,
@@ -3828,14 +3840,15 @@ void ref_trtri<double>(char uplo, char diag, int64_t n, double* A, int64_t lda)
 }
 
 template <>
-void ref_trtri<hipblasComplex>(char uplo, char diag, int64_t n, hipblasComplex* A, int64_t lda)
+void ref_trtri<std::complex<float>>(
+    char uplo, char diag, int64_t n, std::complex<float>* A, int64_t lda)
 {
     lapack_xtrtri(uplo, diag, n, A, lda);
 }
 
 template <>
-void ref_trtri<hipblasDoubleComplex>(
-    char uplo, char diag, int64_t n, hipblasDoubleComplex* A, int64_t lda)
+void ref_trtri<std::complex<double>>(
+    char uplo, char diag, int64_t n, std::complex<double>* A, int64_t lda)
 {
     lapack_xtrtri(uplo, diag, n, A, lda);
 }
@@ -3898,17 +3911,17 @@ void ref_trmm<double>(hipblasSideMode_t  side,
 }
 
 template <>
-void ref_trmm<hipblasComplex>(hipblasSideMode_t     side,
-                              hipblasFillMode_t     uplo,
-                              hipblasOperation_t    transA,
-                              hipblasDiagType_t     diag,
-                              int64_t               m,
-                              int64_t               n,
-                              hipblasComplex        alpha,
-                              const hipblasComplex* A,
-                              int64_t               lda,
-                              hipblasComplex*       B,
-                              int64_t               ldb)
+void ref_trmm<std::complex<float>>(hipblasSideMode_t          side,
+                                   hipblasFillMode_t          uplo,
+                                   hipblasOperation_t         transA,
+                                   hipblasDiagType_t          diag,
+                                   int64_t                    m,
+                                   int64_t                    n,
+                                   std::complex<float>        alpha,
+                                   const std::complex<float>* A,
+                                   int64_t                    lda,
+                                   std::complex<float>*       B,
+                                   int64_t                    ldb)
 {
     cblas_ctrmm(CblasColMajor,
                 (CBLAS_SIDE)side,
@@ -3925,16 +3938,16 @@ void ref_trmm<hipblasComplex>(hipblasSideMode_t     side,
 }
 
 template <>
-void ref_trmm<hipblasDoubleComplex>(hipblasSideMode_t           side,
+void ref_trmm<std::complex<double>>(hipblasSideMode_t           side,
                                     hipblasFillMode_t           uplo,
                                     hipblasOperation_t          transA,
                                     hipblasDiagType_t           diag,
                                     int64_t                     m,
                                     int64_t                     n,
-                                    hipblasDoubleComplex        alpha,
-                                    const hipblasDoubleComplex* A,
+                                    std::complex<double>        alpha,
+                                    const std::complex<double>* A,
                                     int64_t                     lda,
-                                    hipblasDoubleComplex*       B,
+                                    std::complex<double>*       B,
                                     int64_t                     ldb)
 {
     cblas_ztrmm(CblasColMajor,
@@ -3989,7 +4002,7 @@ int64_t ref_potrf(char uplo, int64_t m, double* A, int64_t lda)
 }
 
 template <>
-int64_t ref_potrf(char uplo, int64_t m, hipblasComplex* A, int64_t lda)
+int64_t ref_potrf(char uplo, int64_t m, std::complex<float>* A, int64_t lda)
 {
     int64_t info;
 
@@ -4003,7 +4016,7 @@ int64_t ref_potrf(char uplo, int64_t m, hipblasComplex* A, int64_t lda)
 }
 
 template <>
-int64_t ref_potrf(char uplo, int64_t m, hipblasDoubleComplex* A, int64_t lda)
+int64_t ref_potrf(char uplo, int64_t m, std::complex<double>* A, int64_t lda)
 {
     int64_t info;
 
@@ -4046,30 +4059,30 @@ int64_t ref_getrf<double>(int64_t m, int64_t n, double* A, int64_t lda, int64_t*
 }
 
 template <>
-int64_t
-    ref_getrf<hipblasComplex>(int64_t m, int64_t n, hipblasComplex* A, int64_t lda, int64_t* ipiv)
+int64_t ref_getrf<std::complex<float>>(
+    int64_t m, int64_t n, std::complex<float>* A, int64_t lda, int64_t* ipiv)
 {
     int64_t info;
 
 #ifdef FLA_ENABLE_ILP64
     info = LAPACKE_cgetrf(LAPACK_COL_MAJOR, m, n, (lapack_complex_float*)A, lda, ipiv);
 #else
-    cgetrf_(&m, &n, (hipblasComplex*)A, &lda, ipiv, &info);
+    cgetrf_(&m, &n, (std::complex<float>*)A, &lda, ipiv, &info);
 #endif
 
     return info;
 }
 
 template <>
-int64_t ref_getrf<hipblasDoubleComplex>(
-    int64_t m, int64_t n, hipblasDoubleComplex* A, int64_t lda, int64_t* ipiv)
+int64_t ref_getrf<std::complex<double>>(
+    int64_t m, int64_t n, std::complex<double>* A, int64_t lda, int64_t* ipiv)
 {
     int64_t info;
 
 #ifdef FLA_ENABLE_ILP64
     info = LAPACKE_zgetrf(LAPACK_COL_MAJOR, m, n, (lapack_complex_double*)A, lda, ipiv);
 #else
-    zgetrf_(&m, &n, (hipblasDoubleComplex*)A, &lda, ipiv, &info);
+    zgetrf_(&m, &n, (std::complex<double>*)A, &lda, ipiv, &info);
 #endif
 
     return info;
@@ -4119,14 +4132,14 @@ int64_t ref_getrs<double>(char     trans,
 }
 
 template <>
-int64_t ref_getrs<hipblasComplex>(char            trans,
-                                  int64_t         n,
-                                  int64_t         nrhs,
-                                  hipblasComplex* A,
-                                  int64_t         lda,
-                                  int64_t*        ipiv,
-                                  hipblasComplex* B,
-                                  int64_t         ldb)
+int64_t ref_getrs<std::complex<float>>(char                 trans,
+                                       int64_t              n,
+                                       int64_t              nrhs,
+                                       std::complex<float>* A,
+                                       int64_t              lda,
+                                       int64_t*             ipiv,
+                                       std::complex<float>* B,
+                                       int64_t              ldb)
 {
     int64_t info;
 
@@ -4141,20 +4154,28 @@ int64_t ref_getrs<hipblasComplex>(char            trans,
                           (lapack_complex_float*)B,
                           ldb);
 #else
-    cgetrs_(&trans, &n, &nrhs, (hipblasComplex*)A, &lda, ipiv, (hipblasComplex*)B, &ldb, &info);
+    cgetrs_(&trans,
+            &n,
+            &nrhs,
+            (std::complex<float>*)A,
+            &lda,
+            ipiv,
+            (std::complex<float>*)B,
+            &ldb,
+            &info);
 #endif
 
     return info;
 }
 
 template <>
-int64_t ref_getrs<hipblasDoubleComplex>(char                  trans,
+int64_t ref_getrs<std::complex<double>>(char                  trans,
                                         int64_t               n,
                                         int64_t               nrhs,
-                                        hipblasDoubleComplex* A,
+                                        std::complex<double>* A,
                                         int64_t               lda,
                                         int64_t*              ipiv,
-                                        hipblasDoubleComplex* B,
+                                        std::complex<double>* B,
                                         int64_t               ldb)
 {
 
@@ -4174,10 +4195,10 @@ int64_t ref_getrs<hipblasDoubleComplex>(char                  trans,
     zgetrs_(&trans,
             &n,
             &nrhs,
-            (hipblasDoubleComplex*)A,
+            (std::complex<double>*)A,
             &lda,
             ipiv,
-            (hipblasDoubleComplex*)B,
+            (std::complex<double>*)B,
             &ldb,
             &info);
 #endif
@@ -4217,8 +4238,12 @@ int64_t
 }
 
 template <>
-int64_t ref_getri<hipblasComplex>(
-    int64_t n, hipblasComplex* A, int64_t lda, int64_t* ipiv, hipblasComplex* work, int64_t lwork)
+int64_t ref_getri<std::complex<float>>(int64_t              n,
+                                       std::complex<float>* A,
+                                       int64_t              lda,
+                                       int64_t*             ipiv,
+                                       std::complex<float>* work,
+                                       int64_t              lwork)
 {
     int64_t info;
 
@@ -4238,11 +4263,11 @@ int64_t ref_getri<hipblasComplex>(
 }
 
 template <>
-int64_t ref_getri<hipblasDoubleComplex>(int64_t               n,
-                                        hipblasDoubleComplex* A,
+int64_t ref_getri<std::complex<double>>(int64_t               n,
+                                        std::complex<double>* A,
                                         int64_t               lda,
                                         int64_t*              ipiv,
-                                        hipblasDoubleComplex* work,
+                                        std::complex<double>* work,
                                         int64_t               lwork)
 {
     int64_t info;
@@ -4293,13 +4318,13 @@ int64_t ref_geqrf<double>(
     return info;
 }
 template <>
-int64_t ref_geqrf<hipblasComplex>(int64_t         m,
-                                  int64_t         n,
-                                  hipblasComplex* A,
-                                  int64_t         lda,
-                                  hipblasComplex* tau,
-                                  hipblasComplex* work,
-                                  int64_t         lwork)
+int64_t ref_geqrf<std::complex<float>>(int64_t              m,
+                                       int64_t              n,
+                                       std::complex<float>* A,
+                                       int64_t              lda,
+                                       std::complex<float>* tau,
+                                       std::complex<float>* work,
+                                       int64_t              lwork)
 {
     int64_t info;
 
@@ -4320,12 +4345,12 @@ int64_t ref_geqrf<hipblasComplex>(int64_t         m,
 }
 
 template <>
-int64_t ref_geqrf<hipblasDoubleComplex>(int64_t               m,
+int64_t ref_geqrf<std::complex<double>>(int64_t               m,
                                         int64_t               n,
-                                        hipblasDoubleComplex* A,
+                                        std::complex<double>* A,
                                         int64_t               lda,
-                                        hipblasDoubleComplex* tau,
-                                        hipblasDoubleComplex* work,
+                                        std::complex<double>* tau,
+                                        std::complex<double>* work,
                                         int64_t               lwork)
 {
     int64_t info;
@@ -4394,16 +4419,16 @@ int64_t ref_gels<double>(char    trans,
 }
 
 template <>
-int64_t ref_gels<hipblasComplex>(char            trans,
-                                 int64_t         m,
-                                 int64_t         n,
-                                 int64_t         nrhs,
-                                 hipblasComplex* A,
-                                 int64_t         lda,
-                                 hipblasComplex* B,
-                                 int64_t         ldb,
-                                 hipblasComplex* work,
-                                 int64_t         lwork)
+int64_t ref_gels<std::complex<float>>(char                 trans,
+                                      int64_t              m,
+                                      int64_t              n,
+                                      int64_t              nrhs,
+                                      std::complex<float>* A,
+                                      int64_t              lda,
+                                      std::complex<float>* B,
+                                      int64_t              ldb,
+                                      std::complex<float>* work,
+                                      int64_t              lwork)
 {
     int64_t info;
 #ifdef FLA_ENABLE_ILP64
@@ -4426,15 +4451,15 @@ int64_t ref_gels<hipblasComplex>(char            trans,
 }
 
 template <>
-int64_t ref_gels<hipblasDoubleComplex>(char                  trans,
+int64_t ref_gels<std::complex<double>>(char                  trans,
                                        int64_t               m,
                                        int64_t               n,
                                        int64_t               nrhs,
-                                       hipblasDoubleComplex* A,
+                                       std::complex<double>* A,
                                        int64_t               lda,
-                                       hipblasDoubleComplex* B,
+                                       std::complex<double>* B,
                                        int64_t               ldb,
-                                       hipblasDoubleComplex* work,
+                                       std::complex<double>* work,
                                        int64_t               lwork)
 {
     int64_t info;
diff --git a/clients/common/clients_common.cpp b/clients/common/clients_common.cpp
index bc84584..e62556a 100644
--- a/clients/common/clients_common.cpp
+++ b/clients/common/clients_common.cpp
@@ -1,5 +1,5 @@
 /* ************************************************************************
- * Copyright (C) 2016-2023 Advanced Micro Devices, Inc. All rights reserved.
+ * Copyright (C) 2016-2025 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
@@ -265,7 +265,7 @@ void run_function(const func_map& map, const Arguments& arg, const std::string& 
     auto match = map.find(arg.function);
     if(match == map.end())
         throw std::invalid_argument("Invalid combination --function "s + arg.function
-                                    + " --a_type "s + hipblas_datatype2string(arg.a_type) + msg);
+                                    + " --a_type "s + hip_datatype2string(arg.a_type) + msg);
     match->second(arg);
 }
 
@@ -743,11 +743,10 @@ struct perf_blas<T, U, std::enable_if_t<std::is_same<T, hipblasHalf>{}>> : hipbl
 };
 
 template <typename T, typename U>
-struct perf_blas<
-    T,
-    U,
-    std::enable_if_t<std::is_same<T, hipblasDoubleComplex>{} || std::is_same<T, hipblasComplex>{}>>
-    : hipblas_test_valid
+struct perf_blas<T,
+                 U,
+                 std::enable_if_t<std::is_same<T, std::complex<double>>{}
+                                  || std::is_same<T, std::complex<float>>{}>> : hipblas_test_valid
 {
     void operator()(const Arguments& arg)
     {
@@ -946,10 +945,12 @@ struct perf_blas_axpy_ex<
                 hipblasHalf> && std::is_same_v<Ta, Tx> && std::is_same_v<Tx, Ty> && std::is_same_v<Ty, Tex>)
         || (std::is_same_v<
                 Ta,
-                hipblasComplex> && std::is_same_v<Ta, Tx> && std::is_same_v<Tx, Ty> && std::is_same_v<Ty, Tex>)
+                std::complex<
+                    float>> && std::is_same_v<Ta, Tx> && std::is_same_v<Tx, Ty> && std::is_same_v<Ty, Tex>)
         || (std::is_same_v<
                 Ta,
-                hipblasDoubleComplex> && std::is_same_v<Ta, Tx> && std::is_same_v<Tx, Ty> && std::is_same_v<Ty, Tex>)
+                std::complex<
+                    double>> && std::is_same_v<Ta, Tx> && std::is_same_v<Tx, Ty> && std::is_same_v<Ty, Tex>)
         || (std::is_same_v<
                 Ta,
                 hipblasHalf> && std::is_same_v<Ta, Tx> && std::is_same_v<Tx, Ty> && std::is_same_v<Tex, float>)
@@ -992,9 +993,9 @@ struct perf_blas_dot_ex<
                          && std::is_same<Ty, Tr>{} && std::is_same<Tr, Tex>{})
                      || (std::is_same<Tx, hipblasHalf>{} && std::is_same<Tx, Ty>{}
                          && std::is_same<Ty, Tr>{} && std::is_same<Tr, Tex>{})
-                     || (std::is_same<Tx, hipblasComplex>{} && std::is_same<Tx, Ty>{}
+                     || (std::is_same<Tx, std::complex<float>>{} && std::is_same<Tx, Ty>{}
                          && std::is_same<Ty, Tr>{} && std::is_same<Tr, Tex>{})
-                     || (std::is_same<Tx, hipblasDoubleComplex>{} && std::is_same<Tx, Ty>{}
+                     || (std::is_same<Tx, std::complex<double>>{} && std::is_same<Tx, Ty>{}
                          && std::is_same<Ty, Tr>{} && std::is_same<Tr, Tex>{})
                      || (std::is_same<Tx, hipblasHalf>{} && std::is_same<Tx, Ty>{}
                          && std::is_same<Ty, Tr>{} && std::is_same<Tex, float>{})
@@ -1029,9 +1030,9 @@ struct perf_blas_nrm2_ex<
     std::enable_if_t<
         (std::is_same<Tx, float>{} && std::is_same<Tx, Tr>{} && std::is_same<Tr, Tex>{})
         || (std::is_same<Tx, double>{} && std::is_same<Tx, Tr>{} && std::is_same<Tr, Tex>{})
-        || (std::is_same<Tx, hipblasComplex>{} && std::is_same<Tr, float>{}
+        || (std::is_same<Tx, std::complex<float>>{} && std::is_same<Tr, float>{}
             && std::is_same<Tr, Tex>{})
-        || (std::is_same<Tx, hipblasDoubleComplex>{} && std::is_same<Tr, double>{}
+        || (std::is_same<Tx, std::complex<double>>{} && std::is_same<Tr, double>{}
             && std::is_same<Tr, Tex>{})
         || (std::is_same<Tx, hipblasHalf>{} && std::is_same<Tr, Tx>{} && std::is_same<Tex, float>{})
         || (std::is_same<Tx, hipblasBfloat16>{} && std::is_same<Tr, Tx>{}
@@ -1063,15 +1064,15 @@ struct perf_blas_rot_ex<
                       && std::is_same<Tcs, Tex>{})
                      || (std::is_same<Tx, double>{} && std::is_same<Ty, Tx>{}
                          && std::is_same<Ty, Tcs>{} && std::is_same<Tex, Tcs>{})
-                     || (std::is_same<Tx, hipblasComplex>{} && std::is_same<Ty, Tx>{}
+                     || (std::is_same<Tx, std::complex<float>>{} && std::is_same<Ty, Tx>{}
                          && std::is_same<Tcs, Ty>{} && std::is_same<Tcs, Tex>{})
-                     || (std::is_same<Tx, hipblasDoubleComplex>{} && std::is_same<Tx, Ty>{}
+                     || (std::is_same<Tx, std::complex<double>>{} && std::is_same<Tx, Ty>{}
                          && std::is_same<Tcs, Ty>{} && std::is_same<Tex, Tcs>{})
-                     || (std::is_same<Tx, hipblasComplex>{} && std::is_same<Ty, Tx>{}
-                         && std::is_same<Tcs, float>{} && std::is_same<Tex, hipblasComplex>{})
-                     || (std::is_same<Tx, hipblasDoubleComplex>{} && std::is_same<Tx, Ty>{}
+                     || (std::is_same<Tx, std::complex<float>>{} && std::is_same<Ty, Tx>{}
+                         && std::is_same<Tcs, float>{} && std::is_same<Tex, std::complex<float>>{})
+                     || (std::is_same<Tx, std::complex<double>>{} && std::is_same<Tx, Ty>{}
                          && std::is_same<Tcs, double>{}
-                         && std::is_same<Tex, hipblasDoubleComplex>{})
+                         && std::is_same<Tex, std::complex<double>>{})
                      || (std::is_same<Tx, hipblasHalf>{} && std::is_same<Ty, Tx>{}
                          && std::is_same<Tcs, Ty>{} && std::is_same<Tex, float>{})
                      || (std::is_same<Tx, hipblasBfloat16>{} && std::is_same<Ty, Tx>{}
@@ -1102,13 +1103,13 @@ struct perf_blas_rot<
     std::enable_if_t<(std::is_same<Ti, float>{} && std::is_same<Ti, To>{} && std::is_same<To, Tc>{})
                      || (std::is_same<Ti, double>{} && std::is_same<Ti, To>{}
                          && std::is_same<To, Tc>{})
-                     || (std::is_same<Ti, hipblasComplex>{} && std::is_same<To, float>{}
-                         && std::is_same<Tc, hipblasComplex>{})
-                     || (std::is_same<Ti, hipblasComplex>{} && std::is_same<To, float>{}
+                     || (std::is_same<Ti, std::complex<float>>{} && std::is_same<To, float>{}
+                         && std::is_same<Tc, std::complex<float>>{})
+                     || (std::is_same<Ti, std::complex<float>>{} && std::is_same<To, float>{}
                          && std::is_same<Tc, float>{})
-                     || (std::is_same<Ti, hipblasDoubleComplex>{} && std::is_same<To, double>{}
-                         && std::is_same<Tc, hipblasDoubleComplex>{})
-                     || (std::is_same<Ti, hipblasDoubleComplex>{} && std::is_same<To, double>{}
+                     || (std::is_same<Ti, std::complex<double>>{} && std::is_same<To, double>{}
+                         && std::is_same<Tc, std::complex<double>>{})
+                     || (std::is_same<Ti, std::complex<double>>{} && std::is_same<To, double>{}
                          && std::is_same<Tc, double>{})>> : hipblas_test_valid
 {
     void operator()(const Arguments& arg)
@@ -1131,12 +1132,12 @@ template <typename Ta, typename Tb>
 struct perf_blas_scal<
     Ta,
     Tb,
-    std::enable_if_t<(std::is_same<Ta, double>{} && std::is_same<Tb, hipblasDoubleComplex>{})
-                     || (std::is_same<Ta, float>{} && std::is_same<Tb, hipblasComplex>{})
+    std::enable_if_t<(std::is_same<Ta, double>{} && std::is_same<Tb, std::complex<double>>{})
+                     || (std::is_same<Ta, float>{} && std::is_same<Tb, std::complex<float>>{})
                      || (std::is_same<Ta, Tb>{} && std::is_same<Ta, float>{})
                      || (std::is_same<Ta, Tb>{} && std::is_same<Ta, double>{})
-                     || (std::is_same<Ta, Tb>{} && std::is_same<Ta, hipblasComplex>{})
-                     || (std::is_same<Ta, Tb>{} && std::is_same<Ta, hipblasDoubleComplex>{})>>
+                     || (std::is_same<Ta, Tb>{} && std::is_same<Ta, std::complex<float>>{})
+                     || (std::is_same<Ta, Tb>{} && std::is_same<Ta, std::complex<double>>{})>>
     : hipblas_test_valid
 {
     void operator()(const Arguments& arg)
@@ -1164,14 +1165,15 @@ struct perf_blas_scal_ex<
         (std::is_same<Ta, float>{} && std::is_same<Ta, Tx>{} && std::is_same<Tx, Tex>{})
         || (std::is_same<Ta, double>{} && std::is_same<Ta, Tx>{} && std::is_same<Tx, Tex>{})
         || (std::is_same<Ta, hipblasHalf>{} && std::is_same<Ta, Tx>{} && std::is_same<Tx, Tex>{})
-        || (std::is_same<Ta, hipblasComplex>{} && std::is_same<Ta, Tx>{} && std::is_same<Tx, Tex>{})
-        || (std::is_same<Ta, hipblasDoubleComplex>{} && std::is_same<Ta, Tx>{}
+        || (std::is_same<Ta, std::complex<float>>{} && std::is_same<Ta, Tx>{}
+            && std::is_same<Tx, Tex>{})
+        || (std::is_same<Ta, std::complex<double>>{} && std::is_same<Ta, Tx>{}
             && std::is_same<Tx, Tex>{})
         || (std::is_same<Ta, hipblasHalf>{} && std::is_same<Ta, Tx>{} && std::is_same<Tex, float>{})
         || (std::is_same<Ta, float>{} && std::is_same<Tx, hipblasHalf>{} && std::is_same<Ta, Tex>{})
-        || (std::is_same<Ta, float>{} && std::is_same<Tx, hipblasComplex>{}
+        || (std::is_same<Ta, float>{} && std::is_same<Tx, std::complex<float>>{}
             && std::is_same<Tx, Tex>{})
-        || (std::is_same<Ta, double>{} && std::is_same<Tx, hipblasDoubleComplex>{}
+        || (std::is_same<Ta, double>{} && std::is_same<Tx, std::complex<double>>{}
             && std::is_same<Tx, Tex>{})
         || (std::is_same<Ta, hipblasBfloat16>{} && std::is_same<Ta, Tx>{}
             && std::is_same<Tex, float>{})
diff --git a/clients/common/hipblas_datatype2string.cpp b/clients/common/hipblas_datatype2string.cpp
index 098ec70..42b0af9 100644
--- a/clients/common/hipblas_datatype2string.cpp
+++ b/clients/common/hipblas_datatype2string.cpp
@@ -1,5 +1,5 @@
 /* ************************************************************************
- * Copyright (C) 2016-2023 Advanced Micro Devices, Inc. All rights reserved.
+ * Copyright (C) 2016-2025 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
@@ -165,28 +165,30 @@ hipblasSideMode_t char2hipblas_side(char value)
 }
 
 // clang-format off
-hipblasDatatype_t string2hipblas_datatype(const std::string& value)
+/*! \brief Convert string to a hipDataType. Returns HIP_R_32F if invalid string. */
+hipDataType string2hip_datatype(const std::string& value)
 {
     return
-        value == "f16_r" || value == "h" ? HIPBLAS_R_16F  :
-        value == "f32_r" || value == "s" ? HIPBLAS_R_32F  :
-        value == "f64_r" || value == "d" ? HIPBLAS_R_64F  :
-        value == "bf16_r"                ? HIPBLAS_R_16B :
-        value == "f16_c"                 ? HIPBLAS_C_16B  :
-        value == "f32_c" || value == "c" ? HIPBLAS_C_32F  :
-        value == "f64_c" || value == "z" ? HIPBLAS_C_64F  :
-        value == "bf16_c"                ? HIPBLAS_C_16B :
-        value == "i8_r"                  ? HIPBLAS_R_8I   :
-        value == "i32_r"                 ? HIPBLAS_R_32I  :
-        value == "i8_c"                  ? HIPBLAS_C_8I   :
-        value == "i32_c"                 ? HIPBLAS_C_32I  :
-        value == "u8_r"                  ? HIPBLAS_R_8U   :
-        value == "u32_r"                 ? HIPBLAS_R_32U  :
-        value == "u8_c"                  ? HIPBLAS_C_8U   :
-        value == "u32_c"                 ? HIPBLAS_C_32U  :
-        HIPBLAS_DATATYPE_INVALID;
+        value == "f16_r" || value == "h" ? HIP_R_16F  :
+        value == "f32_r" || value == "s" ? HIP_R_32F  :
+        value == "f64_r" || value == "d" ? HIP_R_64F  :
+        value == "bf16_r"                ? HIP_R_16BF :
+        value == "f16_c"                 ? HIP_C_16BF  :
+        value == "f32_c" || value == "c" ? HIP_C_32F  :
+        value == "f64_c" || value == "z" ? HIP_C_64F  :
+        value == "bf16_c"                ? HIP_C_16BF :
+        value == "i8_r"                  ? HIP_R_8I   :
+        value == "i32_r"                 ? HIP_R_32I  :
+        value == "i8_c"                  ? HIP_C_8I   :
+        value == "i32_c"                 ? HIP_C_32I  :
+        value == "u8_r"                  ? HIP_R_8U   :
+        value == "u32_r"                 ? HIP_R_32U  :
+        value == "u8_c"                  ? HIP_C_8U   :
+        value == "u32_c"                 ? HIP_C_32U  :
+        HIP_R_32F;
 }
 
+/*! \brief Convert string to a hipblasComputeType_t. Returns HIPBLAS_COMPUTE_32F if invalid string. */
 hipblasComputeType_t string2hipblas_computetype(const std::string& value)
 {
     return value == "c16f"           ? HIPBLAS_COMPUTE_16F :
diff --git a/clients/common/hipblas_gentest.py b/clients/common/hipblas_gentest.py
index 5e9143a..4f572e0 100755
--- a/clients/common/hipblas_gentest.py
+++ b/clients/common/hipblas_gentest.py
@@ -1,5 +1,5 @@
 #!/usr/bin/env python3
-"""Copyright (C) 2018-2023 Advanced Micro Devices, Inc. All rights reserved.
+"""Copyright (C) 2018-2025 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
@@ -114,9 +114,6 @@ Expand hipBLAS YAML test data file into binary Arguments records
                         default=[])
     parser.add_argument('-t', '--template',
                         type=argparse.FileType('r'))
-    parser.add_argument('--hipblas_v2',
-                        action='store_true',
-                        help="Uses HIPBLAS_V2 datatypes, ensure HIPBLAS_V2 is defined in your build when using this.")
     return parser.parse_args()
 
 
@@ -185,7 +182,7 @@ def get_datatypes(doc):
         for name, decl in declaration.items():
             if isinstance(decl, dict):
                 # Create derived class type based on bases and attr entries
-                decl_attr = decl.get('attr_v2') if args.get('hipblas_v2') else decl.get('attr')
+                decl_attr = decl.get('attr')
                 dt[name] = type(name,
                                 tuple([eval(t, dt)
                                        for t in decl.get('bases') or ()
diff --git a/clients/common/hipblas_parse_data.cpp b/clients/common/hipblas_parse_data.cpp
index f2450d7..4b72b2a 100644
--- a/clients/common/hipblas_parse_data.cpp
+++ b/clients/common/hipblas_parse_data.cpp
@@ -1,5 +1,5 @@
 /* ************************************************************************
- * Copyright (C) 2019-2023 Advanced Micro Devices, Inc. All rights reserved.
+ * Copyright (C) 2019-2025 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
@@ -35,15 +35,19 @@
 // Parse YAML data
 static std::string hipblas_parse_yaml(const std::string& yaml)
 {
+#ifdef WIN32
+    // Explicitly run via `python.exe`, without relying on the .py file being
+    // treated as an executable that should be run via the python interpreter.
+    std::string python_command_launcher = "python ";
+#else
+    // Rely on the shebang in the file, e.g. `#!/usr/bin/env python3`.
+    std::string python_command_launcher = "";
+#endif
+
     std::string tmp     = hipblas_tempname();
     auto        exepath = hipblas_exepath();
-#ifdef HIPBLAS_V2
-    auto cmd = exepath + "hipblas_gentest.py --hipblas_v2 --template " + exepath
+    auto        cmd = python_command_launcher + exepath + "hipblas_gentest.py --template " + exepath
                + "hipblas_template.yaml -o " + tmp + " " + yaml;
-#else
-    auto cmd = exepath + "hipblas_gentest.py --template " + exepath + "hipblas_template.yaml -o "
-               + tmp + " " + yaml;
-#endif
     std::cerr << cmd << std::endl;
 
 #ifdef WIN32
@@ -51,7 +55,7 @@ static std::string hipblas_parse_yaml(const std::string& yaml)
     if(status == -1)
         exit(EXIT_FAILURE);
 #else
-    int status = system(cmd.c_str());
+    int         status                  = system(cmd.c_str());
     if(status == -1 || !WIFEXITED(status) || WEXITSTATUS(status))
         exit(EXIT_FAILURE);
 #endif
diff --git a/clients/common/hipblas_template_specialization.cpp b/clients/common/hipblas_template_specialization.cpp
deleted file mode 100644
index b073cdc..0000000
--- a/clients/common/hipblas_template_specialization.cpp
+++ /dev/null
@@ -1,14310 +0,0 @@
-/* ************************************************************************
- * Copyright (C) 2016-2024 Advanced Micro Devices, Inc. All rights reserved.
- *
- * Permission is hereby granted, free of charge, to any person obtaining a copy
- * of this software and associated documentation files (the "Software"), to deal
- * in the Software without restriction, including without limitation the rights
- * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
- * copies of the Software, and to permit persons to whom the Software is
- * furnished to do so, subject to the following conditions:
- *
- * The above copyright notice and this permission notice shall be included in
- * all copies or substantial portions of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
- * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
- * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
- * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
- * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
- * SOFTWARE.
- *
- *
- * ************************************************************************/
-
-#include "hipblas.h"
-#include "hipblas.hpp"
-
-#ifndef WIN32
-#include "hipblas_fortran.hpp"
-#else
-#include "hipblas_no_fortran.hpp"
-#endif
-
-#include <typeinfo>
-
-// This file's purpose is now only for casting hipblasComplex -> hipComplex when necessary.
-// When we finish transitioning to hipComplex, this file can be deleted.
-
-/*
- * ===========================================================================
- *    level 1 BLAS
- * ===========================================================================
- */
-
-#ifdef HIPBLAS_V2
-// axpy
-hipblasStatus_t hipblasCaxpyCast(hipblasHandle_t       handle,
-                                 int                   n,
-                                 const hipblasComplex* alpha,
-                                 const hipblasComplex* x,
-                                 int                   incx,
-                                 hipblasComplex*       y,
-                                 int                   incy)
-{
-    return hipblasCaxpy(
-        handle, n, (const hipComplex*)alpha, (const hipComplex*)x, incx, (hipComplex*)y, incy);
-}
-
-hipblasStatus_t hipblasZaxpyCast(hipblasHandle_t             handle,
-                                 int                         n,
-                                 const hipblasDoubleComplex* alpha,
-                                 const hipblasDoubleComplex* x,
-                                 int                         incx,
-                                 hipblasDoubleComplex*       y,
-                                 int                         incy)
-{
-    return hipblasZaxpy(handle,
-                        n,
-                        (const hipDoubleComplex*)alpha,
-                        (const hipDoubleComplex*)x,
-                        incx,
-                        (hipDoubleComplex*)y,
-                        incy);
-}
-
-hipblasStatus_t hipblasCaxpyCast_64(hipblasHandle_t       handle,
-                                    int64_t               n,
-                                    const hipblasComplex* alpha,
-                                    const hipblasComplex* x,
-                                    int64_t               incx,
-                                    hipblasComplex*       y,
-                                    int64_t               incy)
-{
-    return hipblasCaxpy_64(
-        handle, n, (const hipComplex*)alpha, (const hipComplex*)x, incx, (hipComplex*)y, incy);
-}
-
-hipblasStatus_t hipblasZaxpyCast_64(hipblasHandle_t             handle,
-                                    int64_t                     n,
-                                    const hipblasDoubleComplex* alpha,
-                                    const hipblasDoubleComplex* x,
-                                    int64_t                     incx,
-                                    hipblasDoubleComplex*       y,
-                                    int64_t                     incy)
-{
-    return hipblasZaxpy_64(handle,
-                           n,
-                           (const hipDoubleComplex*)alpha,
-                           (const hipDoubleComplex*)x,
-                           incx,
-                           (hipDoubleComplex*)y,
-                           incy);
-}
-
-// axpy_batched
-hipblasStatus_t hipblasCaxpyBatchedCast(hipblasHandle_t             handle,
-                                        int                         n,
-                                        const hipblasComplex*       alpha,
-                                        const hipblasComplex* const x[],
-                                        int                         incx,
-                                        hipblasComplex* const       y[],
-                                        int                         incy,
-                                        int                         batch_count)
-{
-    return hipblasCaxpyBatched(handle,
-                               n,
-                               (const hipComplex*)alpha,
-                               (const hipComplex* const*)x,
-                               incx,
-                               (hipComplex* const*)y,
-                               incy,
-                               batch_count);
-}
-
-hipblasStatus_t hipblasZaxpyBatchedCast(hipblasHandle_t                   handle,
-                                        int                               n,
-                                        const hipblasDoubleComplex*       alpha,
-                                        const hipblasDoubleComplex* const x[],
-                                        int                               incx,
-                                        hipblasDoubleComplex* const       y[],
-                                        int                               incy,
-                                        int                               batch_count)
-{
-    return hipblasZaxpyBatched(handle,
-                               n,
-                               (const hipDoubleComplex*)alpha,
-                               (const hipDoubleComplex* const*)x,
-                               incx,
-                               (hipDoubleComplex* const*)y,
-                               incy,
-                               batch_count);
-}
-
-hipblasStatus_t hipblasCaxpyBatchedCast_64(hipblasHandle_t             handle,
-                                           int64_t                     n,
-                                           const hipblasComplex*       alpha,
-                                           const hipblasComplex* const x[],
-                                           int64_t                     incx,
-                                           hipblasComplex* const       y[],
-                                           int64_t                     incy,
-                                           int64_t                     batch_count)
-{
-    return hipblasCaxpyBatched_64(handle,
-                                  n,
-                                  (const hipComplex*)alpha,
-                                  (const hipComplex* const*)x,
-                                  incx,
-                                  (hipComplex* const*)y,
-                                  incy,
-                                  batch_count);
-}
-
-hipblasStatus_t hipblasZaxpyBatchedCast_64(hipblasHandle_t                   handle,
-                                           int64_t                           n,
-                                           const hipblasDoubleComplex*       alpha,
-                                           const hipblasDoubleComplex* const x[],
-                                           int64_t                           incx,
-                                           hipblasDoubleComplex* const       y[],
-                                           int64_t                           incy,
-                                           int64_t                           batch_count)
-{
-    return hipblasZaxpyBatched_64(handle,
-                                  n,
-                                  (const hipDoubleComplex*)alpha,
-                                  (const hipDoubleComplex* const*)x,
-                                  incx,
-                                  (hipDoubleComplex* const*)y,
-                                  incy,
-                                  batch_count);
-}
-
-// axpy_strided_batched
-hipblasStatus_t hipblasCaxpyStridedBatchedCast(hipblasHandle_t       handle,
-                                               int                   n,
-                                               const hipblasComplex* alpha,
-                                               const hipblasComplex* x,
-                                               int                   incx,
-                                               hipblasStride         stridex,
-                                               hipblasComplex*       y,
-                                               int                   incy,
-                                               hipblasStride         stridey,
-                                               int                   batch_count)
-{
-    return hipblasCaxpyStridedBatched(handle,
-                                      n,
-                                      (const hipComplex*)alpha,
-                                      (const hipComplex*)x,
-                                      incx,
-                                      stridex,
-                                      (hipComplex*)y,
-                                      incy,
-                                      stridey,
-                                      batch_count);
-}
-
-hipblasStatus_t hipblasZaxpyStridedBatchedCast(hipblasHandle_t             handle,
-                                               int                         n,
-                                               const hipblasDoubleComplex* alpha,
-                                               const hipblasDoubleComplex* x,
-                                               int                         incx,
-                                               hipblasStride               stridex,
-                                               hipblasDoubleComplex*       y,
-                                               int                         incy,
-                                               hipblasStride               stridey,
-                                               int                         batch_count)
-{
-    return hipblasZaxpyStridedBatched(handle,
-                                      n,
-                                      (const hipDoubleComplex*)alpha,
-                                      (const hipDoubleComplex*)x,
-                                      incx,
-                                      stridex,
-                                      (hipDoubleComplex*)y,
-                                      incy,
-                                      stridey,
-                                      batch_count);
-}
-
-hipblasStatus_t hipblasCaxpyStridedBatchedCast_64(hipblasHandle_t       handle,
-                                                  int64_t               n,
-                                                  const hipblasComplex* alpha,
-                                                  const hipblasComplex* x,
-                                                  int64_t               incx,
-                                                  hipblasStride         stridex,
-                                                  hipblasComplex*       y,
-                                                  int64_t               incy,
-                                                  hipblasStride         stridey,
-                                                  int64_t               batch_count)
-{
-    return hipblasCaxpyStridedBatched_64(handle,
-                                         n,
-                                         (const hipComplex*)alpha,
-                                         (const hipComplex*)x,
-                                         incx,
-                                         stridex,
-                                         (hipComplex*)y,
-                                         incy,
-                                         stridey,
-                                         batch_count);
-}
-
-hipblasStatus_t hipblasZaxpyStridedBatchedCast_64(hipblasHandle_t             handle,
-                                                  int64_t                     n,
-                                                  const hipblasDoubleComplex* alpha,
-                                                  const hipblasDoubleComplex* x,
-                                                  int64_t                     incx,
-                                                  hipblasStride               stridex,
-                                                  hipblasDoubleComplex*       y,
-                                                  int64_t                     incy,
-                                                  hipblasStride               stridey,
-                                                  int64_t                     batch_count)
-{
-    return hipblasZaxpyStridedBatched_64(handle,
-                                         n,
-                                         (const hipDoubleComplex*)alpha,
-                                         (const hipDoubleComplex*)x,
-                                         incx,
-                                         stridex,
-                                         (hipDoubleComplex*)y,
-                                         incy,
-                                         stridey,
-                                         batch_count);
-}
-
-// swap
-hipblasStatus_t hipblasCswapCast(
-    hipblasHandle_t handle, int n, hipblasComplex* x, int incx, hipblasComplex* y, int incy)
-{
-    return hipblasCswap(handle, n, (hipComplex*)x, incx, (hipComplex*)y, incy);
-}
-
-hipblasStatus_t hipblasZswapCast(hipblasHandle_t       handle,
-                                 int                   n,
-                                 hipblasDoubleComplex* x,
-                                 int                   incx,
-                                 hipblasDoubleComplex* y,
-                                 int                   incy)
-{
-    return hipblasZswap(handle, n, (hipDoubleComplex*)x, incx, (hipDoubleComplex*)y, incy);
-}
-
-// swap_64
-hipblasStatus_t hipblasCswapCast_64(hipblasHandle_t handle,
-                                    int64_t         n,
-                                    hipblasComplex* x,
-                                    int64_t         incx,
-                                    hipblasComplex* y,
-                                    int64_t         incy)
-{
-    return hipblasCswap_64(handle, n, (hipComplex*)x, incx, (hipComplex*)y, incy);
-}
-
-hipblasStatus_t hipblasZswapCast_64(hipblasHandle_t       handle,
-                                    int64_t               n,
-                                    hipblasDoubleComplex* x,
-                                    int64_t               incx,
-                                    hipblasDoubleComplex* y,
-                                    int64_t               incy)
-{
-    return hipblasZswap_64(handle, n, (hipDoubleComplex*)x, incx, (hipDoubleComplex*)y, incy);
-}
-
-// swap_batched
-hipblasStatus_t hipblasCswapBatchedCast(hipblasHandle_t       handle,
-                                        int                   n,
-                                        hipblasComplex* const x[],
-                                        int                   incx,
-                                        hipblasComplex* const y[],
-                                        int                   incy,
-                                        int                   batch_count)
-{
-    return hipblasCswapBatched(
-        handle, n, (hipComplex* const*)x, incx, (hipComplex* const*)y, incy, batch_count);
-}
-
-hipblasStatus_t hipblasZswapBatchedCast(hipblasHandle_t             handle,
-                                        int                         n,
-                                        hipblasDoubleComplex* const x[],
-                                        int                         incx,
-                                        hipblasDoubleComplex* const y[],
-                                        int                         incy,
-                                        int                         batch_count)
-{
-    return hipblasZswapBatched(handle,
-                               n,
-                               (hipDoubleComplex* const*)x,
-                               incx,
-                               (hipDoubleComplex* const*)y,
-                               incy,
-                               batch_count);
-}
-
-// swap_batched_64
-hipblasStatus_t hipblasCswapBatchedCast_64(hipblasHandle_t       handle,
-                                           int64_t               n,
-                                           hipblasComplex* const x[],
-                                           int64_t               incx,
-                                           hipblasComplex* const y[],
-                                           int64_t               incy,
-                                           int64_t               batch_count)
-{
-    return hipblasCswapBatched_64(
-        handle, n, (hipComplex* const*)x, incx, (hipComplex* const*)y, incy, batch_count);
-}
-
-hipblasStatus_t hipblasZswapBatchedCast_64(hipblasHandle_t             handle,
-                                           int64_t                     n,
-                                           hipblasDoubleComplex* const x[],
-                                           int64_t                     incx,
-                                           hipblasDoubleComplex* const y[],
-                                           int64_t                     incy,
-                                           int64_t                     batch_count)
-{
-    return hipblasZswapBatched_64(handle,
-                                  n,
-                                  (hipDoubleComplex* const*)x,
-                                  incx,
-                                  (hipDoubleComplex* const*)y,
-                                  incy,
-                                  batch_count);
-}
-
-// swap_strided_batched
-hipblasStatus_t hipblasCswapStridedBatchedCast(hipblasHandle_t handle,
-                                               int             n,
-                                               hipblasComplex* x,
-                                               int             incx,
-                                               hipblasStride   stridex,
-                                               hipblasComplex* y,
-                                               int             incy,
-                                               hipblasStride   stridey,
-                                               int             batch_count)
-{
-    return hipblasCswapStridedBatched(
-        handle, n, (hipComplex*)x, incx, stridex, (hipComplex*)y, incy, stridey, batch_count);
-}
-
-hipblasStatus_t hipblasZswapStridedBatchedCast(hipblasHandle_t       handle,
-                                               int                   n,
-                                               hipblasDoubleComplex* x,
-                                               int                   incx,
-                                               hipblasStride         stridex,
-                                               hipblasDoubleComplex* y,
-                                               int                   incy,
-                                               hipblasStride         stridey,
-                                               int                   batch_count)
-{
-    return hipblasZswapStridedBatched(handle,
-                                      n,
-                                      (hipDoubleComplex*)x,
-                                      incx,
-                                      stridex,
-                                      (hipDoubleComplex*)y,
-                                      incy,
-                                      stridey,
-                                      batch_count);
-}
-
-// swap_strided_batched_64
-hipblasStatus_t hipblasCswapStridedBatchedCast_64(hipblasHandle_t handle,
-                                                  int64_t         n,
-                                                  hipblasComplex* x,
-                                                  int64_t         incx,
-                                                  hipblasStride   stridex,
-                                                  hipblasComplex* y,
-                                                  int64_t         incy,
-                                                  hipblasStride   stridey,
-                                                  int64_t         batch_count)
-{
-    return hipblasCswapStridedBatched_64(
-        handle, n, (hipComplex*)x, incx, stridex, (hipComplex*)y, incy, stridey, batch_count);
-}
-
-hipblasStatus_t hipblasZswapStridedBatchedCast_64(hipblasHandle_t       handle,
-                                                  int64_t               n,
-                                                  hipblasDoubleComplex* x,
-                                                  int64_t               incx,
-                                                  hipblasStride         stridex,
-                                                  hipblasDoubleComplex* y,
-                                                  int64_t               incy,
-                                                  hipblasStride         stridey,
-                                                  int64_t               batch_count)
-{
-    return hipblasZswapStridedBatched_64(handle,
-                                         n,
-                                         (hipDoubleComplex*)x,
-                                         incx,
-                                         stridex,
-                                         (hipDoubleComplex*)y,
-                                         incy,
-                                         stridey,
-                                         batch_count);
-}
-
-// copy
-hipblasStatus_t hipblasCcopyCast(
-    hipblasHandle_t handle, int n, const hipblasComplex* x, int incx, hipblasComplex* y, int incy)
-{
-    return hipblasCcopy(handle, n, (const hipComplex*)x, incx, (hipComplex*)y, incy);
-}
-
-hipblasStatus_t hipblasZcopyCast(hipblasHandle_t             handle,
-                                 int                         n,
-                                 const hipblasDoubleComplex* x,
-                                 int                         incx,
-                                 hipblasDoubleComplex*       y,
-                                 int                         incy)
-{
-    return hipblasZcopy(handle, n, (const hipDoubleComplex*)x, incx, (hipDoubleComplex*)y, incy);
-}
-
-hipblasStatus_t hipblasCcopyCast_64(hipblasHandle_t       handle,
-                                    int64_t               n,
-                                    const hipblasComplex* x,
-                                    int64_t               incx,
-                                    hipblasComplex*       y,
-                                    int64_t               incy)
-{
-    return hipblasCcopy_64(handle, n, (const hipComplex*)x, incx, (hipComplex*)y, incy);
-}
-
-hipblasStatus_t hipblasZcopyCast_64(hipblasHandle_t             handle,
-                                    int64_t                     n,
-                                    const hipblasDoubleComplex* x,
-                                    int64_t                     incx,
-                                    hipblasDoubleComplex*       y,
-                                    int64_t                     incy)
-{
-    return hipblasZcopy_64(handle, n, (const hipDoubleComplex*)x, incx, (hipDoubleComplex*)y, incy);
-}
-
-// batched
-hipblasStatus_t hipblasCcopyBatchedCast(hipblasHandle_t             handle,
-                                        int                         n,
-                                        const hipblasComplex* const x[],
-                                        int                         incx,
-                                        hipblasComplex* const       y[],
-                                        int                         incy,
-                                        int                         batch_count)
-{
-    return hipblasCcopyBatched(
-        handle, n, (const hipComplex* const*)x, incx, (hipComplex* const*)y, incy, batch_count);
-}
-
-hipblasStatus_t hipblasZcopyBatchedCast(hipblasHandle_t                   handle,
-                                        int                               n,
-                                        const hipblasDoubleComplex* const x[],
-                                        int                               incx,
-                                        hipblasDoubleComplex* const       y[],
-                                        int                               incy,
-                                        int                               batch_count)
-{
-    return hipblasZcopyBatched(handle,
-                               n,
-                               (const hipDoubleComplex* const*)x,
-                               incx,
-                               (hipDoubleComplex* const*)y,
-                               incy,
-                               batch_count);
-}
-
-hipblasStatus_t hipblasCcopyBatchedCast_64(hipblasHandle_t             handle,
-                                           int64_t                     n,
-                                           const hipblasComplex* const x[],
-                                           int64_t                     incx,
-                                           hipblasComplex* const       y[],
-                                           int64_t                     incy,
-                                           int64_t                     batch_count)
-{
-    return hipblasCcopyBatched_64(
-        handle, n, (const hipComplex* const*)x, incx, (hipComplex* const*)y, incy, batch_count);
-}
-
-hipblasStatus_t hipblasZcopyBatchedCast_64(hipblasHandle_t                   handle,
-                                           int64_t                           n,
-                                           const hipblasDoubleComplex* const x[],
-                                           int64_t                           incx,
-                                           hipblasDoubleComplex* const       y[],
-                                           int64_t                           incy,
-                                           int64_t                           batch_count)
-{
-    return hipblasZcopyBatched_64(handle,
-                                  n,
-                                  (const hipDoubleComplex* const*)x,
-                                  incx,
-                                  (hipDoubleComplex* const*)y,
-                                  incy,
-                                  batch_count);
-}
-
-// strided_batched
-hipblasStatus_t hipblasCcopyStridedBatchedCast(hipblasHandle_t       handle,
-                                               int                   n,
-                                               const hipblasComplex* x,
-                                               int                   incx,
-                                               hipblasStride         stridex,
-                                               hipblasComplex*       y,
-                                               int                   incy,
-                                               hipblasStride         stridey,
-                                               int                   batch_count)
-{
-    return hipblasCcopyStridedBatched(
-        handle, n, (const hipComplex*)x, incx, stridex, (hipComplex*)y, incy, stridey, batch_count);
-}
-
-hipblasStatus_t hipblasZcopyStridedBatchedCast(hipblasHandle_t             handle,
-                                               int                         n,
-                                               const hipblasDoubleComplex* x,
-                                               int                         incx,
-                                               hipblasStride               stridex,
-                                               hipblasDoubleComplex*       y,
-                                               int                         incy,
-                                               hipblasStride               stridey,
-                                               int                         batch_count)
-{
-    return hipblasZcopyStridedBatched(handle,
-                                      n,
-                                      (const hipDoubleComplex*)x,
-                                      incx,
-                                      stridex,
-                                      (hipDoubleComplex*)y,
-                                      incy,
-                                      stridey,
-                                      batch_count);
-}
-
-hipblasStatus_t hipblasCcopyStridedBatchedCast_64(hipblasHandle_t       handle,
-                                                  int64_t               n,
-                                                  const hipblasComplex* x,
-                                                  int64_t               incx,
-                                                  hipblasStride         stridex,
-                                                  hipblasComplex*       y,
-                                                  int64_t               incy,
-                                                  hipblasStride         stridey,
-                                                  int64_t               batch_count)
-{
-    return hipblasCcopyStridedBatched_64(
-        handle, n, (const hipComplex*)x, incx, stridex, (hipComplex*)y, incy, stridey, batch_count);
-}
-
-hipblasStatus_t hipblasZcopyStridedBatchedCast_64(hipblasHandle_t             handle,
-                                                  int64_t                     n,
-                                                  const hipblasDoubleComplex* x,
-                                                  int64_t                     incx,
-                                                  hipblasStride               stridex,
-                                                  hipblasDoubleComplex*       y,
-                                                  int64_t                     incy,
-                                                  hipblasStride               stridey,
-                                                  int64_t                     batch_count)
-{
-    return hipblasZcopyStridedBatched_64(handle,
-                                         n,
-                                         (const hipDoubleComplex*)x,
-                                         incx,
-                                         stridex,
-                                         (hipDoubleComplex*)y,
-                                         incy,
-                                         stridey,
-                                         batch_count);
-}
-
-// dot
-hipblasStatus_t hipblasCdotuCast(hipblasHandle_t       handle,
-                                 int                   n,
-                                 const hipblasComplex* x,
-                                 int                   incx,
-                                 const hipblasComplex* y,
-                                 int                   incy,
-                                 hipblasComplex*       result)
-{
-    return hipblasCdotu(
-        handle, n, (const hipComplex*)x, incx, (const hipComplex*)y, incy, (hipComplex*)result);
-}
-
-hipblasStatus_t hipblasZdotuCast(hipblasHandle_t             handle,
-                                 int                         n,
-                                 const hipblasDoubleComplex* x,
-                                 int                         incx,
-                                 const hipblasDoubleComplex* y,
-                                 int                         incy,
-                                 hipblasDoubleComplex*       result)
-{
-    return hipblasZdotu(handle,
-                        n,
-                        (const hipDoubleComplex*)x,
-                        incx,
-                        (const hipDoubleComplex*)y,
-                        incy,
-                        (hipDoubleComplex*)result);
-}
-
-hipblasStatus_t hipblasCdotcCast(hipblasHandle_t       handle,
-                                 int                   n,
-                                 const hipblasComplex* x,
-                                 int                   incx,
-                                 const hipblasComplex* y,
-                                 int                   incy,
-                                 hipblasComplex*       result)
-{
-    return hipblasCdotc(
-        handle, n, (const hipComplex*)x, incx, (const hipComplex*)y, incy, (hipComplex*)result);
-}
-
-hipblasStatus_t hipblasZdotcCast(hipblasHandle_t             handle,
-                                 int                         n,
-                                 const hipblasDoubleComplex* x,
-                                 int                         incx,
-                                 const hipblasDoubleComplex* y,
-                                 int                         incy,
-                                 hipblasDoubleComplex*       result)
-{
-    return hipblasZdotc(handle,
-                        n,
-                        (const hipDoubleComplex*)x,
-                        incx,
-                        (const hipDoubleComplex*)y,
-                        incy,
-                        (hipDoubleComplex*)result);
-}
-
-hipblasStatus_t hipblasCdotuCast_64(hipblasHandle_t       handle,
-                                    int64_t               n,
-                                    const hipblasComplex* x,
-                                    int64_t               incx,
-                                    const hipblasComplex* y,
-                                    int64_t               incy,
-                                    hipblasComplex*       result)
-{
-    return hipblasCdotu_64(
-        handle, n, (const hipComplex*)x, incx, (const hipComplex*)y, incy, (hipComplex*)result);
-}
-
-hipblasStatus_t hipblasZdotuCast_64(hipblasHandle_t             handle,
-                                    int64_t                     n,
-                                    const hipblasDoubleComplex* x,
-                                    int64_t                     incx,
-                                    const hipblasDoubleComplex* y,
-                                    int64_t                     incy,
-                                    hipblasDoubleComplex*       result)
-{
-    return hipblasZdotu_64(handle,
-                           n,
-                           (const hipDoubleComplex*)x,
-                           incx,
-                           (const hipDoubleComplex*)y,
-                           incy,
-                           (hipDoubleComplex*)result);
-}
-
-hipblasStatus_t hipblasCdotcCast_64(hipblasHandle_t       handle,
-                                    int64_t               n,
-                                    const hipblasComplex* x,
-                                    int64_t               incx,
-                                    const hipblasComplex* y,
-                                    int64_t               incy,
-                                    hipblasComplex*       result)
-{
-    return hipblasCdotc_64(
-        handle, n, (const hipComplex*)x, incx, (const hipComplex*)y, incy, (hipComplex*)result);
-}
-
-hipblasStatus_t hipblasZdotcCast_64(hipblasHandle_t             handle,
-                                    int64_t                     n,
-                                    const hipblasDoubleComplex* x,
-                                    int64_t                     incx,
-                                    const hipblasDoubleComplex* y,
-                                    int64_t                     incy,
-                                    hipblasDoubleComplex*       result)
-{
-    return hipblasZdotc_64(handle,
-                           n,
-                           (const hipDoubleComplex*)x,
-                           incx,
-                           (const hipDoubleComplex*)y,
-                           incy,
-                           (hipDoubleComplex*)result);
-}
-
-// dot_batched
-hipblasStatus_t hipblasCdotuBatchedCast(hipblasHandle_t             handle,
-                                        int                         n,
-                                        const hipblasComplex* const x[],
-                                        int                         incx,
-                                        const hipblasComplex* const y[],
-                                        int                         incy,
-                                        int                         batch_count,
-                                        hipblasComplex*             result)
-{
-    return hipblasCdotuBatched(handle,
-                               n,
-                               (const hipComplex* const*)x,
-                               incx,
-                               (const hipComplex* const*)y,
-                               incy,
-                               batch_count,
-                               (hipComplex*)result);
-}
-
-hipblasStatus_t hipblasCdotcBatchedCast(hipblasHandle_t             handle,
-                                        int                         n,
-                                        const hipblasComplex* const x[],
-                                        int                         incx,
-                                        const hipblasComplex* const y[],
-                                        int                         incy,
-                                        int                         batch_count,
-                                        hipblasComplex*             result)
-{
-    return hipblasCdotcBatched(handle,
-                               n,
-                               (const hipComplex* const*)x,
-                               incx,
-                               (const hipComplex* const*)y,
-                               incy,
-                               batch_count,
-                               (hipComplex*)result);
-}
-
-hipblasStatus_t hipblasZdotuBatchedCast(hipblasHandle_t                   handle,
-                                        int                               n,
-                                        const hipblasDoubleComplex* const x[],
-                                        int                               incx,
-                                        const hipblasDoubleComplex* const y[],
-                                        int                               incy,
-                                        int                               batch_count,
-                                        hipblasDoubleComplex*             result)
-{
-    return hipblasZdotuBatched(handle,
-                               n,
-                               (const hipDoubleComplex* const*)x,
-                               incx,
-                               (const hipDoubleComplex* const*)y,
-                               incy,
-                               batch_count,
-                               (hipDoubleComplex*)result);
-}
-
-hipblasStatus_t hipblasZdotcBatchedCast(hipblasHandle_t                   handle,
-                                        int                               n,
-                                        const hipblasDoubleComplex* const x[],
-                                        int                               incx,
-                                        const hipblasDoubleComplex* const y[],
-                                        int                               incy,
-                                        int                               batch_count,
-                                        hipblasDoubleComplex*             result)
-{
-    return hipblasZdotcBatched(handle,
-                               n,
-                               (const hipDoubleComplex* const*)x,
-                               incx,
-                               (const hipDoubleComplex* const*)y,
-                               incy,
-                               batch_count,
-                               (hipDoubleComplex*)result);
-}
-
-hipblasStatus_t hipblasCdotuBatchedCast_64(hipblasHandle_t             handle,
-                                           int64_t                     n,
-                                           const hipblasComplex* const x[],
-                                           int64_t                     incx,
-                                           const hipblasComplex* const y[],
-                                           int64_t                     incy,
-                                           int64_t                     batch_count,
-                                           hipblasComplex*             result)
-{
-    return hipblasCdotuBatched_64(handle,
-                                  n,
-                                  (const hipComplex* const*)x,
-                                  incx,
-                                  (const hipComplex* const*)y,
-                                  incy,
-                                  batch_count,
-                                  (hipComplex*)result);
-}
-
-hipblasStatus_t hipblasCdotcBatchedCast_64(hipblasHandle_t             handle,
-                                           int64_t                     n,
-                                           const hipblasComplex* const x[],
-                                           int64_t                     incx,
-                                           const hipblasComplex* const y[],
-                                           int64_t                     incy,
-                                           int64_t                     batch_count,
-                                           hipblasComplex*             result)
-{
-    return hipblasCdotcBatched_64(handle,
-                                  n,
-                                  (const hipComplex* const*)x,
-                                  incx,
-                                  (const hipComplex* const*)y,
-                                  incy,
-                                  batch_count,
-                                  (hipComplex*)result);
-}
-
-hipblasStatus_t hipblasZdotuBatchedCast_64(hipblasHandle_t                   handle,
-                                           int64_t                           n,
-                                           const hipblasDoubleComplex* const x[],
-                                           int64_t                           incx,
-                                           const hipblasDoubleComplex* const y[],
-                                           int64_t                           incy,
-                                           int64_t                           batch_count,
-                                           hipblasDoubleComplex*             result)
-{
-    return hipblasZdotuBatched_64(handle,
-                                  n,
-                                  (const hipDoubleComplex* const*)x,
-                                  incx,
-                                  (const hipDoubleComplex* const*)y,
-                                  incy,
-                                  batch_count,
-                                  (hipDoubleComplex*)result);
-}
-
-hipblasStatus_t hipblasZdotcBatchedCast_64(hipblasHandle_t                   handle,
-                                           int64_t                           n,
-                                           const hipblasDoubleComplex* const x[],
-                                           int64_t                           incx,
-                                           const hipblasDoubleComplex* const y[],
-                                           int64_t                           incy,
-                                           int64_t                           batch_count,
-                                           hipblasDoubleComplex*             result)
-{
-    return hipblasZdotcBatched_64(handle,
-                                  n,
-                                  (const hipDoubleComplex* const*)x,
-                                  incx,
-                                  (const hipDoubleComplex* const*)y,
-                                  incy,
-                                  batch_count,
-                                  (hipDoubleComplex*)result);
-}
-
-// dot_strided_batched
-hipblasStatus_t hipblasCdotuStridedBatchedCast(hipblasHandle_t       handle,
-                                               int                   n,
-                                               const hipblasComplex* x,
-                                               int                   incx,
-                                               hipblasStride         stridex,
-                                               const hipblasComplex* y,
-                                               int                   incy,
-                                               hipblasStride         stridey,
-                                               int                   batch_count,
-                                               hipblasComplex*       result)
-{
-    return hipblasCdotuStridedBatched(handle,
-                                      n,
-                                      (const hipComplex*)x,
-                                      incx,
-                                      stridex,
-                                      (const hipComplex*)y,
-                                      incy,
-                                      stridey,
-                                      batch_count,
-                                      (hipComplex*)result);
-}
-
-hipblasStatus_t hipblasCdotcStridedBatchedCast(hipblasHandle_t       handle,
-                                               int                   n,
-                                               const hipblasComplex* x,
-                                               int                   incx,
-                                               hipblasStride         stridex,
-                                               const hipblasComplex* y,
-                                               int                   incy,
-                                               hipblasStride         stridey,
-                                               int                   batch_count,
-                                               hipblasComplex*       result)
-{
-    return hipblasCdotcStridedBatched(handle,
-                                      n,
-                                      (const hipComplex*)x,
-                                      incx,
-                                      stridex,
-                                      (const hipComplex*)y,
-                                      incy,
-                                      stridey,
-                                      batch_count,
-                                      (hipComplex*)result);
-}
-
-hipblasStatus_t hipblasZdotuStridedBatchedCast(hipblasHandle_t             handle,
-                                               int                         n,
-                                               const hipblasDoubleComplex* x,
-                                               int                         incx,
-                                               hipblasStride               stridex,
-                                               const hipblasDoubleComplex* y,
-                                               int                         incy,
-                                               hipblasStride               stridey,
-                                               int                         batch_count,
-                                               hipblasDoubleComplex*       result)
-{
-    return hipblasZdotuStridedBatched(handle,
-                                      n,
-                                      (const hipDoubleComplex*)x,
-                                      incx,
-                                      stridex,
-                                      (const hipDoubleComplex*)y,
-                                      incy,
-                                      stridey,
-                                      batch_count,
-                                      (hipDoubleComplex*)result);
-}
-
-hipblasStatus_t hipblasZdotcStridedBatchedCast(hipblasHandle_t             handle,
-                                               int                         n,
-                                               const hipblasDoubleComplex* x,
-                                               int                         incx,
-                                               hipblasStride               stridex,
-                                               const hipblasDoubleComplex* y,
-                                               int                         incy,
-                                               hipblasStride               stridey,
-                                               int                         batch_count,
-                                               hipblasDoubleComplex*       result)
-{
-    return hipblasZdotcStridedBatched(handle,
-                                      n,
-                                      (const hipDoubleComplex*)x,
-                                      incx,
-                                      stridex,
-                                      (const hipDoubleComplex*)y,
-                                      incy,
-                                      stridey,
-                                      batch_count,
-                                      (hipDoubleComplex*)result);
-}
-
-hipblasStatus_t hipblasCdotuStridedBatchedCast_64(hipblasHandle_t       handle,
-                                                  int64_t               n,
-                                                  const hipblasComplex* x,
-                                                  int64_t               incx,
-                                                  hipblasStride         stridex,
-                                                  const hipblasComplex* y,
-                                                  int64_t               incy,
-                                                  hipblasStride         stridey,
-                                                  int64_t               batch_count,
-                                                  hipblasComplex*       result)
-{
-    return hipblasCdotuStridedBatched_64(handle,
-                                         n,
-                                         (const hipComplex*)x,
-                                         incx,
-                                         stridex,
-                                         (const hipComplex*)y,
-                                         incy,
-                                         stridey,
-                                         batch_count,
-                                         (hipComplex*)result);
-}
-
-hipblasStatus_t hipblasCdotcStridedBatchedCast_64(hipblasHandle_t       handle,
-                                                  int64_t               n,
-                                                  const hipblasComplex* x,
-                                                  int64_t               incx,
-                                                  hipblasStride         stridex,
-                                                  const hipblasComplex* y,
-                                                  int64_t               incy,
-                                                  hipblasStride         stridey,
-                                                  int64_t               batch_count,
-                                                  hipblasComplex*       result)
-{
-    return hipblasCdotcStridedBatched_64(handle,
-                                         n,
-                                         (const hipComplex*)x,
-                                         incx,
-                                         stridex,
-                                         (const hipComplex*)y,
-                                         incy,
-                                         stridey,
-                                         batch_count,
-                                         (hipComplex*)result);
-}
-
-hipblasStatus_t hipblasZdotuStridedBatchedCast_64(hipblasHandle_t             handle,
-                                                  int64_t                     n,
-                                                  const hipblasDoubleComplex* x,
-                                                  int64_t                     incx,
-                                                  hipblasStride               stridex,
-                                                  const hipblasDoubleComplex* y,
-                                                  int64_t                     incy,
-                                                  hipblasStride               stridey,
-                                                  int64_t                     batch_count,
-                                                  hipblasDoubleComplex*       result)
-{
-    return hipblasZdotuStridedBatched_64(handle,
-                                         n,
-                                         (const hipDoubleComplex*)x,
-                                         incx,
-                                         stridex,
-                                         (const hipDoubleComplex*)y,
-                                         incy,
-                                         stridey,
-                                         batch_count,
-                                         (hipDoubleComplex*)result);
-}
-
-hipblasStatus_t hipblasZdotcStridedBatchedCast_64(hipblasHandle_t             handle,
-                                                  int64_t                     n,
-                                                  const hipblasDoubleComplex* x,
-                                                  int64_t                     incx,
-                                                  hipblasStride               stridex,
-                                                  const hipblasDoubleComplex* y,
-                                                  int64_t                     incy,
-                                                  hipblasStride               stridey,
-                                                  int64_t                     batch_count,
-                                                  hipblasDoubleComplex*       result)
-{
-    return hipblasZdotcStridedBatched_64(handle,
-                                         n,
-                                         (const hipDoubleComplex*)x,
-                                         incx,
-                                         stridex,
-                                         (const hipDoubleComplex*)y,
-                                         incy,
-                                         stridey,
-                                         batch_count,
-                                         (hipDoubleComplex*)result);
-}
-
-// asum
-hipblasStatus_t hipblasScasumCast(
-    hipblasHandle_t handle, int n, const hipblasComplex* x, int incx, float* result)
-{
-    return hipblasScasum(handle, n, (const hipComplex*)x, incx, result);
-}
-
-hipblasStatus_t hipblasDzasumCast(
-    hipblasHandle_t handle, int n, const hipblasDoubleComplex* x, int incx, double* result)
-{
-    return hipblasDzasum(handle, n, (const hipDoubleComplex*)x, incx, result);
-}
-
-hipblasStatus_t hipblasScasumCast_64(
-    hipblasHandle_t handle, int64_t n, const hipblasComplex* x, int64_t incx, float* result)
-{
-    return hipblasScasum_64(handle, n, (const hipComplex*)x, incx, result);
-}
-
-hipblasStatus_t hipblasDzasumCast_64(
-    hipblasHandle_t handle, int64_t n, const hipblasDoubleComplex* x, int64_t incx, double* result)
-{
-    return hipblasDzasum_64(handle, n, (const hipDoubleComplex*)x, incx, result);
-}
-
-// asum_batched
-hipblasStatus_t hipblasScasumBatchedCast(hipblasHandle_t             handle,
-                                         int                         n,
-                                         const hipblasComplex* const x[],
-                                         int                         incx,
-                                         int                         batch_count,
-                                         float*                      result)
-{
-    return hipblasScasumBatched(handle, n, (const hipComplex* const*)x, incx, batch_count, result);
-}
-
-hipblasStatus_t hipblasDzasumBatchedCast(hipblasHandle_t                   handle,
-                                         int                               n,
-                                         const hipblasDoubleComplex* const x[],
-                                         int                               incx,
-                                         int                               batch_count,
-                                         double*                           result)
-{
-    return hipblasDzasumBatched(
-        handle, n, (const hipDoubleComplex* const*)x, incx, batch_count, result);
-}
-
-hipblasStatus_t hipblasScasumBatchedCast_64(hipblasHandle_t             handle,
-                                            int64_t                     n,
-                                            const hipblasComplex* const x[],
-                                            int64_t                     incx,
-                                            int64_t                     batch_count,
-                                            float*                      result)
-{
-    return hipblasScasumBatched_64(
-        handle, n, (const hipComplex* const*)x, incx, batch_count, result);
-}
-
-hipblasStatus_t hipblasDzasumBatchedCast_64(hipblasHandle_t                   handle,
-                                            int64_t                           n,
-                                            const hipblasDoubleComplex* const x[],
-                                            int64_t                           incx,
-                                            int64_t                           batch_count,
-                                            double*                           result)
-{
-    return hipblasDzasumBatched_64(
-        handle, n, (const hipDoubleComplex* const*)x, incx, batch_count, result);
-}
-
-// asum_strided_batched
-hipblasStatus_t hipblasScasumStridedBatchedCast(hipblasHandle_t       handle,
-                                                int                   n,
-                                                const hipblasComplex* x,
-                                                int                   incx,
-                                                hipblasStride         stridex,
-                                                int                   batch_count,
-                                                float*                result)
-{
-    return hipblasScasumStridedBatched(
-        handle, n, (const hipComplex*)x, incx, stridex, batch_count, result);
-}
-
-hipblasStatus_t hipblasDzasumStridedBatchedCast(hipblasHandle_t             handle,
-                                                int                         n,
-                                                const hipblasDoubleComplex* x,
-                                                int                         incx,
-                                                hipblasStride               stridex,
-                                                int                         batch_count,
-                                                double*                     result)
-{
-    return hipblasDzasumStridedBatched(
-        handle, n, (const hipDoubleComplex*)x, incx, stridex, batch_count, result);
-}
-
-hipblasStatus_t hipblasScasumStridedBatchedCast_64(hipblasHandle_t       handle,
-                                                   int64_t               n,
-                                                   const hipblasComplex* x,
-                                                   int64_t               incx,
-                                                   hipblasStride         stridex,
-                                                   int64_t               batch_count,
-                                                   float*                result)
-{
-    return hipblasScasumStridedBatched_64(
-        handle, n, (const hipComplex*)x, incx, stridex, batch_count, result);
-}
-
-hipblasStatus_t hipblasDzasumStridedBatchedCast_64(hipblasHandle_t             handle,
-                                                   int64_t                     n,