d1/d82/dyndlist_8cc_source.html

/*

                          Aleph_w


  Data structures & Algorithms

  version 2.0.0b

  https://github.com/lrleon/Aleph-w


  This file is part of Aleph-w library


  Copyright (c) 2002-2026 Leandro Rabindranath Leon


  Permission is hereby granted, free of charge, to any person obtaining a copy

  of this software and associated documentation files (the "Software"), to deal

  in the Software without restriction, including without limitation the rights

  to use, copy, modify, merge, publish, distribute, sublicense, and/or sell

  copies of the Software, and to permit persons to whom the Software is

  furnished to do so, subject to the following conditions:


  The above copyright notice and this permission notice shall be included in all

  copies or substantial portions of the Software.


  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR

  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,

  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE

  AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER

  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,

  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE

  SOFTWARE.

*/


# include <gtest/gtest.h>


# include <tpl_dynDlist.H>

# include <ah-unique.H>

# include <ah-convert.H>


using namespace std;

using namespace testing;

using namespace Aleph;


# define Declare_list_n_items(num)            \

  struct List_of_##num##_items : public Test  \

  {                                           \

    size_t n = 0;                             \

    DynDlist<int> list##num;                  \

    DynDlist<int> rlist##num;                 \

    List_of_##num##_items()                   \

      {                                       \

        for (size_t i = 0; i < num; ++i, ++n) \

          list##num.append(i + 1);            \

                                              \

        const DynDlist<int> l = list##num;    \

        rlist##num = l.rev();                 \

      }                                       \

  };


Declare_list_n_items(25);

Declare_list_n_items(10);


TEST(DynDlist, Basic_operations)

{

  DynDlist<int> list;

  EXPECT_TRUE(list.is_empty());

  EXPECT_FALSE(list.is_unitarian());

  EXPECT_TRUE(list.is_unitarian_or_empty());


  list.append(2);

  EXPECT_FALSE(list.is_empty());

  EXPECT_TRUE(list.is_unitarian());

  EXPECT_TRUE(list.is_unitarian_or_empty());

  EXPECT_EQ(list.get_first(), list.get_last());


  list.insert(1);

  EXPECT_FALSE(list.is_empty());

  EXPECT_FALSE(list.is_unitarian());

  EXPECT_FALSE(list.is_unitarian_or_empty());


  EXPECT_EQ(list.get_first(), 1);

  EXPECT_EQ(list.get_last(), 2);


  list.insert(0);

  list.append(3);

  EXPECT_EQ(list.get_first(), 0);

  EXPECT_EQ(list.get_last(), 3);


  EXPECT_EQ(list.remove_first(), 0);

  EXPECT_EQ(list.size(), 3);

  EXPECT_EQ(list.get_last(), 3);


  EXPECT_EQ(list.remove_first(), 1);

  EXPECT_EQ(list.size(), 2);

  EXPECT_EQ(list.get_last(), 3);


  EXPECT_EQ(list.remove_first(), 2);

  EXPECT_EQ(list.size(), 1);

  EXPECT_EQ(list.get_last(), 3);


  EXPECT_TRUE(list.is_unitarian());

  EXPECT_TRUE(list.is_unitarian_or_empty());


  EXPECT_EQ(list.remove_first(), 3);

  EXPECT_TRUE(list.is_empty());

  EXPECT_EQ(list.size(), 0);


  EXPECT_THROW(list.rotate_left(1), std::domain_error);

  EXPECT_NO_THROW(list.rotate_left(0));

}


TEST(DynDlist, Simple_append_and_insert_of_list)

{

  {                                // by copy

    DynDlist<int> laux, list;

    laux.insert(2);                // laux = { 2 }

    list.append(laux);             // list = { 2 }


    EXPECT_FALSE(laux.is_empty());

    EXPECT_FALSE(list.is_empty());

    EXPECT_EQ(list.get_first(), 2);

    EXPECT_EQ(list.get_first(), laux.get_first());

    EXPECT_TRUE(list.is_unitarian());


    laux.insert(1);                // laux = { 1, 2 }

    list.insert(laux);             // list = { 1, 2, 2 }

    EXPECT_FALSE(laux.is_empty());

    EXPECT_EQ(laux.get_first(), 1);

    EXPECT_EQ(laux.get_last(), 2);

    EXPECT_EQ(list.size(), 3);

    EXPECT_EQ(list.get_first(), 1);

    EXPECT_EQ(list.get_last(), 2);

  }


  {                                // by move

    DynDlist<int> laux, list;

    laux.insert(2);

    list.append(move(laux));


    EXPECT_TRUE(laux.is_empty());

    EXPECT_FALSE(list.is_empty());

    EXPECT_EQ(list.get_first(), 2);

    EXPECT_EQ(list.get_last(), 2);

    EXPECT_TRUE(list.is_unitarian());

    EXPECT_TRUE(list.is_unitarian_or_empty());


    laux.insert(1);

    list.insert(move(laux));

    EXPECT_TRUE(laux.is_empty());

    EXPECT_EQ(list.size(), 2);

    EXPECT_EQ(list.get_first(), 1);

    EXPECT_EQ(list.get_last(), 2);

  }

}


TEST(DynDlistAlgorithms, InPlaceUnique)

{

  DynDlist<int> list;

  list.append(1);

  list.append(2);

  list.append(1);

  list.append(3);

  list.append(2);

  list.append(4);

  list.append(4);


  in_place_unique(list);


  ASSERT_EQ(list.size(), 4u);

  auto it = list.get_it();

  ASSERT_TRUE(it.has_curr()); EXPECT_EQ(it.get_curr(), 1); it.next();

  ASSERT_TRUE(it.has_curr()); EXPECT_EQ(it.get_curr(), 2); it.next();

  ASSERT_TRUE(it.has_curr()); EXPECT_EQ(it.get_curr(), 3); it.next();

  ASSERT_TRUE(it.has_curr()); EXPECT_EQ(it.get_curr(), 4); it.next();

  EXPECT_FALSE(it.has_curr());

}


TEST_F(List_of_10_items, copy_and_assignment)

{

  {                    // copy constructor

    auto tmp = list10;


    EXPECT_EQ(tmp.size(), list10.size());

    EXPECT_EQ(tmp.size(), 10);


    auto it1 = list10.get_it();

    auto it2 = tmp.get_it();

    for (; it1.has_curr() and it2.has_curr(); it1.next(), it2.next())

      ASSERT_EQ(it1.get_curr(), it2.get_curr());


    EXPECT_FALSE(it1.has_curr());

    EXPECT_FALSE(it2.has_curr());

  }


  EXPECT_FALSE(list10.is_empty());


  {                // move constructor

    auto tmp = move(list10);


    EXPECT_TRUE(list10.is_empty());

    EXPECT_EQ(list10.size(), 0);

    EXPECT_EQ(tmp.size(), 10);

    int i = 1;

    for (auto it = tmp.get_it(); it.has_curr(); it.next(), ++i)

      ASSERT_EQ(it.get_curr(), i);

    EXPECT_EQ(i, 11);

    list10.swap(tmp);

  }


  EXPECT_FALSE(list10.is_empty());

  DynDlist<int> aux;

  aux = list10;

  EXPECT_EQ(aux.size(), 10);

  int i = 1;

  for (auto it = aux.get_it(); it.has_curr(); it.next(), ++i)

    ASSERT_EQ(it.get_curr(), i);

  EXPECT_EQ(i, 11);


  aux.empty();

  EXPECT_TRUE(aux.is_empty());


  aux = move(list10);

  EXPECT_TRUE(list10.is_empty());

  EXPECT_EQ(aux.size(), 10);


  i = 1;

  for (auto it = aux.get_it(); it.has_curr(); it.next(), ++i)

    ASSERT_EQ(it.get_curr(), i);

  EXPECT_EQ(i, 11);


  list10 = move(aux);


  EXPECT_TRUE(aux.is_empty());

  EXPECT_EQ(list10.size(), 10);

  i = 1;

  for (auto it = list10.get_it(); it.has_curr(); it.next(), ++i)

    ASSERT_EQ(it.get_curr(), i);

  EXPECT_EQ(i, 11);

}


TEST_F(List_of_25_items, Basic_operations)

{

  EXPECT_EQ(list25.get_first(), 1);

  EXPECT_EQ(list25.get_last(), 25);

  EXPECT_EQ(list25.size(), 25);

  EXPECT_FALSE(list25.is_empty());

  EXPECT_FALSE(list25.is_unitarian());

  EXPECT_FALSE(list25.is_unitarian_or_empty());

}


TEST_F(List_of_25_items, Iterator_operations)

{

  list25.for_each([] (auto i) { cout << i << " "; }); cout << endl;

  int i = 1;

  auto it = list25.get_it();

  for (; it.has_curr(); it.next(), ++i)

    {

      EXPECT_EQ(it.get_curr(), i);

      EXPECT_EQ(it.get_pos(), i - 1);

    }

  EXPECT_EQ(i, 26);


  i = 25;

  it.reset_last();

  for (; it.has_curr(); it.prev(), --i)

    {

      EXPECT_EQ(it.get_curr(), i);

      EXPECT_EQ(it.get_pos(), i - 1);

    }

  EXPECT_EQ(i, 0);

}


TEST_F(List_of_25_items, Split_and_concat)

{

  DynDlist<int> l, r;

  list25.split(l, r);


  EXPECT_TRUE(list25.is_empty());

  EXPECT_EQ(l.size(), 13);

  EXPECT_EQ(r.size(), 12);

  EXPECT_EQ(l.get_first(), 1);

  EXPECT_EQ(l.get_last(), 13);

  EXPECT_EQ(r.get_first(), 14);

  EXPECT_EQ(r.get_last(), 25);


  int i = 1;

  for (auto it = l.get_it(); it.has_curr(); it.next(), ++i)

    EXPECT_EQ(it.get_curr(), i);


  for (auto it = r.get_it(); it.has_curr(); it.next(), ++i)

    EXPECT_EQ(it.get_curr(), i);


  list25.append(r);

  list25.insert(l);

  i = 1;

  for (auto it = l.get_it(); it.has_curr(); it.next(), ++i)

    EXPECT_EQ(it.get_curr(), i);

}


TEST_F(List_of_25_items, swap)

{

  DynDlist<int> laux;

  laux.swap(list25);


  EXPECT_TRUE(list25.is_empty());

  EXPECT_EQ(list25.size(), 0);

  EXPECT_FALSE(laux.is_empty());


  int i = 1;

  for (auto it = laux.get_it(); it.has_curr(); it.next(), ++i)

    EXPECT_EQ(it.get_curr(), i);

}


TEST_F(List_of_25_items, reverse)

{

  list25.reverse();

  int i = 25;

  for (auto it = list25.get_it(); it.has_curr(); it.next(), --i)

    EXPECT_EQ(it.get_curr(), i);


  list25.reverse();


  i = 1;

  for (auto it = list25.get_it(); it.has_curr(); it.next(), ++i)

    EXPECT_EQ(it.get_curr(), i);


  DynDlist<int> l, r;

  list25.split(l, r);


  EXPECT_TRUE(list25.is_empty());


  l.reverse();

  r.reverse();

  list25.insert(l);

  list25.insert(r);


  list25.reverse();

  i = 1;

  for (auto it = list25.get_it(); it.has_curr(); it.next(), ++i)

    EXPECT_EQ(it.get_curr(), i);

}


TEST_F(List_of_25_items, rotate_left)

{

  list25.rotate_left(3);


  {

    auto it = list25.get_it();

    for (int i = 0, n = 4; i < 3; ++i, ++n, it.next())

      EXPECT_EQ(it.get_curr(), n);

  }


  list25.rotate_left(22);

  int i = 1;

  for (auto it = list25.get_it(); it.has_curr(); it.next(), ++i)

    EXPECT_EQ(it.get_curr(), i);

}


TEST_F(List_of_25_items, rotate_right)

{

  list25.rotate_right(3);


  {

    auto it = list25.get_it();

    for (int i = 0, n = 23; i < 3; ++i, ++n, it.next())

      EXPECT_EQ(it.get_curr(), n);

  }


  list25.rotate_right(22);

  int i = 1;

  for (auto it = list25.get_it(); it.has_curr(); it.next(), ++i)

    EXPECT_EQ(it.get_curr(), i);

}


TEST_F(List_of_25_items, append_and_insert_by_moving)

{

  DynDlist<int> ll = { 0, -1, -2, -3, -4, -5, -6, -7, -8, -9 };

  DynDlist<int> lg = { 26, 27, 28, 29, 30, 31, 32, 33, 34, 35 };


  ll.reverse();


  list25.insert(std::move(ll));

  list25.append(std::move(lg));


  EXPECT_TRUE(ll.is_empty());

  EXPECT_TRUE(lg.is_empty());


  int i = -9;

  for (auto it = list25.get_it(); it.has_curr(); it.next(), ++i)

    EXPECT_EQ(it.get_curr(), i);

}


TEST(DynDlist, traverse_on_empty_container)

{

  DynDlist<int> m;

  size_t n = 0;

  auto ret = m.traverse([&n] (int) { ++n; return true; });

  EXPECT_TRUE(ret);

  EXPECT_EQ(n, 0);

}


TEST_F(List_of_25_items, traverse)

{

  EXPECT_TRUE(list25.size() > 0);

  EXPECT_EQ(list25.size(), n);

  int N = 0;

  auto ret = list25.traverse([&N, this] (int i) { ++N; return i < n/2; });

  EXPECT_FALSE(ret);

  EXPECT_EQ(N, n/2);

}


TEST(DynDlist, RemoveAndEraseByReference)

{

  DynDlist<int> list;

  for (int i = 1; i <= 4; ++i)

    list.append(i);


  int &middle = list[2];

  list.remove(middle);

  ASSERT_EQ(list.size(), 3u);

  int expected_after_remove[] = {1, 2, 4};

  int idx = 0;

  for (auto it = list.get_it(); it.has_curr(); it.next(), ++idx)

    EXPECT_EQ(it.get_curr(), expected_after_remove[idx]);


  int &first = list.get_first();

  list.erase(first);

  EXPECT_EQ(list.size(), 2u);

  EXPECT_EQ(list.get_first(), 2);

  EXPECT_EQ(list.get_last(), 4);

}


TEST(DynDlist, OperatorIndexEnforcesBounds)

{

  DynDlist<int> list;

  for (int i = 0; i < 5; ++i)

    list.append(i);


  list[2] = 99;

  EXPECT_EQ(list[2], 99);


  const DynDlist<int> &clist = list;

  EXPECT_EQ(clist[0], 0);


  EXPECT_THROW(list[5], std::out_of_range);

  EXPECT_THROW(list[10], std::out_of_range);


  DynDlist<int> empty;

  EXPECT_THROW(empty[0], std::out_of_range);

}


TEST_F(List_of_10_items, ConstReverseReturnsIndependentCopy)

{

  const DynDlist<int> &cref = list10;

  auto reversed = cref.reverse();


  int expected_desc = 10;

  for (auto it = reversed.get_it(); it.has_curr(); it.next(), --expected_desc)

    EXPECT_EQ(it.get_curr(), expected_desc);

  EXPECT_EQ(expected_desc, 0);


  int expected_orig = 1;

  for (auto it = cref.get_it(); it.has_curr(); it.next(), ++expected_orig)

    EXPECT_EQ(it.get_curr(), expected_orig);

  EXPECT_EQ(expected_orig, 11);


  auto reversed_alias = cref.rev();

  int expected_desc_alias = 10;

  for (auto it = reversed_alias.get_it(); it.has_curr(); it.next(), --expected_desc_alias)

    EXPECT_EQ(it.get_curr(), expected_desc_alias);

  EXPECT_EQ(expected_desc_alias, 0);

}


TEST(DynDlist, IteratorInsertAndAppendOperations)

{

  DynDlist<int> list = {1, 3};

  auto it = list.get_it();

  ASSERT_TRUE(it.has_curr());


  it.insert(2);

  int expected_after_insert[] = {1, 2, 3};

  int idx = 0;

  for (auto iter = list.get_it(); iter.has_curr(); iter.next(), ++idx)

    EXPECT_EQ(iter.get_curr(), expected_after_insert[idx]);


  it.reset_first();

  it.append(0);

  int expected_after_append[] = {0, 1, 2, 3};

  idx = 0;

  for (auto iter = list.get_it(); iter.has_curr(); iter.next(), ++idx)

    EXPECT_EQ(iter.get_curr(), expected_after_append[idx]);


  auto at_end = list.get_it();

  at_end.end();

  EXPECT_THROW(at_end.insert(42), std::overflow_error);

  EXPECT_THROW(at_end.append(42), std::overflow_error);

}


TEST(DynDlist, IteratorListOperations)

{

  DynDlist<int> base = {1, 4};

  DynDlist<int> middle = {2, 3};

  DynDlist<int> head = {-1, 0};


  auto it = base.get_it();

  ASSERT_TRUE(it.has_curr());

  it.insert_list(middle);

  EXPECT_TRUE(middle.is_empty());


  int expected_after_insert_list[] = {1, 2, 3, 4};

  int idx = 0;

  for (auto iter = base.get_it(); iter.has_curr(); iter.next(), ++idx)

    EXPECT_EQ(iter.get_curr(), expected_after_insert_list[idx]);


  it.reset_first();

  it.append_list(head);

  EXPECT_TRUE(head.is_empty());


  int expected_after_append_list[] = {-1, 0, 1, 2, 3, 4};

  idx = 0;

  for (auto iter = base.get_it(); iter.has_curr(); iter.next(), ++idx)

    EXPECT_EQ(iter.get_curr(), expected_after_append_list[idx]);

}


TEST(DynDlist, IteratorListOperationsRequireCurrent)

{

  DynDlist<int> base = {1, 2, 3};

  DynDlist<int> extra = {4, 5};


  auto it = base.get_it();

  it.end();

  EXPECT_THROW(it.insert_list(extra), std::overflow_error);

  EXPECT_THROW(it.append_list(extra), std::overflow_error);


  // ni la lista base ni la extra deberían alterarse tras los errores

  int expected_base[] = {1, 2, 3};

  int idx = 0;

  for (auto iter = base.get_it(); iter.has_curr(); iter.next(), ++idx)

    EXPECT_EQ(iter.get_curr(), expected_base[idx]);

  EXPECT_FALSE(extra.is_empty());

  EXPECT_EQ(extra.size(), 2u);

}


TEST(DynDlist, SplitRequiresEmptyDestination)

{

  DynDlist<int> source = {1, 2, 3};

  DynDlist<int> left;

  DynDlist<int> right;


  left.append(42);

  EXPECT_THROW(source.split(left, right), std::domain_error);


  left.empty();

  right.append(99);

  EXPECT_THROW(source.split(left, right), std::domain_error);

}


TEST(DynDlist, StackAndQueueAliases)

{

  DynDlist<int> list;

  list.push(3);

  list.push(2);

  list.push(1);


  EXPECT_EQ(list.top(), 1);

  EXPECT_EQ(list.pop(), 1);

  EXPECT_EQ(list.top(), 2);


  list.put(99);

  EXPECT_EQ(list.rear(), 99);

  EXPECT_EQ(list.front(), 2);

  EXPECT_EQ(list.get(), 2);

  EXPECT_EQ(list.front(), 3);


  list.pop();

  list.pop();

  EXPECT_TRUE(list.is_empty());

  EXPECT_THROW(list.pop(), std::underflow_error);

}


TEST(DynDlistFunctional, ToArrayHelperPreservesOrder)

{

  DynDlist<int> list;

  for (int v : {2, 4, 8})

    list.append(v);


  auto arr = to_array(list);


  ASSERT_EQ(arr.size(), list.size());

  size_t i = 0;

  for (auto it = list.get_it(); it.has_curr(); it.next_ne(), ++i)

    EXPECT_EQ(arr(i), it.get_curr());

}


TEST(DynDlist, EqualityOperator)

{

  DynDlist<int> l1 = {1, 2, 3};

  DynDlist<int> l2 = {1, 2, 3};

  DynDlist<int> l3 = {1, 2, 4};

  DynDlist<int> l4 = {1, 2};


  EXPECT_TRUE(l1 == l2);

  EXPECT_FALSE(l1 != l2);


  EXPECT_FALSE(l1 == l3);

  EXPECT_TRUE(l1 != l3);


  EXPECT_FALSE(l1 == l4);

  EXPECT_TRUE(l1 != l4);


  DynDlist<int> empty1, empty2;

  EXPECT_TRUE(empty1 == empty2);

}


ah-convert.H
Conversion utilities between Aleph-w and STL container types.

ah-unique.H
Deduplicate sequential Aleph containers in-place.

Aleph::Dlink::is_unitarian_or_empty
constexpr bool is_unitarian_or_empty() const noexcept
Return true if this (as header node) has zero or one element.
Definition dlink.H:252

Aleph::Dlink::is_empty
constexpr bool is_empty() const noexcept
Return true if this (as header node) is empty.
Definition dlink.H:246

Aleph::Dlink::is_unitarian
constexpr bool is_unitarian() const noexcept
Return true if this (as header node) has exactly one element.
Definition dlink.H:249

Aleph::Dlink::rotate_left
void rotate_left(size_t n)
Rotate to left the list n positions.
Definition dlink.H:855

Aleph::DynDlist
Dynamic doubly linked list with O(1) size and bidirectional access.
Definition tpl_dynDlist.H:123

Aleph::DynDlist::get_last
T & get_last() const
Return a modifiable reference to last item in the list.
Definition tpl_dynDlist.H:318

Aleph::DynDlist::size
const size_t & size() const noexcept
Return the number of elements (constant time)
Definition tpl_dynDlist.H:137

Aleph::DynDlist::reverse
DynDlist & reverse() noexcept
Definition tpl_dynDlist.H:840

Aleph::DynDlist::front
T & front()
If this was treated as a queue, the it returns the most oldlest inserted item.
Definition tpl_dynDlist.H:401

Aleph::DynDlist::pop
T pop()
Definition tpl_dynDlist.H:419

Aleph::DynDlist::swap
void swap(DynDlist &l) noexcept
Swap in constant time all the items of this with all the items of l (very fast!)
Definition tpl_dynDlist.H:459

Aleph::DynDlist::push
T & push(const T &item)
Definition tpl_dynDlist.H:407

Aleph::DynDlist::remove
void remove(T &data) noexcept
Assuming that data is a reference to the item in the list, it removes the item.
Definition tpl_dynDlist.H:443

Aleph::DynDlist::put
T & put(const T &item)
Definition tpl_dynDlist.H:375

Aleph::DynDlist::empty
void empty() noexcept
@brief Empties the container.
Definition tpl_dynDlist.H:164

Aleph::DynDlist::append
T & append(const T &item)
Append a copied item at the end of the list.
Definition tpl_dynDlist.H:230

Aleph::DynDlist::rear
T & rear()
If this was treated as a queue, the it returns the most recently inserted item.
Definition tpl_dynDlist.H:394

Aleph::DynDlist::split
void split(DynDlist &l, DynDlist &r)
This is an overloaded member function, provided for convenience. It differs from the above function o...
Definition tpl_dynDlist.H:512

Aleph::DynDlist::get_first
T & get_first() const
Return a modifiable reference to first item in the list.
Definition tpl_dynDlist.H:311

Aleph::DynDlist::erase
void erase(T &data) noexcept
Definition tpl_dynDlist.H:452

Aleph::DynDlist::insert
T & insert(const T &item)
Insert a copy of item at the beginning of the list.
Definition tpl_dynDlist.H:208

Aleph::DynDlist::get
T get()
Definition tpl_dynDlist.H:387

Aleph::DynDlist::remove_first
T remove_first()
Remove the first item of the list; return a copy of removed item.
Definition tpl_dynDlist.H:357

Aleph::DynDlist::top
T & top() const
Definition tpl_dynDlist.H:425

Aleph::DynList::insert
T & insert(const T &item)
Definition htlist.H:1220

Aleph::DynList::get_last
T & get_last() const
Return the last item of the list.
Definition htlist.H:1363

Aleph::DynList::get_first
T & get_first() const
Return the first item of the list.
Definition htlist.H:1375

Aleph::DynList::reverse
DynList & reverse() noexcept
Definition htlist.H:1469

Aleph::HTList::split
size_t split(HTList &l, HTList &r) noexcept
Definition htlist.H:778

Aleph::HTList::size
size_t size() const noexcept
Count the number of elements of the list.
Definition htlist.H:1065

LocateFunctions::get_it
auto get_it() const
Return a properly initialized iterator positioned at the first item on the container.
Definition ah-dry.H:222

TEST
#define TEST(name)
Definition disjoint_sparse_table_test.cc:95

TEST_F
TEST_F(List_of_10_items, copy_and_assignment)
Definition dyndlist.cc:182

Declare_list_n_items
#define Declare_list_n_items(num)
Definition dyndlist.cc:48

N
#define N
Definition fib.C:294

Aleph
Main namespace for Aleph-w library functions.
Definition ah-arena.H:89

Aleph::and
and
Check uniqueness with explicit hash + equality functors.
Definition ahFunctional.H:2594

Aleph::to_array
Array< typename C::Item_Type > to_array(const C &c)
Convenience wrapper identical to to_Array (copy contents).
Definition ah-convert.H:180

Aleph::in_place_unique
void in_place_unique(Container &c, Compare cmp={})
Remove duplicates in-place preserving first occurrence order.
Definition ah-unique.H:74

Aleph::reverse
void reverse(Itor beg, Itor end)
Reverse elements in a range.
Definition ahAlgo.H:1094

Aleph::swap
T & swap(T &t1, T &t2)
Generic swap using object's swap method.
Definition ahTypes.H:121

Aleph::traverse
bool traverse(Node *root, Op op)
Definition tpl_binNodeUtils.H:2878

Aleph::divide_and_conquer_partition_dp
Divide_Conquer_DP_Result< Cost > divide_and_conquer_partition_dp(const size_t groups, const size_t n, Transition_Cost_Fn transition_cost, const Cost inf=dp_optimization_detail::default_inf< Cost >())
Optimize partition DP using divide-and-conquer optimization.
Definition DP_Optimizations.H:133

Aleph::rotate_left
void rotate_left(T *ptr, const size_t n, size_t m) noexcept
Rotate array elements left by m positions.
Definition array_utils.H:180

Aleph::rotate_right
void rotate_right(T *ptr, const size_t n, size_t m) noexcept
Rotate array elements right by m positions.
Definition array_utils.H:213

std
STL namespace.

GenericTraverse::traverse
bool traverse(Operation &operation) noexcept(traverse_is_noexcept< Operation >())
Traverse the container via its iterator and performs a conditioned operation on each item.
Definition ah-dry.H:97

List_of_10_items
Definition dyndlist.cc:65

List_of_25_items
Definition dyndlist.cc:64

m
FooMap m(5, fst_unit_pair_hash, snd_unit_pair_hash)

l3
DynList< char > l3
Definition test-zip-it.cc:38

l1
DynList< int > l1
Definition test-zip-it.cc:36

l2
DynList< int > l2
Definition test-zip-it.cc:37

r
gsl_rng * r
Definition test_sort_lists.C:40

tpl_dynDlist.H
Dynamic doubly linked list implementation.

l
DynList< int > l
Definition tree-node-common.H:69