diff options
Diffstat (limited to 'test/std/numerics/numarray/template.valarray/valarray.cassign')
20 files changed, 690 insertions, 0 deletions
diff --git a/test/std/numerics/numarray/template.valarray/valarray.cassign/and_valarray.pass.cpp b/test/std/numerics/numarray/template.valarray/valarray.cassign/and_valarray.pass.cpp new file mode 100644 index 000000000000..5b1c1b9911b4 --- /dev/null +++ b/test/std/numerics/numarray/template.valarray/valarray.cassign/and_valarray.pass.cpp @@ -0,0 +1,36 @@ +//===----------------------------------------------------------------------===// +// +// The LLVM Compiler Infrastructure +// +// This file is dual licensed under the MIT and the University of Illinois Open +// Source Licenses. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// + +// <valarray> + +// template<class T> class valarray; + +// valarray& operator&=(const valarray& v); + +#include <valarray> +#include <cassert> + +int main() +{ + { + typedef int T; + T a1[] = {1, 2, 3, 4, 5}; + T a2[] = {6, 7, 8, 9, 10}; + T a3[] = {0, 2, 0, 0, 0}; + const unsigned N = sizeof(a1)/sizeof(a1[0]); + std::valarray<T> v1(a1, N); + std::valarray<T> v2(a2, N); + std::valarray<T> v3(a3, N); + v1 &= v2; + assert(v1.size() == v2.size()); + assert(v1.size() == v3.size()); + for (int i = 0; i < v1.size(); ++i) + assert(v1[i] == v3[i]); + } +} diff --git a/test/std/numerics/numarray/template.valarray/valarray.cassign/and_value.pass.cpp b/test/std/numerics/numarray/template.valarray/valarray.cassign/and_value.pass.cpp new file mode 100644 index 000000000000..2106a13e2c35 --- /dev/null +++ b/test/std/numerics/numarray/template.valarray/valarray.cassign/and_value.pass.cpp @@ -0,0 +1,33 @@ +//===----------------------------------------------------------------------===// +// +// The LLVM Compiler Infrastructure +// +// This file is dual licensed under the MIT and the University of Illinois Open +// Source Licenses. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// + +// <valarray> + +// template<class T> class valarray; + +// valarray& operator&=(const value_type& x); + +#include <valarray> +#include <cassert> + +int main() +{ + { + typedef int T; + T a1[] = { 1, 2, 3, 4, 5}; + T a2[] = { 1, 2, 3, 0, 1}; + const unsigned N = sizeof(a1)/sizeof(a1[0]); + std::valarray<T> v1(a1, N); + std::valarray<T> v2(a2, N); + v1 &= 3; + assert(v1.size() == v2.size()); + for (int i = 0; i < v1.size(); ++i) + assert(v1[i] == v2[i]); + } +} diff --git a/test/std/numerics/numarray/template.valarray/valarray.cassign/divide_valarray.pass.cpp b/test/std/numerics/numarray/template.valarray/valarray.cassign/divide_valarray.pass.cpp new file mode 100644 index 000000000000..3992d0aa43da --- /dev/null +++ b/test/std/numerics/numarray/template.valarray/valarray.cassign/divide_valarray.pass.cpp @@ -0,0 +1,36 @@ +//===----------------------------------------------------------------------===// +// +// The LLVM Compiler Infrastructure +// +// This file is dual licensed under the MIT and the University of Illinois Open +// Source Licenses. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// + +// <valarray> + +// template<class T> class valarray; + +// valarray& operator/=(const valarray& v); + +#include <valarray> +#include <cassert> + +int main() +{ + { + typedef int T; + T a1[] = {1, 2, 3, 4, 5}; + T a2[] = {6, 7, 8, 9, 10}; + T a3[] = {6, 14, 24, 36, 50}; + const unsigned N = sizeof(a1)/sizeof(a1[0]); + std::valarray<T> v1(a1, N); + std::valarray<T> v2(a2, N); + std::valarray<T> v3(a3, N); + v3 /= v2; + assert(v1.size() == v2.size()); + assert(v1.size() == v3.size()); + for (int i = 0; i < v1.size(); ++i) + assert(v1[i] == v3[i]); + } +} diff --git a/test/std/numerics/numarray/template.valarray/valarray.cassign/divide_value.pass.cpp b/test/std/numerics/numarray/template.valarray/valarray.cassign/divide_value.pass.cpp new file mode 100644 index 000000000000..7bd1cc84df6c --- /dev/null +++ b/test/std/numerics/numarray/template.valarray/valarray.cassign/divide_value.pass.cpp @@ -0,0 +1,33 @@ +//===----------------------------------------------------------------------===// +// +// The LLVM Compiler Infrastructure +// +// This file is dual licensed under the MIT and the University of Illinois Open +// Source Licenses. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// + +// <valarray> + +// template<class T> class valarray; + +// valarray& operator/=(const value_type& x); + +#include <valarray> +#include <cassert> + +int main() +{ + { + typedef int T; + T a1[] = {1, 2, 3, 4, 5}; + T a2[] = {6, 12, 18, 24, 30}; + const unsigned N = sizeof(a1)/sizeof(a1[0]); + std::valarray<T> v1(a1, N); + std::valarray<T> v2(a2, N); + v2 /= 6; + assert(v1.size() == v2.size()); + for (int i = 0; i < v1.size(); ++i) + assert(v1[i] == v2[i]); + } +} diff --git a/test/std/numerics/numarray/template.valarray/valarray.cassign/minus_valarray.pass.cpp b/test/std/numerics/numarray/template.valarray/valarray.cassign/minus_valarray.pass.cpp new file mode 100644 index 000000000000..e3d308abacc1 --- /dev/null +++ b/test/std/numerics/numarray/template.valarray/valarray.cassign/minus_valarray.pass.cpp @@ -0,0 +1,36 @@ +//===----------------------------------------------------------------------===// +// +// The LLVM Compiler Infrastructure +// +// This file is dual licensed under the MIT and the University of Illinois Open +// Source Licenses. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// + +// <valarray> + +// template<class T> class valarray; + +// valarray& operator-=(const valarray& v); + +#include <valarray> +#include <cassert> + +int main() +{ + { + typedef int T; + T a1[] = {1, 2, 3, 4, 5}; + T a2[] = {6, 7, 8, 9, 10}; + T a3[] = {7, 9, 11, 13, 15}; + const unsigned N = sizeof(a1)/sizeof(a1[0]); + std::valarray<T> v1(a1, N); + std::valarray<T> v2(a2, N); + std::valarray<T> v3(a3, N); + v3 -= v2; + assert(v1.size() == v2.size()); + assert(v1.size() == v3.size()); + for (int i = 0; i < v1.size(); ++i) + assert(v1[i] == v3[i]); + } +} diff --git a/test/std/numerics/numarray/template.valarray/valarray.cassign/minus_value.pass.cpp b/test/std/numerics/numarray/template.valarray/valarray.cassign/minus_value.pass.cpp new file mode 100644 index 000000000000..27ea8c2c0366 --- /dev/null +++ b/test/std/numerics/numarray/template.valarray/valarray.cassign/minus_value.pass.cpp @@ -0,0 +1,33 @@ +//===----------------------------------------------------------------------===// +// +// The LLVM Compiler Infrastructure +// +// This file is dual licensed under the MIT and the University of Illinois Open +// Source Licenses. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// + +// <valarray> + +// template<class T> class valarray; + +// valarray& operator-=(const value_type& x); + +#include <valarray> +#include <cassert> + +int main() +{ + { + typedef int T; + T a1[] = { 1, 2, 3, 4, 5}; + T a2[] = {-2, -1, 0, 1, 2}; + const unsigned N = sizeof(a1)/sizeof(a1[0]); + std::valarray<T> v1(a1, N); + std::valarray<T> v2(a2, N); + v1 -= 3; + assert(v1.size() == v2.size()); + for (int i = 0; i < v1.size(); ++i) + assert(v1[i] == v2[i]); + } +} diff --git a/test/std/numerics/numarray/template.valarray/valarray.cassign/modulo_valarray.pass.cpp b/test/std/numerics/numarray/template.valarray/valarray.cassign/modulo_valarray.pass.cpp new file mode 100644 index 000000000000..1754a5575eb5 --- /dev/null +++ b/test/std/numerics/numarray/template.valarray/valarray.cassign/modulo_valarray.pass.cpp @@ -0,0 +1,36 @@ +//===----------------------------------------------------------------------===// +// +// The LLVM Compiler Infrastructure +// +// This file is dual licensed under the MIT and the University of Illinois Open +// Source Licenses. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// + +// <valarray> + +// template<class T> class valarray; + +// valarray& operator%=(const valarray& v); + +#include <valarray> +#include <cassert> + +int main() +{ + { + typedef int T; + T a1[] = {1, 2, 3, 4, 5}; + T a2[] = {6, 7, 8, 9, 10}; + T a3[] = {0, 1, 2, 1, 0}; + const unsigned N = sizeof(a1)/sizeof(a1[0]); + std::valarray<T> v1(a1, N); + std::valarray<T> v2(a2, N); + std::valarray<T> v3(a3, N); + v2 %= v1; + assert(v1.size() == v2.size()); + assert(v1.size() == v3.size()); + for (int i = 0; i < v1.size(); ++i) + assert(v2[i] == v3[i]); + } +} diff --git a/test/std/numerics/numarray/template.valarray/valarray.cassign/modulo_value.pass.cpp b/test/std/numerics/numarray/template.valarray/valarray.cassign/modulo_value.pass.cpp new file mode 100644 index 000000000000..794a0b629268 --- /dev/null +++ b/test/std/numerics/numarray/template.valarray/valarray.cassign/modulo_value.pass.cpp @@ -0,0 +1,33 @@ +//===----------------------------------------------------------------------===// +// +// The LLVM Compiler Infrastructure +// +// This file is dual licensed under the MIT and the University of Illinois Open +// Source Licenses. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// + +// <valarray> + +// template<class T> class valarray; + +// valarray& operator%=(const value_type& x); + +#include <valarray> +#include <cassert> + +int main() +{ + { + typedef int T; + T a1[] = {1, 2, 3, 4, 5}; + T a2[] = {1, 2, 0, 1, 2}; + const unsigned N = sizeof(a1)/sizeof(a1[0]); + std::valarray<T> v1(a1, N); + std::valarray<T> v2(a2, N); + v1 %= 3; + assert(v1.size() == v2.size()); + for (int i = 0; i < v1.size(); ++i) + assert(v1[i] == v2[i]); + } +} diff --git a/test/std/numerics/numarray/template.valarray/valarray.cassign/or_valarray.pass.cpp b/test/std/numerics/numarray/template.valarray/valarray.cassign/or_valarray.pass.cpp new file mode 100644 index 000000000000..0d70b4e715da --- /dev/null +++ b/test/std/numerics/numarray/template.valarray/valarray.cassign/or_valarray.pass.cpp @@ -0,0 +1,36 @@ +//===----------------------------------------------------------------------===// +// +// The LLVM Compiler Infrastructure +// +// This file is dual licensed under the MIT and the University of Illinois Open +// Source Licenses. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// + +// <valarray> + +// template<class T> class valarray; + +// valarray& operator|=(const valarray& v); + +#include <valarray> +#include <cassert> + +int main() +{ + { + typedef int T; + T a1[] = {1, 2, 3, 4, 5}; + T a2[] = {6, 7, 8, 9, 10}; + T a3[] = {7, 7, 11, 13, 15}; + const unsigned N = sizeof(a1)/sizeof(a1[0]); + std::valarray<T> v1(a1, N); + std::valarray<T> v2(a2, N); + std::valarray<T> v3(a3, N); + v1 |= v2; + assert(v1.size() == v2.size()); + assert(v1.size() == v3.size()); + for (int i = 0; i < v1.size(); ++i) + assert(v1[i] == v3[i]); + } +} diff --git a/test/std/numerics/numarray/template.valarray/valarray.cassign/or_value.pass.cpp b/test/std/numerics/numarray/template.valarray/valarray.cassign/or_value.pass.cpp new file mode 100644 index 000000000000..4030907ff3e7 --- /dev/null +++ b/test/std/numerics/numarray/template.valarray/valarray.cassign/or_value.pass.cpp @@ -0,0 +1,33 @@ +//===----------------------------------------------------------------------===// +// +// The LLVM Compiler Infrastructure +// +// This file is dual licensed under the MIT and the University of Illinois Open +// Source Licenses. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// + +// <valarray> + +// template<class T> class valarray; + +// valarray& operator|=(const value_type& x); + +#include <valarray> +#include <cassert> + +int main() +{ + { + typedef int T; + T a1[] = { 1, 2, 3, 4, 5}; + T a2[] = { 3, 3, 3, 7, 7}; + const unsigned N = sizeof(a1)/sizeof(a1[0]); + std::valarray<T> v1(a1, N); + std::valarray<T> v2(a2, N); + v1 |= 3; + assert(v1.size() == v2.size()); + for (int i = 0; i < v1.size(); ++i) + assert(v1[i] == v2[i]); + } +} diff --git a/test/std/numerics/numarray/template.valarray/valarray.cassign/plus_valarray.pass.cpp b/test/std/numerics/numarray/template.valarray/valarray.cassign/plus_valarray.pass.cpp new file mode 100644 index 000000000000..fdf999c2a044 --- /dev/null +++ b/test/std/numerics/numarray/template.valarray/valarray.cassign/plus_valarray.pass.cpp @@ -0,0 +1,36 @@ +//===----------------------------------------------------------------------===// +// +// The LLVM Compiler Infrastructure +// +// This file is dual licensed under the MIT and the University of Illinois Open +// Source Licenses. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// + +// <valarray> + +// template<class T> class valarray; + +// valarray& operator+=(const valarray& v); + +#include <valarray> +#include <cassert> + +int main() +{ + { + typedef int T; + T a1[] = {1, 2, 3, 4, 5}; + T a2[] = {6, 7, 8, 9, 10}; + T a3[] = {7, 9, 11, 13, 15}; + const unsigned N = sizeof(a1)/sizeof(a1[0]); + std::valarray<T> v1(a1, N); + std::valarray<T> v2(a2, N); + std::valarray<T> v3(a3, N); + v1 += v2; + assert(v1.size() == v2.size()); + assert(v1.size() == v3.size()); + for (int i = 0; i < v1.size(); ++i) + assert(v1[i] == v3[i]); + } +} diff --git a/test/std/numerics/numarray/template.valarray/valarray.cassign/plus_value.pass.cpp b/test/std/numerics/numarray/template.valarray/valarray.cassign/plus_value.pass.cpp new file mode 100644 index 000000000000..23d6d9d05229 --- /dev/null +++ b/test/std/numerics/numarray/template.valarray/valarray.cassign/plus_value.pass.cpp @@ -0,0 +1,33 @@ +//===----------------------------------------------------------------------===// +// +// The LLVM Compiler Infrastructure +// +// This file is dual licensed under the MIT and the University of Illinois Open +// Source Licenses. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// + +// <valarray> + +// template<class T> class valarray; + +// valarray& operator+=(const value_type& x); + +#include <valarray> +#include <cassert> + +int main() +{ + { + typedef int T; + T a1[] = {1, 2, 3, 4, 5}; + T a2[] = {4, 5, 6, 7, 8}; + const unsigned N = sizeof(a1)/sizeof(a1[0]); + std::valarray<T> v1(a1, N); + std::valarray<T> v2(a2, N); + v1 += 3; + assert(v1.size() == v2.size()); + for (int i = 0; i < v1.size(); ++i) + assert(v1[i] == v2[i]); + } +} diff --git a/test/std/numerics/numarray/template.valarray/valarray.cassign/shift_left_valarray.pass.cpp b/test/std/numerics/numarray/template.valarray/valarray.cassign/shift_left_valarray.pass.cpp new file mode 100644 index 000000000000..ad44e3887eca --- /dev/null +++ b/test/std/numerics/numarray/template.valarray/valarray.cassign/shift_left_valarray.pass.cpp @@ -0,0 +1,36 @@ +//===----------------------------------------------------------------------===// +// +// The LLVM Compiler Infrastructure +// +// This file is dual licensed under the MIT and the University of Illinois Open +// Source Licenses. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// + +// <valarray> + +// template<class T> class valarray; + +// valarray& operator<<=(const valarray& v); + +#include <valarray> +#include <cassert> + +int main() +{ + { + typedef int T; + T a1[] = { 1, 2, 3, 4, 5}; + T a2[] = { 6, 7, 8, 9, 10}; + T a3[] = {64, 256, 768, 2048, 5120}; + const unsigned N = sizeof(a1)/sizeof(a1[0]); + std::valarray<T> v1(a1, N); + std::valarray<T> v2(a2, N); + std::valarray<T> v3(a3, N); + v1 <<= v2; + assert(v1.size() == v2.size()); + assert(v1.size() == v3.size()); + for (int i = 0; i < v1.size(); ++i) + assert(v1[i] == v3[i]); + } +} diff --git a/test/std/numerics/numarray/template.valarray/valarray.cassign/shift_left_value.pass.cpp b/test/std/numerics/numarray/template.valarray/valarray.cassign/shift_left_value.pass.cpp new file mode 100644 index 000000000000..366407a95c6f --- /dev/null +++ b/test/std/numerics/numarray/template.valarray/valarray.cassign/shift_left_value.pass.cpp @@ -0,0 +1,33 @@ +//===----------------------------------------------------------------------===// +// +// The LLVM Compiler Infrastructure +// +// This file is dual licensed under the MIT and the University of Illinois Open +// Source Licenses. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// + +// <valarray> + +// template<class T> class valarray; + +// valarray& operator<<=(const value_type& x); + +#include <valarray> +#include <cassert> + +int main() +{ + { + typedef int T; + T a1[] = { 1, 2, 3, 4, 5}; + T a2[] = { 8, 16, 24, 32, 40}; + const unsigned N = sizeof(a1)/sizeof(a1[0]); + std::valarray<T> v1(a1, N); + std::valarray<T> v2(a2, N); + v1 <<= 3; + assert(v1.size() == v2.size()); + for (int i = 0; i < v1.size(); ++i) + assert(v1[i] == v2[i]); + } +} diff --git a/test/std/numerics/numarray/template.valarray/valarray.cassign/shift_right_valarray.pass.cpp b/test/std/numerics/numarray/template.valarray/valarray.cassign/shift_right_valarray.pass.cpp new file mode 100644 index 000000000000..f7df16b843ca --- /dev/null +++ b/test/std/numerics/numarray/template.valarray/valarray.cassign/shift_right_valarray.pass.cpp @@ -0,0 +1,36 @@ +//===----------------------------------------------------------------------===// +// +// The LLVM Compiler Infrastructure +// +// This file is dual licensed under the MIT and the University of Illinois Open +// Source Licenses. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// + +// <valarray> + +// template<class T> class valarray; + +// valarray& operator>>=(const valarray& v); + +#include <valarray> +#include <cassert> + +int main() +{ + { + typedef int T; + T a1[] = { 1, 2, 3, 4, 5}; + T a2[] = { 6, 7, 8, 9, 10}; + T a3[] = {64, 256, 768, 2048, 5120}; + const unsigned N = sizeof(a1)/sizeof(a1[0]); + std::valarray<T> v1(a1, N); + std::valarray<T> v2(a2, N); + std::valarray<T> v3(a3, N); + v3 >>= v2; + assert(v1.size() == v2.size()); + assert(v1.size() == v3.size()); + for (int i = 0; i < v1.size(); ++i) + assert(v1[i] == v3[i]); + } +} diff --git a/test/std/numerics/numarray/template.valarray/valarray.cassign/shift_right_value.pass.cpp b/test/std/numerics/numarray/template.valarray/valarray.cassign/shift_right_value.pass.cpp new file mode 100644 index 000000000000..7c568b14cbea --- /dev/null +++ b/test/std/numerics/numarray/template.valarray/valarray.cassign/shift_right_value.pass.cpp @@ -0,0 +1,33 @@ +//===----------------------------------------------------------------------===// +// +// The LLVM Compiler Infrastructure +// +// This file is dual licensed under the MIT and the University of Illinois Open +// Source Licenses. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// + +// <valarray> + +// template<class T> class valarray; + +// valarray& operator>>=(const value_type& x); + +#include <valarray> +#include <cassert> + +int main() +{ + { + typedef int T; + T a1[] = { 1, 2, 3, 4, 5}; + T a2[] = { 8, 16, 24, 32, 40}; + const unsigned N = sizeof(a1)/sizeof(a1[0]); + std::valarray<T> v1(a1, N); + std::valarray<T> v2(a2, N); + v2 >>= 3; + assert(v1.size() == v2.size()); + for (int i = 0; i < v1.size(); ++i) + assert(v1[i] == v2[i]); + } +} diff --git a/test/std/numerics/numarray/template.valarray/valarray.cassign/times_valarray.pass.cpp b/test/std/numerics/numarray/template.valarray/valarray.cassign/times_valarray.pass.cpp new file mode 100644 index 000000000000..d3cf1eb88641 --- /dev/null +++ b/test/std/numerics/numarray/template.valarray/valarray.cassign/times_valarray.pass.cpp @@ -0,0 +1,36 @@ +//===----------------------------------------------------------------------===// +// +// The LLVM Compiler Infrastructure +// +// This file is dual licensed under the MIT and the University of Illinois Open +// Source Licenses. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// + +// <valarray> + +// template<class T> class valarray; + +// valarray& operator*=(const valarray& v); + +#include <valarray> +#include <cassert> + +int main() +{ + { + typedef int T; + T a1[] = {1, 2, 3, 4, 5}; + T a2[] = {6, 7, 8, 9, 10}; + T a3[] = {6, 14, 24, 36, 50}; + const unsigned N = sizeof(a1)/sizeof(a1[0]); + std::valarray<T> v1(a1, N); + std::valarray<T> v2(a2, N); + std::valarray<T> v3(a3, N); + v1 *= v2; + assert(v1.size() == v2.size()); + assert(v1.size() == v3.size()); + for (int i = 0; i < v1.size(); ++i) + assert(v1[i] == v3[i]); + } +} diff --git a/test/std/numerics/numarray/template.valarray/valarray.cassign/times_value.pass.cpp b/test/std/numerics/numarray/template.valarray/valarray.cassign/times_value.pass.cpp new file mode 100644 index 000000000000..aea9806bc0d0 --- /dev/null +++ b/test/std/numerics/numarray/template.valarray/valarray.cassign/times_value.pass.cpp @@ -0,0 +1,33 @@ +//===----------------------------------------------------------------------===// +// +// The LLVM Compiler Infrastructure +// +// This file is dual licensed under the MIT and the University of Illinois Open +// Source Licenses. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// + +// <valarray> + +// template<class T> class valarray; + +// valarray& operator*=(const value_type& x); + +#include <valarray> +#include <cassert> + +int main() +{ + { + typedef int T; + T a1[] = {1, 2, 3, 4, 5}; + T a2[] = {6, 12, 18, 24, 30}; + const unsigned N = sizeof(a1)/sizeof(a1[0]); + std::valarray<T> v1(a1, N); + std::valarray<T> v2(a2, N); + v1 *= 6; + assert(v1.size() == v2.size()); + for (int i = 0; i < v1.size(); ++i) + assert(v1[i] == v2[i]); + } +} diff --git a/test/std/numerics/numarray/template.valarray/valarray.cassign/xor_valarray.pass.cpp b/test/std/numerics/numarray/template.valarray/valarray.cassign/xor_valarray.pass.cpp new file mode 100644 index 000000000000..a10bd7e0a000 --- /dev/null +++ b/test/std/numerics/numarray/template.valarray/valarray.cassign/xor_valarray.pass.cpp @@ -0,0 +1,36 @@ +//===----------------------------------------------------------------------===// +// +// The LLVM Compiler Infrastructure +// +// This file is dual licensed under the MIT and the University of Illinois Open +// Source Licenses. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// + +// <valarray> + +// template<class T> class valarray; + +// valarray& operator^=(const valarray& v); + +#include <valarray> +#include <cassert> + +int main() +{ + { + typedef int T; + T a1[] = {1, 2, 3, 4, 5}; + T a2[] = {6, 7, 8, 9, 10}; + T a3[] = {7, 5, 11, 13, 15}; + const unsigned N = sizeof(a1)/sizeof(a1[0]); + std::valarray<T> v1(a1, N); + std::valarray<T> v2(a2, N); + std::valarray<T> v3(a3, N); + v1 ^= v2; + assert(v1.size() == v2.size()); + assert(v1.size() == v3.size()); + for (int i = 0; i < v1.size(); ++i) + assert(v1[i] == v3[i]); + } +} diff --git a/test/std/numerics/numarray/template.valarray/valarray.cassign/xor_value.pass.cpp b/test/std/numerics/numarray/template.valarray/valarray.cassign/xor_value.pass.cpp new file mode 100644 index 000000000000..327952f7b3aa --- /dev/null +++ b/test/std/numerics/numarray/template.valarray/valarray.cassign/xor_value.pass.cpp @@ -0,0 +1,33 @@ +//===----------------------------------------------------------------------===// +// +// The LLVM Compiler Infrastructure +// +// This file is dual licensed under the MIT and the University of Illinois Open +// Source Licenses. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// + +// <valarray> + +// template<class T> class valarray; + +// valarray& operator^=(const value_type& x); + +#include <valarray> +#include <cassert> + +int main() +{ + { + typedef int T; + T a1[] = { 1, 2, 3, 4, 5}; + T a2[] = { 2, 1, 0, 7, 6}; + const unsigned N = sizeof(a1)/sizeof(a1[0]); + std::valarray<T> v1(a1, N); + std::valarray<T> v2(a2, N); + v1 ^= 3; + assert(v1.size() == v2.size()); + for (int i = 0; i < v1.size(); ++i) + assert(v1[i] == v2[i]); + } +} |