generic-library/cxx
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

libcxx initial import

Browse Source 
git-svn-id: https://llvm.org/svn/llvm-project/libcxx/trunk@103490 91177308-0d34-0410-b5e6-96231b3b80d8
This commit is contained in:
Howard Hinnant
2010-05-11 19:42:16 +00:00
commit bc8d3f97eb
3893 changed files with 1209942 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

51
test/numerics/numarray/template.valarray/valarray.members/apply_cref.pass.cpp Normal file
View File

@@ -0,0 +1,51 @@
//===----------------------------------------------------------------------===//
//
// <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>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;
// valarray apply(value_type f(const value_type&)) const;
#include <valarray>
#include <cassert>
typedef int T;
T f(const T& t) {return t + 5;}
int main()
{
{
T a1[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
T a2[] = {6, 7, 8, 9, 10, 11, 12, 13, 14, 15};
const unsigned N1 = sizeof(a1)/sizeof(a1[0]);
std::valarray<T> v1(a1, N1);
std::valarray<T> v2 = v1.apply(f);
assert(v2.size() == N1);
for (unsigned i = 0; i < N1; ++i)
assert(v2[i] == a2[i]);
}
{
const unsigned N1 = 0;
std::valarray<T> v1;
std::valarray<T> v2 = v1.apply(f);
assert(v2.size() == N1);
}
{
T a1[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
T a2[] = {7, 9, 11, 13, 15, 17, 19, 21, 23, 25};
const unsigned N1 = sizeof(a1)/sizeof(a1[0]);
std::valarray<T> v1(a1, N1);
std::valarray<T> v2 = (v1+v1).apply(f);
assert(v2.size() == N1);
for (unsigned i = 0; i < N1; ++i)
assert(v2[i] == a2[i]);
}
}

51
test/numerics/numarray/template.valarray/valarray.members/apply_value.pass.cpp Normal file
View File

@@ -0,0 +1,51 @@
//===----------------------------------------------------------------------===//
//
// <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>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;
// valarray apply(value_type f(value_type)) const;
#include <valarray>
#include <cassert>
typedef int T;
T f(T t) {return t + 5;}
int main()
{
{
T a1[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
T a2[] = {6, 7, 8, 9, 10, 11, 12, 13, 14, 15};
const unsigned N1 = sizeof(a1)/sizeof(a1[0]);
std::valarray<T> v1(a1, N1);
std::valarray<T> v2 = v1.apply(f);
assert(v2.size() == N1);
for (unsigned i = 0; i < N1; ++i)
assert(v2[i] == a2[i]);
}
{
const unsigned N1 = 0;
std::valarray<T> v1;
std::valarray<T> v2 = v1.apply(f);
assert(v2.size() == N1);
}
{
T a1[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
T a2[] = {7, 9, 11, 13, 15, 17, 19, 21, 23, 25};
const unsigned N1 = sizeof(a1)/sizeof(a1[0]);
std::valarray<T> v1(a1, N1);
std::valarray<T> v2 = (v1+v1).apply(f);
assert(v2.size() == N1);
for (unsigned i = 0; i < N1; ++i)
assert(v2[i] == a2[i]);
}
}

127
test/numerics/numarray/template.valarray/valarray.members/cshift.pass.cpp Normal file
View File

@@ -0,0 +1,127 @@
//===----------------------------------------------------------------------===//
//
// <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>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;
// valarray cshift(int i) const;
#include <valarray>
#include <cassert>
int main()
{
{
typedef int T;
T a1[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
T a2[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
const unsigned N1 = sizeof(a1)/sizeof(a1[0]);
std::valarray<T> v1(a1, N1);
std::valarray<T> v2 = v1.cshift(0);
assert(v2.size() == N1);
for (unsigned i = 0; i < N1; ++i)
assert(v2[i] == a2[i]);
}
{
typedef int T;
T a1[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
T a2[] = {4, 5, 6, 7, 8, 9, 10, 1, 2, 3};
const unsigned N1 = sizeof(a1)/sizeof(a1[0]);
std::valarray<T> v1(a1, N1);
std::valarray<T> v2 = v1.cshift(3);
assert(v2.size() == N1);
for (unsigned i = 0; i < N1; ++i)
assert(v2[i] == a2[i]);
}
{
typedef int T;
T a1[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
T a2[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
const unsigned N1 = sizeof(a1)/sizeof(a1[0]);
std::valarray<T> v1(a1, N1);
std::valarray<T> v2 = v1.cshift(10);
assert(v2.size() == N1);
for (unsigned i = 0; i < N1; ++i)
assert(v2[i] == a2[i]);
}
{
typedef int T;
T a1[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
T a2[] = {8, 9, 10, 1, 2, 3, 4, 5, 6, 7};
const unsigned N1 = sizeof(a1)/sizeof(a1[0]);
std::valarray<T> v1(a1, N1);
std::valarray<T> v2 = v1.cshift(17);
assert(v2.size() == N1);
for (unsigned i = 0; i < N1; ++i)
assert(v2[i] == a2[i]);
}
{
typedef int T;
T a1[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
T a2[] = {8, 9, 10, 1, 2, 3, 4, 5, 6, 7};
const unsigned N1 = sizeof(a1)/sizeof(a1[0]);
std::valarray<T> v1(a1, N1);
std::valarray<T> v2 = v1.cshift(-3);
assert(v2.size() == N1);
for (unsigned i = 0; i < N1; ++i)
assert(v2[i] == a2[i]);
}
{
typedef int T;
T a1[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
T a2[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
const unsigned N1 = sizeof(a1)/sizeof(a1[0]);
std::valarray<T> v1(a1, N1);
std::valarray<T> v2 = v1.cshift(-10);
assert(v2.size() == N1);
for (unsigned i = 0; i < N1; ++i)
assert(v2[i] == a2[i]);
}
{
typedef int T;
T a1[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
T a2[] = {4, 5, 6, 7, 8, 9, 10, 1, 2, 3};
const unsigned N1 = sizeof(a1)/sizeof(a1[0]);
std::valarray<T> v1(a1, N1);
std::valarray<T> v2 = v1.cshift(-17);
assert(v2.size() == N1);
for (unsigned i = 0; i < N1; ++i)
assert(v2[i] == a2[i]);
}
{
typedef int T;
const unsigned N1 = 0;
std::valarray<T> v1;
std::valarray<T> v2 = v1.cshift(-17);
assert(v2.size() == N1);
}
{
typedef int T;
T a1[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
T a2[] = {8, 10, 12, 14, 16, 18, 20, 2, 4, 6};
const unsigned N1 = sizeof(a1)/sizeof(a1[0]);
std::valarray<T> v1(a1, N1);
std::valarray<T> v2 = (v1 + v1).cshift(3);
assert(v2.size() == N1);
for (unsigned i = 0; i < N1; ++i)
assert(v2[i] == a2[i]);
}
{
typedef int T;
T a1[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
T a2[] = {16, 18, 20, 2, 4, 6, 8, 10, 12, 14};
const unsigned N1 = sizeof(a1)/sizeof(a1[0]);
std::valarray<T> v1(a1, N1);
std::valarray<T> v2 = (v1 + v1).cshift(-3);
assert(v2.size() == N1);
for (unsigned i = 0; i < N1; ++i)
assert(v2[i] == a2[i]);
}
}

40
test/numerics/numarray/template.valarray/valarray.members/max.pass.cpp Normal file
View File

@@ -0,0 +1,40 @@
//===----------------------------------------------------------------------===//
//
// <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>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;
// value_type max() const;
#include <valarray>
#include <cassert>
int main()
{
{
typedef double T;
T a1[] = {1.5, 2.5, -3, 4, -5.5};
const unsigned N1 = sizeof(a1)/sizeof(a1[0]);
std::valarray<T> v1(a1, N1);
assert(v1.max() == 4.0);
}
{
typedef double T;
std::valarray<T> v1;
v1.max();
}
{
typedef double T;
T a1[] = {1.5, 2.5, -3, 4, -5.5};
const unsigned N1 = sizeof(a1)/sizeof(a1[0]);
std::valarray<T> v1(a1, N1);
assert((2*v1).max() == 8.0);
}
}

40
test/numerics/numarray/template.valarray/valarray.members/min.pass.cpp Normal file
View File

@@ -0,0 +1,40 @@
//===----------------------------------------------------------------------===//
//
// <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>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;
// value_type min() const;
#include <valarray>
#include <cassert>
int main()
{
{
typedef double T;
T a1[] = {1.5, 2.5, -3, 4, 5.5};
const unsigned N1 = sizeof(a1)/sizeof(a1[0]);
std::valarray<T> v1(a1, N1);
assert(v1.min() == -3.0);
}
{
typedef double T;
std::valarray<T> v1;
v1.min();
}
{
typedef double T;
T a1[] = {1.5, 2.5, -3, 4, 5.5};
const unsigned N1 = sizeof(a1)/sizeof(a1[0]);
std::valarray<T> v1(a1, N1);
assert((2*v1).min() == -6.0);
}
}

41
test/numerics/numarray/template.valarray/valarray.members/resize.pass.cpp Normal file
View File

@@ -0,0 +1,41 @@
//===----------------------------------------------------------------------===//
//
// <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>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;
// void resize(size_t n, value_type x = value_type());
#include <valarray>
#include <cassert>
int main()
{
{
typedef int T;
T a1[] = {1, 2, 3, 4, 5};
const unsigned N1 = sizeof(a1)/sizeof(a1[0]);
std::valarray<T> v1(a1, N1);
v1.resize(8);
assert(v1.size() == 8);
for (int i = 0; i < v1.size(); ++i)
assert(v1[i] == 0);
v1.resize(0);
assert(v1.size() == 0);
v1.resize(80);
assert(v1.size() == 80);
for (int i = 0; i < v1.size(); ++i)
assert(v1[i] == 0);
v1.resize(40);
assert(v1.size() == 40);
for (int i = 0; i < v1.size(); ++i)
assert(v1[i] == 0);
}
}

127
test/numerics/numarray/template.valarray/valarray.members/shift.pass.cpp Normal file
View File

@@ -0,0 +1,127 @@
//===----------------------------------------------------------------------===//
//
// <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>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;
// valarray shift(int i) const;
#include <valarray>
#include <cassert>
int main()
{
{
typedef int T;
T a1[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
T a2[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
const unsigned N1 = sizeof(a1)/sizeof(a1[0]);
std::valarray<T> v1(a1, N1);
std::valarray<T> v2 = v1.shift(0);
assert(v2.size() == N1);
for (unsigned i = 0; i < N1; ++i)
assert(v2[i] == a2[i]);
}
{
typedef int T;
T a1[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
T a2[] = {2, 3, 4, 5, 6, 7, 8, 9, 10, 0};
const unsigned N1 = sizeof(a1)/sizeof(a1[0]);
std::valarray<T> v1(a1, N1);
std::valarray<T> v2 = v1.shift(1);
assert(v2.size() == N1);
for (unsigned i = 0; i < N1; ++i)
assert(v2[i] == a2[i]);
}
{
typedef int T;
T a1[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
T a2[] = {10, 0, 0, 0, 0, 0, 0, 0, 0, 0};
const unsigned N1 = sizeof(a1)/sizeof(a1[0]);
std::valarray<T> v1(a1, N1);
std::valarray<T> v2 = v1.shift(9);
assert(v2.size() == N1);
for (unsigned i = 0; i < N1; ++i)
assert(v2[i] == a2[i]);
}
{
typedef int T;
T a1[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
T a2[] = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0};
const unsigned N1 = sizeof(a1)/sizeof(a1[0]);
std::valarray<T> v1(a1, N1);
std::valarray<T> v2 = v1.shift(90);
assert(v2.size() == N1);
for (unsigned i = 0; i < N1; ++i)
assert(v2[i] == a2[i]);
}
{
typedef int T;
T a1[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
T a2[] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9};
const unsigned N1 = sizeof(a1)/sizeof(a1[0]);
std::valarray<T> v1(a1, N1);
std::valarray<T> v2 = v1.shift(-1);
assert(v2.size() == N1);
for (unsigned i = 0; i < N1; ++i)
assert(v2[i] == a2[i]);
}
{
typedef int T;
T a1[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
T a2[] = {0, 0, 0, 0, 0, 0, 0, 0, 0, 1};
const unsigned N1 = sizeof(a1)/sizeof(a1[0]);
std::valarray<T> v1(a1, N1);
std::valarray<T> v2 = v1.shift(-9);
assert(v2.size() == N1);
for (unsigned i = 0; i < N1; ++i)
assert(v2[i] == a2[i]);
}
{
typedef int T;
T a1[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
T a2[] = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0};
const unsigned N1 = sizeof(a1)/sizeof(a1[0]);
std::valarray<T> v1(a1, N1);
std::valarray<T> v2 = v1.shift(-90);
assert(v2.size() == N1);
for (unsigned i = 0; i < N1; ++i)
assert(v2[i] == a2[i]);
}
{
typedef int T;
const unsigned N1 = 0;
std::valarray<T> v1;
std::valarray<T> v2 = v1.shift(-90);
assert(v2.size() == N1);
}
{
typedef int T;
T a1[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
T a2[] = {8, 10, 12, 14, 16, 18, 20, 0, 0, 0};
const unsigned N1 = sizeof(a1)/sizeof(a1[0]);
std::valarray<T> v1(a1, N1);
std::valarray<T> v2 = (v1 + v1).shift(3);
assert(v2.size() == N1);
for (unsigned i = 0; i < N1; ++i)
assert(v2[i] == a2[i]);
}
{
typedef int T;
T a1[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
T a2[] = {0, 0, 0, 2, 4, 6, 8, 10, 12, 14};
const unsigned N1 = sizeof(a1)/sizeof(a1[0]);
std::valarray<T> v1(a1, N1);
std::valarray<T> v2 = (v1 + v1).shift(-3);
assert(v2.size() == N1);
for (unsigned i = 0; i < N1; ++i)
assert(v2[i] == a2[i]);
}
}

41
test/numerics/numarray/template.valarray/valarray.members/size.pass.cpp Normal file
View File

@@ -0,0 +1,41 @@
//===----------------------------------------------------------------------===//
//
// <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>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;
// size_t size() const;
#include <valarray>
#include <cassert>
int main()
{
{
typedef int T;
T a1[] = {1, 2, 3, 4, 5};
const unsigned N1 = sizeof(a1)/sizeof(a1[0]);
std::valarray<T> v1(a1, N1);
assert(v1.size() == N1);
}
{
typedef int T;
T a1[] = {1, 2, 3, 4, 5};
const unsigned N1 = 0;
std::valarray<T> v1(a1, N1);
assert(v1.size() == N1);
}
{
typedef int T;
const unsigned N1 = 0;
std::valarray<T> v1;
assert(v1.size() == N1);
}
}

28
test/numerics/numarray/template.valarray/valarray.members/sum.pass.cpp Normal file
View File

@@ -0,0 +1,28 @@
//===----------------------------------------------------------------------===//
//
// <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>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;
// value_type sum() const;
#include <valarray>
#include <cassert>
int main()
{
{
typedef double T;
T a1[] = {1.5, 2.5, 3, 4, 5.5};
const unsigned N1 = sizeof(a1)/sizeof(a1[0]);
std::valarray<T> v1(a1, N1);
assert(v1.sum() == 16.5);
}
}

89
test/numerics/numarray/template.valarray/valarray.members/swap.pass.cpp Normal file
View File

@@ -0,0 +1,89 @@
//===----------------------------------------------------------------------===//
//
// <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>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;
// void swap(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, 11, 12};
const unsigned N1 = sizeof(a1)/sizeof(a1[0]);
const unsigned N2 = sizeof(a2)/sizeof(a2[0]);
std::valarray<T> v1(a1, N1);
std::valarray<T> v2(a2, N2);
std::valarray<T> v1_save = v1;
std::valarray<T> v2_save = v2;
v1.swap(v2);
assert(v1.size() == v2_save.size());
for (int i = 0; i < v1.size(); ++i)
assert(v1[i] == v2_save[i]);
assert(v2.size() == v1_save.size());
for (int i = 0; i < v2.size(); ++i)
assert(v2[i] == v1_save[i]);
}
{
typedef int T;
T a1[] = {1, 2, 3, 4, 5};
const unsigned N1 = sizeof(a1)/sizeof(a1[0]);
const unsigned N2 = 0;
std::valarray<T> v1(a1, N1);
std::valarray<T> v2;
std::valarray<T> v1_save = v1;
std::valarray<T> v2_save = v2;
v1.swap(v2);
assert(v1.size() == v2_save.size());
for (int i = 0; i < v1.size(); ++i)
assert(v1[i] == v2_save[i]);
assert(v2.size() == v1_save.size());
for (int i = 0; i < v2.size(); ++i)
assert(v2[i] == v1_save[i]);
}
{
typedef int T;
T a2[] = {6, 7, 8, 9, 10, 11, 12};
const unsigned N1 = 0;
const unsigned N2 = sizeof(a2)/sizeof(a2[0]);
std::valarray<T> v1;
std::valarray<T> v2(a2, N2);
std::valarray<T> v1_save = v1;
std::valarray<T> v2_save = v2;
v1.swap(v2);
assert(v1.size() == v2_save.size());
for (int i = 0; i < v1.size(); ++i)
assert(v1[i] == v2_save[i]);
assert(v2.size() == v1_save.size());
for (int i = 0; i < v2.size(); ++i)
assert(v2[i] == v1_save[i]);
}
{
typedef int T;
const unsigned N1 = 0;
const unsigned N2 = 0;
std::valarray<T> v1;
std::valarray<T> v2;
std::valarray<T> v1_save = v1;
std::valarray<T> v2_save = v2;
v1.swap(v2);
assert(v1.size() == v2_save.size());
for (int i = 0; i < v1.size(); ++i)
assert(v1[i] == v2_save[i]);
assert(v2.size() == v1_save.size());
for (int i = 0; i < v2.size(); ++i)
assert(v2[i] == v1_save[i]);
}
}