示例#1
0
int main()
{
// Sequence creation
    std::vector<int> ilvec = initialize<int>();
    std::vector<int> ivec(ilvec.cbegin(), ilvec.cend());

    constexpr int arr_sz(11);
    ilvec = initialize<int>(arr_sz);
    std::array<int, arr_sz> ilarr({1,2,3,4,5,6,7,8,9,50,61});

    ilvec = initialize<int>();
    std::list<int> ilst(ilvec.cbegin(), ilvec.cend());

    ilvec = initialize<int>();
    std::forward_list<int> iflst(ilvec.cbegin(), ilvec.cend());

    ilvec = initialize<int>();
    std::deque<int> ideq(ilvec.cbegin(), ilvec.cend());

    int iarr[]{1, 2, 3, 6, 5, 4, 3, 44, 5, 232, 45, 76, 654, 96, 687, 4, 65, 89,343, 23};

// Print
    print(ivec, "ivec");
    print(ilarr, "ilarr");
    print(ilst, "ilst");
    print(iflst, "iflst");
    print(ideq, "ideq");
    print(iarr, "iarr");

// Use algorithms
    int val1 = 85, val2 = 54;
    std::cout << "sum = " << std::accumulate(ivec.cbegin(), ivec.cend(), 0) << std::endl;
    std::cout << "difference = " << std::accumulate(ideq.cbegin(), ideq.cend(), 10, diff<int>) << std::endl;
    std::cout << "inner product = " << std::inner_product(ilarr.cbegin(), ilarr.cend(),ilst.cbegin(), 0) << std::endl;
    std::cout << "custom inner product = " << std::inner_product(iflst.cbegin(), iflst.cend(), std::begin(iarr), 777, mod<int>, diff<int>) << std::endl;

    std::vector<int> cpy(ilst.size()), cpy1(ivec.size());
    std::partial_sum(ilst.cbegin(), ilst.cend(), cpy.begin());
    print(cpy, "cpy");

    std::partial_sum(ivec.cbegin(), ivec.cend(), cpy1.begin(), diff<int>);
    print(cpy1, "cpy1");

    std::vector<int> cpy2(arr_sz), cpy3(20);
    std::adjacent_difference(ilarr.cbegin(), ilarr.cend(), cpy2.begin());
    print(cpy2, "cpy2");

    std::adjacent_difference(std::begin(iarr), std::end(iarr), cpy3.begin(), mod<int>);
    print(cpy3, "cpy3");

    print(iflst, "iflst");
    std::iota(iflst.begin(), iflst.end(), val1);
    print(iflst, "iflst");

    return 0;
}
void TestVectorManipulation(size_t n)
{
    typedef typename Vector::value_type T;

    thrust::host_vector<T> src = unittest::random_samples<T>(n);
    ASSERT_EQUAL(src.size(), n);

    // basic initialization
    Vector test0(n);
    Vector test1(n, (T) 3);
    ASSERT_EQUAL(test0.size(), n);
    ASSERT_EQUAL(test1.size(), n);
    ASSERT_EQUAL((test1 == std::vector<T>(n, (T) 3)), true);
   
    // initializing from other vector
    std::vector<T> stl_vector(src.begin(), src.end());
    Vector cpy0 = src;
    Vector cpy1(stl_vector);
    Vector cpy2(stl_vector.begin(), stl_vector.end());
    ASSERT_EQUAL(cpy0, src);
    ASSERT_EQUAL(cpy1, src);
    ASSERT_EQUAL(cpy2, src);

    // resizing
    Vector vec1(src);
    vec1.resize(n + 3);
    ASSERT_EQUAL(vec1.size(), n + 3);
    vec1.resize(n);
    ASSERT_EQUAL(vec1.size(), n);
    ASSERT_EQUAL(vec1, src); 
    
    vec1.resize(n + 20, (T) 11);
    Vector tail(vec1.begin() + n, vec1.end());
    ASSERT_EQUAL( (tail == std::vector<T>(20, (T) 11)), true);

    vec1.resize(0);
    ASSERT_EQUAL(vec1.size(), 0);
    ASSERT_EQUAL(vec1.empty(), true);
    vec1.resize(10);
    ASSERT_EQUAL(vec1.size(), 10);
    vec1.clear();
    ASSERT_EQUAL(vec1.size(), 0);
    vec1.resize(5);
    ASSERT_EQUAL(vec1.size(), 5);

    // push_back
    Vector vec2;
    for(size_t i = 0; i < 10; ++i){
        ASSERT_EQUAL(vec2.size(), i);
        vec2.push_back( (T) i );
        ASSERT_EQUAL(vec2.size(), i + 1);
        for(size_t j = 0; j <= i; j++)
            ASSERT_EQUAL(vec2[j],     j);
        ASSERT_EQUAL(vec2.back(), i);
    }

    // pop_back
    for(size_t i = 10; i > 0; --i){
        ASSERT_EQUAL(vec2.size(), i);
        ASSERT_EQUAL(vec2.back(), i-1);
        vec2.pop_back();
        ASSERT_EQUAL(vec2.size(), i-1);
        for(size_t j = 0; j < i; j++)
            ASSERT_EQUAL(vec2[j], j);
    }

    //TODO test swap, erase(pos), erase(begin, end)
}