*b = t;
}
-/* Reverses the order of the CNT integers starting at VALUES. */
+/* Reverses the order of the N integers starting at VALUES. */
static void
-reverse (int *values, size_t cnt)
+reverse (int *values, size_t n)
{
size_t i = 0;
- size_t j = cnt;
+ size_t j = n;
while (j > i)
swap (&values[i++], &values[--j]);
}
-/* Arranges the CNT blocks in VALUES into the lexicographically
+/* Arranges the N blocks in VALUES into the lexicographically
next greater permutation. Returns true if successful.
If VALUES is already the lexicographically greatest
permutation of its blocks (i.e. ordered from greatest to
permutation (i.e. ordered from smallest to largest) and
returns false. */
static bool
-next_permutation (int *values, size_t cnt)
+next_permutation (int *values, size_t n)
{
- if (cnt > 0)
+ if (n > 0)
{
- size_t i = cnt - 1;
+ size_t i = n - 1;
while (i != 0)
{
i--;
if (values[i] < values[i + 1])
{
size_t j;
- for (j = cnt - 1; values[i] >= values[j]; j--)
+ for (j = n - 1; values[i] >= values[j]; j--)
continue;
swap (values + i, values + j);
- reverse (values + (i + 1), cnt - (i + 1));
+ reverse (values + (i + 1), n - (i + 1));
return true;
}
}
- reverse (values, cnt);
+ reverse (values, n);
}
return false;
return a->start < b->start ? -1 : a->start > b->start;
}
-/* Checks that RM contains the ELEM_CNT elements described by
+/* Checks that RM contains the ELEM_N elements described by
ELEMENTS[]. */
static void
check_range_map (struct range_map *rm,
- struct expected_element elements[], size_t elem_cnt)
+ struct expected_element elements[], size_t n_elems)
{
struct expected_element *sorted;
struct range_map_node *node;
size_t i;
- sorted = xnmalloc (elem_cnt, sizeof *sorted);
- memcpy (sorted, elements, elem_cnt * sizeof *elements);
- qsort (sorted, elem_cnt, sizeof *sorted, compare_expected_element);
+ sorted = xnmalloc (n_elems, sizeof *sorted);
+ memcpy (sorted, elements, n_elems * sizeof *elements);
+ qsort (sorted, n_elems, sizeof *sorted, compare_expected_element);
- check (range_map_is_empty (rm) == (elem_cnt == 0));
+ check (range_map_is_empty (rm) == (n_elems == 0));
- for (i = 0; i < elem_cnt; i++)
+ for (i = 0; i < n_elems; i++)
{
struct expected_element *e = &sorted[i];
unsigned long int position;
range_map_lookup doesn't find any there. */
if (e->start > 0 && (i == 0 || e[-1].end < e->start))
check (range_map_lookup (rm, e->start - 1) == NULL);
- if (i == elem_cnt - 1 || e->end < e[1].start)
+ if (i == n_elems - 1 || e->end < e[1].start)
check (range_map_lookup (rm, e->end) == NULL);
}
struct expected_element *e = &sorted[i];
check (range_map_node_to_element (node)->x == e->x);
}
- check (i == elem_cnt);
+ check (i == n_elems);
free (sorted);
}
test_insert (void)
{
const int max_range = 7;
- int cnt;
+ int n;
- for (cnt = 1; cnt <= max_range; cnt++)
+ for (n = 1; n <= max_range; n++)
{
- unsigned int composition_cnt;
+ unsigned int n_compositions;
struct expected_element *expected;
int *widths;
- int elem_cnt;
+ int n_elems;
int *order;
struct element *elements;
- expected = xnmalloc (cnt, sizeof *expected);
- widths = xnmalloc (cnt, sizeof *widths);
- order = xnmalloc (cnt, sizeof *order);
- elements = xnmalloc (cnt, sizeof *elements);
+ expected = xnmalloc (n, sizeof *expected);
+ widths = xnmalloc (n, sizeof *widths);
+ order = xnmalloc (n, sizeof *order);
+ elements = xnmalloc (n, sizeof *elements);
- elem_cnt = 0;
- composition_cnt = 0;
- while (next_composition (cnt, &elem_cnt, widths))
+ n_elems = 0;
+ n_compositions = 0;
+ while (next_composition (n, &n_elems, widths))
{
int i, j;
- unsigned int permutation_cnt;
+ unsigned int n_permutations;
- for (i = 0; i < elem_cnt; i++)
+ for (i = 0; i < n_elems; i++)
order[i] = i;
- permutation_cnt = 0;
- while (permutation_cnt == 0 || next_permutation (order, elem_cnt))
+ n_permutations = 0;
+ while (n_permutations == 0 || next_permutation (order, n_elems))
{
struct range_map rm;
- /* Inserts the elem_cnt elements with the given
+ /* Inserts the n_elems elements with the given
widths[] into T in the order given by order[]. */
range_map_init (&rm);
- for (i = 0; i < elem_cnt; i++)
+ for (i = 0; i < n_elems; i++)
{
unsigned long int start, end;
int idx;
expected[i].end = end;
check_range_map (&rm, expected, i + 1);
}
- permutation_cnt++;
+ n_permutations++;
}
- check (permutation_cnt == factorial (elem_cnt));
+ check (n_permutations == factorial (n_elems));
- composition_cnt++;
+ n_compositions++;
}
- check (composition_cnt == 1 << (cnt - 1));
+ check (n_compositions == 1 << (n - 1));
free (expected);
free (widths);
test_delete (int gap)
{
const int max_range = 7;
- int cnt;
+ int n;
- for (cnt = 1; cnt <= max_range; cnt++)
+ for (n = 1; n <= max_range; n++)
{
- unsigned int composition_cnt;
+ unsigned int n_compositions;
struct expected_element *expected;
int *widths;
- int elem_cnt;
+ int n_elems;
int *order;
struct element *elements;
- expected = xnmalloc (cnt, sizeof *expected);
- widths = xnmalloc (cnt, sizeof *widths);
- order = xnmalloc (cnt, sizeof *order);
- elements = xnmalloc (cnt, sizeof *elements);
+ expected = xnmalloc (n, sizeof *expected);
+ widths = xnmalloc (n, sizeof *widths);
+ order = xnmalloc (n, sizeof *order);
+ elements = xnmalloc (n, sizeof *elements);
- elem_cnt = 0;
- composition_cnt = 0;
- while (next_composition (cnt, &elem_cnt, widths))
+ n_elems = 0;
+ n_compositions = 0;
+ while (next_composition (n, &n_elems, widths))
{
int i, j;
- unsigned int permutation_cnt;
+ unsigned int n_permutations;
- for (i = 0; i < elem_cnt; i++)
+ for (i = 0; i < n_elems; i++)
order[i] = i;
- permutation_cnt = 0;
- while (permutation_cnt == 0 || next_permutation (order, elem_cnt))
+ n_permutations = 0;
+ while (n_permutations == 0 || next_permutation (order, n_elems))
{
struct range_map rm;
unsigned long int start;
/* Insert all the elements. */
range_map_init (&rm);
start = 0;
- for (i = 0; i < elem_cnt; i++)
+ for (i = 0; i < n_elems; i++)
{
int width = widths[i] > gap ? widths[i] - gap : widths[i];
unsigned long int end = start + width;
for (j = 0; ; j++)
{
- assert (j < elem_cnt);
+ assert (j < n_elems);
if (order[j] == i)
{
expected[j].x = i;
start += widths[i];
}
- check_range_map (&rm, expected, elem_cnt);
+ check_range_map (&rm, expected, n_elems);
/* Delete the elements in the specified order. */
- for (i = 0; i < elem_cnt; i++)
+ for (i = 0; i < n_elems; i++)
{
range_map_delete (&rm, &elements[order[i]].node);
- check_range_map (&rm, expected + i + 1, elem_cnt - i - 1);
+ check_range_map (&rm, expected + i + 1, n_elems - i - 1);
}
- permutation_cnt++;
+ n_permutations++;
}
- check (permutation_cnt == factorial (elem_cnt));
+ check (n_permutations == factorial (n_elems));
- composition_cnt++;
+ n_compositions++;
}
- check (composition_cnt == 1 << (cnt - 1));
+ check (n_compositions == 1 << (n - 1));
free (expected);
free (widths);