diff options
Diffstat (limited to 'libcxx/test/numerics/numarray/valarray.nonmembers/valarray.comparison')
24 files changed, 884 insertions, 0 deletions
diff --git a/libcxx/test/numerics/numarray/valarray.nonmembers/valarray.comparison/and_valarray_valarray.pass.cpp b/libcxx/test/numerics/numarray/valarray.nonmembers/valarray.comparison/and_valarray_valarray.pass.cpp new file mode 100644 index 00000000000..9a2451207ae --- /dev/null +++ b/libcxx/test/numerics/numarray/valarray.nonmembers/valarray.comparison/and_valarray_valarray.pass.cpp @@ -0,0 +1,37 @@ +//===----------------------------------------------------------------------===// +// +// ΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚThe LLVM Compiler Infrastructure +// +// This file is distributed under the University of Illinois Open Source +// License. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// + +// <valarray> + +// template<class T> class valarray; + +// template<class T> +// valarray<bool> +// operator&&(const valarray<T>& x, const valarray<T>& y); + +#include <valarray> +#include <cassert> + +int main() +{ + { + typedef int T; + T a1[] = {1, 2, 3, 4, 0}; + T a2[] = {6, 7, 0, 9, 10}; + bool a3[] = {true, true, false, true, false}; + const unsigned N = sizeof(a1)/sizeof(a1[0]); + std::valarray<T> v1(a1, N); + std::valarray<T> v2(a2, N); + std::valarray<bool> v3 = v1 && v2; + assert(v1.size() == v2.size()); + assert(v1.size() == v3.size()); + for (int i = 0; i < v1.size(); ++i) + assert(v3[i] == a3[i]); + } +} diff --git a/libcxx/test/numerics/numarray/valarray.nonmembers/valarray.comparison/and_valarray_value.pass.cpp b/libcxx/test/numerics/numarray/valarray.nonmembers/valarray.comparison/and_valarray_value.pass.cpp new file mode 100644 index 00000000000..bc8f5d2bfb5 --- /dev/null +++ b/libcxx/test/numerics/numarray/valarray.nonmembers/valarray.comparison/and_valarray_value.pass.cpp @@ -0,0 +1,45 @@ +//===----------------------------------------------------------------------===// +// +// ΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚThe LLVM Compiler Infrastructure +// +// This file is distributed under the University of Illinois Open Source +// License. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// + +// <valarray> + +// template<class T> class valarray; + +// template<class T> +// valarray<bool> +// operator&&(const valarray<T>& x, const T& y); + +#include <valarray> +#include <cassert> + +int main() +{ + { + typedef int T; + T a1[] = {1, 2, 3, 4, 0}; + bool a3[] = {true, true, true, true, false}; + const unsigned N = sizeof(a1)/sizeof(a1[0]); + std::valarray<T> v1(a1, N); + std::valarray<bool> v3 = v1 && 5; + assert(v1.size() == v3.size()); + for (int i = 0; i < v1.size(); ++i) + assert(v3[i] == a3[i]); + } + { + typedef int T; + T a1[] = {1, 2, 3, 4, 0}; + bool a3[] = {false, false, false, false, false}; + const unsigned N = sizeof(a1)/sizeof(a1[0]); + std::valarray<T> v1(a1, N); + std::valarray<bool> v3 = v1 && 0; + assert(v1.size() == v3.size()); + for (int i = 0; i < v1.size(); ++i) + assert(v3[i] == a3[i]); + } +} diff --git a/libcxx/test/numerics/numarray/valarray.nonmembers/valarray.comparison/and_value_valarray.pass.cpp b/libcxx/test/numerics/numarray/valarray.nonmembers/valarray.comparison/and_value_valarray.pass.cpp new file mode 100644 index 00000000000..8b02ec29ea0 --- /dev/null +++ b/libcxx/test/numerics/numarray/valarray.nonmembers/valarray.comparison/and_value_valarray.pass.cpp @@ -0,0 +1,45 @@ +//===----------------------------------------------------------------------===// +// +// ΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚThe LLVM Compiler Infrastructure +// +// This file is distributed under the University of Illinois Open Source +// License. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// + +// <valarray> + +// template<class T> class valarray; + +// template<class T> +// valarray<bool> +// operator&&(const T& x, const valarray<T>& y); + +#include <valarray> +#include <cassert> + +int main() +{ + { + typedef int T; + T a2[] = {1, 2, 3, 4, 0}; + bool a3[] = {true, true, true, true, false}; + const unsigned N = sizeof(a2)/sizeof(a2[0]); + std::valarray<T> v2(a2, N); + std::valarray<bool> v3 = 5 && v2; + assert(v2.size() == v3.size()); + for (int i = 0; i < v3.size(); ++i) + assert(v3[i] == a3[i]); + } + { + typedef int T; + T a2[] = {1, 2, 3, 4, 0}; + bool a3[] = {false, false, false, false, false}; + const unsigned N = sizeof(a2)/sizeof(a2[0]); + std::valarray<T> v2(a2, N); + std::valarray<bool> v3 = 0 && v2; + assert(v2.size() == v3.size()); + for (int i = 0; i < v3.size(); ++i) + assert(v3[i] == a3[i]); + } +} diff --git a/libcxx/test/numerics/numarray/valarray.nonmembers/valarray.comparison/equal_valarray_valarray.pass.cpp b/libcxx/test/numerics/numarray/valarray.nonmembers/valarray.comparison/equal_valarray_valarray.pass.cpp new file mode 100644 index 00000000000..4ac72158a72 --- /dev/null +++ b/libcxx/test/numerics/numarray/valarray.nonmembers/valarray.comparison/equal_valarray_valarray.pass.cpp @@ -0,0 +1,37 @@ +//===----------------------------------------------------------------------===// +// +// ΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚThe LLVM Compiler Infrastructure +// +// This file is distributed under the University of Illinois Open Source +// License. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// + +// <valarray> + +// template<class T> class valarray; + +// template<class T> +// valarray<bool> +// operator==(const valarray<T>& x, const valarray<T>& y); + +#include <valarray> +#include <cassert> + +int main() +{ + { + typedef int T; + T a1[] = {1, 2, 0, 4, 10}; + T a2[] = {6, 7, 0, 9, 10}; + bool a3[] = {false, false, true, false, true}; + const unsigned N = sizeof(a1)/sizeof(a1[0]); + std::valarray<T> v1(a1, N); + std::valarray<T> v2(a2, N); + std::valarray<bool> v3 = v1 == v2; + assert(v1.size() == v2.size()); + assert(v1.size() == v3.size()); + for (int i = 0; i < v1.size(); ++i) + assert(v3[i] == a3[i]); + } +} diff --git a/libcxx/test/numerics/numarray/valarray.nonmembers/valarray.comparison/equal_valarray_value.pass.cpp b/libcxx/test/numerics/numarray/valarray.nonmembers/valarray.comparison/equal_valarray_value.pass.cpp new file mode 100644 index 00000000000..e71ce246455 --- /dev/null +++ b/libcxx/test/numerics/numarray/valarray.nonmembers/valarray.comparison/equal_valarray_value.pass.cpp @@ -0,0 +1,34 @@ +//===----------------------------------------------------------------------===// +// +// ΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚThe LLVM Compiler Infrastructure +// +// This file is distributed under the University of Illinois Open Source +// License. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// + +// <valarray> + +// template<class T> class valarray; + +// template<class T> +// valarray<bool> +// operator==(const valarray<T>& x, const T& y); + +#include <valarray> +#include <cassert> + +int main() +{ + { + typedef int T; + T a1[] = {1, 2, 3, 4, 0}; + bool a3[] = {false, true, false, false, false}; + const unsigned N = sizeof(a1)/sizeof(a1[0]); + std::valarray<T> v1(a1, N); + std::valarray<bool> v3 = v1 == 2; + assert(v1.size() == v3.size()); + for (int i = 0; i < v1.size(); ++i) + assert(v3[i] == a3[i]); + } +} diff --git a/libcxx/test/numerics/numarray/valarray.nonmembers/valarray.comparison/equal_value_valarray.pass.cpp b/libcxx/test/numerics/numarray/valarray.nonmembers/valarray.comparison/equal_value_valarray.pass.cpp new file mode 100644 index 00000000000..33c1680956d --- /dev/null +++ b/libcxx/test/numerics/numarray/valarray.nonmembers/valarray.comparison/equal_value_valarray.pass.cpp @@ -0,0 +1,34 @@ +//===----------------------------------------------------------------------===// +// +// ΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚThe LLVM Compiler Infrastructure +// +// This file is distributed under the University of Illinois Open Source +// License. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// + +// <valarray> + +// template<class T> class valarray; + +// template<class T> +// valarray<bool> +// operator==(const T& x, const valarray<T>& y); + +#include <valarray> +#include <cassert> + +int main() +{ + { + typedef int T; + T a2[] = {1, 2, 3, 4, 0}; + bool a3[] = {false, true, false, false, false}; + const unsigned N = sizeof(a2)/sizeof(a2[0]); + std::valarray<T> v2(a2, N); + std::valarray<bool> v3 = 2 == v2; + assert(v2.size() == v3.size()); + for (int i = 0; i < v3.size(); ++i) + assert(v3[i] == a3[i]); + } +} diff --git a/libcxx/test/numerics/numarray/valarray.nonmembers/valarray.comparison/greater_equal_valarray_valarray.pass.cpp b/libcxx/test/numerics/numarray/valarray.nonmembers/valarray.comparison/greater_equal_valarray_valarray.pass.cpp new file mode 100644 index 00000000000..5b23ccf8b8b --- /dev/null +++ b/libcxx/test/numerics/numarray/valarray.nonmembers/valarray.comparison/greater_equal_valarray_valarray.pass.cpp @@ -0,0 +1,37 @@ +//===----------------------------------------------------------------------===// +// +// ΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚThe LLVM Compiler Infrastructure +// +// This file is distributed under the University of Illinois Open Source +// License. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// + +// <valarray> + +// template<class T> class valarray; + +// template<class T> +// valarray<bool> +// operator>=(const valarray<T>& x, const valarray<T>& y); + +#include <valarray> +#include <cassert> + +int main() +{ + { + typedef int T; + T a1[] = {1, 2, 0, 4, 10}; + T a2[] = {6, 7, 0, 2, 1}; + bool a3[] = {false, false, true, true, true}; + const unsigned N = sizeof(a1)/sizeof(a1[0]); + std::valarray<T> v1(a1, N); + std::valarray<T> v2(a2, N); + std::valarray<bool> v3 = v1 >= v2; + assert(v1.size() == v2.size()); + assert(v1.size() == v3.size()); + for (int i = 0; i < v1.size(); ++i) + assert(v3[i] == a3[i]); + } +} diff --git a/libcxx/test/numerics/numarray/valarray.nonmembers/valarray.comparison/greater_equal_valarray_value.pass.cpp b/libcxx/test/numerics/numarray/valarray.nonmembers/valarray.comparison/greater_equal_valarray_value.pass.cpp new file mode 100644 index 00000000000..daba8aa345f --- /dev/null +++ b/libcxx/test/numerics/numarray/valarray.nonmembers/valarray.comparison/greater_equal_valarray_value.pass.cpp @@ -0,0 +1,34 @@ +//===----------------------------------------------------------------------===// +// +// ΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚThe LLVM Compiler Infrastructure +// +// This file is distributed under the University of Illinois Open Source +// License. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// + +// <valarray> + +// template<class T> class valarray; + +// template<class T> +// valarray<bool> +// operator>=(const valarray<T>& x, const T& y); + +#include <valarray> +#include <cassert> + +int main() +{ + { + typedef int T; + T a1[] = {1, 2, 3, 4, 0}; + bool a3[] = {false, true, true, true, false}; + const unsigned N = sizeof(a1)/sizeof(a1[0]); + std::valarray<T> v1(a1, N); + std::valarray<bool> v3 = v1 >= 2; + assert(v1.size() == v3.size()); + for (int i = 0; i < v1.size(); ++i) + assert(v3[i] == a3[i]); + } +} diff --git a/libcxx/test/numerics/numarray/valarray.nonmembers/valarray.comparison/greater_equal_value_valarray.pass.cpp b/libcxx/test/numerics/numarray/valarray.nonmembers/valarray.comparison/greater_equal_value_valarray.pass.cpp new file mode 100644 index 00000000000..4804c5fde05 --- /dev/null +++ b/libcxx/test/numerics/numarray/valarray.nonmembers/valarray.comparison/greater_equal_value_valarray.pass.cpp @@ -0,0 +1,34 @@ +//===----------------------------------------------------------------------===// +// +// ΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚThe LLVM Compiler Infrastructure +// +// This file is distributed under the University of Illinois Open Source +// License. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// + +// <valarray> + +// template<class T> class valarray; + +// template<class T> +// valarray<bool> +// operator>=(const T& x, const valarray<T>& y); + +#include <valarray> +#include <cassert> + +int main() +{ + { + typedef int T; + T a2[] = {1, 2, 3, 4, 0}; + bool a3[] = {true, true, false, false, true}; + const unsigned N = sizeof(a2)/sizeof(a2[0]); + std::valarray<T> v2(a2, N); + std::valarray<bool> v3 = 2 >= v2; + assert(v2.size() == v3.size()); + for (int i = 0; i < v3.size(); ++i) + assert(v3[i] == a3[i]); + } +} diff --git a/libcxx/test/numerics/numarray/valarray.nonmembers/valarray.comparison/greater_valarray_valarray.pass.cpp b/libcxx/test/numerics/numarray/valarray.nonmembers/valarray.comparison/greater_valarray_valarray.pass.cpp new file mode 100644 index 00000000000..57f9014b480 --- /dev/null +++ b/libcxx/test/numerics/numarray/valarray.nonmembers/valarray.comparison/greater_valarray_valarray.pass.cpp @@ -0,0 +1,37 @@ +//===----------------------------------------------------------------------===// +// +// ΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚThe LLVM Compiler Infrastructure +// +// This file is distributed under the University of Illinois Open Source +// License. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// + +// <valarray> + +// template<class T> class valarray; + +// template<class T> +// valarray<bool> +// operator>(const valarray<T>& x, const valarray<T>& y); + +#include <valarray> +#include <cassert> + +int main() +{ + { + typedef int T; + T a1[] = {1, 2, 0, 4, 10}; + T a2[] = {6, 7, 0, 2, 1}; + bool a3[] = {false, false, false, true, true}; + const unsigned N = sizeof(a1)/sizeof(a1[0]); + std::valarray<T> v1(a1, N); + std::valarray<T> v2(a2, N); + std::valarray<bool> v3 = v1 > v2; + assert(v1.size() == v2.size()); + assert(v1.size() == v3.size()); + for (int i = 0; i < v1.size(); ++i) + assert(v3[i] == a3[i]); + } +} diff --git a/libcxx/test/numerics/numarray/valarray.nonmembers/valarray.comparison/greater_valarray_value.pass.cpp b/libcxx/test/numerics/numarray/valarray.nonmembers/valarray.comparison/greater_valarray_value.pass.cpp new file mode 100644 index 00000000000..91ef3e98cdf --- /dev/null +++ b/libcxx/test/numerics/numarray/valarray.nonmembers/valarray.comparison/greater_valarray_value.pass.cpp @@ -0,0 +1,34 @@ +//===----------------------------------------------------------------------===// +// +// ΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚThe LLVM Compiler Infrastructure +// +// This file is distributed under the University of Illinois Open Source +// License. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// + +// <valarray> + +// template<class T> class valarray; + +// template<class T> +// valarray<bool> +// operator>(const valarray<T>& x, const T& y); + +#include <valarray> +#include <cassert> + +int main() +{ + { + typedef int T; + T a1[] = {1, 2, 3, 4, 0}; + bool a3[] = {false, false, true, true, false}; + const unsigned N = sizeof(a1)/sizeof(a1[0]); + std::valarray<T> v1(a1, N); + std::valarray<bool> v3 = v1 > 2; + assert(v1.size() == v3.size()); + for (int i = 0; i < v1.size(); ++i) + assert(v3[i] == a3[i]); + } +} diff --git a/libcxx/test/numerics/numarray/valarray.nonmembers/valarray.comparison/greater_value_valarray.pass.cpp b/libcxx/test/numerics/numarray/valarray.nonmembers/valarray.comparison/greater_value_valarray.pass.cpp new file mode 100644 index 00000000000..c03bc96274a --- /dev/null +++ b/libcxx/test/numerics/numarray/valarray.nonmembers/valarray.comparison/greater_value_valarray.pass.cpp @@ -0,0 +1,34 @@ +//===----------------------------------------------------------------------===// +// +// ΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚThe LLVM Compiler Infrastructure +// +// This file is distributed under the University of Illinois Open Source +// License. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// + +// <valarray> + +// template<class T> class valarray; + +// template<class T> +// valarray<bool> +// operator>(const T& x, const valarray<T>& y); + +#include <valarray> +#include <cassert> + +int main() +{ + { + typedef int T; + T a2[] = {1, 2, 3, 4, 0}; + bool a3[] = {true, false, false, false, true}; + const unsigned N = sizeof(a2)/sizeof(a2[0]); + std::valarray<T> v2(a2, N); + std::valarray<bool> v3 = 2 > v2; + assert(v2.size() == v3.size()); + for (int i = 0; i < v3.size(); ++i) + assert(v3[i] == a3[i]); + } +} diff --git a/libcxx/test/numerics/numarray/valarray.nonmembers/valarray.comparison/less_equal_valarray_valarray.pass.cpp b/libcxx/test/numerics/numarray/valarray.nonmembers/valarray.comparison/less_equal_valarray_valarray.pass.cpp new file mode 100644 index 00000000000..dd3ca9de091 --- /dev/null +++ b/libcxx/test/numerics/numarray/valarray.nonmembers/valarray.comparison/less_equal_valarray_valarray.pass.cpp @@ -0,0 +1,37 @@ +//===----------------------------------------------------------------------===// +// +// ΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚThe LLVM Compiler Infrastructure +// +// This file is distributed under the University of Illinois Open Source +// License. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// + +// <valarray> + +// template<class T> class valarray; + +// template<class T> +// valarray<bool> +// operator<=(const valarray<T>& x, const valarray<T>& y); + +#include <valarray> +#include <cassert> + +int main() +{ + { + typedef int T; + T a1[] = {1, 2, 0, 4, 10}; + T a2[] = {6, 7, 0, 2, 1}; + bool a3[] = {true, true, true, false, false}; + const unsigned N = sizeof(a1)/sizeof(a1[0]); + std::valarray<T> v1(a1, N); + std::valarray<T> v2(a2, N); + std::valarray<bool> v3 = v1 <= v2; + assert(v1.size() == v2.size()); + assert(v1.size() == v3.size()); + for (int i = 0; i < v1.size(); ++i) + assert(v3[i] == a3[i]); + } +} diff --git a/libcxx/test/numerics/numarray/valarray.nonmembers/valarray.comparison/less_equal_valarray_value.pass.cpp b/libcxx/test/numerics/numarray/valarray.nonmembers/valarray.comparison/less_equal_valarray_value.pass.cpp new file mode 100644 index 00000000000..919765e0c22 --- /dev/null +++ b/libcxx/test/numerics/numarray/valarray.nonmembers/valarray.comparison/less_equal_valarray_value.pass.cpp @@ -0,0 +1,34 @@ +//===----------------------------------------------------------------------===// +// +// ΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚThe LLVM Compiler Infrastructure +// +// This file is distributed under the University of Illinois Open Source +// License. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// + +// <valarray> + +// template<class T> class valarray; + +// template<class T> +// valarray<bool> +// operator<=(const valarray<T>& x, const T& y); + +#include <valarray> +#include <cassert> + +int main() +{ + { + typedef int T; + T a1[] = {1, 2, 3, 4, 0}; + bool a3[] = {true, true, false, false, true}; + const unsigned N = sizeof(a1)/sizeof(a1[0]); + std::valarray<T> v1(a1, N); + std::valarray<bool> v3 = v1 <= 2; + assert(v1.size() == v3.size()); + for (int i = 0; i < v1.size(); ++i) + assert(v3[i] == a3[i]); + } +} diff --git a/libcxx/test/numerics/numarray/valarray.nonmembers/valarray.comparison/less_equal_value_valarray.pass.cpp b/libcxx/test/numerics/numarray/valarray.nonmembers/valarray.comparison/less_equal_value_valarray.pass.cpp new file mode 100644 index 00000000000..2ad6d7ac4fd --- /dev/null +++ b/libcxx/test/numerics/numarray/valarray.nonmembers/valarray.comparison/less_equal_value_valarray.pass.cpp @@ -0,0 +1,34 @@ +//===----------------------------------------------------------------------===// +// +// ΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚThe LLVM Compiler Infrastructure +// +// This file is distributed under the University of Illinois Open Source +// License. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// + +// <valarray> + +// template<class T> class valarray; + +// template<class T> +// valarray<bool> +// operator<=(const T& x, const valarray<T>& y); + +#include <valarray> +#include <cassert> + +int main() +{ + { + typedef int T; + T a2[] = {1, 2, 3, 4, 0}; + bool a3[] = {false, true, true, true, false}; + const unsigned N = sizeof(a2)/sizeof(a2[0]); + std::valarray<T> v2(a2, N); + std::valarray<bool> v3 = 2 <= v2; + assert(v2.size() == v3.size()); + for (int i = 0; i < v3.size(); ++i) + assert(v3[i] == a3[i]); + } +} diff --git a/libcxx/test/numerics/numarray/valarray.nonmembers/valarray.comparison/less_valarray_valarray.pass.cpp b/libcxx/test/numerics/numarray/valarray.nonmembers/valarray.comparison/less_valarray_valarray.pass.cpp new file mode 100644 index 00000000000..ea476e4e5d5 --- /dev/null +++ b/libcxx/test/numerics/numarray/valarray.nonmembers/valarray.comparison/less_valarray_valarray.pass.cpp @@ -0,0 +1,37 @@ +//===----------------------------------------------------------------------===// +// +// ΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚThe LLVM Compiler Infrastructure +// +// This file is distributed under the University of Illinois Open Source +// License. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// + +// <valarray> + +// template<class T> class valarray; + +// template<class T> +// valarray<bool> +// operator<(const valarray<T>& x, const valarray<T>& y); + +#include <valarray> +#include <cassert> + +int main() +{ + { + typedef int T; + T a1[] = {1, 2, 0, 4, 10}; + T a2[] = {6, 7, 0, 2, 1}; + bool a3[] = {true, true, false, false, false}; + const unsigned N = sizeof(a1)/sizeof(a1[0]); + std::valarray<T> v1(a1, N); + std::valarray<T> v2(a2, N); + std::valarray<bool> v3 = v1 < v2; + assert(v1.size() == v2.size()); + assert(v1.size() == v3.size()); + for (int i = 0; i < v1.size(); ++i) + assert(v3[i] == a3[i]); + } +} diff --git a/libcxx/test/numerics/numarray/valarray.nonmembers/valarray.comparison/less_valarray_value.pass.cpp b/libcxx/test/numerics/numarray/valarray.nonmembers/valarray.comparison/less_valarray_value.pass.cpp new file mode 100644 index 00000000000..0f45c4d1823 --- /dev/null +++ b/libcxx/test/numerics/numarray/valarray.nonmembers/valarray.comparison/less_valarray_value.pass.cpp @@ -0,0 +1,34 @@ +//===----------------------------------------------------------------------===// +// +// ΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚThe LLVM Compiler Infrastructure +// +// This file is distributed under the University of Illinois Open Source +// License. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// + +// <valarray> + +// template<class T> class valarray; + +// template<class T> +// valarray<bool> +// operator<(const valarray<T>& x, const T& y); + +#include <valarray> +#include <cassert> + +int main() +{ + { + typedef int T; + T a1[] = {1, 2, 3, 4, 0}; + bool a3[] = {true, false, false, false, true}; + const unsigned N = sizeof(a1)/sizeof(a1[0]); + std::valarray<T> v1(a1, N); + std::valarray<bool> v3 = v1 < 2; + assert(v1.size() == v3.size()); + for (int i = 0; i < v1.size(); ++i) + assert(v3[i] == a3[i]); + } +} diff --git a/libcxx/test/numerics/numarray/valarray.nonmembers/valarray.comparison/less_value_valarray.pass.cpp b/libcxx/test/numerics/numarray/valarray.nonmembers/valarray.comparison/less_value_valarray.pass.cpp new file mode 100644 index 00000000000..e80ba4e7535 --- /dev/null +++ b/libcxx/test/numerics/numarray/valarray.nonmembers/valarray.comparison/less_value_valarray.pass.cpp @@ -0,0 +1,34 @@ +//===----------------------------------------------------------------------===// +// +// ΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚThe LLVM Compiler Infrastructure +// +// This file is distributed under the University of Illinois Open Source +// License. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// + +// <valarray> + +// template<class T> class valarray; + +// template<class T> +// valarray<bool> +// operator<(const T& x, const valarray<T>& y); + +#include <valarray> +#include <cassert> + +int main() +{ + { + typedef int T; + T a2[] = {1, 2, 3, 4, 0}; + bool a3[] = {false, false, true, true, false}; + const unsigned N = sizeof(a2)/sizeof(a2[0]); + std::valarray<T> v2(a2, N); + std::valarray<bool> v3 = 2 < v2; + assert(v2.size() == v3.size()); + for (int i = 0; i < v3.size(); ++i) + assert(v3[i] == a3[i]); + } +} diff --git a/libcxx/test/numerics/numarray/valarray.nonmembers/valarray.comparison/not_equal_valarray_valarray.pass.cpp b/libcxx/test/numerics/numarray/valarray.nonmembers/valarray.comparison/not_equal_valarray_valarray.pass.cpp new file mode 100644 index 00000000000..3bdfefec3d4 --- /dev/null +++ b/libcxx/test/numerics/numarray/valarray.nonmembers/valarray.comparison/not_equal_valarray_valarray.pass.cpp @@ -0,0 +1,37 @@ +//===----------------------------------------------------------------------===// +// +// ΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚThe LLVM Compiler Infrastructure +// +// This file is distributed under the University of Illinois Open Source +// License. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// + +// <valarray> + +// template<class T> class valarray; + +// template<class T> +// valarray<bool> +// operator!=(const valarray<T>& x, const valarray<T>& y); + +#include <valarray> +#include <cassert> + +int main() +{ + { + typedef int T; + T a1[] = {1, 2, 0, 4, 10}; + T a2[] = {6, 7, 0, 9, 10}; + bool a3[] = {true, true, false, true, false}; + const unsigned N = sizeof(a1)/sizeof(a1[0]); + std::valarray<T> v1(a1, N); + std::valarray<T> v2(a2, N); + std::valarray<bool> v3 = v1 != v2; + assert(v1.size() == v2.size()); + assert(v1.size() == v3.size()); + for (int i = 0; i < v1.size(); ++i) + assert(v3[i] == a3[i]); + } +} diff --git a/libcxx/test/numerics/numarray/valarray.nonmembers/valarray.comparison/not_equal_valarray_value.pass.cpp b/libcxx/test/numerics/numarray/valarray.nonmembers/valarray.comparison/not_equal_valarray_value.pass.cpp new file mode 100644 index 00000000000..73afabc5320 --- /dev/null +++ b/libcxx/test/numerics/numarray/valarray.nonmembers/valarray.comparison/not_equal_valarray_value.pass.cpp @@ -0,0 +1,34 @@ +//===----------------------------------------------------------------------===// +// +// ΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚThe LLVM Compiler Infrastructure +// +// This file is distributed under the University of Illinois Open Source +// License. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// + +// <valarray> + +// template<class T> class valarray; + +// template<class T> +// valarray<bool> +// operator!=(const valarray<T>& x, const T& y); + +#include <valarray> +#include <cassert> + +int main() +{ + { + typedef int T; + T a1[] = {1, 2, 3, 4, 0}; + bool a3[] = {true, false, true, true, true}; + const unsigned N = sizeof(a1)/sizeof(a1[0]); + std::valarray<T> v1(a1, N); + std::valarray<bool> v3 = v1 != 2; + assert(v1.size() == v3.size()); + for (int i = 0; i < v1.size(); ++i) + assert(v3[i] == a3[i]); + } +} diff --git a/libcxx/test/numerics/numarray/valarray.nonmembers/valarray.comparison/not_equal_value_valarray.pass.cpp b/libcxx/test/numerics/numarray/valarray.nonmembers/valarray.comparison/not_equal_value_valarray.pass.cpp new file mode 100644 index 00000000000..50c50bb9063 --- /dev/null +++ b/libcxx/test/numerics/numarray/valarray.nonmembers/valarray.comparison/not_equal_value_valarray.pass.cpp @@ -0,0 +1,34 @@ +//===----------------------------------------------------------------------===// +// +// ΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚThe LLVM Compiler Infrastructure +// +// This file is distributed under the University of Illinois Open Source +// License. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// + +// <valarray> + +// template<class T> class valarray; + +// template<class T> +// valarray<bool> +// operator!=(const T& x, const valarray<T>& y); + +#include <valarray> +#include <cassert> + +int main() +{ + { + typedef int T; + T a2[] = {1, 2, 3, 4, 0}; + bool a3[] = {true, false, true, true, true}; + const unsigned N = sizeof(a2)/sizeof(a2[0]); + std::valarray<T> v2(a2, N); + std::valarray<bool> v3 = 2 != v2; + assert(v2.size() == v3.size()); + for (int i = 0; i < v3.size(); ++i) + assert(v3[i] == a3[i]); + } +} diff --git a/libcxx/test/numerics/numarray/valarray.nonmembers/valarray.comparison/or_valarray_valarray.pass.cpp b/libcxx/test/numerics/numarray/valarray.nonmembers/valarray.comparison/or_valarray_valarray.pass.cpp new file mode 100644 index 00000000000..2c9cfb1e567 --- /dev/null +++ b/libcxx/test/numerics/numarray/valarray.nonmembers/valarray.comparison/or_valarray_valarray.pass.cpp @@ -0,0 +1,37 @@ +//===----------------------------------------------------------------------===// +// +// ΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚThe LLVM Compiler Infrastructure +// +// This file is distributed under the University of Illinois Open Source +// License. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// + +// <valarray> + +// template<class T> class valarray; + +// template<class T> +// valarray<bool> +// operator||(const valarray<T>& x, const valarray<T>& y); + +#include <valarray> +#include <cassert> + +int main() +{ + { + typedef int T; + T a1[] = {1, 2, 0, 4, 0}; + T a2[] = {6, 7, 0, 9, 10}; + bool a3[] = {true, true, false, true, true}; + const unsigned N = sizeof(a1)/sizeof(a1[0]); + std::valarray<T> v1(a1, N); + std::valarray<T> v2(a2, N); + std::valarray<bool> v3 = v1 || v2; + assert(v1.size() == v2.size()); + assert(v1.size() == v3.size()); + for (int i = 0; i < v1.size(); ++i) + assert(v3[i] == a3[i]); + } +} diff --git a/libcxx/test/numerics/numarray/valarray.nonmembers/valarray.comparison/or_valarray_value.pass.cpp b/libcxx/test/numerics/numarray/valarray.nonmembers/valarray.comparison/or_valarray_value.pass.cpp new file mode 100644 index 00000000000..a7e404cec0c --- /dev/null +++ b/libcxx/test/numerics/numarray/valarray.nonmembers/valarray.comparison/or_valarray_value.pass.cpp @@ -0,0 +1,45 @@ +//===----------------------------------------------------------------------===// +// +// ΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚThe LLVM Compiler Infrastructure +// +// This file is distributed under the University of Illinois Open Source +// License. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// + +// <valarray> + +// template<class T> class valarray; + +// template<class T> +// valarray<bool> +// operator||(const valarray<T>& x, const T& y); + +#include <valarray> +#include <cassert> + +int main() +{ + { + typedef int T; + T a1[] = {1, 2, 3, 4, 0}; + bool a3[] = {true, true, true, true, true}; + const unsigned N = sizeof(a1)/sizeof(a1[0]); + std::valarray<T> v1(a1, N); + std::valarray<bool> v3 = v1 || 5; + assert(v1.size() == v3.size()); + for (int i = 0; i < v1.size(); ++i) + assert(v3[i] == a3[i]); + } + { + typedef int T; + T a1[] = {1, 2, 3, 4, 0}; + bool a3[] = {true, true, true, true, false}; + const unsigned N = sizeof(a1)/sizeof(a1[0]); + std::valarray<T> v1(a1, N); + std::valarray<bool> v3 = v1 || 0; + assert(v1.size() == v3.size()); + for (int i = 0; i < v1.size(); ++i) + assert(v3[i] == a3[i]); + } +} diff --git a/libcxx/test/numerics/numarray/valarray.nonmembers/valarray.comparison/or_value_valarray.pass.cpp b/libcxx/test/numerics/numarray/valarray.nonmembers/valarray.comparison/or_value_valarray.pass.cpp new file mode 100644 index 00000000000..a2c4d44bdd6 --- /dev/null +++ b/libcxx/test/numerics/numarray/valarray.nonmembers/valarray.comparison/or_value_valarray.pass.cpp @@ -0,0 +1,45 @@ +//===----------------------------------------------------------------------===// +// +// ΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚThe LLVM Compiler Infrastructure +// +// This file is distributed under the University of Illinois Open Source +// License. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// + +// <valarray> + +// template<class T> class valarray; + +// template<class T> +// valarray<bool> +// operator||(const T& x, const valarray<T>& y); + +#include <valarray> +#include <cassert> + +int main() +{ + { + typedef int T; + T a2[] = {1, 2, 3, 4, 0}; + bool a3[] = {true, true, true, true, true}; + const unsigned N = sizeof(a2)/sizeof(a2[0]); + std::valarray<T> v2(a2, N); + std::valarray<bool> v3 = 5 || v2; + assert(v2.size() == v3.size()); + for (int i = 0; i < v3.size(); ++i) + assert(v3[i] == a3[i]); + } + { + typedef int T; + T a2[] = {1, 2, 3, 4, 0}; + bool a3[] = {true, true, true, true, false}; + const unsigned N = sizeof(a2)/sizeof(a2[0]); + std::valarray<T> v2(a2, N); + std::valarray<bool> v3 = 0 || v2; + assert(v2.size() == v3.size()); + for (int i = 0; i < v3.size(); ++i) + assert(v3[i] == a3[i]); + } +} |
