? abt.patch
Index: src/libpspp/ChangeLog
===================================================================
RCS file: /cvsroot/pspp/pspp/src/libpspp/ChangeLog,v
retrieving revision 1.48
diff -u -p -r1.48 ChangeLog
--- src/libpspp/ChangeLog	16 Jan 2007 00:14:41 -0000	1.48
+++ src/libpspp/ChangeLog	25 Jan 2007 05:13:53 -0000
@@ -1,3 +1,11 @@
+Wed Jan 24 21:13:32 2007  Ben Pfaff  <blp@gnu.org>
+
+	* abt.c: New file.
+
+	* abt.h: New file.
+
+	* automake.mk: Add abt.c, abt.h to sources.
+
 Sun Jan 14 21:44:18 2007  Ben Pfaff  <blp@gnu.org>
 
 	* automake.mk: Add deque.h to sources.
Index: src/libpspp/abt.c
===================================================================
RCS file: src/libpspp/abt.c
diff -N src/libpspp/abt.c
--- /dev/null	1 Jan 1970 00:00:00 -0000
+++ src/libpspp/abt.c	25 Jan 2007 05:13:53 -0000
@@ -0,0 +1,399 @@
+/* PSPP - computes sample statistics.
+   Copyright (C) 2007 Free Software Foundation, Inc.
+
+   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 the Free Software
+   Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
+   02110-1301, USA. */
+
+/* Augmented binary tree (ABT) data structure. */
+
+/* These library routines have no external dependencies other
+   than the standard C library.
+
+   If you add routines in this file, please add a corresponding
+   test to abt-test.c.  This test program should achieve 100%
+   coverage of lines and branches in this code, as reported by
+   "gcov -b". */
+
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+
+#include <libpspp/abt.h>
+
+static struct abt_node **down_link (struct abt *, struct abt_node *);
+static struct abt_node *skew (struct abt *, struct abt_node *);
+static struct abt_node *split (struct abt *, struct abt_node *);
+
+/* Initializes ABT as an empty ABT that uses COMPARE and
+   REAUGMENT functions, passing in AUX as auxiliary data. */
+void
+abt_init (struct abt *abt,
+          abt_compare_func *compare,
+          abt_reaugment_func *reaugment,
+          void *aux) 
+{
+  abt->root = NULL;
+  abt->compare = compare;
+  abt->reaugment = reaugment;
+  abt->aux = aux;
+}
+
+/* Inserts the given NODE into ABT.
+   Returns a null pointer if successful.
+   Returns the existing node already in ABT equal to NODE, on
+   failure. */
+struct abt_node *
+abt_insert (struct abt *abt, struct abt_node *node) 
+{
+  node->down[0] = NULL;
+  node->down[1] = NULL;
+  node->level = 1;
+
+  if (abt->root == NULL) 
+    {
+      abt->root = node;
+      node->up = NULL;
+      abt_reaugmented (abt, node);
+    }
+  else 
+    {
+      struct abt_node *p = abt->root;
+      for (;;) 
+        {
+          int cmp, dir;
+
+          cmp = abt->compare (node, p, abt->aux);
+          if (cmp == 0)
+            return p;
+
+          dir = cmp > 0;
+          if (p->down[dir] == NULL)
+            {
+              p->down[dir] = node;
+              node->up = p;
+              abt_reaugmented (abt, node);
+              break;
+            }
+          p = p->down[dir];
+        } 
+    }
+
+  while ((node = node->up) != NULL) 
+    {
+      node = skew (abt, node);
+      node = split (abt, node);
+    }
+
+  return NULL;
+}
+
+/* Deletes P from ABT. */
+void
+abt_delete (struct abt *abt, struct abt_node *p)
+{
+  struct abt_node **q = down_link (abt, p);
+  struct abt_node *r = p->down[1];
+  if (r == NULL)
+    {
+      *q = NULL;
+      p = p->up;
+    }
+  else if (r->down[0] == NULL)
+    {
+      r->down[0] = p->down[0];
+      *q = r;
+      r->up = p->up;
+      if (r->down[0] != NULL)
+        r->down[0]->up = r;
+      r->level = p->level;
+      p = r;
+    }
+  else
+    {
+      struct abt_node *s = r->down[0];
+      while (s->down[0] != NULL)
+        s = s->down[0];
+      r = s->up;
+      r->down[0] = s->down[1];
+      s->down[0] = p->down[0];
+      s->down[1] = p->down[1];
+      *q = s;
+      s->down[0]->up = s;
+      s->down[1]->up = s;
+      s->up = p->up;
+      s->level = p->level;
+      if (r->down[0] != NULL)
+        r->down[0]->up = r;
+      p = r;
+    }
+  abt_reaugmented (abt, p);
+
+  for (; p != NULL; p = p->up)
+    if ((p->down[0] != NULL ? p->down[0]->level : 0) < p->level - 1
+        || (p->down[1] != NULL ? p->down[1]->level : 0) < p->level - 1)
+      {
+        p->level--;
+        if (p->down[1] != NULL && p->down[1]->level > p->level)
+          p->down[1]->level = p->level;
+
+        p = skew (abt, p);
+        skew (abt, p->down[1]);
+        if (p->down[1]->down[1] != NULL)
+          skew (abt, p->down[1]->down[1]);
+
+        p = split (abt, p);
+        split (abt, p->down[1]);
+      }
+}
+
+/* Returns the node with minimum value in ABT, or a null pointer
+   if ABT is empty. */ 
+struct abt_node *
+abt_first (const struct abt *abt) 
+{
+  struct abt_node *p = abt->root;
+  if (p != NULL) 
+    while (p->down[0] != NULL)
+      p = p->down[0];
+  return (struct abt_node *) p;
+}
+
+/* Returns the node with maximum value in ABT, or a null pointer
+   if ABT is empty. */ 
+struct abt_node *
+abt_last (const struct abt *abt) 
+{
+  struct abt_node *p = abt->root;
+  if (p != NULL) 
+    while (p->down[1] != NULL)
+      p = p->down[1];
+  return p;
+}
+
+/* Searches ABT for a node equal to TARGET.
+   Returns the node if found, or a null pointer otherwise. */
+struct abt_node *
+abt_find (const struct abt *abt, const struct abt_node *target)
+{
+  const struct abt_node *p;
+  int cmp;
+  
+  for (p = abt->root; p != NULL; p = p->down[cmp > 0])
+    {
+      cmp = abt->compare (target, p, abt->aux);
+      if (cmp == 0)
+        return (struct abt_node *) p;
+    }
+  
+  return NULL;
+}
+
+/* Returns the node in ABT following P in in-order.
+   If P is null, returns the minimum node in ABT.
+   Returns a null pointer if P is the maximum node in ABT or if P
+   is null and ABT is empty. */
+struct abt_node *
+abt_next (const struct abt *abt, const struct abt_node *p) 
+{
+  if (p == NULL) 
+    return abt_first (abt);
+  else if (p->down[1] == NULL)
+    {
+      struct abt_node *q;
+      for (q = p->up; ; p = q, q = q->up)
+        if (q == NULL || p == q->down[0])
+          return q;
+    }
+  else
+    {
+      p = p->down[1];
+      while (p->down[0] != NULL)
+        p = p->down[0];
+      return (struct abt_node *) p;
+    }
+}
+
+/* Returns the node in ABT preceding P in in-order.
+   If P is null, returns the maximum node in ABT.
+   Returns a null pointer if P is the minimum node in ABT or if P
+   is null and ABT is empty. */
+struct abt_node *
+abt_prev (const struct abt *abt, const struct abt_node *p) 
+{
+  if (p == NULL) 
+    return abt_last (abt);
+  else if (p->down[0] == NULL)
+    {
+      struct abt_node *q;
+      for (q = p->up; ; p = q, q = q->up)
+        if (q == NULL || p == q->down[1])
+          return q;
+    }
+  else
+    {
+      p = p->down[0];
+      while (p->down[1] != NULL)
+        p = p->down[1];
+      return (struct abt_node *) p;
+    }
+}
+
+/* Calls ABT's reaugmentation function to compensate for
+   augmentation data in P having been modified.  Use abt_changed,
+   instead, if the key data in P has changed.
+
+   It is not safe to update more than one node's augmentation
+   data, then to call this function for each node.  Instead,
+   update a single node's data, call this function, update
+   another node's data, and so on.  Alternatively, remove all
+   affected nodes from the tree, update their values, then
+   re-insert all of them. */
+void
+abt_reaugmented (const struct abt *abt, struct abt_node *p) 
+{
+  for (; p != NULL; p = p->up)
+    abt->reaugment (p, p->down[0], p->down[1], abt->aux);
+}
+
+/* Moves P around in ABT to compensate for its key having
+   changed.  Returns a null pointer if successful.  If P's new
+   value is equal to that of some other node in ABT, returns the
+   other node after removing P from ABT.
+
+   This function is an optimization only if it is likely that P
+   can actually retain its relative position in ABT, e.g. its key
+   has only been adjusted slightly.  Otherwise, it is more
+   efficient to simply remove P from ABT, change its key, and
+   re-insert P.  
+
+   It is not safe to update more than one node's key, then to
+   call this function for each node.  Instead, update a single
+   node's key, call this function, update another node's key, and
+   so on.  Alternatively, remove all affected nodes from the
+   tree, update their keys, then re-insert all of them. */
+struct abt_node *
+abt_changed (struct abt *abt, struct abt_node *p) 
+{
+  struct abt_node *prev = abt_prev (abt, p);
+  struct abt_node *next = abt_next (abt, p);
+
+  if ((prev != NULL && abt->compare (prev, p, abt->aux) >= 0)
+      || (next != NULL && abt->compare (p, next, abt->aux) >= 0)) 
+    {
+      abt_delete (abt, p);
+      return abt_insert (abt, p);
+    }
+  else 
+    {
+      abt_reaugmented (abt, p);
+      return NULL; 
+    }
+}
+
+/* ABT nodes may be moved around in memory as necessary, e.g. as
+   the result of an realloc operation on a block that contains a
+   node.  Once this is done, call this function passing node P
+   that was moved and its ABT before attempting any other
+   operation on ABT.
+
+   It is not safe to move more than one node, then to call this
+   function for each node.  Instead, move a single node, call
+   this function, move another node, and so on.  Alternatively,
+   remove all affected nodes from the tree, move them, then
+   re-insert all of them. */
+void
+abt_moved (struct abt *abt, struct abt_node *p) 
+{
+  if (p->up != NULL) 
+    {
+      int d = p->up->down[0] == NULL || abt->compare (p, p->up, abt->aux) > 0;
+      p->up->down[d] = p; 
+    }
+  else
+    abt->root = p;
+  if (p->down[0] != NULL)
+    p->down[0]->up = p;
+  if (p->down[1] != NULL)
+    p->down[1]->up = p;
+}
+
+/* Returns the address of the pointer that points down to P
+   within ABT. */
+static struct abt_node **
+down_link (struct abt *abt, struct abt_node *p) 
+{
+  return (p->up != NULL
+          ? &p->up->down[p->up->down[0] != p]
+          : &abt->root);
+}
+
+/* Remove a left "horizontal link" at A, if present.
+   Returns the node that occupies the position previously
+   occupied by A. */
+static struct abt_node *
+skew (struct abt *abt, struct abt_node *a)
+{
+  struct abt_node *b = a->down[0];
+  if (b != NULL && b->level == a->level)
+    {
+      /* Rotate right. */
+      a->down[0] = b->down[1];
+      b->down[1] = a;
+      *down_link (abt, a) = b;
+
+      if (a->down[0] != NULL)
+        a->down[0]->up = a;
+      b->up = a->up;
+      a->up = b;
+
+      abt->reaugment (a, a->down[0], a->down[1], abt->aux);
+      abt->reaugment (b, b->down[0], b->down[1], abt->aux);
+
+      return b;
+    }
+  else
+    return a;
+}
+
+/* Removes a pair of consecutive right "horizontal links" at A,
+   if present.
+   Returns the node that occupies the position previously
+   occupied by A. */
+static struct abt_node *
+split (struct abt *abt, struct abt_node *a)
+{
+  struct abt_node *b = a->down[1];
+  if (b != NULL && b->down[1] != NULL && b->down[1]->level == a->level)
+    {
+      /* Rotate left. */
+      a->down[1] = b->down[0];
+      b->down[0] = a;
+      *down_link (abt, a) = b;
+
+      if (a->down[1] != NULL)
+        a->down[1]->up = a;
+      b->up = a->up;
+      a->up = b;
+
+      b->level++;
+
+      abt->reaugment (a, a->down[0], a->down[1], abt->aux);
+      abt->reaugment (b, b->down[0], b->down[1], abt->aux);
+
+      return b;
+    }
+  else
+    return a;
+}
Index: src/libpspp/abt.h
===================================================================
RCS file: src/libpspp/abt.h
diff -N src/libpspp/abt.h
--- /dev/null	1 Jan 1970 00:00:00 -0000
+++ src/libpspp/abt.h	25 Jan 2007 05:13:53 -0000
@@ -0,0 +1,208 @@
+/* PSPP - computes sample statistics.
+   Copyright (C) 2007 Free Software Foundation, Inc.
+
+   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 the Free Software
+   Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
+   02110-1301, USA. */
+
+#ifndef LIBPSPP_ABT_H
+#define LIBPSPP_ABT_H 1
+
+/* Augmented binary tree (ABT) data structure.
+
+   A data structure can be "augmented" by defining new
+   information for it to maintain.  One commonly useful way to
+   augment a binary search tree-based data structure is to define
+   part of its data as a function of its immediate children's
+   data.  Furthermore, augmented data defined in this way can be
+   efficiently maintained as the tree changes over time.
+   
+   For example, suppose we define the "size" of a node as the sum
+   of the "size" of its immediate children, plus 1.  In such an
+   annotated BST with height H, we can find the node that would
+   be Kth in in-order traversal in O(H) time, instead of O(K)
+   time, which is a significant saving for balanced trees.
+
+   The ABT data structure partially abstracts augmentation.  The
+   client passes in a "reaugmentation" function that accepts a
+   node and its left and right children.  This function must
+   recalculate the node's augmentation data based on its own
+   contents and the contents of its children, and store the new
+   augmentation data in the node.
+
+   The ABT automatically calls the reaugmentation function
+   whenever it can tell that a node's augmentation data might
+   need to be updated: when the node is inserted or when a node's
+   descendants change due to insertion or deletion.  The ABT does
+   not know to call the reaugmentation function if a node's data
+   is updated while it is in the ABT.  In such a case, call the
+   abt_reaugmented or abt_changed function to update the
+   augmentation.
+
+   Augmentation is only partially abstracted: we do not provide
+   any way to search an ABT based on its augmentations.  The
+   tree structure is thus exposed to the client to allow it to
+   implement search.
+
+   To allow for optimization, the ABT implementation assumes that
+   the augmentation function in use is unaffected by the shape of
+   a binary search tree.  That is, if a given subtree within a
+   larger tree is rearranged, e.g. via a series of rotations,
+   then the implementation will not call the reaugmentation
+   function outside of the subtree, because the overall
+   augmentation data for the subtree is assumed not to changed.
+   This optimization is valid for the forms of augmentation
+   described in CLR and Knuth (see below), and it is possible
+   that it is valid for every efficient binary search tree
+   augmentation.
+
+   The client should not need to be aware of the form of
+   balancing applied to the ABT, as its operation should be fully
+   encapsulated by the reaugmentation function.  The current
+   implementation uses an AA (Arne Andersson) tree, but this is
+   subject to change.
+
+   The following example illustrates how to use an ABT to build a
+   tree that can be searched either by a data value or in-order
+   position:
+
+     // Test data element.
+     struct element
+       {
+         struct abt_node node;       // Embedded binary tree element.
+         int data;                   // Primary value.
+         int count;                  // Number of nodes in subtree,
+                                     // including this node. 
+       };
+
+     // Returns the `struct element' that NODE is embedded within.
+     static struct element *
+     node_to_element (const struct abt_node *node)
+     {
+       return abt_data (node, struct element, node);
+     }
+
+     // Compares the DATA values in A and B and returns a
+     // strcmp-type return value.
+     static int
+     compare_elements (const struct abt_node *a_, const struct abt_node *b_,
+                       const void *aux) 
+     {
+       const struct element *a = node_to_element (a_);
+       const struct element *b = node_to_element (b_);
+
+       return a->data < b->data ? -1 : a->data > b->data;
+     }
+
+     // Recalculates the count for NODE's subtree by adding up the
+     // counts for its LEFT and RIGHT child subtrees.
+     static void
+     reaugment_elements (struct abt_node *node_,
+                         const struct abt_node *left,
+                         const struct abt_node *right,
+                         const void *aux) 
+     {
+       struct element *node = node_to_element (node_);
+       node->count = 1;
+       if (left != NULL)
+         node->count += node_to_element (left)->count;
+       if (right != NULL)
+         node->count += node_to_element (right)->count;
+     }
+
+     // Finds and returns the element in ABT that is in the given
+     // 0-based POSITION in in-order.
+     static struct element *
+     find_by_position (struct abt *abt, int position) 
+     {
+       struct abt_node *p;
+       for (p = abt->root; p != NULL; ) 
+         {
+           int p_pos = p->down[0] ? node_to_element (p->down[0])->count : 0;
+           if (position == p_pos)
+             return node_to_element (p);
+           else if (position < p_pos)
+             p = p->down[0]; 
+           else
+             {
+               p = p->down[1];
+               position -= p_pos + 1;
+             }
+         }
+       return NULL;
+     }
+
+   For more information on augmenting binary search tree-based
+   data structures, see Cormen-Leiserson-Rivest, chapter 15, or
+   Knuth vol. 3, section 6.2.3, under "Linear list
+   representation."  For more information on AA trees, see
+   <http://en.wikipedia.org/wiki/AA_tree>, which includes source
+   code and links to other resources, such as the original AA
+   tree paper.  */
+
+#include <stddef.h>
+
+/* Returns the data structure corresponding to the given NODE,
+   assuming that NODE is embedded as the given MEMBER name in
+   data type STRUCT. */
+#define abt_data(NODE, STRUCT, MEMBER)                                  \
+        ((STRUCT *) ((char *) (NODE) - offsetof (STRUCT, MEMBER)))
+
+/* Node in an augmented binary tree. */
+struct abt_node 
+  {
+    struct abt_node *up;        /* Parent (NULL for root). */
+    struct abt_node *down[2];   /* Left child, right child. */
+    int level;                  /* AA tree level (not ordinary BST level). */
+  };
+
+/* Compares nodes A and B, with the tree's AUX.
+   Returns a strcmp-like result. */
+typedef int abt_compare_func (const struct abt_node *a,
+                              const struct abt_node *b,
+                              const void *aux);
+
+/* Recalculates NODE's augmentation based on NODE's data and that
+   of its LEFT and RIGHT children, with the tree's AUX. */
+typedef void abt_reaugment_func (struct abt_node *node,
+                                 const struct abt_node *left,
+                                 const struct abt_node *right,
+                                 const void *aux);
+
+/* An augmented binary tree. */
+struct abt 
+  {
+    struct abt_node *root;         /* Tree's root, NULL if empty. */
+    abt_compare_func *compare;     /* To compare nodes. */
+    abt_reaugment_func *reaugment; /* To augment a node using its children. */
+    void *aux;                     /* Auxiliary data. */
+  };
+
+void abt_init (struct abt *, abt_compare_func *, abt_reaugment_func *,
+               void *aux);
+
+struct abt_node *abt_insert (struct abt *, struct abt_node *);
+void abt_delete (struct abt *, struct abt_node *);
+
+struct abt_node *abt_first (const struct abt *);
+struct abt_node *abt_last (const struct abt *);
+struct abt_node *abt_find (const struct abt *, const struct abt_node *);
+struct abt_node *abt_next (const struct abt *, const struct abt_node *);
+struct abt_node *abt_prev (const struct abt *, const struct abt_node *);
+
+void abt_reaugmented (const struct abt *, struct abt_node *);
+struct abt_node *abt_changed (struct abt *, struct abt_node *);
+void abt_moved (struct abt *, struct abt_node *);
+
+#endif /* libpspp/abt.h */
Index: src/libpspp/automake.mk
===================================================================
RCS file: /cvsroot/pspp/pspp/src/libpspp/automake.mk,v
retrieving revision 1.20
diff -u -p -r1.20 automake.mk
--- src/libpspp/automake.mk	16 Jan 2007 00:14:41 -0000	1.20
+++ src/libpspp/automake.mk	25 Jan 2007 05:13:54 -0000
@@ -4,6 +4,8 @@
 noinst_LIBRARIES += src/libpspp/libpspp.a
 
 src_libpspp_libpspp_a_SOURCES = \
+	src/libpspp/abt.c \
+	src/libpspp/abt.h \
 	src/libpspp/array.c \
 	src/libpspp/array.h \
 	src/libpspp/assertion.h \
Index: tests/ChangeLog
===================================================================
RCS file: /cvsroot/pspp/pspp/tests/ChangeLog,v
retrieving revision 1.76
diff -u -p -r1.76 ChangeLog
--- tests/ChangeLog	10 Jan 2007 14:50:16 -0000	1.76
+++ tests/ChangeLog	25 Jan 2007 05:13:54 -0000
@@ -1,8 +1,14 @@
+Wed Jan 24 21:13:53 2007  Ben Pfaff  <blp@gnu.org>
+
+	* automake.mk: Add tests/libpspp/abt-test.
+
+	* libpspp/abt-test.c: New test.
+
 Wed Jan 10 06:50:01 2007  Ben Pfaff  <blp@gnu.org>
 
 	* automake.mk: Add tests/libpspp/heap-test.
 
-	* test/libpspp/heap-test.c: New test.
+	* libpspp/heap-test.c: New test.
 
 Wed Dec 13 21:00:46 2006  Ben Pfaff  <blp@gnu.org>
 
Index: tests/automake.mk
===================================================================
RCS file: /cvsroot/pspp/pspp/tests/automake.mk,v
retrieving revision 1.25
diff -u -p -r1.25 automake.mk
--- tests/automake.mk	20 Jan 2007 00:02:13 -0000	1.25
+++ tests/automake.mk	25 Jan 2007 05:13:54 -0000
@@ -132,13 +132,15 @@ TESTS = \
 	tests/expressions/vectors.sh \
 	tests/libpspp/ll-test \
 	tests/libpspp/llx-test \
-	tests/libpspp/heap-test
+	tests/libpspp/heap-test \
+	tests/libpspp/abt-test
 
 check_PROGRAMS += \
 	tests/libpspp/ll-test \
 	tests/libpspp/llx-test \
 	tests/formats/inexactify \
-	tests/libpspp/heap-test
+	tests/libpspp/heap-test \
+	tests/libpspp/abt-test
 
 tests_libpspp_ll_test_SOURCES = \
 	src/libpspp/ll.c \
@@ -161,6 +163,13 @@ tests_libpspp_heap_test_SOURCES = \
 tests_libpspp_heap_test_LDADD = gl/libgl.la @LIBINTL@
 tests_libpspp_heap_test_CPPFLAGS = $(AM_CPPFLAGS) -DASSERT_LEVEL=10
 
+tests_libpspp_abt_test_SOURCES = \
+	src/libpspp/abt.c \
+	src/libpspp/abt.h \
+	tests/libpspp/abt-test.c
+tests_libpspp_abt_test_LDADD = gl/libgl.la
+tests_libpspp_abt_test_CPPFLAGS = $(AM_CPPFLAGS) -DASSERT_LEVEL=10
+
 tests_formats_inexactify_SOURCES = tests/formats/inexactify.c
 
 EXTRA_DIST += $(TESTS) tests/weighting.data tests/data-list.data tests/list.data \
Index: tests/libpspp/abt-test.c
===================================================================
RCS file: tests/libpspp/abt-test.c
diff -N tests/libpspp/abt-test.c
--- /dev/null	1 Jan 1970 00:00:00 -0000
+++ tests/libpspp/abt-test.c	25 Jan 2007 05:13:55 -0000
@@ -0,0 +1,720 @@
+/* PSPP - computes sample statistics.
+   Copyright (C) 2007 Free Software Foundation, Inc.
+
+   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 wiabt 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 the Free Software
+   Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
+   02110-1301, USA. */
+
+/* This is a test program for the abt_* routines defined in
+   abt.c.  This test program aims to be as comprehensive as
+   possible.  "gcov -b" should report 100% coverage of lines and
+   branches in the abt_* routines.  "valgrind --leak-check=yes
+   --show-reachable=yes" should give a clean report. */
+
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+
+#include <libpspp/abt.h>
+
+#include <assert.h>
+#include <stdbool.h>
+#include <stddef.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+#include <libpspp/compiler.h>
+
+/* Currently running test. */
+static const char *test_name;
+
+/* Exit with a failure code.
+   (Place a breakpoint on this function while debugging.) */
+static void
+check_die (void) 
+{
+  exit (EXIT_FAILURE);   
+}
+
+/* If OK is not true, prints a message about failure on the
+   current source file and the given LINE and terminates. */
+static void
+check_func (bool ok, int line) 
+{
+  if (!ok) 
+    {
+      printf ("Check failed in %s test at %s, line %d\n",
+              test_name, __FILE__, line);
+      check_die ();
+    }
+}
+
+/* Verifies that EXPR evaluates to true.
+   If not, prints a message citing the calling line number and
+   terminates. */
+#define check(EXPR) check_func ((EXPR), __LINE__)
+
+/* Prints a message about memory exhaustion and exits with a
+   failure code. */
+static void
+xalloc_die (void)
+{
+  printf ("virtual memory exhausted\n");
+  exit (EXIT_FAILURE);
+}
+
+/* Allocates and returns N bytes of memory. */
+static void *
+xmalloc (size_t n) 
+{
+  if (n != 0) 
+    {
+      void *p = malloc (n);
+      if (p == NULL)
+        xalloc_die ();
+
+      return p;
+    }
+  else
+    return NULL;
+}
+
+static void *
+xmemdup (const void *p, size_t n) 
+{
+  void *q = xmalloc (n);
+  memcpy (q, p, n);
+  return q;
+}
+
+/* Allocates and returns N * M bytes of memory. */
+static void *
+xnmalloc (size_t n, size_t m) 
+{
+  if ((size_t) -1 / m <= n)
+    xalloc_die ();
+  return xmalloc (n * m);
+}
+
+/* Node type and support routines. */
+
+/* Test data element. */
+struct element
+  {
+    struct abt_node node;       /* Embedded binary tree element. */
+    int data;                   /* Primary value. */
+    int count;                  /* Number of nodes in subtree,
+                                   including this node. */
+  };
+
+static int aux_data;
+
+/* Returns the `struct element' that NODE is embedded within. */
+static struct element *
+abt_node_to_element (const struct abt_node *node)
+{
+  return abt_data (node, struct element, node);
+}
+
+/* Compares the `x' values in A and B and returns a strcmp-type
+   return value.  Verifies that AUX points to aux_data. */
+static int
+compare_elements (const struct abt_node *a_, const struct abt_node *b_,
+                  const void *aux) 
+{
+  const struct element *a = abt_node_to_element (a_);
+  const struct element *b = abt_node_to_element (b_);
+
+  check (aux == &aux_data);
+  return a->data < b->data ? -1 : a->data > b->data;
+}
+
+/* Recalculates the count for NODE's subtree by adding up the
+   counts for its LEFT and RIGHT child subtrees. */
+static void
+reaugment_elements (struct abt_node *node_,
+                    const struct abt_node *left,
+                    const struct abt_node *right,
+                    const void *aux) 
+{
+  struct element *node = abt_node_to_element (node_);
+
+  check (aux == &aux_data);
+
+  node->count = 1;
+  if (left != NULL)
+    node->count += abt_node_to_element (left)->count;
+  if (right != NULL)
+    node->count += abt_node_to_element (right)->count;
+}
+
+/* Compares A and B and returns a strcmp-type return value. */
+static int
+compare_ints_noaux (const void *a_, const void *b_) 
+{
+  const int *a = a_;
+  const int *b = b_;
+
+  return *a < *b ? -1 : *a > *b;
+}
+
+/* Swaps *A and *B. */
+static void
+swap (int *a, int *b) 
+{
+  int t = *a;
+  *a = *b;
+  *b = t;
+}
+
+/* Reverses the order of the CNT integers starting at VALUES. */
+static void
+reverse (int *values, size_t cnt) 
+{
+  for (; cnt > 1; cnt -= 2, values++)
+    swap (values, &values[cnt - 1]);
+}
+
+/* Arranges the CNT elements in VALUES into the lexicographically
+   next greater permutation.  Returns true if successful.
+   If VALUES is already the lexicographically greatest
+   permutation of its elements (i.e. ordered from greatest to
+   smallest), arranges them into the lexicographically least
+   permutation (i.e. ordered from smallest to largest) and
+   returns false. */
+static bool
+next_permutation (int *values, size_t cnt)
+{
+  if (cnt > 0)
+    {
+      size_t i = cnt - 1;
+      while (i != 0) 
+        {
+          i--;
+          if (values[i] < values[i + 1])
+            {
+              size_t j;
+              for (j = cnt - 1; values[i] >= values[j]; j--)
+                continue;
+              swap (values + i, values + j);
+              reverse (values + (i + 1), cnt - (i + 1));
+              return true;
+            } 
+        }
+      
+      reverse (values, cnt);
+    }
+  
+  return false;
+}
+
+/* Returns N!. */
+static unsigned
+factorial (unsigned n) 
+{
+  unsigned value = 1;
+  while (n > 1)
+    value *= n--;
+  return value;
+}
+
+/* Randomly shuffles the CNT elements in ARRAY, each of which is
+   SIZE bytes in size. */
+static void
+random_shuffle (void *array_, size_t cnt, size_t size)
+{
+  char *array = array_;
+  char *tmp = xmalloc (size);
+  size_t i;
+
+  for (i = 0; i < cnt; i++) 
+    {
+      size_t j = rand () % (cnt - i) + i;
+      if (i != j) 
+        {
+          memcpy (tmp, array + j * size, size);
+          memcpy (array + j * size, array + i * size, size);
+          memcpy (array + i * size, tmp, size);
+        }
+    }
+
+  free (tmp);
+}
+
+/* Finds and returns the element in ABT that is in the given
+   0-based POSITION in in-order. */
+static struct element *
+find_by_position (struct abt *abt, int position) 
+{
+  struct abt_node *p;
+  for (p = abt->root; p != NULL; ) 
+    {
+      int p_pos = p->down[0] ? abt_node_to_element (p->down[0])->count : 0;
+      if (position == p_pos)
+        return abt_node_to_element (p);
+      else if (position < p_pos)
+        p = p->down[0]; 
+      else
+        {
+          p = p->down[1];
+          position -= p_pos + 1;
+        }
+    }
+  return NULL;
+}
+
+/* Checks that all the augmentations are correct in the subtree
+   rooted at P.  Returns the number of nodes in the subtree. */
+static int
+check_augmentations (struct abt_node *p_) 
+{
+  if (p_ == NULL)
+    return 0;
+  else 
+    {
+      struct element *p = abt_node_to_element (p_);
+      int left_count = check_augmentations (p->node.down[0]);
+      int right_count = check_augmentations (p->node.down[1]);
+      int total = left_count + right_count + 1;
+      check (p->count == total);
+      return total;
+    }
+}
+
+/* Check that the levels are correct in the subtree rooted at P. */
+static void
+check_levels (struct abt_node *p) 
+{
+  if (p != NULL) 
+    {
+      int i, j;
+
+      check_levels (p->down[0]);
+      check_levels (p->down[1]);
+
+      check (p->level >= 1);
+      if (p->level > 1) 
+        {
+          struct abt_node *q = p->down[1];
+          check (q != NULL);
+          check (q->level == p->level || q->level == p->level - 1); 
+        }
+
+      for (i = 0; i < 2; i++)
+        if (p->down[i] != NULL)
+          for (j = 0; j < 2; j++)
+            if (p->down[i]->down[j] != NULL)
+              check (p->down[i]->down[j]->level < p->level);
+    }
+}
+
+/* Checks that ABT contains the CNT ints in DATA, that its
+   structure is correct, and that certain operations on ABT
+   produce the expected results. */
+static void
+check_abt (struct abt *abt, const int data[], size_t cnt) 
+{
+  struct element e;
+  size_t i;
+  int *order;
+
+  order = xmemdup (data, cnt * sizeof *data);
+  qsort (order, cnt, sizeof *order, compare_ints_noaux);
+
+  for (i = 0; i < cnt; i++)
+    {
+      struct abt_node *p;
+      
+      e.data = data[i];
+      if (rand () % 2)
+        p = abt_find (abt, &e.node);
+      else
+        p = abt_insert (abt, &e.node);
+      check (p != NULL);
+      check (p != &e.node);
+      check (abt_node_to_element (p)->data == data[i]);
+    }
+
+  e.data = -1;
+  check (abt_find (abt, &e.node) == NULL);
+
+  check_levels (abt->root);
+  check_augmentations (abt->root);
+  for (i = 0; i < cnt; i++)
+    check (find_by_position (abt, i)->data == order[i]);
+
+  if (cnt == 0) 
+    {
+      check (abt_first (abt) == NULL);
+      check (abt_last (abt) == NULL);
+      check (abt_next (abt, NULL) == NULL);
+      check (abt_prev (abt, NULL) == NULL);
+    }
+  else 
+    {
+      struct abt_node *p;
+  
+      for (p = abt_first (abt), i = 0; i < cnt; p = abt_next (abt, p), i++)
+        check (abt_node_to_element (p)->data == order[i]);
+      check (p == NULL);
+
+      for (p = abt_last (abt), i = 0; i < cnt; p = abt_prev (abt, p), i++)
+        check (abt_node_to_element (p)->data == order[cnt - i - 1]);
+      check (p == NULL);
+    }
+
+  free (order);
+}
+
+/* Inserts the CNT values from 0 to CNT - 1 (inclusive) into an
+   ABT in the order specified by INSERTIONS, then deletes them in
+   the order specified by DELETIONS, checking the ABT's contents
+   for correctness after each operation. */
+static void
+test_insert_delete (const int insertions[],
+                    const int deletions[],
+                    size_t cnt) 
+{
+  struct element *elements;
+  struct abt abt;
+  size_t i;
+  
+  elements = xnmalloc (cnt, sizeof *elements);
+  for (i = 0; i < cnt; i++)
+    elements[i].data = i;
+
+  abt_init (&abt, compare_elements, reaugment_elements, &aux_data);
+  check_abt (&abt, NULL, 0);
+  for (i = 0; i < cnt; i++)
+    {
+      check (abt_insert (&abt, &elements[insertions[i]].node) == NULL);
+      check_abt (&abt, insertions, i + 1);
+    }
+  for (i = 0; i < cnt; i++)
+    {
+      abt_delete (&abt, &elements[deletions[i]].node);
+      check_abt (&abt, deletions + i + 1, cnt - i - 1);
+    }
+
+  free (elements);
+}
+
+/* Inserts values into an ABT in each possible order, then
+   removes them in each possible order, up to a specified maximum
+   size. */
+static void
+test_insert_any_remove_any (void) 
+{
+  const int max_elems = 5;
+  int cnt;
+
+  for (cnt = 0; cnt <= max_elems; cnt++) 
+    {
+      int *insertions, *deletions;
+      unsigned int ins_perm_cnt;
+      int i;
+
+      insertions = xnmalloc (cnt, sizeof *insertions);
+      deletions = xnmalloc (cnt, sizeof *deletions);
+      for (i = 0; i < cnt; i++) 
+        insertions[i] = i;
+
+      for (ins_perm_cnt = 0;
+           ins_perm_cnt == 0 || next_permutation (insertions, cnt);
+           ins_perm_cnt++) 
+        {
+          unsigned int del_perm_cnt;
+          int i;
+
+          for (i = 0; i < cnt; i++) 
+            deletions[i] = i;
+
+          for (del_perm_cnt = 0;
+               del_perm_cnt == 0 || next_permutation (deletions, cnt);
+               del_perm_cnt++) 
+            test_insert_delete (insertions, deletions, cnt);
+
+          check (del_perm_cnt == factorial (cnt));
+        }
+      check (ins_perm_cnt == factorial (cnt));
+
+      free (insertions);
+      free (deletions);
+    }
+}
+
+/* Inserts values into an ABT in each possible order, then
+   removes them in the same order, up to a specified maximum
+   size. */
+static void
+test_insert_any_remove_same (void) 
+{
+  const int max_elems = 7;
+  int cnt;
+
+  for (cnt = 0; cnt <= max_elems; cnt++) 
+    {
+      int *values;
+      unsigned int permutation_cnt;
+      int i;
+
+      values = xnmalloc (cnt, sizeof *values);
+      for (i = 0; i < cnt; i++) 
+        values[i] = i;
+
+      for (permutation_cnt = 0;
+           permutation_cnt == 0 || next_permutation (values, cnt);
+           permutation_cnt++)
+        test_insert_delete (values, values, cnt);
+      check (permutation_cnt == factorial (cnt));
+
+      free (values);
+    }
+}
+
+/* Inserts values into an ABT in each possible order, then
+   removes them in reverse order, up to a specified maximum
+   size. */
+static void
+test_insert_any_remove_reverse (void) 
+{
+  const int max_elems = 7;
+  int cnt;
+
+  for (cnt = 0; cnt <= max_elems; cnt++) 
+    {
+      int *insertions, *deletions;
+      unsigned int permutation_cnt;
+      int i;
+
+      insertions = xnmalloc (cnt, sizeof *insertions);
+      deletions = xnmalloc (cnt, sizeof *deletions);
+      for (i = 0; i < cnt; i++) 
+        insertions[i] = i;
+
+      for (permutation_cnt = 0;
+           permutation_cnt == 0 || next_permutation (insertions, cnt);
+           permutation_cnt++) 
+        {
+          memcpy (deletions, insertions, sizeof *insertions * cnt);
+          reverse (deletions, cnt);
+          
+          test_insert_delete (insertions, deletions, cnt); 
+        }
+      check (permutation_cnt == factorial (cnt));
+
+      free (insertions);
+      free (deletions);
+    }
+}
+
+/* Inserts and removes values in an ABT in random orders. */
+static void
+test_random_sequence (void) 
+{
+  const int max_elems = 128;
+  const int max_trials = 8;
+  int cnt;
+
+  for (cnt = 0; cnt <= max_elems; cnt += 2) 
+    {
+      int *insertions, *deletions;
+      int trial;
+      int i;
+
+      insertions = xnmalloc (cnt, sizeof *insertions);
+      deletions = xnmalloc (cnt, sizeof *deletions);
+      for (i = 0; i < cnt; i++) 
+        insertions[i] = i;
+      for (i = 0; i < cnt; i++) 
+        deletions[i] = i;
+
+      for (trial = 0; trial < max_trials; trial++) 
+        {
+          random_shuffle (insertions, cnt, sizeof *insertions);
+          random_shuffle (deletions, cnt, sizeof *deletions);
+      
+          test_insert_delete (insertions, deletions, cnt); 
+        }
+
+      free (insertions);
+      free (deletions);
+    }
+}
+
+/* Inserts elements into an ABT in ascending order. */
+static void
+test_insert_ordered (void) 
+{
+  const int max_elems = 1024;
+  struct element *elements;
+  int *values;
+  struct abt abt;
+  int i;
+
+  abt_init (&abt, compare_elements, reaugment_elements, &aux_data);
+  elements = xnmalloc (max_elems, sizeof *elements);
+  values = xnmalloc (max_elems, sizeof *values);
+  for (i = 0; i < max_elems; i++) 
+    {
+      values[i] = elements[i].data = i;
+      check (abt_insert (&abt, &elements[i].node) == NULL);
+      check_abt (&abt, values, i + 1);
+    }
+  free (elements);
+  free (values);
+}
+
+/* Inserts elements into an ABT, then moves the nodes around in
+   memory. */
+static void
+test_moved (void) 
+{
+  const int max_elems = 128;
+  struct element *e[2];
+  int cur;
+  int *values;
+  struct abt abt;
+  int i, j;
+
+  abt_init (&abt, compare_elements, reaugment_elements, &aux_data);
+  e[0] = xnmalloc (max_elems, sizeof *e[0]);
+  e[1] = xnmalloc (max_elems, sizeof *e[1]);
+  values = xnmalloc (max_elems, sizeof *values);
+  cur = 0;
+  for (i = 0; i < max_elems; i++) 
+    {
+      values[i] = e[cur][i].data = i;
+      check (abt_insert (&abt, &e[cur][i].node) == NULL);
+      check_abt (&abt, values, i + 1);
+
+      for (j = 0; j <= i; j++) 
+        {
+          e[!cur][j] = e[cur][j];
+          abt_moved (&abt, &e[!cur][j].node);
+          check_abt (&abt, values, i + 1);
+        }
+      cur = !cur;
+    }
+  free (e[0]);
+  free (e[1]);
+  free (values);
+}
+
+/* Inserts values into an ABT, then changes their values. */
+static void
+test_changed (void)
+{
+  const int max_elems = 6;
+  int cnt;
+
+  for (cnt = 0; cnt <= max_elems; cnt++) 
+    {
+      int *values, *changed_values;
+      struct element *elements;
+      unsigned int permutation_cnt;
+      int i;
+
+      values = xnmalloc (cnt, sizeof *values);
+      changed_values = xnmalloc (cnt, sizeof *changed_values);
+      elements = xnmalloc (cnt, sizeof *elements);
+      for (i = 0; i < cnt; i++) 
+        values[i] = i;
+
+      for (permutation_cnt = 0;
+           permutation_cnt == 0 || next_permutation (values, cnt);
+           permutation_cnt++) 
+        {
+          for (i = 0; i < cnt; i++) 
+            {
+              int j, k;
+              for (j = 0; j <= cnt; j++) 
+                {
+                  struct abt abt;
+                  struct abt_node *changed_retval;
+
+                  abt_init (&abt, compare_elements, reaugment_elements,
+                            &aux_data);
+
+                  /* Add to ABT in order. */
+                  for (k = 0; k < cnt; k++) 
+                    {
+                      int n = values[k];
+                      elements[n].data = n;
+                      check (abt_insert (&abt, &elements[n].node) == NULL); 
+                    }
+                  check_abt (&abt, values, cnt);
+
+                  /* Change value i to j. */
+                  elements[i].data = j;
+                  for (k = 0; k < cnt; k++)
+                    changed_values[k] = k;
+                  changed_retval = abt_changed (&abt, &elements[i].node);
+                  if (i != j && j < cnt)
+                    {
+                      /* Will cause duplicate. */
+                      check (changed_retval == &elements[j].node);
+                      changed_values[i] = changed_values[cnt - 1];
+                      check_abt (&abt, changed_values, cnt - 1);
+                    }
+                  else
+                    {
+                      /* Succeeds. */
+                      check (changed_retval == NULL);
+                      changed_values[i] = j;
+                      check_abt (&abt, changed_values, cnt);
+                    }
+                }
+            } 
+        }
+      check (permutation_cnt == factorial (cnt));
+
+      free (values);
+      free (changed_values);
+      free (elements);
+    }
+}
+
+/* Main program. */
+
+/* Runs TEST_FUNCTION and prints a message about NAME. */
+static void
+run_test (void (*test_function) (void), const char *name) 
+{
+  test_name = name;
+  putchar ('.');
+  fflush (stdout);
+  test_function ();
+}
+
+int
+main (void) 
+{
+  run_test (test_insert_any_remove_any,
+            "insert any order, delete any order");
+  run_test (test_insert_any_remove_same,
+            "insert any order, delete same order");
+  run_test (test_insert_any_remove_reverse,
+            "insert any order, delete reverse order");
+  run_test (test_random_sequence,
+            "insert and delete in random sequence");
+  run_test (test_insert_ordered,
+            "insert in ascending order");
+  run_test (test_moved, "move elements around in memory");
+  run_test (test_changed, "change key data in nodes");
+  putchar ('\n');
+
+  return 0;
+}
