Implement constexpr (n3302) and fix operator *= and /=

git-svn-id: https://llvm.org/svn/llvm-project/libcxx/trunk@187529 91177308-0d34-0410-b5e6-96231b3b80d8

test/numerics/complex.number/cmplx.over/imag.pass.cpp

@@ -19,29 +19,41 @@
 
 #include "../cases.h"
 
-template <class T>
+template <class T, int x>
 void
-test(T x, typename std::enable_if<std::is_integral<T>::value>::type* = 0)
+test(typename std::enable_if<std::is_integral<T>::value>::type* = 0)
 {
-    static_assert((std::is_same<decltype(std::imag(x)), double>::value), "");
+    static_assert((std::is_same<decltype(std::imag(T(x))), double>::value), "");
     assert(std::imag(x) == 0);
+#if _LIBCPP_STD_VER > 11
+    constexpr T val {x};
+    static_assert(std::imag(val) == 0, "");
+	constexpr std::complex<T> t{val, val};
+	static_assert(t.imag() == x, "" );
+#endif    
 }
 
-template <class T>
+template <class T, int x>
 void
-test(T x, typename std::enable_if<!std::is_integral<T>::value>::type* = 0)
+test(typename std::enable_if<!std::is_integral<T>::value>::type* = 0)
 {
-    static_assert((std::is_same<decltype(std::imag(x)), T>::value), "");
+    static_assert((std::is_same<decltype(std::imag(T(x))), T>::value), "");
     assert(std::imag(x) == 0);
+#if _LIBCPP_STD_VER > 11
+    constexpr T val {x};
+    static_assert(std::imag(val) == 0, "");
+	constexpr std::complex<T> t{val, val};
+	static_assert(t.imag() == x, "" );
+#endif    
 }
 
 template <class T>
 void
 test()
 {
-    test<T>(0);
-    test<T>(1);
-    test<T>(10);
+    test<T, 0>();
+    test<T, 1>();
+    test<T, 10>();
 }
 
 int main()

test/numerics/complex.number/cmplx.over/real.pass.cpp

@@ -19,29 +19,41 @@
 
 #include "../cases.h"
 
-template <class T>
+template <class T, int x>
 void
-test(T x, typename std::enable_if<std::is_integral<T>::value>::type* = 0)
+test(typename std::enable_if<std::is_integral<T>::value>::type* = 0)
 {
-    static_assert((std::is_same<decltype(std::real(x)), double>::value), "");
+    static_assert((std::is_same<decltype(std::real(T(x))), double>::value), "");
     assert(std::real(x) == x);
+#if _LIBCPP_STD_VER > 11
+    constexpr T val {x};
+    static_assert(std::real(val) == val, "");
+	constexpr std::complex<T> t{val, val};
+	static_assert(t.real() == x, "" );
+#endif    
 }
 
-template <class T>
+template <class T, int x>
 void
-test(T x, typename std::enable_if<!std::is_integral<T>::value>::type* = 0)
+test(typename std::enable_if<!std::is_integral<T>::value>::type* = 0)
 {
-    static_assert((std::is_same<decltype(std::real(x)), T>::value), "");
+    static_assert((std::is_same<decltype(std::real(T(x))), T>::value), "");
     assert(std::real(x) == x);
+#if _LIBCPP_STD_VER > 11
+    constexpr T val {x};
+    static_assert(std::real(val) == val, "");
+	constexpr std::complex<T> t{val, val};
+	static_assert(t.real() == x, "" );
+#endif    
 }
 
 template <class T>
 void
 test()
 {
-    test<T>(0);
-    test<T>(1);
-    test<T>(10);
+    test<T, 0>();
+    test<T, 1>();
+    test<T, 10>();
 }
 
 int main()

test/numerics/complex.number/complex.member.ops/divide_equal_complex.pass.cpp

@@ -28,6 +28,21 @@ test()
     c /= c2;
     assert(c.real() == 1);
     assert(c.imag() == 0);
+    
+    std::complex<T> c3;
+
+    c3 = c;
+    std::complex<int> ic (1,1);
+    c3 /= ic;
+    assert(c3.real() ==  0.5);
+    assert(c3.imag() == -0.5);
+    
+    c3 = c;
+    std::complex<float> fc (1,1);
+    c3 /= fc;
+    assert(c3.real() ==  0.5);
+    assert(c3.imag() == -0.5);
+    
 }
 
 int main()

test/numerics/complex.number/complex.member.ops/minus_equal_complex.pass.cpp

@@ -28,6 +28,20 @@ test()
     c -= c2;
     assert(c.real() == -3);
     assert(c.imag() == -5);
+
+    std::complex<T> c3;
+
+    c3 = c;
+    std::complex<int> ic (1,1);
+    c3 -= ic;
+    assert(c3.real() == -4);
+    assert(c3.imag() == -6);
+
+    c3 = c;
+    std::complex<float> fc (1,1);
+    c3 -= fc;
+    assert(c3.real() == -4);
+    assert(c3.imag() == -6);
 }
 
 int main()

test/numerics/complex.number/complex.member.ops/plus_equal_complex.pass.cpp

@@ -28,6 +28,20 @@ test()
     c += c2;
     assert(c.real() == 3);
     assert(c.imag() == 5);
+
+    std::complex<T> c3;
+
+    c3 = c;
+    std::complex<int> ic (1,1);
+    c3 += ic;
+    assert(c3.real() == 4);
+    assert(c3.imag() == 6);
+    
+    c3 = c;
+    std::complex<float> fc (1,1);
+    c3 += fc;
+    assert(c3.real() == 4);
+    assert(c3.imag() == 6);
 }
 
 int main()

test/numerics/complex.number/complex.member.ops/times_equal_complex.pass.cpp

@@ -28,6 +28,20 @@ test()
     c *= c2;
     assert(c.real() == -4);
     assert(c.imag() == 7.5);
+
+    std::complex<T> c3;
+
+    c3 = c;
+    std::complex<int> ic (1,1);
+    c3 *= ic;
+    assert(c3.real() == -11.5);
+    assert(c3.imag() ==   3.5);
+    
+    c3 = c;
+    std::complex<float> fc (1,1);
+    c3 *= fc;
+    assert(c3.real() == -11.5);
+    assert(c3.imag() ==   3.5);
 }
 
 int main()

test/numerics/complex.number/complex.members/real_imag.pass.cpp

@@ -15,6 +15,23 @@
 #include <complex>
 #include <cassert>
 
+template <class T>
+void
+test_constexpr()
+{
+#if _LIBCPP_STD_VER > 11
+    constexpr std::complex<T> c1;
+    static_assert(c1.real() == 0, "");
+    static_assert(c1.imag() == 0, "");
+    constexpr std::complex<T> c2(3);
+    static_assert(c2.real() == 3, "");
+    static_assert(c2.imag() == 0, "");
+    constexpr std::complex<T> c3(3, 4);
+    static_assert(c3.real() == 3, "");
+    static_assert(c3.imag() == 4, "");
+#endif
+}
+
 template <class T>
 void
 test()
@@ -34,6 +51,8 @@ test()
     c.imag(-5.5);
     assert(c.real() == -4.5);
     assert(c.imag() == -5.5);
+
+    test_constexpr<T> ();
 }
 
 int main()
@@ -41,4 +60,5 @@ int main()
     test<float>();
     test<double>();
     test<long double>();
+    test_constexpr<int> ();
 }

test/numerics/complex.number/complex.ops/complex_equals_complex.pass.cpp

@@ -18,9 +18,20 @@
 
 template <class T>
 void
-test(const std::complex<T>& lhs, const std::complex<T>& rhs, bool x)
+test_constexpr()
 {
-    assert((lhs == rhs) == x);
+#if _LIBCPP_STD_VER > 11
+    {
+    constexpr std::complex<T> lhs(1.5,  2.5);
+    constexpr std::complex<T> rhs(1.5, -2.5);
+    static_assert( !(lhs == rhs), "");
+    }
+    {
+    constexpr std::complex<T> lhs(1.5, 2.5);
+    constexpr std::complex<T> rhs(1.5, 2.5);
+    static_assert(lhs == rhs, "");
+    }
+#endif
 }
 
 template <class T>
@@ -30,13 +41,14 @@ test()
     {
     std::complex<T> lhs(1.5,  2.5);
     std::complex<T> rhs(1.5, -2.5);
-    test(lhs, rhs, false);
+    assert( !(lhs == rhs));
     }
     {
     std::complex<T> lhs(1.5, 2.5);
     std::complex<T> rhs(1.5, 2.5);
-    test(lhs, rhs, true);
+    assert(lhs == rhs);
     }
+    test_constexpr<T> ();
 }
 
 int main()
@@ -44,4 +56,5 @@ int main()
     test<float>();
     test<double>();
     test<long double>();
+//    test_constexpr<int> ();
 }

test/numerics/complex.number/complex.ops/complex_equals_scalar.pass.cpp

@@ -18,9 +18,30 @@
 
 template <class T>
 void
-test(const std::complex<T>& lhs, const T& rhs, bool x)
+test_constexpr()
 {
-    assert((lhs == rhs) == x);
+#if _LIBCPP_STD_VER > 11
+    {
+    constexpr std::complex<T> lhs(1.5, 2.5);
+    constexpr T rhs(-2.5);
+    static_assert(!(lhs == rhs), "");
+    }
+    {
+    constexpr std::complex<T> lhs(1.5, 0);
+    constexpr T rhs(-2.5);
+    static_assert(!(lhs == rhs), "");
+    }
+    {
+    constexpr std::complex<T> lhs(1.5, 2.5);
+    constexpr T rhs(1.5);
+    static_assert(!(lhs == rhs), "");
+    }
+    {
+    constexpr std::complex<T> lhs(1.5, 0);
+    constexpr T rhs(1.5);
+    static_assert( (lhs == rhs), "");
+    }
+#endif
 }
 
 template <class T>
@@ -30,28 +51,31 @@ test()
     {
     std::complex<T> lhs(1.5,  2.5);
     T rhs(-2.5);
-    test(lhs, rhs, false);
+    assert(!(lhs == rhs));
     }
     {
-    std::complex<T> lhs(1.5,  0);
+    std::complex<T> lhs(1.5, 0);
     T rhs(-2.5);
-    test(lhs, rhs, false);
+    assert(!(lhs == rhs));
     }
     {
     std::complex<T> lhs(1.5, 2.5);
     T rhs(1.5);
-    test(lhs, rhs, false);
+    assert(!(lhs == rhs));
     }
     {
     std::complex<T> lhs(1.5, 0);
     T rhs(1.5);
-    test(lhs, rhs, true);
+    assert( (lhs == rhs));
+    }
+
+    test_constexpr<T> ();
     }
-}
 
 int main()
 {
     test<float>();
     test<double>();
     test<long double>();
+//     test_constexpr<int> ();
 }

test/numerics/complex.number/complex.ops/complex_not_equals_complex.pass.cpp

@@ -18,11 +18,23 @@
 
 template <class T>
 void
-test(const std::complex<T>& lhs, const std::complex<T>& rhs, bool x)
+test_constexpr()
 {
-    assert((lhs != rhs) == x);
+#if _LIBCPP_STD_VER > 11
+    {
+    constexpr std::complex<T> lhs(1.5,  2.5);
+    constexpr std::complex<T> rhs(1.5, -2.5);
+    static_assert(lhs != rhs, "");
+    }
+    {
+    constexpr std::complex<T> lhs(1.5, 2.5);
+    constexpr std::complex<T> rhs(1.5, 2.5);
+    static_assert(!(lhs != rhs), "" );
+    }
+#endif
 }
 
+
 template <class T>
 void
 test()
@@ -30,18 +42,21 @@ test()
     {
     std::complex<T> lhs(1.5,  2.5);
     std::complex<T> rhs(1.5, -2.5);
-    test(lhs, rhs, true);
+    assert(lhs != rhs);
     }
     {
     std::complex<T> lhs(1.5, 2.5);
     std::complex<T> rhs(1.5, 2.5);
-    test(lhs, rhs, false);
+    assert(!(lhs != rhs));
     }
-}
+
+	test_constexpr<T> ();
+	}
 
 int main()
 {
     test<float>();
     test<double>();
     test<long double>();
+//   test_constexpr<int> ();
 }

test/numerics/complex.number/complex.ops/complex_not_equals_scalar.pass.cpp

@@ -18,9 +18,30 @@
 
 template <class T>
 void
-test(const std::complex<T>& lhs, const T& rhs, bool x)
+test_constexpr()
 {
-    assert((lhs != rhs) == x);
+#if _LIBCPP_STD_VER > 11
+    {
+    constexpr std::complex<T> lhs(1.5,  2.5);
+    constexpr T rhs(-2.5);
+    static_assert(lhs != rhs, "");
+    }
+    {
+    constexpr std::complex<T> lhs(1.5,  0);
+    constexpr T rhs(-2.5);
+    static_assert(lhs != rhs, "");
+    }
+    {
+    constexpr std::complex<T> lhs(1.5, 2.5);
+    constexpr T rhs(1.5);
+    static_assert(lhs != rhs, "");
+    }
+    {
+    constexpr std::complex<T> lhs(1.5, 0);
+    constexpr T rhs(1.5);
+    static_assert( !(lhs != rhs), "");
+    }
+#endif
 }
 
 template <class T>
@@ -30,23 +51,25 @@ test()
     {
     std::complex<T> lhs(1.5,  2.5);
     T rhs(-2.5);
-    test(lhs, rhs, true);
+    assert(lhs != rhs);
     }
     {
     std::complex<T> lhs(1.5,  0);
     T rhs(-2.5);
-    test(lhs, rhs, true);
+    assert(lhs != rhs);
     }
     {
     std::complex<T> lhs(1.5, 2.5);
     T rhs(1.5);
-    test(lhs, rhs, true);
+    assert(lhs != rhs);
     }
     {
     std::complex<T> lhs(1.5, 0);
     T rhs(1.5);
-    test(lhs, rhs, false);
+    assert( !(lhs != rhs));
     }
+
+    test_constexpr<T> ();
 }
 
 int main()
@@ -54,4 +77,5 @@ int main()
     test<float>();
     test<double>();
     test<long double>();
-}
+//     test_constexpr<int> ();
+    }

test/numerics/complex.number/complex.ops/scalar_equals_complex.pass.cpp

@@ -18,9 +18,30 @@
 
 template <class T>
 void
-test(const T& lhs, const std::complex<T>& rhs, bool x)
+test_constexpr()
 {
-    assert((lhs == rhs) == x);
+#if _LIBCPP_STD_VER > 11
+    {
+    constexpr T lhs(-2.5);
+    constexpr std::complex<T> rhs(1.5,  2.5);
+    static_assert(!(lhs == rhs), "");
+    }
+    {
+    constexpr T lhs(-2.5);
+    constexpr std::complex<T> rhs(1.5,  0);
+    static_assert(!(lhs == rhs), "");
+    }
+    {
+    constexpr T lhs(1.5);
+    constexpr std::complex<T> rhs(1.5, 2.5);
+    static_assert(!(lhs == rhs), "");
+    }
+    {
+    constexpr T lhs(1.5);
+    constexpr std::complex<T> rhs(1.5, 0);
+    static_assert(lhs == rhs, "");
+    }
+#endif
 }
 
 template <class T>
@@ -30,23 +51,25 @@ test()
     {
     T lhs(-2.5);
     std::complex<T> rhs(1.5,  2.5);
-    test(lhs, rhs, false);
+    assert(!(lhs == rhs));
     }
     {
     T lhs(-2.5);
     std::complex<T> rhs(1.5,  0);
-    test(lhs, rhs, false);
+    assert(!(lhs == rhs));
     }
     {
     T lhs(1.5);
     std::complex<T> rhs(1.5, 2.5);
-    test(lhs, rhs, false);
+    assert(!(lhs == rhs));
     }
     {
     T lhs(1.5);
     std::complex<T> rhs(1.5, 0);
-    test(lhs, rhs, true);
+    assert(lhs == rhs);
     }
+
+    test_constexpr<T> ();
 }
 
 int main()
@@ -54,4 +77,5 @@ int main()
     test<float>();
     test<double>();
     test<long double>();
+//     test_constexpr<int>();
 }

test/numerics/complex.number/complex.ops/scalar_not_equals_complex.pass.cpp

@@ -18,9 +18,30 @@
 
 template <class T>
 void
-test(const T& lhs, const std::complex<T>& rhs, bool x)
+test_constexpr()
 {
-    assert((lhs != rhs) == x);
+#if _LIBCPP_STD_VER > 11
+    {
+    constexpr T lhs(-2.5);
+    constexpr std::complex<T> rhs(1.5,  2.5);
+    static_assert (lhs != rhs, "");
+    }
+    {
+    constexpr T lhs(-2.5);
+    constexpr std::complex<T> rhs(1.5,  0);
+    static_assert (lhs != rhs, "");
+    }
+    {
+    constexpr T lhs(1.5);
+    constexpr std::complex<T> rhs(1.5, 2.5);
+    static_assert (lhs != rhs, "");
+    }
+    {
+    constexpr T lhs(1.5);
+    constexpr std::complex<T> rhs(1.5, 0);
+    static_assert (!(lhs != rhs), "");
+    }
+#endif
 }
 
 template <class T>
@@ -30,28 +51,31 @@ test()
     {
     T lhs(-2.5);
     std::complex<T> rhs(1.5,  2.5);
-    test(lhs, rhs, true);
+    assert (lhs != rhs);
     }
     {
     T lhs(-2.5);
     std::complex<T> rhs(1.5,  0);
-    test(lhs, rhs, true);
+    assert (lhs != rhs);
     }
     {
     T lhs(1.5);
     std::complex<T> rhs(1.5, 2.5);
-    test(lhs, rhs, true);
+    assert (lhs != rhs);
     }
     {
     T lhs(1.5);
     std::complex<T> rhs(1.5, 0);
-    test(lhs, rhs, false);
+    assert (!(lhs != rhs));
+    }
+
+    test_constexpr<T> ();
     }
-}
 
 int main()
 {
     test<float>();
     test<double>();
     test<long double>();
+//     test_constexpr<int>();
 }