[CUDA, test-suite] Disable testing of non-FP complex types.

[tra]

Summary

According to the standard, instantiating of non-FP complex types is an
unspecified behavior.
http://eel.is/c++draft/complex.numbers.general#2.sentence-1

Non-FP complex types happen to work with libc++, libstdc++ 8 and older, but
break with libstdc++ 9 and newer due to the library not providing implicit
conversion std::complex<FP> ones.

[tra]

fixed comment typos.

External/CUDA/complex.cu

 #include <stdio.h>
 
 // These tests are pretty annoying to write without C++11, so we require that.
 //
 // In addition, these tests don't work in C++14 mode with pre-C++14 versions of
 // libstdc++ (compile errors in <complex>).
 #if __cplusplus >= 201103L && (__cplusplus < 201402L || STDLIB_VERSION >= 2014)
 
+// Support for non-fp std::complex is unspecified:
+// http://eel.is/c++draft/complex.numbers.general#2.sentence-1
+#if defined(__GLIBCXX__) && _GLIBCXX_RELEASE >= 9
+// newer versions of libstdc++ do not support implicit conversion from such
+// types.
+#undef TEST_NONFLOAT_COMPLEX
+#else
+// libc++ and the older versions of libstdc++ have better support for non-float
+// complex, so we can still test them.
+#define TEST_NONFLOAT_COMPLEX 1
+#endif
+
 #include <assert.h>
 #include <complex>
 #include <type_traits>
 
 template <class T>
 __device__ double promote(
     T, typename std::enable_if<std::is_integral<T>::value>::type* = 0);
 __device__ float promote(float);
__device__ void test_plus_equals() {
     std::complex<T> c;
     const std::complex<T> c2(1.5, 2.5);
     c += c2;
     c += c2;
     assert(c.real() == 3);
     assert(c.imag() == 5);
 
     std::complex<T> c3;
-
+#if TEST_NONFLOAT_COMPLEX
     c3 = c;
     std::complex<int> ic(1, 1);
     c3 += ic;
     assert(c3.real() == 4);
     assert(c3.imag() == 6);
-
+#endif
     c3 = c;
     std::complex<float> fc(1, 1);
     c3 += fc;
     assert(c3.real() == 4);
     assert(c3.imag() == 6);
   }
 }
 
__device__ void test_minus_equals() {
     c -= c2;
     assert(c.real() == -1.5);
     assert(c.imag() == -2.5);
     c -= c2;
     assert(c.real() == -3);
     assert(c.imag() == -5);
 
     std::complex<T> c3;
-
+#if TEST_NONFLOAT_COMPLEX
     c3 = c;
     std::complex<int> ic (1,1);
     c3 -= ic;
     assert(c3.real() == -4);
     assert(c3.imag() == -6);
-
+#endif
     c3 = c;
     std::complex<float> fc (1,1);
     c3 -= fc;
     assert(c3.real() == -4);
     assert(c3.imag() == -6);
   }
 }
 
__device__ void test_times_equals() {
     const std::complex<T> c2(1.5, 2.5);
     c *= c2;
     c *= c2;
     assert(c.real() == -4);
     assert(c.imag() == 7.5);
 
     std::complex<T> c3;
 
+#if TEST_NONFLOAT_COMPLEX
     c3 = c;
     std::complex<int> ic (1,1);
     c3 *= ic;
     assert(c3.real() == -11.5);
     assert(c3.imag() ==   3.5);
+#endif
 
     c3 = c;
     std::complex<float> fc (1,1);
     c3 *= fc;
     assert(c3.real() == -11.5);
     assert(c3.imag() ==   3.5);
   }
 }
__device__ void test_divide_equals() {
     assert(c.imag() == 2.5);
     c /= c2;
     assert(c.real() == 1);
     assert(c.imag() == 0);
 
     std::complex<T> c3;
 
     c3 = c;
+#if TEST_NONFLOAT_COMPLEX
     std::complex<int> ic (1,1);
     c3 /= ic;
     assert(c3.real() ==  0.5);
     assert(c3.imag() == -0.5);
+#endif
 
     c3 = c;
     std::complex<float> fc (1,1);
     c3 /= fc;
     assert(c3.real() ==  0.5);
     assert(c3.imag() == -0.5);
   }
 }