Exemplos de indirect_less em C++ (Cpp)

Exemplo n.º 1

Arquivo: inplace_merge_comp.pass.cpp Projeto: Aj0Ay/libcxx

int main()
{
    test<bidirectional_iterator<int*> >();
    test<random_access_iterator<int*> >();
    test<int*>();

#if TEST_STD_VER >= 11
    test<bidirectional_iterator<S*> >();
    test<random_access_iterator<S*> >();
    test<S*>();

    {
    unsigned N = 100;
    unsigned M = 50;
    std::unique_ptr<int>* ia = new std::unique_ptr<int>[N];
    for (unsigned i = 0; i < N; ++i)
        ia[i].reset(new int(i));
    std::random_shuffle(ia, ia+N);
    std::sort(ia, ia+M, indirect_less());
    std::sort(ia+M, ia+N, indirect_less());
    std::inplace_merge(ia, ia+M, ia+N, indirect_less());
    if(N > 0)
    {
        assert(*ia[0] == 0);
        assert(*ia[N-1] == N-1);
        assert(std::is_sorted(ia, ia+N, indirect_less()));
    }
    delete [] ia;
    }
#endif  // TEST_STD_VER >= 11
}

Exemplo n.º 2

Arquivo: make_heap.cpp Projeto: CornedBee/range-v3

void test_9(int N)
{
    std::unique_ptr<int>* ia = new std::unique_ptr<int> [N];
    for (int i = 0; i < N; ++i)
        ia[i].reset(new int(i));
    std::random_shuffle(ia, ia+N);
    CHECK(ranges::make_heap(ia, ia+N, indirect_less()) == ia+N);
    CHECK(std::is_heap(ia, ia+N, indirect_less()));
    delete [] ia;
}

Exemplo n.º 3

Arquivo: push_heap.cpp Projeto: CornedBee/range-v3

void test_move_only(int N)
{
    auto const push_heap = make_testable_1(ranges::push_heap);
    std::unique_ptr<int>* ia = new std::unique_ptr<int> [N];
    for (int i = 0; i < N; ++i)
        ia[i].reset(new int(i));
    std::random_shuffle(ia, ia+N);
    for (int i = 0; i <= N; ++i)
    {
        push_heap(ia, ia+i, indirect_less()).check([&](std::unique_ptr<int> *r){CHECK(r == ia+i);});
        CHECK(std::is_heap(ia, ia+i, indirect_less()));
    }
    delete [] ia;
}

Exemplo n.º 4

Arquivo: pop_heap.cpp Projeto: QiTai/range-v3

void test_9(int N)
{
    std::unique_ptr<int>* ia = new std::unique_ptr<int> [N];
    for (int i = 0; i < N; ++i)
        ia[i].reset(new int(i));
    std::shuffle(ia, ia+N, gen);
    std::make_heap(ia, ia+N, indirect_less());
    for (int i = N; i > 0; --i)
    {
        CHECK(ranges::pop_heap(ia, ia+i, indirect_less()) == ia+i);
        CHECK(std::is_heap(ia, ia+i-1, indirect_less()));
    }
    delete [] ia;
}

Exemplo n.º 5

Arquivo: partial_sort_comp.pass.cpp Projeto: 32bitmicro/libcxx

int main()
{
    int i = 0;
    std::partial_sort(&i, &i, &i);
    assert(i == 0);
    test_larger_sorts(10);
    test_larger_sorts(256);
    test_larger_sorts(257);
    test_larger_sorts(499);
    test_larger_sorts(500);
    test_larger_sorts(997);
    test_larger_sorts(1000);
    test_larger_sorts(1009);

#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
    {
    std::vector<std::unique_ptr<int> > v(1000);
    for (int i = 0; i < v.size(); ++i)
        v[i].reset(new int(i));
    std::partial_sort(v.begin(), v.begin() + v.size()/2, v.end(), indirect_less());
    for (int i = 0; i < v.size()/2; ++i)
        assert(*v[i] == i);
    }
#endif  // _LIBCPP_HAS_NO_RVALUE_REFERENCES
}

Exemplo n.º 6

Arquivo: stable_sort_comp.pass.cpp Projeto: themiwi/libcxx

int main()
{
    test();

#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
    {
    std::vector<std::unique_ptr<int> > v(1000);
    for (int i = 0; i < v.size(); ++i)
        v[i].reset(new int(i));
    std::stable_sort(v.begin(), v.end(), indirect_less());
    assert(std::is_sorted(v.begin(), v.end(), indirect_less()));
    assert(*v[0] == 0);
    assert(*v[1] == 1);
    assert(*v[2] == 2);
    }
#endif  // _LIBCPP_HAS_NO_RVALUE_REFERENCES
}

Exemplo n.º 7

Arquivo: push_heap_comp.pass.cpp Projeto: AstroVPK/LLVM-4.0.0

int main()
{
    test(1000);

#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
    {
    const int N = 1000;
    std::unique_ptr<int>* ia = new std::unique_ptr<int> [N];
    for (int i = 0; i < N; ++i)
        ia[i].reset(new int(i));
    std::random_shuffle(ia, ia+N);
    for (int i = 0; i <= N; ++i)
    {
        std::push_heap(ia, ia+i, indirect_less());
        assert(std::is_heap(ia, ia+i, indirect_less()));
    }
    delete [] ia;
    }
#endif  // _LIBCPP_HAS_NO_RVALUE_REFERENCES
}

Exemplo n.º 8

Arquivo: push_heap_comp.pass.cpp Projeto: ingowald/llvm-project

int main(int, char**)
{
    test(1000);

#if TEST_STD_VER >= 11
    {
    const int N = 1000;
    std::unique_ptr<int>* ia = new std::unique_ptr<int> [N];
    for (int i = 0; i < N; ++i)
        ia[i].reset(new int(i));
    std::shuffle(ia, ia+N, randomness);
    for (int i = 0; i <= N; ++i)
    {
        std::push_heap(ia, ia+i, indirect_less());
        assert(std::is_heap(ia, ia+i, indirect_less()));
    }
    delete [] ia;
    }
#endif

  return 0;
}

Exemplo n.º 9

Arquivo: make_heap_comp.pass.cpp Projeto: AstroVPK/LLVM-4.0.0

int main()
{
    test(0);
    test(1);
    test(2);
    test(3);
    test(10);
    test(1000);
    test(10000);
    test(100000);

#if TEST_STD_VER >= 11
    {
    const int N = 1000;
    std::unique_ptr<int>* ia = new std::unique_ptr<int> [N];
    for (int i = 0; i < N; ++i)
        ia[i].reset(new int(i));
    std::random_shuffle(ia, ia+N);
    std::make_heap(ia, ia+N, indirect_less());
    assert(std::is_heap(ia, ia+N, indirect_less()));
    delete [] ia;
    }
#endif
}

Exemplo n.º 10

Arquivo: partial_sort.cpp Projeto: OhGameKillers/range-v3

int main()
{
    int i = 0;
    int * res = ranges::partial_sort(&i, &i, &i);
    CHECK(i == 0);
    CHECK(res == &i);
    test_larger_sorts(10);
    test_larger_sorts(256);
    test_larger_sorts(257);
    test_larger_sorts(499);
    test_larger_sorts(500);
    test_larger_sorts(997);
    test_larger_sorts(1000);
    test_larger_sorts(1009);

    // Check move-only types
    {
        std::vector<std::unique_ptr<int> > v(1000);
        for(int i = 0; i < (int)v.size(); ++i)
            v[i].reset(new int((int)v.size() - i - 1));
        ranges::partial_sort(v, v.begin() + v.size()/2, indirect_less());
        for(int i = 0; i < (int)v.size()/2; ++i)
            CHECK(*v[i] == i);
    }

    // Check projections
    {
        std::vector<S> v(1000, S{});
        for(int i = 0; (std::size_t)i < v.size(); ++i)
        {
            v[i].i = (int)v.size() - i - 1;
            v[i].j = i;
        }
        ranges::partial_sort(v, v.begin() + v.size()/2, std::less<int>{}, &S::i);
        for(int i = 0; (std::size_t)i < v.size()/2; ++i)
        {
            CHECK(v[i].i == i);
            CHECK((std::size_t)v[i].j == v.size() - i - 1);
        }
    }

    return ::test_result();
}

Exemplo n.º 11

Arquivo: nth_element_comp.pass.cpp Projeto: themiwi/libcxx

int main()
{
    int d = 0;
    std::nth_element(&d, &d, &d);
    assert(d == 0);
    test(256);
    test(257);
    test(499);
    test(500);
    test(997);
    test(1000);
    test(1009);

#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
    {
    std::vector<std::unique_ptr<int> > v(1000);
    for (int i = 0; i < v.size(); ++i)
        v[i].reset(new int(i));
    std::nth_element(v.begin(), v.begin() + v.size()/2, v.end(), indirect_less());
    assert(*v[v.size()/2] == v.size()/2);
    }
#endif  // _LIBCPP_HAS_NO_RVALUE_REFERENCES
}

Exemplo n.º 12

Arquivo: stable_sort.cpp Projeto: Manu343726/range-v3

int main()
{
    // test null range
    int d = 0;
    int * r = ranges::stable_sort(&d, &d);
    CHECK(r == &d);
    // exhaustively test all possibilities up to length 8
    test_sort_<1>();
    test_sort_<2>();
    test_sort_<3>();
    test_sort_<4>();
    test_sort_<5>();
    test_sort_<6>();
    test_sort_<7>();
    test_sort_<8>();

    test_larger_sorts(15);
    test_larger_sorts(16);
    test_larger_sorts(17);
    test_larger_sorts(256);
    test_larger_sorts(257);
    test_larger_sorts(499);
    test_larger_sorts(500);
    test_larger_sorts(997);
    test_larger_sorts(1000);
    test_larger_sorts(1009);

    // Check move-only types
    {
        std::vector<std::unique_ptr<int> > v(1000);
        for(int i = 0; (std::size_t)i < v.size(); ++i)
            v[i].reset(new int(v.size() - i - 1));
        ranges::stable_sort(v, indirect_less());
        for(int i = 0; (std::size_t)i < v.size(); ++i)
            CHECK(*v[i] == i);
    }

    // Check projections
    {
        std::vector<S> v(1000, S{});
        for(int i = 0; (std::size_t)i < v.size(); ++i)
        {
            v[i].i = v.size() - i - 1;
            v[i].j = i;
        }
        ranges::stable_sort(v, std::less<int>{}, &S::i);
        for(int i = 0; (std::size_t)i < v.size(); ++i)
        {
            CHECK(v[i].i == i);
            CHECK((std::size_t)v[i].j == v.size() - i - 1);
        }
    }

    // Check rvalue range
    {
        std::vector<S> v(1000, S{});
        for(int i = 0; (std::size_t)i < v.size(); ++i)
        {
            v[i].i = v.size() - i - 1;
            v[i].j = i;
        }
        CHECK(ranges::stable_sort(ranges::view::all(v), std::less<int>{}, &S::i).get_unsafe() == v.end());
        for(int i = 0; (std::size_t)i < v.size(); ++i)
        {
            CHECK(v[i].i == i);
            CHECK((std::size_t)v[i].j == v.size() - i - 1);
        }
    }

    return ::test_result();
}