Fixed a namespace clash with CUDA FP16 for the half-datatype

include/clblast_half.h

@@ -32,9 +32,8 @@
 
 // =================================================================================================
 
-// Host data-type for half-precision floating-point (16-bit). This is based on the OpenCL type,
-// which is a typedef for unsigned short.
-typedef cl_half half;
+// The host data-type for half-precision floating-point (16-bit) is based on the `cl_half` OpenCL
+// type, which is a typedef for unsigned short.
 
 // 32-bit union for conversions
 typedef union ConversionBits_ {
@@ -47,7 +46,7 @@ typedef union ConversionBits_ {
 // Converts a IEEE-compliant single-precision value to half-precision floating-point. This function
 // applies simple truncation (round toward zero, but with overflows set to infinity) as rounding
 // mode.
-inline half FloatToHalf(const float value) {
+inline cl_half FloatToHalf(const float value) {
   static const unsigned short base_table[512] = { 
     0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
     0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
@@ -108,7 +107,7 @@ inline half FloatToHalf(const float value) {
 }
 
 // Converts a half-precision value to IEEE-compliant single-precision floating-point
-inline float HalfToFloat(const half value) {
+inline float HalfToFloat(const cl_half value) {
   static const unsigned int mantissa_table[2048] = { 
     0x00000000, 0x33800000, 0x34000000, 0x34400000, 0x34800000, 0x34A00000, 0x34C00000, 0x34E00000, 0x35000000, 0x35100000, 0x35200000, 0x35300000, 0x35400000, 0x35500000, 0x35600000, 0x35700000,
     0x35800000, 0x35880000, 0x35900000, 0x35980000, 0x35A00000, 0x35A80000, 0x35B00000, 0x35B80000, 0x35C00000, 0x35C80000, 0x35D00000, 0x35D80000, 0x35E00000, 0x35E80000, 0x35F00000, 0x35F80000,

scripts/generator/generator.py

@@ -42,7 +42,7 @@ FILES = [
     "/include/clblast_netlib_c.h",
     "/src/clblast_netlib_c.cpp",
 ]
-HEADER_LINES = [122, 77, 126, 23, 29, 41, 29, 65, 32]
+HEADER_LINES = [122, 77, 126, 24, 29, 41, 29, 65, 32]
 FOOTER_LINES = [25, 139, 27, 38, 6, 6, 6, 9, 2]
 HEADER_LINES_DOC = 0
 FOOTER_LINES_DOC = 63

scripts/generator/generator/datatype.py

@@ -72,8 +72,8 @@ class DataType:
 
     def test_template(self):
         """Returns the template as used in the correctness/performance tests"""
-        buffer_type = "clblast::" + self.buffer_type if self.buffer_type in [D_FLOAT2, D_DOUBLE2] else self.buffer_type
-        beta_cpp = "clblast::" + self.beta_cpp if self.beta_cpp in [D_FLOAT2, D_DOUBLE2] else self.beta_cpp
+        buffer_type = "clblast::" + self.buffer_type if self.is_non_standard() else self.buffer_type
+        beta_cpp = "clblast::" + self.beta_cpp if self.beta_cpp in [D_HALF, D_FLOAT2, D_DOUBLE2] else self.beta_cpp
         if self.buffer_type != self.beta_cpp:
             return "<" + buffer_type + "," + self.beta_cpp + ">, " + buffer_type + ", " + beta_cpp
         return "<" + buffer_type + ">, " + buffer_type + ", " + beta_cpp

src/clblast_c.cpp

@@ -19,6 +19,7 @@
 #include "clblast.h"
 
 // Shortcuts to the clblast namespace
+using half = clblast::half;
 using float2 = clblast::float2;
 using double2 = clblast::double2;
 

src/tuning/kernels/copy_fast.cpp

@@ -105,6 +105,7 @@ class TuneCopy {
 } // namespace clblast
 
 // Shortcuts to the clblast namespace
+using half = clblast::half;
 using float2 = clblast::float2;
 using double2 = clblast::double2;
 

src/tuning/kernels/copy_pad.cpp

@@ -113,6 +113,7 @@ class TunePad {
 } // namespace clblast
 
 // Shortcuts to the clblast namespace
+using half = clblast::half;
 using float2 = clblast::float2;
 using double2 = clblast::double2;
 

src/tuning/kernels/transpose_fast.cpp

@@ -110,6 +110,7 @@ class TuneTranspose {
 } // namespace clblast
 
 // Shortcuts to the clblast namespace
+using half = clblast::half;
 using float2 = clblast::float2;
 using double2 = clblast::double2;
 

src/tuning/kernels/transpose_pad.cpp

@@ -117,6 +117,7 @@ class TunePadTranspose {
 } // namespace clblast
 
 // Shortcuts to the clblast namespace
+using half = clblast::half;
 using float2 = clblast::float2;
 using double2 = clblast::double2;
 

src/tuning/kernels/xaxpy.cpp

@@ -108,6 +108,7 @@ class TuneXaxpy {
 } // namespace clblast
 
 // Shortcuts to the clblast namespace
+using half = clblast::half;
 using float2 = clblast::float2;
 using double2 = clblast::double2;
 

src/tuning/kernels/xdot.cpp

@@ -114,6 +114,7 @@ class TuneXdot {
 } // namespace clblast
 
 // Shortcuts to the clblast namespace
+using half = clblast::half;
 using float2 = clblast::float2;
 using double2 = clblast::double2;
 

src/tuning/kernels/xgemm.cpp

@@ -173,6 +173,7 @@ class TuneXgemm {
 } // namespace clblast
 
 // Shortcuts to the clblast namespace
+using half = clblast::half;
 using float2 = clblast::float2;
 using double2 = clblast::double2;
 

src/tuning/kernels/xgemm_direct.cpp

@@ -172,6 +172,7 @@ class TuneXgemmDirect {
 } // namespace clblast
 
 // Shortcuts to the clblast namespace
+using half = clblast::half;
 using float2 = clblast::float2;
 using double2 = clblast::double2;
 

src/tuning/kernels/xgemv.cpp

@@ -154,6 +154,7 @@ class TuneXgemv {
 } // namespace clblast
 
 // Shortcuts to the clblast namespace
+using half = clblast::half;
 using float2 = clblast::float2;
 using double2 = clblast::double2;
 

src/tuning/kernels/xger.cpp

@@ -113,6 +113,7 @@ class TuneXger {
 } // namespace clblast
 
 // Shortcuts to the clblast namespace
+using half = clblast::half;
 using float2 = clblast::float2;
 using double2 = clblast::double2;
 

src/utilities/utilities.hpp

@@ -31,6 +31,9 @@
 namespace clblast {
 // =================================================================================================
 
+// Shorthands for half-precision
+using half = cl_half; // based on the OpenCL type, which is actually an 'unsigned short'
+
 // Shorthands for complex data-types
 using float2 = std::complex<float>;
 using double2 = std::complex<double>;

test/correctness/routines/level1/xamax.cpp

@@ -19,7 +19,7 @@ int main(int argc, char *argv[]) {
   errors += clblast::RunTests<clblast::TestXamax<double>, double, double>(argc, argv, true, "iDAMAX");
   errors += clblast::RunTests<clblast::TestXamax<clblast::float2>, clblast::float2, clblast::float2>(argc, argv, true, "iCAMAX");
   errors += clblast::RunTests<clblast::TestXamax<clblast::double2>, clblast::double2, clblast::double2>(argc, argv, true, "iZAMAX");
-  errors += clblast::RunTests<clblast::TestXamax<half>, half, half>(argc, argv, true, "iHAMAX");
+  errors += clblast::RunTests<clblast::TestXamax<clblast::half>, clblast::half, clblast::half>(argc, argv, true, "iHAMAX");
   if (errors > 0) { return 1; } else { return 0; }
 }
 

test/correctness/routines/level1/xasum.cpp

@@ -19,7 +19,7 @@ int main(int argc, char *argv[]) {
   errors += clblast::RunTests<clblast::TestXasum<double>, double, double>(argc, argv, true, "DASUM");
   errors += clblast::RunTests<clblast::TestXasum<clblast::float2>, clblast::float2, clblast::float2>(argc, argv, true, "ScASUM");
   errors += clblast::RunTests<clblast::TestXasum<clblast::double2>, clblast::double2, clblast::double2>(argc, argv, true, "DzASUM");
-  errors += clblast::RunTests<clblast::TestXasum<half>, half, half>(argc, argv, true, "HASUM");
+  errors += clblast::RunTests<clblast::TestXasum<clblast::half>, clblast::half, clblast::half>(argc, argv, true, "HASUM");
   if (errors > 0) { return 1; } else { return 0; }
 }
 

test/correctness/routines/level1/xaxpy.cpp

@@ -19,7 +19,7 @@ int main(int argc, char *argv[]) {
   errors += clblast::RunTests<clblast::TestXaxpy<double>, double, double>(argc, argv, true, "DAXPY");
   errors += clblast::RunTests<clblast::TestXaxpy<clblast::float2>, clblast::float2, clblast::float2>(argc, argv, true, "CAXPY");
   errors += clblast::RunTests<clblast::TestXaxpy<clblast::double2>, clblast::double2, clblast::double2>(argc, argv, true, "ZAXPY");
-  errors += clblast::RunTests<clblast::TestXaxpy<half>, half, half>(argc, argv, true, "HAXPY");
+  errors += clblast::RunTests<clblast::TestXaxpy<clblast::half>, clblast::half, clblast::half>(argc, argv, true, "HAXPY");
   if (errors > 0) { return 1; } else { return 0; }
 }
 

test/correctness/routines/level1/xcopy.cpp

@@ -19,7 +19,7 @@ int main(int argc, char *argv[]) {
   errors += clblast::RunTests<clblast::TestXcopy<double>, double, double>(argc, argv, true, "DCOPY");
   errors += clblast::RunTests<clblast::TestXcopy<clblast::float2>, clblast::float2, clblast::float2>(argc, argv, true, "CCOPY");
   errors += clblast::RunTests<clblast::TestXcopy<clblast::double2>, clblast::double2, clblast::double2>(argc, argv, true, "ZCOPY");
-  errors += clblast::RunTests<clblast::TestXcopy<half>, half, half>(argc, argv, true, "HCOPY");
+  errors += clblast::RunTests<clblast::TestXcopy<clblast::half>, clblast::half, clblast::half>(argc, argv, true, "HCOPY");
   if (errors > 0) { return 1; } else { return 0; }
 }
 

test/correctness/routines/level1/xdot.cpp

@@ -17,7 +17,7 @@ int main(int argc, char *argv[]) {
   auto errors = size_t{0};
   errors += clblast::RunTests<clblast::TestXdot<float>, float, float>(argc, argv, false, "SDOT");
   errors += clblast::RunTests<clblast::TestXdot<double>, double, double>(argc, argv, true, "DDOT");
-  errors += clblast::RunTests<clblast::TestXdot<half>, half, half>(argc, argv, true, "HDOT");
+  errors += clblast::RunTests<clblast::TestXdot<clblast::half>, clblast::half, clblast::half>(argc, argv, true, "HDOT");
   if (errors > 0) { return 1; } else { return 0; }
 }
 

test/correctness/routines/level1/xnrm2.cpp

@@ -19,7 +19,7 @@ int main(int argc, char *argv[]) {
   errors += clblast::RunTests<clblast::TestXnrm2<double>, double, double>(argc, argv, true, "DNRM2");
   errors += clblast::RunTests<clblast::TestXnrm2<clblast::float2>, clblast::float2, clblast::float2>(argc, argv, true, "ScNRM2");
   errors += clblast::RunTests<clblast::TestXnrm2<clblast::double2>, clblast::double2, clblast::double2>(argc, argv, true, "DzNRM2");
-  errors += clblast::RunTests<clblast::TestXnrm2<half>, half, half>(argc, argv, true, "HNRM2");
+  errors += clblast::RunTests<clblast::TestXnrm2<clblast::half>, clblast::half, clblast::half>(argc, argv, true, "HNRM2");
   if (errors > 0) { return 1; } else { return 0; }
 }
 

test/correctness/routines/level1/xscal.cpp

@@ -19,7 +19,7 @@ int main(int argc, char *argv[]) {
   errors += clblast::RunTests<clblast::TestXscal<double>, double, double>(argc, argv, true, "DSCAL");
   errors += clblast::RunTests<clblast::TestXscal<clblast::float2>, clblast::float2, clblast::float2>(argc, argv, true, "CSCAL");
   errors += clblast::RunTests<clblast::TestXscal<clblast::double2>, clblast::double2, clblast::double2>(argc, argv, true, "ZSCAL");
-  errors += clblast::RunTests<clblast::TestXscal<half>, half, half>(argc, argv, true, "HSCAL");
+  errors += clblast::RunTests<clblast::TestXscal<clblast::half>, clblast::half, clblast::half>(argc, argv, true, "HSCAL");
   if (errors > 0) { return 1; } else { return 0; }
 }
 

test/correctness/routines/level1/xswap.cpp

@@ -19,7 +19,7 @@ int main(int argc, char *argv[]) {
   errors += clblast::RunTests<clblast::TestXswap<double>, double, double>(argc, argv, true, "DSWAP");
   errors += clblast::RunTests<clblast::TestXswap<clblast::float2>, clblast::float2, clblast::float2>(argc, argv, true, "CSWAP");
   errors += clblast::RunTests<clblast::TestXswap<clblast::double2>, clblast::double2, clblast::double2>(argc, argv, true, "ZSWAP");
-  errors += clblast::RunTests<clblast::TestXswap<half>, half, half>(argc, argv, true, "HSWAP");
+  errors += clblast::RunTests<clblast::TestXswap<clblast::half>, clblast::half, clblast::half>(argc, argv, true, "HSWAP");
   if (errors > 0) { return 1; } else { return 0; }
 }
 

test/correctness/routines/level2/xgbmv.cpp

@@ -19,7 +19,7 @@ int main(int argc, char *argv[]) {
   errors += clblast::RunTests<clblast::TestXgbmv<double>, double, double>(argc, argv, true, "DGBMV");
   errors += clblast::RunTests<clblast::TestXgbmv<clblast::float2>, clblast::float2, clblast::float2>(argc, argv, true, "CGBMV");
   errors += clblast::RunTests<clblast::TestXgbmv<clblast::double2>, clblast::double2, clblast::double2>(argc, argv, true, "ZGBMV");
-  errors += clblast::RunTests<clblast::TestXgbmv<half>, half, half>(argc, argv, true, "HGBMV");
+  errors += clblast::RunTests<clblast::TestXgbmv<clblast::half>, clblast::half, clblast::half>(argc, argv, true, "HGBMV");
   if (errors > 0) { return 1; } else { return 0; }
 }
 

test/correctness/routines/level2/xgemv.cpp

@@ -19,7 +19,7 @@ int main(int argc, char *argv[]) {
   errors += clblast::RunTests<clblast::TestXgemv<double>, double, double>(argc, argv, true, "DGEMV");
   errors += clblast::RunTests<clblast::TestXgemv<clblast::float2>, clblast::float2, clblast::float2>(argc, argv, true, "CGEMV");
   errors += clblast::RunTests<clblast::TestXgemv<clblast::double2>, clblast::double2, clblast::double2>(argc, argv, true, "ZGEMV");
-  errors += clblast::RunTests<clblast::TestXgemv<half>, half, half>(argc, argv, true, "HGEMV");
+  errors += clblast::RunTests<clblast::TestXgemv<clblast::half>, clblast::half, clblast::half>(argc, argv, true, "HGEMV");
   if (errors > 0) { return 1; } else { return 0; }
 }
 

test/correctness/routines/level2/xger.cpp

@@ -17,7 +17,7 @@ int main(int argc, char *argv[]) {
   auto errors = size_t{0};
   errors += clblast::RunTests<clblast::TestXger<float>, float, float>(argc, argv, false, "SGER");
   errors += clblast::RunTests<clblast::TestXger<double>, double, double>(argc, argv, true, "DGER");
-  errors += clblast::RunTests<clblast::TestXger<half>, half, half>(argc, argv, true, "HGER");
+  errors += clblast::RunTests<clblast::TestXger<clblast::half>, clblast::half, clblast::half>(argc, argv, true, "HGER");
   if (errors > 0) { return 1; } else { return 0; }
 }
 

test/correctness/routines/level2/xsbmv.cpp

@@ -17,7 +17,7 @@ int main(int argc, char *argv[]) {
   auto errors = size_t{0};
   errors += clblast::RunTests<clblast::TestXsbmv<float>, float, float>(argc, argv, false, "SSBMV");
   errors += clblast::RunTests<clblast::TestXsbmv<double>, double, double>(argc, argv, true, "DSBMV");
-  errors += clblast::RunTests<clblast::TestXsbmv<half>, half, half>(argc, argv, true, "HSBMV");
+  errors += clblast::RunTests<clblast::TestXsbmv<clblast::half>, clblast::half, clblast::half>(argc, argv, true, "HSBMV");
   if (errors > 0) { return 1; } else { return 0; }
 }
 

test/correctness/routines/level2/xspmv.cpp

@@ -17,7 +17,7 @@ int main(int argc, char *argv[]) {
   auto errors = size_t{0};
   errors += clblast::RunTests<clblast::TestXspmv<float>, float, float>(argc, argv, false, "SSPMV");
   errors += clblast::RunTests<clblast::TestXspmv<double>, double, double>(argc, argv, true, "DSPMV");
-  errors += clblast::RunTests<clblast::TestXspmv<half>, half, half>(argc, argv, true, "HSPMV");
+  errors += clblast::RunTests<clblast::TestXspmv<clblast::half>, clblast::half, clblast::half>(argc, argv, true, "HSPMV");
   if (errors > 0) { return 1; } else { return 0; }
 }
 

test/correctness/routines/level2/xspr.cpp

@@ -17,7 +17,7 @@ int main(int argc, char *argv[]) {
   auto errors = size_t{0};
   errors += clblast::RunTests<clblast::TestXspr<float>, float, float>(argc, argv, false, "SSPR");
   errors += clblast::RunTests<clblast::TestXspr<double>, double, double>(argc, argv, true, "DSPR");
-  errors += clblast::RunTests<clblast::TestXspr<half>, half, half>(argc, argv, true, "HSPR");
+  errors += clblast::RunTests<clblast::TestXspr<clblast::half>, clblast::half, clblast::half>(argc, argv, true, "HSPR");
   if (errors > 0) { return 1; } else { return 0; }
 }
 

test/correctness/routines/level2/xspr2.cpp

@@ -17,7 +17,7 @@ int main(int argc, char *argv[]) {
   auto errors = size_t{0};
   errors += clblast::RunTests<clblast::TestXspr2<float>, float, float>(argc, argv, false, "SSPR2");
   errors += clblast::RunTests<clblast::TestXspr2<double>, double, double>(argc, argv, true, "DSPR2");
-  errors += clblast::RunTests<clblast::TestXspr2<half>, half, half>(argc, argv, true, "HSPR2");
+  errors += clblast::RunTests<clblast::TestXspr2<clblast::half>, clblast::half, clblast::half>(argc, argv, true, "HSPR2");
   if (errors > 0) { return 1; } else { return 0; }
 }
 

test/correctness/routines/level2/xsymv.cpp

@@ -17,7 +17,7 @@ int main(int argc, char *argv[]) {
   auto errors = size_t{0};
   errors += clblast::RunTests<clblast::TestXsymv<float>, float, float>(argc, argv, false, "SSYMV");
   errors += clblast::RunTests<clblast::TestXsymv<double>, double, double>(argc, argv, true, "DSYMV");
-  errors += clblast::RunTests<clblast::TestXsymv<half>, half, half>(argc, argv, true, "HSYMV");
+  errors += clblast::RunTests<clblast::TestXsymv<clblast::half>, clblast::half, clblast::half>(argc, argv, true, "HSYMV");
   if (errors > 0) { return 1; } else { return 0; }
 }
 

test/correctness/routines/level2/xsyr.cpp

@@ -17,7 +17,7 @@ int main(int argc, char *argv[]) {
   auto errors = size_t{0};
   errors += clblast::RunTests<clblast::TestXsyr<float>, float, float>(argc, argv, false, "SSYR");
   errors += clblast::RunTests<clblast::TestXsyr<double>, double, double>(argc, argv, true, "DSYR");
-  errors += clblast::RunTests<clblast::TestXsyr<half>, half, half>(argc, argv, true, "HSYR");
+  errors += clblast::RunTests<clblast::TestXsyr<clblast::half>, clblast::half, clblast::half>(argc, argv, true, "HSYR");
   if (errors > 0) { return 1; } else { return 0; }
 }
 

test/correctness/routines/level2/xsyr2.cpp

@@ -17,7 +17,7 @@ int main(int argc, char *argv[]) {
   auto errors = size_t{0};
   errors += clblast::RunTests<clblast::TestXsyr2<float>, float, float>(argc, argv, false, "SSYR2");
   errors += clblast::RunTests<clblast::TestXsyr2<double>, double, double>(argc, argv, true, "DSYR2");
-  errors += clblast::RunTests<clblast::TestXsyr2<half>, half, half>(argc, argv, true, "HSYR2");
+  errors += clblast::RunTests<clblast::TestXsyr2<clblast::half>, clblast::half, clblast::half>(argc, argv, true, "HSYR2");
   if (errors > 0) { return 1; } else { return 0; }
 }
 

test/correctness/routines/level2/xtbmv.cpp

@@ -19,7 +19,7 @@ int main(int argc, char *argv[]) {
   errors += clblast::RunTests<clblast::TestXtbmv<double>, double, double>(argc, argv, true, "DTBMV");
   errors += clblast::RunTests<clblast::TestXtbmv<clblast::float2>, clblast::float2, clblast::float2>(argc, argv, true, "CTBMV");
   errors += clblast::RunTests<clblast::TestXtbmv<clblast::double2>, clblast::double2, clblast::double2>(argc, argv, true, "ZTBMV");
-  errors += clblast::RunTests<clblast::TestXtbmv<half>, half, half>(argc, argv, true, "HTBMV");
+  errors += clblast::RunTests<clblast::TestXtbmv<clblast::half>, clblast::half, clblast::half>(argc, argv, true, "HTBMV");
   if (errors > 0) { return 1; } else { return 0; }
 }
 

test/correctness/routines/level2/xtpmv.cpp

@@ -19,7 +19,7 @@ int main(int argc, char *argv[]) {
   errors += clblast::RunTests<clblast::TestXtpmv<double>, double, double>(argc, argv, true, "DTPMV");
   errors += clblast::RunTests<clblast::TestXtpmv<clblast::float2>, clblast::float2, clblast::float2>(argc, argv, true, "CTPMV");
   errors += clblast::RunTests<clblast::TestXtpmv<clblast::double2>, clblast::double2, clblast::double2>(argc, argv, true, "ZTPMV");
-  errors += clblast::RunTests<clblast::TestXtpmv<half>, half, half>(argc, argv, true, "HTPMV");
+  errors += clblast::RunTests<clblast::TestXtpmv<clblast::half>, clblast::half, clblast::half>(argc, argv, true, "HTPMV");
   if (errors > 0) { return 1; } else { return 0; }
 }
 

test/correctness/routines/level2/xtrmv.cpp

@@ -19,7 +19,7 @@ int main(int argc, char *argv[]) {
   errors += clblast::RunTests<clblast::TestXtrmv<double>, double, double>(argc, argv, true, "DTRMV");
   errors += clblast::RunTests<clblast::TestXtrmv<clblast::float2>, clblast::float2, clblast::float2>(argc, argv, true, "CTRMV");
   errors += clblast::RunTests<clblast::TestXtrmv<clblast::double2>, clblast::double2, clblast::double2>(argc, argv, true, "ZTRMV");
-  errors += clblast::RunTests<clblast::TestXtrmv<half>, half, half>(argc, argv, true, "HTRMV");
+  errors += clblast::RunTests<clblast::TestXtrmv<clblast::half>, clblast::half, clblast::half>(argc, argv, true, "HTRMV");
   if (errors > 0) { return 1; } else { return 0; }
 }
 

test/correctness/routines/level3/xgemm.cpp

@@ -19,7 +19,7 @@ int main(int argc, char *argv[]) {
   errors += clblast::RunTests<clblast::TestXgemm<double>, double, double>(argc, argv, true, "DGEMM");
   errors += clblast::RunTests<clblast::TestXgemm<clblast::float2>, clblast::float2, clblast::float2>(argc, argv, true, "CGEMM");
   errors += clblast::RunTests<clblast::TestXgemm<clblast::double2>, clblast::double2, clblast::double2>(argc, argv, true, "ZGEMM");
-  errors += clblast::RunTests<clblast::TestXgemm<half>, half, half>(argc, argv, true, "HGEMM");
+  errors += clblast::RunTests<clblast::TestXgemm<clblast::half>, clblast::half, clblast::half>(argc, argv, true, "HGEMM");
   if (errors > 0) { return 1; } else { return 0; }
 }
 

test/correctness/routines/level3/xsymm.cpp

@@ -19,7 +19,7 @@ int main(int argc, char *argv[]) {
   errors += clblast::RunTests<clblast::TestXsymm<double>, double, double>(argc, argv, true, "DSYMM");
   errors += clblast::RunTests<clblast::TestXsymm<clblast::float2>, clblast::float2, clblast::float2>(argc, argv, true, "CSYMM");
   errors += clblast::RunTests<clblast::TestXsymm<clblast::double2>, clblast::double2, clblast::double2>(argc, argv, true, "ZSYMM");
-  errors += clblast::RunTests<clblast::TestXsymm<half>, half, half>(argc, argv, true, "HSYMM");
+  errors += clblast::RunTests<clblast::TestXsymm<clblast::half>, clblast::half, clblast::half>(argc, argv, true, "HSYMM");
   if (errors > 0) { return 1; } else { return 0; }
 }
 

test/correctness/routines/level3/xsyr2k.cpp

@@ -19,7 +19,7 @@ int main(int argc, char *argv[]) {
   errors += clblast::RunTests<clblast::TestXsyr2k<double>, double, double>(argc, argv, true, "DSYR2K");
   errors += clblast::RunTests<clblast::TestXsyr2k<clblast::float2>, clblast::float2, clblast::float2>(argc, argv, true, "CSYR2K");
   errors += clblast::RunTests<clblast::TestXsyr2k<clblast::double2>, clblast::double2, clblast::double2>(argc, argv, true, "ZSYR2K");
-  errors += clblast::RunTests<clblast::TestXsyr2k<half>, half, half>(argc, argv, true, "HSYR2K");
+  errors += clblast::RunTests<clblast::TestXsyr2k<clblast::half>, clblast::half, clblast::half>(argc, argv, true, "HSYR2K");
   if (errors > 0) { return 1; } else { return 0; }
 }
 

test/correctness/routines/level3/xsyrk.cpp

@@ -19,7 +19,7 @@ int main(int argc, char *argv[]) {
   errors += clblast::RunTests<clblast::TestXsyrk<double>, double, double>(argc, argv, true, "DSYRK");
   errors += clblast::RunTests<clblast::TestXsyrk<clblast::float2>, clblast::float2, clblast::float2>(argc, argv, true, "CSYRK");
   errors += clblast::RunTests<clblast::TestXsyrk<clblast::double2>, clblast::double2, clblast::double2>(argc, argv, true, "ZSYRK");
-  errors += clblast::RunTests<clblast::TestXsyrk<half>, half, half>(argc, argv, true, "HSYRK");
+  errors += clblast::RunTests<clblast::TestXsyrk<clblast::half>, clblast::half, clblast::half>(argc, argv, true, "HSYRK");
   if (errors > 0) { return 1; } else { return 0; }
 }
 

test/correctness/routines/level3/xtrmm.cpp

@@ -19,7 +19,7 @@ int main(int argc, char *argv[]) {
   errors += clblast::RunTests<clblast::TestXtrmm<double>, double, double>(argc, argv, true, "DTRMM");
   errors += clblast::RunTests<clblast::TestXtrmm<clblast::float2>, clblast::float2, clblast::float2>(argc, argv, true, "CTRMM");
   errors += clblast::RunTests<clblast::TestXtrmm<clblast::double2>, clblast::double2, clblast::double2>(argc, argv, true, "ZTRMM");
-  errors += clblast::RunTests<clblast::TestXtrmm<half>, half, half>(argc, argv, true, "HTRMM");
+  errors += clblast::RunTests<clblast::TestXtrmm<clblast::half>, clblast::half, clblast::half>(argc, argv, true, "HTRMM");
   if (errors > 0) { return 1; } else { return 0; }
 }
 

test/correctness/routines/levelx/xaxpybatched.cpp

@@ -19,7 +19,7 @@ int main(int argc, char *argv[]) {
   errors += clblast::RunTests<clblast::TestXaxpyBatched<double>, double, double>(argc, argv, true, "DAXPYBATCHED");
   errors += clblast::RunTests<clblast::TestXaxpyBatched<clblast::float2>, clblast::float2, clblast::float2>(argc, argv, true, "CAXPYBATCHED");
   errors += clblast::RunTests<clblast::TestXaxpyBatched<clblast::double2>, clblast::double2, clblast::double2>(argc, argv, true, "ZAXPYBATCHED");
-  errors += clblast::RunTests<clblast::TestXaxpyBatched<half>, half, half>(argc, argv, true, "HAXPYBATCHED");
+  errors += clblast::RunTests<clblast::TestXaxpyBatched<clblast::half>, clblast::half, clblast::half>(argc, argv, true, "HAXPYBATCHED");
   if (errors > 0) { return 1; } else { return 0; }
 }
 

test/correctness/routines/levelx/xgemmbatched.cpp

@@ -19,7 +19,7 @@ int main(int argc, char *argv[]) {
   errors += clblast::RunTests<clblast::TestXgemmBatched<double>, double, double>(argc, argv, true, "DGEMMBATCHED");
   errors += clblast::RunTests<clblast::TestXgemmBatched<clblast::float2>, clblast::float2, clblast::float2>(argc, argv, true, "CGEMMBATCHED");
   errors += clblast::RunTests<clblast::TestXgemmBatched<clblast::double2>, clblast::double2, clblast::double2>(argc, argv, true, "ZGEMMBATCHED");
-  errors += clblast::RunTests<clblast::TestXgemmBatched<half>, half, half>(argc, argv, true, "HGEMMBATCHED");
+  errors += clblast::RunTests<clblast::TestXgemmBatched<clblast::half>, clblast::half, clblast::half>(argc, argv, true, "HGEMMBATCHED");
   if (errors > 0) { return 1; } else { return 0; }
 }
 

test/correctness/routines/levelx/xomatcopy.cpp

@@ -19,7 +19,7 @@ int main(int argc, char *argv[]) {
   errors += clblast::RunTests<clblast::TestXomatcopy<double>, double, double>(argc, argv, true, "DOMATCOPY");
   errors += clblast::RunTests<clblast::TestXomatcopy<clblast::float2>, clblast::float2, clblast::float2>(argc, argv, true, "COMATCOPY");
   errors += clblast::RunTests<clblast::TestXomatcopy<clblast::double2>, clblast::double2, clblast::double2>(argc, argv, true, "ZOMATCOPY");
-  errors += clblast::RunTests<clblast::TestXomatcopy<half>, half, half>(argc, argv, true, "HOMATCOPY");
+  errors += clblast::RunTests<clblast::TestXomatcopy<clblast::half>, clblast::half, clblast::half>(argc, argv, true, "HOMATCOPY");
   if (errors > 0) { return 1; } else { return 0; }
 }
 

test/performance/routines/level1/xamax.cpp

@@ -17,7 +17,7 @@ int main(int argc, char *argv[]) {
   const auto command_line_args = clblast::RetrieveCommandLineArguments(argc, argv);
   switch(clblast::GetPrecision(command_line_args, clblast::Precision::kSingle)) {
     case clblast::Precision::kHalf:
-      clblast::RunClient<clblast::TestXamax<half>, half, half>(argc, argv); break;
+      clblast::RunClient<clblast::TestXamax<clblast::half>, clblast::half, clblast::half>(argc, argv); break;
     case clblast::Precision::kSingle:
       clblast::RunClient<clblast::TestXamax<float>, float, float>(argc, argv); break;
     case clblast::Precision::kDouble:

test/performance/routines/level1/xasum.cpp

@@ -17,7 +17,7 @@ int main(int argc, char *argv[]) {
   const auto command_line_args = clblast::RetrieveCommandLineArguments(argc, argv);
   switch(clblast::GetPrecision(command_line_args, clblast::Precision::kSingle)) {
     case clblast::Precision::kHalf:
-      clblast::RunClient<clblast::TestXasum<half>, half, half>(argc, argv); break;
+      clblast::RunClient<clblast::TestXasum<clblast::half>, clblast::half, clblast::half>(argc, argv); break;
     case clblast::Precision::kSingle:
       clblast::RunClient<clblast::TestXasum<float>, float, float>(argc, argv); break;
     case clblast::Precision::kDouble:

test/performance/routines/level1/xaxpy.cpp

@@ -17,7 +17,7 @@ int main(int argc, char *argv[]) {
   const auto command_line_args = clblast::RetrieveCommandLineArguments(argc, argv);
   switch(clblast::GetPrecision(command_line_args, clblast::Precision::kSingle)) {
     case clblast::Precision::kHalf:
-      clblast::RunClient<clblast::TestXaxpy<half>, half, half>(argc, argv); break;
+      clblast::RunClient<clblast::TestXaxpy<clblast::half>, clblast::half, clblast::half>(argc, argv); break;
     case clblast::Precision::kSingle:
       clblast::RunClient<clblast::TestXaxpy<float>, float, float>(argc, argv); break;
     case clblast::Precision::kDouble:

test/performance/routines/level1/xcopy.cpp

@@ -17,7 +17,7 @@ int main(int argc, char *argv[]) {
   const auto command_line_args = clblast::RetrieveCommandLineArguments(argc, argv);
   switch(clblast::GetPrecision(command_line_args, clblast::Precision::kSingle)) {
     case clblast::Precision::kHalf:
-      clblast::RunClient<clblast::TestXcopy<half>, half, half>(argc, argv); break;
+      clblast::RunClient<clblast::TestXcopy<clblast::half>, clblast::half, clblast::half>(argc, argv); break;
     case clblast::Precision::kSingle:
       clblast::RunClient<clblast::TestXcopy<float>, float, float>(argc, argv); break;
     case clblast::Precision::kDouble:

test/performance/routines/level1/xdot.cpp

@@ -17,7 +17,7 @@ int main(int argc, char *argv[]) {
   const auto command_line_args = clblast::RetrieveCommandLineArguments(argc, argv);
   switch(clblast::GetPrecision(command_line_args, clblast::Precision::kSingle)) {
     case clblast::Precision::kHalf:
-      clblast::RunClient<clblast::TestXdot<half>, half, half>(argc, argv); break;
+      clblast::RunClient<clblast::TestXdot<clblast::half>, clblast::half, clblast::half>(argc, argv); break;
     case clblast::Precision::kSingle:
       clblast::RunClient<clblast::TestXdot<float>, float, float>(argc, argv); break;
     case clblast::Precision::kDouble:

test/performance/routines/level1/xnrm2.cpp

@@ -17,7 +17,7 @@ int main(int argc, char *argv[]) {
   const auto command_line_args = clblast::RetrieveCommandLineArguments(argc, argv);
   switch(clblast::GetPrecision(command_line_args, clblast::Precision::kSingle)) {
     case clblast::Precision::kHalf:
-      clblast::RunClient<clblast::TestXnrm2<half>, half, half>(argc, argv); break;
+      clblast::RunClient<clblast::TestXnrm2<clblast::half>, clblast::half, clblast::half>(argc, argv); break;
     case clblast::Precision::kSingle:
       clblast::RunClient<clblast::TestXnrm2<float>, float, float>(argc, argv); break;
     case clblast::Precision::kDouble:

test/performance/routines/level1/xscal.cpp

@@ -17,7 +17,7 @@ int main(int argc, char *argv[]) {
   const auto command_line_args = clblast::RetrieveCommandLineArguments(argc, argv);
   switch(clblast::GetPrecision(command_line_args, clblast::Precision::kSingle)) {
     case clblast::Precision::kHalf:
-      clblast::RunClient<clblast::TestXscal<half>, half, half>(argc, argv); break;
+      clblast::RunClient<clblast::TestXscal<clblast::half>, clblast::half, clblast::half>(argc, argv); break;
     case clblast::Precision::kSingle:
       clblast::RunClient<clblast::TestXscal<float>, float, float>(argc, argv); break;
     case clblast::Precision::kDouble:

test/performance/routines/level1/xswap.cpp

@@ -17,7 +17,7 @@ int main(int argc, char *argv[]) {
   const auto command_line_args = clblast::RetrieveCommandLineArguments(argc, argv);
   switch(clblast::GetPrecision(command_line_args, clblast::Precision::kSingle)) {
     case clblast::Precision::kHalf:
-      clblast::RunClient<clblast::TestXswap<half>, half, half>(argc, argv); break;
+      clblast::RunClient<clblast::TestXswap<clblast::half>, clblast::half, clblast::half>(argc, argv); break;
     case clblast::Precision::kSingle:
       clblast::RunClient<clblast::TestXswap<float>, float, float>(argc, argv); break;
     case clblast::Precision::kDouble:

test/performance/routines/level2/xgbmv.cpp

@@ -17,7 +17,7 @@ int main(int argc, char *argv[]) {
   const auto command_line_args = clblast::RetrieveCommandLineArguments(argc, argv);
   switch(clblast::GetPrecision(command_line_args, clblast::Precision::kSingle)) {
     case clblast::Precision::kHalf:
-      clblast::RunClient<clblast::TestXgbmv<half>, half, half>(argc, argv); break;
+      clblast::RunClient<clblast::TestXgbmv<clblast::half>, clblast::half, clblast::half>(argc, argv); break;
     case clblast::Precision::kSingle:
       clblast::RunClient<clblast::TestXgbmv<float>, float, float>(argc, argv); break;
     case clblast::Precision::kDouble:

test/performance/routines/level2/xgemv.cpp

@@ -17,7 +17,7 @@ int main(int argc, char *argv[]) {
   const auto command_line_args = clblast::RetrieveCommandLineArguments(argc, argv);
   switch(clblast::GetPrecision(command_line_args, clblast::Precision::kSingle)) {
     case clblast::Precision::kHalf:
-      clblast::RunClient<clblast::TestXgemv<half>, half, half>(argc, argv); break;
+      clblast::RunClient<clblast::TestXgemv<clblast::half>, clblast::half, clblast::half>(argc, argv); break;
     case clblast::Precision::kSingle:
       clblast::RunClient<clblast::TestXgemv<float>, float, float>(argc, argv); break;
     case clblast::Precision::kDouble:

test/performance/routines/level2/xger.cpp

@@ -17,7 +17,7 @@ int main(int argc, char *argv[]) {
   const auto command_line_args = clblast::RetrieveCommandLineArguments(argc, argv);
   switch(clblast::GetPrecision(command_line_args, clblast::Precision::kSingle)) {
     case clblast::Precision::kHalf:
-      clblast::RunClient<clblast::TestXger<half>, half, half>(argc, argv); break;
+      clblast::RunClient<clblast::TestXger<clblast::half>, clblast::half, clblast::half>(argc, argv); break;
     case clblast::Precision::kSingle:
       clblast::RunClient<clblast::TestXger<float>, float, float>(argc, argv); break;
     case clblast::Precision::kDouble:

test/performance/routines/level2/xsbmv.cpp

@@ -17,7 +17,7 @@ int main(int argc, char *argv[]) {
   const auto command_line_args = clblast::RetrieveCommandLineArguments(argc, argv);
   switch(clblast::GetPrecision(command_line_args, clblast::Precision::kSingle)) {
     case clblast::Precision::kHalf:
-      clblast::RunClient<clblast::TestXsbmv<half>, half, half>(argc, argv); break;
+      clblast::RunClient<clblast::TestXsbmv<clblast::half>, clblast::half, clblast::half>(argc, argv); break;
     case clblast::Precision::kSingle:
       clblast::RunClient<clblast::TestXsbmv<float>, float, float>(argc, argv); break;
     case clblast::Precision::kDouble:

test/performance/routines/level2/xspmv.cpp

@@ -17,7 +17,7 @@ int main(int argc, char *argv[]) {
   const auto command_line_args = clblast::RetrieveCommandLineArguments(argc, argv);
   switch(clblast::GetPrecision(command_line_args, clblast::Precision::kSingle)) {
     case clblast::Precision::kHalf:
-      clblast::RunClient<clblast::TestXspmv<half>, half, half>(argc, argv); break;
+      clblast::RunClient<clblast::TestXspmv<clblast::half>, clblast::half, clblast::half>(argc, argv); break;
     case clblast::Precision::kSingle:
       clblast::RunClient<clblast::TestXspmv<float>, float, float>(argc, argv); break;
     case clblast::Precision::kDouble:

test/performance/routines/level2/xspr.cpp

@@ -17,7 +17,7 @@ int main(int argc, char *argv[]) {
   const auto command_line_args = clblast::RetrieveCommandLineArguments(argc, argv);
   switch(clblast::GetPrecision(command_line_args, clblast::Precision::kSingle)) {
     case clblast::Precision::kHalf:
-      clblast::RunClient<clblast::TestXspr<half>, half, half>(argc, argv); break;
+      clblast::RunClient<clblast::TestXspr<clblast::half>, clblast::half, clblast::half>(argc, argv); break;
     case clblast::Precision::kSingle:
       clblast::RunClient<clblast::TestXspr<float>, float, float>(argc, argv); break;
     case clblast::Precision::kDouble:

test/performance/routines/level2/xspr2.cpp

@@ -17,7 +17,7 @@ int main(int argc, char *argv[]) {
   const auto command_line_args = clblast::RetrieveCommandLineArguments(argc, argv);
   switch(clblast::GetPrecision(command_line_args, clblast::Precision::kSingle)) {
     case clblast::Precision::kHalf:
-      clblast::RunClient<clblast::TestXspr2<half>, half, half>(argc, argv); break;
+      clblast::RunClient<clblast::TestXspr2<clblast::half>, clblast::half, clblast::half>(argc, argv); break;
     case clblast::Precision::kSingle:
       clblast::RunClient<clblast::TestXspr2<float>, float, float>(argc, argv); break;
     case clblast::Precision::kDouble:

test/performance/routines/level2/xsymv.cpp

@@ -17,7 +17,7 @@ int main(int argc, char *argv[]) {
   const auto command_line_args = clblast::RetrieveCommandLineArguments(argc, argv);
   switch(clblast::GetPrecision(command_line_args, clblast::Precision::kSingle)) {
     case clblast::Precision::kHalf:
-      clblast::RunClient<clblast::TestXsymv<half>, half, half>(argc, argv); break;
+      clblast::RunClient<clblast::TestXsymv<clblast::half>, clblast::half, clblast::half>(argc, argv); break;
     case clblast::Precision::kSingle:
       clblast::RunClient<clblast::TestXsymv<float>, float, float>(argc, argv); break;
     case clblast::Precision::kDouble:

test/performance/routines/level2/xsyr.cpp

@@ -17,7 +17,7 @@ int main(int argc, char *argv[]) {
   const auto command_line_args = clblast::RetrieveCommandLineArguments(argc, argv);
   switch(clblast::GetPrecision(command_line_args, clblast::Precision::kSingle)) {
     case clblast::Precision::kHalf:
-      clblast::RunClient<clblast::TestXsyr<half>, half, half>(argc, argv); break;
+      clblast::RunClient<clblast::TestXsyr<clblast::half>, clblast::half, clblast::half>(argc, argv); break;
     case clblast::Precision::kSingle:
       clblast::RunClient<clblast::TestXsyr<float>, float, float>(argc, argv); break;
     case clblast::Precision::kDouble:

test/performance/routines/level2/xsyr2.cpp

@@ -17,7 +17,7 @@ int main(int argc, char *argv[]) {
   const auto command_line_args = clblast::RetrieveCommandLineArguments(argc, argv);
   switch(clblast::GetPrecision(command_line_args, clblast::Precision::kSingle)) {
     case clblast::Precision::kHalf:
-      clblast::RunClient<clblast::TestXsyr2<half>, half, half>(argc, argv); break;
+      clblast::RunClient<clblast::TestXsyr2<clblast::half>, clblast::half, clblast::half>(argc, argv); break;
     case clblast::Precision::kSingle:
       clblast::RunClient<clblast::TestXsyr2<float>, float, float>(argc, argv); break;
     case clblast::Precision::kDouble:

test/performance/routines/level2/xtbmv.cpp

@@ -17,7 +17,7 @@ int main(int argc, char *argv[]) {
   const auto command_line_args = clblast::RetrieveCommandLineArguments(argc, argv);
   switch(clblast::GetPrecision(command_line_args, clblast::Precision::kSingle)) {
     case clblast::Precision::kHalf:
-      clblast::RunClient<clblast::TestXtbmv<half>, half, half>(argc, argv); break;
+      clblast::RunClient<clblast::TestXtbmv<clblast::half>, clblast::half, clblast::half>(argc, argv); break;
     case clblast::Precision::kSingle:
       clblast::RunClient<clblast::TestXtbmv<float>, float, float>(argc, argv); break;
     case clblast::Precision::kDouble:

test/performance/routines/level2/xtpmv.cpp

@@ -17,7 +17,7 @@ int main(int argc, char *argv[]) {
   const auto command_line_args = clblast::RetrieveCommandLineArguments(argc, argv);
   switch(clblast::GetPrecision(command_line_args, clblast::Precision::kSingle)) {
     case clblast::Precision::kHalf:
-      clblast::RunClient<clblast::TestXtpmv<half>, half, half>(argc, argv); break;
+      clblast::RunClient<clblast::TestXtpmv<clblast::half>, clblast::half, clblast::half>(argc, argv); break;
     case clblast::Precision::kSingle:
       clblast::RunClient<clblast::TestXtpmv<float>, float, float>(argc, argv); break;
     case clblast::Precision::kDouble:

test/performance/routines/level2/xtrmv.cpp

@@ -17,7 +17,7 @@ int main(int argc, char *argv[]) {
   const auto command_line_args = clblast::RetrieveCommandLineArguments(argc, argv);
   switch(clblast::GetPrecision(command_line_args, clblast::Precision::kSingle)) {
     case clblast::Precision::kHalf:
-      clblast::RunClient<clblast::TestXtrmv<half>, half, half>(argc, argv); break;
+      clblast::RunClient<clblast::TestXtrmv<clblast::half>, clblast::half, clblast::half>(argc, argv); break;
     case clblast::Precision::kSingle:
       clblast::RunClient<clblast::TestXtrmv<float>, float, float>(argc, argv); break;
     case clblast::Precision::kDouble:

test/performance/routines/level3/xgemm.cpp

@@ -17,7 +17,7 @@ int main(int argc, char *argv[]) {
   const auto command_line_args = clblast::RetrieveCommandLineArguments(argc, argv);
   switch(clblast::GetPrecision(command_line_args, clblast::Precision::kSingle)) {
     case clblast::Precision::kHalf:
-      clblast::RunClient<clblast::TestXgemm<half>, half, half>(argc, argv); break;
+      clblast::RunClient<clblast::TestXgemm<clblast::half>, clblast::half, clblast::half>(argc, argv); break;
     case clblast::Precision::kSingle:
       clblast::RunClient<clblast::TestXgemm<float>, float, float>(argc, argv); break;
     case clblast::Precision::kDouble:

test/performance/routines/level3/xsymm.cpp

@@ -17,7 +17,7 @@ int main(int argc, char *argv[]) {
   const auto command_line_args = clblast::RetrieveCommandLineArguments(argc, argv);
   switch(clblast::GetPrecision(command_line_args, clblast::Precision::kSingle)) {
     case clblast::Precision::kHalf:
-      clblast::RunClient<clblast::TestXsymm<half>, half, half>(argc, argv); break;
+      clblast::RunClient<clblast::TestXsymm<clblast::half>, clblast::half, clblast::half>(argc, argv); break;
     case clblast::Precision::kSingle:
       clblast::RunClient<clblast::TestXsymm<float>, float, float>(argc, argv); break;
     case clblast::Precision::kDouble:

test/performance/routines/level3/xsyr2k.cpp

@@ -17,7 +17,7 @@ int main(int argc, char *argv[]) {
   const auto command_line_args = clblast::RetrieveCommandLineArguments(argc, argv);
   switch(clblast::GetPrecision(command_line_args, clblast::Precision::kSingle)) {
     case clblast::Precision::kHalf:
-      clblast::RunClient<clblast::TestXsyr2k<half>, half, half>(argc, argv); break;
+      clblast::RunClient<clblast::TestXsyr2k<clblast::half>, clblast::half, clblast::half>(argc, argv); break;
     case clblast::Precision::kSingle:
       clblast::RunClient<clblast::TestXsyr2k<float>, float, float>(argc, argv); break;
     case clblast::Precision::kDouble:

test/performance/routines/level3/xsyrk.cpp

@@ -17,7 +17,7 @@ int main(int argc, char *argv[]) {
   const auto command_line_args = clblast::RetrieveCommandLineArguments(argc, argv);
   switch(clblast::GetPrecision(command_line_args, clblast::Precision::kSingle)) {
     case clblast::Precision::kHalf:
-      clblast::RunClient<clblast::TestXsyrk<half>, half, half>(argc, argv); break;
+      clblast::RunClient<clblast::TestXsyrk<clblast::half>, clblast::half, clblast::half>(argc, argv); break;
     case clblast::Precision::kSingle:
       clblast::RunClient<clblast::TestXsyrk<float>, float, float>(argc, argv); break;
     case clblast::Precision::kDouble:

test/performance/routines/level3/xtrmm.cpp

@@ -17,7 +17,7 @@ int main(int argc, char *argv[]) {
   const auto command_line_args = clblast::RetrieveCommandLineArguments(argc, argv);
   switch(clblast::GetPrecision(command_line_args, clblast::Precision::kSingle)) {
     case clblast::Precision::kHalf:
-      clblast::RunClient<clblast::TestXtrmm<half>, half, half>(argc, argv); break;
+      clblast::RunClient<clblast::TestXtrmm<clblast::half>, clblast::half, clblast::half>(argc, argv); break;
     case clblast::Precision::kSingle:
       clblast::RunClient<clblast::TestXtrmm<float>, float, float>(argc, argv); break;
     case clblast::Precision::kDouble:

test/performance/routines/levelx/xaxpybatched.cpp

@@ -17,7 +17,7 @@ int main(int argc, char *argv[]) {
   const auto command_line_args = clblast::RetrieveCommandLineArguments(argc, argv);
   switch(clblast::GetPrecision(command_line_args, clblast::Precision::kSingle)) {
     case clblast::Precision::kHalf:
-      clblast::RunClient<clblast::TestXaxpyBatched<half>, half, half>(argc, argv); break;
+      clblast::RunClient<clblast::TestXaxpyBatched<clblast::half>, clblast::half, clblast::half>(argc, argv); break;
     case clblast::Precision::kSingle:
       clblast::RunClient<clblast::TestXaxpyBatched<float>, float, float>(argc, argv); break;
     case clblast::Precision::kDouble:

test/performance/routines/levelx/xgemmbatched.cpp

@@ -17,7 +17,7 @@ int main(int argc, char *argv[]) {
   const auto command_line_args = clblast::RetrieveCommandLineArguments(argc, argv);
   switch(clblast::GetPrecision(command_line_args, clblast::Precision::kSingle)) {
     case clblast::Precision::kHalf:
-      clblast::RunClient<clblast::TestXgemmBatched<half>, half, half>(argc, argv); break;
+      clblast::RunClient<clblast::TestXgemmBatched<clblast::half>, clblast::half, clblast::half>(argc, argv); break;
     case clblast::Precision::kSingle:
       clblast::RunClient<clblast::TestXgemmBatched<float>, float, float>(argc, argv); break;
     case clblast::Precision::kDouble:

test/performance/routines/levelx/xomatcopy.cpp

@@ -17,7 +17,7 @@ int main(int argc, char *argv[]) {
   const auto command_line_args = clblast::RetrieveCommandLineArguments(argc, argv);
   switch(clblast::GetPrecision(command_line_args, clblast::Precision::kSingle)) {
     case clblast::Precision::kHalf:
-      clblast::RunClient<clblast::TestXomatcopy<half>, half, half>(argc, argv); break;
+      clblast::RunClient<clblast::TestXomatcopy<clblast::half>, clblast::half, clblast::half>(argc, argv); break;
     case clblast::Precision::kSingle:
       clblast::RunClient<clblast::TestXomatcopy<float>, float, float>(argc, argv); break;
     case clblast::Precision::kDouble: