quakeforge/libs/util/set.c

842 lines
17 KiB
C
Raw Normal View History

2012-08-04 12:49:38 +00:00
/*
set.c
Set manipulation.
Copyright (C) 2012 Bill Currie <bill@taniwha.org>
Author: Bill Currie <bill@taniwha.org>
Date: 2012/8/4
This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License
as published by the Free Software Foundation; either version 2
of the License, or (at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
See the GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program; if not, write to:
Free Software Foundation, Inc.
59 Temple Place - Suite 330
Boston, MA 02111-1307, USA
*/
#ifdef HAVE_CONFIG_H
# include "config.h"
#endif
#ifdef HAVE_STRING_H
# include <string.h>
#endif
#ifdef HAVE_STRINGS_H
# include <strings.h>
#endif
#include <stdlib.h>
#include "QF/alloc.h"
2012-10-30 11:10:25 +00:00
#include "QF/dstring.h"
2012-08-04 12:49:38 +00:00
#include "QF/mathlib.h"
#include "QF/set.h"
2012-08-04 12:49:38 +00:00
static set_pool_t static_set_pool = {
0, 0,
DARRAY_STATIC_INIT (8),
DARRAY_STATIC_INIT (8),
};
static set_iter_t *
new_setiter (set_pool_t *set_pool)
{
set_iter_t *set_iter;
ALLOC (16, set_iter_t, set_pool->set_iter, set_iter);
return set_iter;
}
static void
delete_setiter (set_pool_t *set_pool, set_iter_t *set_iter)
{
FREE (set_pool->set_iter, set_iter);
}
void
set_del_iter (set_iter_t *set_iter)
{
delete_setiter (&static_set_pool, set_iter);
}
void
set_del_iter_r (set_pool_t *set_pool, set_iter_t *set_iter)
{
delete_setiter (set_pool, set_iter);
}
void
set_pool_init (set_pool_t *set_pool)
{
*set_pool = (set_pool_t) {
.set_blocks = DARRAY_STATIC_INIT (8),
.set_iter_blocks = DARRAY_STATIC_INIT (8),
};
}
inline set_t *
set_new_r (set_pool_t *set_pool)
2012-08-04 12:49:38 +00:00
{
set_t *set;
ALLOC (16, set_t, set_pool->set, set);
2012-08-04 12:49:38 +00:00
set->size = sizeof (set->defmap) * 8;
set->map = set->defmap;
return set;
}
set_t *
set_new (void)
{
return set_new_r (&static_set_pool);
}
2012-08-04 12:49:38 +00:00
void
set_delete_r (set_pool_t *set_pool, set_t *set)
2012-08-04 12:49:38 +00:00
{
if (set->map != set->defmap)
free (set->map);
FREE (set_pool->set, set);
}
void
set_delete (set_t *set)
{
set_delete_r (&static_set_pool, set);
2012-08-04 12:49:38 +00:00
}
void
set_expand (set_t *set, unsigned size)
2012-08-04 12:49:38 +00:00
{
set_bits_t *map = set->map;
2012-08-04 12:49:38 +00:00
if (size <= set->size)
2012-08-04 12:49:38 +00:00
return;
size = SET_SIZE (size - 1);
2012-08-04 12:49:38 +00:00
set->map = malloc (size / 8);
memcpy (set->map, map, set->size / 8);
memset (set->map + SET_WORDS (set), 0, (size - set->size) / 8);
set->size = size;
2012-08-04 12:49:38 +00:00
if (map != set->defmap)
free (map);
}
void
set_trim (set_t *set)
{
if (set->map == set->defmap) {
return;
}
unsigned words = SET_WORDS (set);
while (words > SET_DEFMAP_SIZE && !set->map[words - 1]) {
words--;
set->size -= SET_BITS;
}
if (words > SET_DEFMAP_SIZE) {
set_bits_t *map = realloc (set->map, words * sizeof (set_bits_t));
if (map && map != set->map) {
set->map = map;
}
} else {
memcpy (set->defmap, set->map, sizeof (set->defmap));
free (set->map);
set->map = set->defmap;
}
}
inline set_t *
set_new_size_r (set_pool_t *set_pool, unsigned size)
{
set_t *set;
set = set_new_r (set_pool);
set_expand (set, size);
return set;
}
set_t *
set_new_size (unsigned size)
{
return set_new_size_r (&static_set_pool, size);
}
static inline void
_set_add (set_t *set, unsigned x)
2012-08-04 12:49:38 +00:00
{
if (x >= set->size)
set_expand (set, x + 1);
SET_ADD(set, x);
2012-08-04 12:49:38 +00:00
}
static inline void
_set_remove (set_t *set, unsigned x)
2012-08-04 12:49:38 +00:00
{
if (x >= set->size)
return;
SET_REMOVE(set, x);
2012-08-04 12:49:38 +00:00
}
static inline void
_set_add_range (set_t *set, unsigned start, unsigned count)
{
if (!count) {
return;
}
if (start + count > set->size) {
set_expand (set, start + count);
}
unsigned end = start + count - 1;
set_bits_t start_mask = (~SET_ZERO) << (start % SET_BITS);
set_bits_t end_mask = (~SET_ZERO) >> (SET_BITS - ((end + 1) % SET_BITS));
unsigned start_ind = start / SET_BITS;
unsigned end_ind = end / SET_BITS;
if (start_ind == end_ind) {
set->map[start_ind] |= start_mask & end_mask;
} else {
set->map[start_ind] |= start_mask;
for (unsigned i = start_ind + 1; i < end_ind; i++) {
set->map[i] = ~SET_ZERO;
}
set->map[end_ind] |= end_mask;
}
}
static inline void
_set_remove_range (set_t *set, unsigned start, unsigned count)
{
if (!count) {
return;
}
if (start >= set->size) {
return;
}
if (start + count > set->size) {
count = set->size - start;
}
unsigned end = start + count - 1;
set_bits_t start_mask = (~SET_ZERO) << (start % SET_BITS);
set_bits_t end_mask = (~SET_ZERO) >> (SET_BITS - ((end + 1) % SET_BITS));
unsigned start_ind = start / SET_BITS;
unsigned end_ind = end / SET_BITS;
if (start_ind == end_ind) {
set->map[start_ind] &= ~(start_mask & end_mask);
} else {
set->map[start_ind] &= ~start_mask;
for (unsigned i = start_ind + 1; i < end_ind; i++) {
set->map[i] = SET_ZERO;
}
set->map[end_ind] &= ~end_mask;
}
}
2012-08-04 12:49:38 +00:00
set_t *
set_add (set_t *set, unsigned x)
{
if (set->inverted)
_set_remove (set, x);
else
_set_add (set, x);
return set;
}
set_t *
set_add_range (set_t *set, unsigned start, unsigned count)
{
if (set->inverted)
_set_remove_range (set, start, count);
else
_set_add_range (set, start, count);
return set;
}
set_t *
set_remove (set_t *set, unsigned x)
{
if (set->inverted)
_set_add (set, x);
else
_set_remove (set, x);
return set;
}
set_t *
set_remove_range (set_t *set, unsigned start, unsigned count)
{
if (set->inverted)
_set_add_range (set, start, count);
else
_set_remove_range (set, start, count);
return set;
}
set_t *
set_invert (set_t *set)
{
set->inverted = !set->inverted;
return set;
}
static set_t *
_set_union (set_t *dst, const set_t *src)
2012-08-04 12:49:38 +00:00
{
unsigned size;
unsigned i;
size = max (dst->size, src->size);
2012-08-04 12:49:38 +00:00
set_expand (dst, size);
for (i = 0; i < SET_WORDS (src); i++)
2012-08-04 12:49:38 +00:00
dst->map[i] |= src->map[i];
return dst;
}
static set_t *
_set_intersection (set_t *dst, const set_t *src)
2012-08-04 12:49:38 +00:00
{
unsigned words;
2012-08-04 12:49:38 +00:00
unsigned i;
words = min (SET_WORDS (dst), SET_WORDS (src));
for (i = 0; i < words; i++)
2012-08-04 12:49:38 +00:00
dst->map[i] &= src->map[i];
// if dst is larger than src, then none of the excess elements in dst
// can be in the intersection
for ( ; i < SET_WORDS (dst); i++)
dst->map[i] = 0;
2012-08-04 12:49:38 +00:00
return dst;
}
static set_t *
_set_difference (set_t *dst, const set_t *src)
2012-08-04 12:49:38 +00:00
{
unsigned words;
2012-08-04 12:49:38 +00:00
unsigned i;
words = min (SET_WORDS (dst), SET_WORDS (src));
for (i = 0; i < words; i++)
2012-08-04 12:49:38 +00:00
dst->map[i] &= ~src->map[i];
// if src is larger than dst, excess elements in src cannot be in dst thus
// there is nothing to remove
// if dst is larger than src, there is nothing to remove regardless of what
// is in src
2012-08-04 12:49:38 +00:00
return dst;
}
static set_t *
_set_reverse_difference (set_t *dst, const set_t *src)
{
unsigned words;
unsigned i;
words = min (SET_WORDS (dst), SET_WORDS (src));
set_expand (dst, src->size);
for (i = 0; i < words; i++)
dst->map[i] = ~dst->map[i] & src->map[i];
// if src is larger than dst, then dst cannot remove the excess elements
// from src and thus the src elements must be copied
for ( ; i < SET_WORDS (src); i++)
dst->map[i] = src->map[i];
// if dst is larger than src, then the excess elements in dst must be
// removed
for ( ; i < SET_WORDS (dst); i++)
dst->map[i] = 0;
return dst;
}
set_t *
set_union (set_t *dst, const set_t *src)
{
if (dst->inverted && src->inverted) {
return _set_intersection (dst, src);
} else if (src->inverted) {
dst->inverted = 1;
return _set_reverse_difference (dst, src);
} else if (dst->inverted) {
return _set_difference (dst, src);
} else {
return _set_union (dst, src);
}
}
set_t *
set_intersection (set_t *dst, const set_t *src)
{
if (dst->inverted && src->inverted) {
return _set_union (dst, src);
} else if (src->inverted) {
return _set_difference (dst, src);
} else if (dst->inverted) {
dst->inverted = 0;
return _set_reverse_difference (dst, src);
} else {
return _set_intersection (dst, src);
}
}
set_t *
set_difference (set_t *dst, const set_t *src)
{
if (dst->inverted && src->inverted) {
dst->inverted = 0;
return _set_reverse_difference (dst, src);
} else if (src->inverted) {
return _set_intersection (dst, src);
} else if (dst->inverted) {
return _set_union (dst, src);
} else {
return _set_difference (dst, src);
}
}
set_t *
set_reverse_difference (set_t *dst, const set_t *src)
{
if (dst->inverted && src->inverted) {
dst->inverted = 0;
return _set_difference (dst, src);
} else if (src->inverted) {
dst->inverted = 1;
return _set_union (dst, src);
} else if (dst->inverted) {
dst->inverted = 0;
return _set_intersection (dst, src);
} else {
return _set_reverse_difference (dst, src);
}
}
2012-08-04 12:49:38 +00:00
set_t *
set_assign (set_t *dst, const set_t *src)
{
unsigned size;
unsigned i;
size = max (dst->size, src->size);
2012-08-04 12:49:38 +00:00
set_expand (dst, size);
dst->inverted = src->inverted;
for (i = 0; i < SET_WORDS (src); i++)
2012-08-04 12:49:38 +00:00
dst->map[i] = src->map[i];
for ( ; i < SET_WORDS (dst); i++)
dst->map[i] = 0;
2012-08-04 12:49:38 +00:00
return dst;
}
set_t *
set_empty (set_t *set)
{
unsigned i;
set->inverted = 0;
for (i = 0; i < SET_WORDS (set); i++)
2012-08-04 12:49:38 +00:00
set->map[i] = 0;
return set;
}
set_t *
set_everything (set_t *set)
{
unsigned i;
set->inverted = 1;
for (i = 0; i < SET_WORDS (set); i++)
set->map[i] = 0;
return set;
}
static inline __attribute__((pure)) int
_set_is_empty (const set_t *set)
2012-08-04 12:49:38 +00:00
{
unsigned i;
for (i = 0; i < SET_WORDS (set); i++)
2012-08-04 12:49:38 +00:00
if (set->map[i])
return 0;
return 1;
}
int
set_is_empty (const set_t *set)
{
if (set->inverted)
return 0;
return _set_is_empty (set);
}
int
set_is_everything (const set_t *set)
{
if (!set->inverted)
return 0;
return _set_is_empty (set);
}
static __attribute__((pure)) int
set_test_n_n (const set_t *s1, const set_t *s2)
2012-08-04 12:49:38 +00:00
{
unsigned i, end;
set_bits_t intersection = 0;
set_bits_t difference = 0;
2012-08-04 12:49:38 +00:00
end = min (s1->size, s2->size) / SET_BITS;
2012-08-04 12:49:38 +00:00
for (i = 0; i < end; i++) {
set_bits_t m1 = s1->map[i];
set_bits_t m2 = s2->map[i];
intersection |= m1 & m2;
difference |= m1 ^ m2;
}
for ( ; i < SET_WORDS (s1); i++) {
difference |= s1->map[i];
2012-08-04 12:49:38 +00:00
}
for ( ; i < SET_WORDS (s2); i++) {
difference |= s2->map[i];
}
return (difference != 0) | ((intersection != 0) << 1);
}
static __attribute__((pure)) int
set_test_n_i (const set_t *s1, const set_t *s2)
{
unsigned i, end;
set_bits_t intersection = 0;
set_bits_t difference = 0;
end = min (s1->size, s2->size) / SET_BITS;
for (i = 0; i < end; i++) {
set_bits_t m1 = s1->map[i];
set_bits_t m2 = ~s2->map[i];
intersection |= m1 & m2;
difference |= m1 ^ m2;
}
for ( ; i < SET_WORDS (s1); i++) {
intersection |= s1->map[i];
difference |= ~s1->map[i];
}
for ( ; i < SET_WORDS (s2); i++) {
difference |= ~s2->map[i];
}
return (difference != 0) | ((intersection != 0) << 1);
}
static __attribute__((pure)) int
set_test_i_n (const set_t *s1, const set_t *s2)
{
unsigned i, end;
set_bits_t intersection = 0;
set_bits_t difference = 0;
end = min (s1->size, s2->size) / SET_BITS;
for (i = 0; i < end; i++) {
set_bits_t m1 = ~s1->map[i];
set_bits_t m2 = s2->map[i];
intersection |= m1 & m2;
difference |= m1 ^ m2;
}
for ( ; i < SET_WORDS (s1); i++) {
difference |= ~s1->map[i];
}
for ( ; i < SET_WORDS (s2); i++) {
intersection |= s2->map[i];
difference |= ~s2->map[i];
}
return (difference != 0) | ((intersection != 0) << 1);
}
static __attribute__((pure)) int
set_test_i_i (const set_t *s1, const set_t *s2)
{
unsigned i, end;
set_bits_t intersection = 0;
set_bits_t difference = 0;
end = min (s1->size, s2->size) / SET_BITS;
for (i = 0; i < end; i++) {
set_bits_t m1 = ~s1->map[i];
set_bits_t m2 = ~s2->map[i];
intersection |= m1 & m2;
difference |= m1 ^ m2;
}
for ( ; i < SET_WORDS (s1); i++) {
difference |= ~s1->map[i];
}
for ( ; i < SET_WORDS (s2); i++) {
intersection |= s2->map[i];
difference |= ~s2->map[i];
}
intersection |= ~0; // two inverted sets can never be disjoint
return (difference != 0) | ((intersection != 0) << 1);
}
static __attribute__((pure)) int
set_test (const set_t *s1, const set_t *s2)
{
if (s1->inverted && s2->inverted)
return set_test_i_i (s1, s2);
else if (s2->inverted)
return set_test_n_i (s1, s2);
else if (s1->inverted)
return set_test_i_n (s1, s2);
else
return set_test_n_n (s1, s2);
2012-08-04 12:49:38 +00:00
}
int
set_is_disjoint (const set_t *s1, const set_t *s2)
{
return !(set_test (s1, s2) & 2);
2012-08-04 12:49:38 +00:00
}
int
set_is_intersecting (const set_t *s1, const set_t *s2)
{
return !!(set_test (s1, s2) & 2);
2012-08-04 12:49:38 +00:00
}
int
set_is_equivalent (const set_t *s1, const set_t *s2)
{
return !(set_test (s1, s2) & 1);
2012-08-04 12:49:38 +00:00
}
int
set_is_subset (const set_t *set, const set_t *sub)
{
unsigned i, end;
end = min (set->size, sub->size) / SET_BITS;
if (set->inverted && sub->inverted) {
for (i = 0; i < end; i++) {
if (~sub->map[i] & set->map[i])
return 0;
}
for ( ; i < SET_WORDS (set); i++)
if (set->map[i])
return 0;
} else if (set->inverted) {
for (i = 0; i < end; i++) {
if (sub->map[i] & set->map[i])
return 0;
}
} else if (sub->inverted) {
// an inverted set cannot be a subset of a set that is not inverted
return 0;
} else {
for (i = 0; i < end; i++) {
if (sub->map[i] & ~set->map[i])
return 0;
}
for ( ; i < SET_WORDS (sub); i++)
if (sub->map[i])
return 0;
2012-08-04 12:49:38 +00:00
}
return 1;
}
static inline int
_set_is_member (const set_t *set, unsigned x)
{
if (x >= set->size)
return 0;
return SET_TEST_MEMBER(set, x) != 0;
}
2012-10-30 11:10:25 +00:00
int
set_is_member (const set_t *set, unsigned x)
{
if (set->inverted)
return !_set_is_member (set, x);
return _set_is_member (set, x);
}
unsigned
set_count (const set_t *set)
{
static byte bit_counts[] = {
0, 1, 1, 2, 1, 2, 2, 3, 1, 2, 2, 3, 2, 3, 3, 4,
1, 2, 2, 3, 2, 3, 3, 4, 2, 3, 3, 4, 3, 4, 4, 5,
1, 2, 2, 3, 2, 3, 3, 4, 2, 3, 3, 4, 3, 4, 4, 5,
2, 3, 3, 4, 3, 4, 4, 5, 3, 4, 4, 5, 4, 5, 5, 6,
1, 2, 2, 3, 2, 3, 3, 4, 2, 3, 3, 4, 3, 4, 4, 5,
2, 3, 3, 4, 3, 4, 4, 5, 3, 4, 4, 5, 4, 5, 5, 6,
2, 3, 3, 4, 3, 4, 4, 5, 3, 4, 4, 5, 4, 5, 5, 6,
3, 4, 4, 5, 4, 5, 5, 6, 4, 5, 5, 6, 5, 6, 6, 7,
1, 2, 2, 3, 2, 3, 3, 4, 2, 3, 3, 4, 3, 4, 4, 5,
2, 3, 3, 4, 3, 4, 4, 5, 3, 4, 4, 5, 4, 5, 5, 6,
2, 3, 3, 4, 3, 4, 4, 5, 3, 4, 4, 5, 4, 5, 5, 6,
3, 4, 4, 5, 4, 5, 5, 6, 4, 5, 5, 6, 5, 6, 6, 7,
2, 3, 3, 4, 3, 4, 4, 5, 3, 4, 4, 5, 4, 5, 5, 6,
3, 4, 4, 5, 4, 5, 5, 6, 4, 5, 5, 6, 5, 6, 6, 7,
3, 4, 4, 5, 4, 5, 5, 6, 4, 5, 5, 6, 5, 6, 6, 7,
4, 5, 5, 6, 5, 6, 6, 7, 5, 6, 6, 7, 6, 7, 7, 8,
};
unsigned count = 0;
byte *b = (byte *) set->map;
unsigned i = SET_WORDS (set) * sizeof (set_bits_t);
while (i-- > 0) {
count += bit_counts[*b++];
}
return count;
}
set_iter_t *
set_first_r (set_pool_t *set_pool, const set_t *set)
{
unsigned x;
set_iter_t *set_iter;
for (x = 0; x < set->size; x++) {
if (_set_is_member (set, x)) {
set_iter = new_setiter (set_pool);
set_iter->set = set;
set_iter->element = x;
return set_iter;
}
}
return 0;
}
set_iter_t *
set_first (const set_t *set)
{
return set_first_r (&static_set_pool, set);
}
set_iter_t *
set_next_r (set_pool_t *set_pool, set_iter_t *set_iter)
{
unsigned x;
for (x = set_iter->element + 1; x < set_iter->set->size; x++) {
if (_set_is_member (set_iter->set, x)) {
set_iter->element = x;
return set_iter;
}
}
delete_setiter (set_pool, set_iter);
return 0;
}
set_iter_t *
set_next (set_iter_t *set_iter)
{
return set_next_r (&static_set_pool, set_iter);
}
set_iter_t *
set_while_r (set_pool_t *set_pool, set_iter_t *set_iter)
{
unsigned x;
if (_set_is_member (set_iter->set, set_iter->element)) {
for (x = set_iter->element + 1; x < set_iter->set->size; x++) {
if (!_set_is_member (set_iter->set, x)) {
set_iter->element = x;
return set_iter;
}
}
} else {
for (x = set_iter->element + 1; x < set_iter->set->size; x++) {
if (_set_is_member (set_iter->set, x)) {
set_iter->element = x;
return set_iter;
}
}
}
delete_setiter (set_pool, set_iter);
return 0;
}
set_iter_t *
set_while (set_iter_t *set_iter)
{
return set_while_r (&static_set_pool, set_iter);
}
2012-10-30 11:10:25 +00:00
const char *
set_to_dstring_r (set_pool_t *set_pool, dstring_t *str, const set_t *set)
2012-10-30 11:10:25 +00:00
{
set_iter_t *iter;
int first = 1;
2012-10-30 11:10:25 +00:00
if (set_is_empty (set)) {
dstring_appendstr (str, "{}");
return str->str;
}
if (set_is_everything (set)) {
dstring_appendstr (str, "{...}");
return str->str;
}
dstring_appendstr (str, "{");
if (set->inverted) {
unsigned start = 0;
for (iter = set_first_r (set_pool, set); iter;
iter = set_next_r (set_pool, iter)) {
unsigned end = iter->element;
while (start < end) {
dasprintf (str, "%s%d", first ? "" : " ", start++);
first = 0;
}
start = end + 1;
}
dasprintf (str, "%s%d ...", first ? "" : " ", start);
} else {
for (iter = set_first_r (set_pool, set); iter;
iter = set_next_r (set_pool, iter)) {
dasprintf (str, "%s%d", first ? "" : " ", iter->element);
first = 0;
}
}
dstring_appendstr (str, "}");
2012-10-30 11:10:25 +00:00
return str->str;
}
const char *
set_to_dstring (dstring_t *str, const set_t *set)
{
return set_to_dstring_r (&static_set_pool, str, set);
}
const char *
set_as_string (const set_t *set)
{
static dstring_t *str;
if (!str) {
str = dstring_new ();
}
dstring_clearstr (str);
return set_to_dstring_r (&static_set_pool, str, set);
}
static void
set_shutdown (void *data)
{
ALLOC_FREE_BLOCKS (static_set_pool.set);
ALLOC_FREE_BLOCKS (static_set_pool.set_iter);
}
static void __attribute__((constructor))
set_init (void)
{
Sys_RegisterShutdown (set_shutdown, 0);
}