void ixGet(analSet*anl, cmpString**list, int *len){
int ix, iz, mylen = 0;
rb_red_blk_tree*ptree;
rb_red_blk_node*pnode;
for(ix = 0; ix < MAXINDEX; ix++) {
ptree = tree[anl->indexes[ix]];
//printf("(rb) %d\n", anl->indexes[ix]);
pnode = ptree->root->left;
while(pnode->right != ptree->nil) {
pnode = pnode->right;
}
for(iz = 0; iz < MAXRES; iz++) {
if(pnode->info) {
list[mylen] = (void*)pnode->info;
// printf("(rb) %s\n", *list[mylen]);
mylen++;
pnode = TreePredecessor(ptree, pnode);
// end of predecessing
if(pnode == ptree->nil) {
break;
}
} else {
break;
}
}
}
*len = mylen;
}
HRESULT std_map_iter(std_map* self, std_map_node** ppNode)
{
if(*ppNode == 0)
{
*ppNode = self->m_pRoot;
}
*ppNode = TreePredecessor(self, *ppNode);
if(*ppNode == self->m_pNil)
{
*ppNode = 0;
}
return S_OK;
}
stk_stack* RBEnumerate(rb_red_blk_tree* tree, void* low, void* high) {
stk_stack* enumResultStack;
rb_red_blk_node* nil=tree->nil;
rb_red_blk_node* x=tree->root->left;
rb_red_blk_node* lastBest=nil;
enumResultStack=StackCreate();
while(nil != x) {
if ( 1 == (tree->comp_func(x->key,high)) ) { /* x->key > high */
x=x->left;
} else {
lastBest=x;
x=x->right;
}
}
while ( (lastBest != nil) && (1 != tree->comp_func(low,lastBest->key))) {
StackPush(enumResultStack,lastBest);
lastBest=TreePredecessor(tree,lastBest);
}
return(enumResultStack);
}
static SparseMatrix get_overlap_graph(int dim, int n, real *x, real *width, int check_overlap_only){
/* if check_overlap_only = TRUE, we only check whether there is one overlap */
scan_point *scanpointsx, *scanpointsy;
int i, k, neighbor;
SparseMatrix A = NULL, B = NULL;
rb_red_blk_node *newNode, *newNode0, *newNode2 = NULL;
rb_red_blk_tree* treey;
real one = 1;
A = SparseMatrix_new(n, n, 1, MATRIX_TYPE_REAL, FORMAT_COORD);
scanpointsx = N_GNEW(2*n,scan_point);
for (i = 0; i < n; i++){
scanpointsx[2*i].node = i;
scanpointsx[2*i].x = x[i*dim] - width[i*dim];
scanpointsx[2*i].status = INTV_OPEN;
scanpointsx[2*i+1].node = i+n;
scanpointsx[2*i+1].x = x[i*dim] + width[i*dim];
scanpointsx[2*i+1].status = INTV_CLOSE;
}
qsort(scanpointsx, 2*n, sizeof(scan_point), comp_scan_points);
scanpointsy = N_GNEW(2*n,scan_point);
for (i = 0; i < n; i++){
scanpointsy[i].node = i;
scanpointsy[i].x = x[i*dim+1] - width[i*dim+1];
scanpointsy[i].status = INTV_OPEN;
scanpointsy[i+n].node = i;
scanpointsy[i+n].x = x[i*dim+1] + width[i*dim+1];
scanpointsy[i+n].status = INTV_CLOSE;
}
treey = RBTreeCreate(NodeComp,NodeDest,InfoDest,NodePrint,InfoPrint);
for (i = 0; i < 2*n; i++){
#ifdef DEBUG_RBTREE
fprintf(stderr," k = %d node = %d x====%f\n",(scanpointsx[i].node)%n, (scanpointsx[i].node), (scanpointsx[i].x));
#endif
k = (scanpointsx[i].node)%n;
if (scanpointsx[i].status == INTV_OPEN){
#ifdef DEBUG_RBTREE
fprintf(stderr, "inserting...");
treey->PrintKey(&(scanpointsy[k]));
#endif
RBTreeInsert(treey, &(scanpointsy[k]), NULL); /* add both open and close int for y */
#ifdef DEBUG_RBTREE
fprintf(stderr, "inserting2...");
treey->PrintKey(&(scanpointsy[k+n]));
#endif
RBTreeInsert(treey, &(scanpointsy[k+n]), NULL);
} else {
real bsta, bbsta, bsto, bbsto; int ii;
assert(scanpointsx[i].node >= n);
newNode = newNode0 = RBExactQuery(treey, &(scanpointsy[k + n]));
ii = ((scan_point *)newNode->key)->node;
assert(ii < n);
bsta = scanpointsy[ii].x; bsto = scanpointsy[ii+n].x;
#ifdef DEBUG_RBTREE
fprintf(stderr, "poping..%d....yinterval={%f,%f}\n", scanpointsy[k + n].node, bsta, bsto);
treey->PrintKey(newNode->key);
#endif
assert(treey->nil != newNode);
while ((newNode) && ((newNode = TreePredecessor(treey, newNode)) != treey->nil)){
neighbor = (((scan_point *)newNode->key)->node)%n;
bbsta = scanpointsy[neighbor].x; bbsto = scanpointsy[neighbor+n].x;/* the y-interval of the node that has one end of the interval lower than the top of the leaving interval (bsto) */
#ifdef DEBUG_RBTREE
fprintf(stderr," predecessor is node %d y = %f\n", ((scan_point *)newNode->key)->node, ((scan_point *)newNode->key)->x);
#endif
if (neighbor != k){
if (ABS(0.5*(bsta+bsto) - 0.5*(bbsta+bbsto)) < 0.5*(bsto-bsta) + 0.5*(bbsto-bbsta)){/* if the distance of the centers of the interval is less than sum of width, we have overlap */
A = SparseMatrix_coordinate_form_add_entries(A, 1, &neighbor, &k, &one);
#ifdef DEBUG_RBTREE
fprintf(stderr,"====================================== %d %d\n",k,neighbor);
#endif
if (check_overlap_only) goto check_overlap_RETURN;
}
} else {
newNode2 = newNode;
}
}
#ifdef DEBUG_RBTREE
fprintf(stderr, "deleteing...");
treey->PrintKey(newNode0->key);
#endif
if (newNode0) RBDelete(treey,newNode0);
if (newNode2 && newNode2 != treey->nil && newNode2 != newNode0) {
#ifdef DEBUG_RBTREE
fprintf(stderr, "deleteing2...");
treey->PrintKey(newNode2->key);
#endif
if (newNode0) RBDelete(treey,newNode2);
}
}
}
check_overlap_RETURN:
FREE(scanpointsx);
FREE(scanpointsy);
RBTreeDestroy(treey);
B = SparseMatrix_from_coordinate_format(A);
SparseMatrix_delete(A);
A = SparseMatrix_symmetrize(B, FALSE);
SparseMatrix_delete(B);
if (Verbose) fprintf(stderr, "found %d clashes\n", A->nz);
return A;
}
//returns the total number of collided cells
int add_block_1_axis(rb_red_blk_tree *tree, int x1, int y1, int x2, int y2, unsigned int type, int add_amount) {
circ_tree_node *node_begin, *node_end;
node_end = get_node(tree, x2, type)->key; //the end strictly needs to be called before the beginning
node_begin = get_node(tree, x1, type)->key;
stk_stack *axis_range = RBEnumerate(tree, node_begin, node_end);
rb_red_blk_node *rb_node, *rb_node_prev = NULL;
int temp_collision = 0, collision = 0, prev_pos;
for (;;) {
//rb_node_prev = rb_node;
rb_node = (rb_red_blk_node *) StackPop(axis_range);
//if (rb_node_prev == NULL)
rb_node_prev = TreePredecessor(tree, rb_node);
circ_tree_node *node = (circ_tree_node *) rb_node->key;
circ_tree_node *node_prev;
if (rb_node_prev == NULL || rb_node_prev == tree->nil)
node_prev = NULL;
else
node_prev = (circ_tree_node *) rb_node_prev->key;
unsigned int stack_not_empty = StackNotEmpty(axis_range);
//collision
if (temp_collision)
//if temp collision is non-zero, by definition, node_prev
//cannot be NULL
collision += temp_collision * (node->pos - prev_pos);
prev_pos = node->pos;
if (type == TOP_LEVEL) {
if (stack_not_empty)
temp_collision = add_block_1_axis(node->data.tree, y1, 0, y2, 0, SECOND_LEVEL, add_amount);
if ((node_prev != NULL &&
!RBTreeCompare(node->data.tree, node_prev->data.tree,
circ_node_equals)) ||
(node_prev == NULL && RBIsTreeEmpty(node->data.tree)))
RBDelete(tree, rb_node);
} else {
if (stack_not_empty) {
if (node->data.state > 0 && node->data.state > -add_amount)
//if there is already a block here, and if there would still
//be a block left, assess collision
temp_collision = add_amount;
else
temp_collision = 0;
node->data.state += add_amount;
}
//if both nodes are the same
if ((node_prev != NULL && node_prev->data.state == node->data.state) ||
//or the previous node is null and this is zero
(node_prev == NULL && node->data.state == 0)) {
RBDelete(tree, rb_node);
}
}
if (!stack_not_empty)
break;
}
StackDestroy(axis_range, dummy_fun);
return collision;
}
int main() {
stk_stack* enumResult;
int option=0;
int newKey,newKey2;
int* newInt;
rb_red_blk_node* newNode;
rb_red_blk_tree* tree;
tree=RBTreeCreate(IntComp,IntDest,InfoDest,IntPrint,InfoPrint);
while(option!=8) {
printf("choose one of the following:\n");
printf("(1) add to tree\n(2) delete from tree\n(3) query\n");
printf("(4) find predecessor\n(5) find sucessor\n(6) enumerate\n");
printf("(7) print tree\n(8) quit\n");
do option=fgetc(stdin); while(-1 != option && isspace(option));
option-='0';
switch(option)
{
case 1:
{
printf("type key for new node\n");
scanf("%i",&newKey);
newInt=(int*) malloc(sizeof(int));
*newInt=newKey;
RBTreeInsert(tree,newInt,0);
}
break;
case 2:
{
printf("type key of node to remove\n");
scanf("%i",&newKey);
if ( ( newNode=RBExactQuery(tree,&newKey ) ) ) RBDelete(tree,newNode);/*assignment*/
else printf("key not found in tree, no action taken\n");
}
break;
case 3:
{
printf("type key of node to query for\n");
scanf("%i",&newKey);
if ( ( newNode = RBExactQuery(tree,&newKey) ) ) {/*assignment*/
printf("data found in tree at location %i\n",(int)newNode);
} else {
printf("data not in tree\n");
}
}
break;
case 4:
{
printf("type key of node to find predecessor of\n");
scanf("%i",&newKey);
if ( ( newNode = RBExactQuery(tree,&newKey) ) ) {/*assignment*/
newNode=TreePredecessor(tree,newNode);
if(tree->nil == newNode) {
printf("there is no predecessor for that node (it is a minimum)\n");
} else {
printf("predecessor has key %i\n",*(int*)newNode->key);
}
} else {
printf("data not in tree\n");
}
}
break;
case 5:
{
printf("type key of node to find successor of\n");
scanf("%i",&newKey);
if ( (newNode = RBExactQuery(tree,&newKey) ) ) {
newNode=TreeSuccessor(tree,newNode);
if(tree->nil == newNode) {
printf("there is no successor for that node (it is a maximum)\n");
} else {
printf("successor has key %i\n",*(int*)newNode->key);
}
} else {
printf("data not in tree\n");
}
}
break;
case 6:
{
printf("type low and high keys to see all keys between them\n");
scanf("%i %i",&newKey,&newKey2);
enumResult=RBEnumerate(tree,&newKey,&newKey2);
while ( (newNode = StackPop(enumResult)) ) {
tree->PrintKey(newNode->key);
printf("\n");
}
free(enumResult);
}
break;
case 7:
{
RBTreePrint(tree);
}
break;
case 8:
{
RBTreeDestroy(tree);
return 0;
}
break;
default:
printf("Invalid input; Please try again.\n");
}
}
return 0;
}
static SparseMatrix get_overlap_graph(int dim, int n, real *x, real *width){
scan_point *scanpointsx, *scanpointsy;
int i, k, neighbor;
SparseMatrix A = NULL, B = NULL;
rb_red_blk_node *newNode, *newNode0;
rb_red_blk_tree* treey;
real one = 1;
A = SparseMatrix_new(n, n, 1, MATRIX_TYPE_REAL, FORMAT_COORD);
scanpointsx = N_GNEW(2*n,scan_point);
for (i = 0; i < n; i++){
scanpointsx[2*i].node = i;
scanpointsx[2*i].x = x[i*dim] - width[i*dim];
scanpointsx[2*i].status = INTV_OPEN;
scanpointsx[2*i+1].node = i+n;
scanpointsx[2*i+1].x = x[i*dim] + width[i*dim];
scanpointsx[2*i+1].status = INTV_CLOSE;
}
qsort(scanpointsx, 2*n, sizeof(scan_point), comp_scan_points);
scanpointsy = N_GNEW(2*n,scan_point);
for (i = 0; i < n; i++){
scanpointsy[i].node = i;
scanpointsy[i].x = x[i*dim+1] - width[i*dim+1];
scanpointsy[i].status = INTV_OPEN;
scanpointsy[i+n].node = i;
scanpointsy[i+n].x = x[i*dim+1] + width[i*dim+1];
scanpointsy[i+n].status = INTV_CLOSE;
}
treey = RBTreeCreate(NodeComp,NodeDest,InfoDest,NodePrint,InfoPrint);
for (i = 0; i < 2*n; i++){
#ifdef DEBUG_RBTREE
fprintf(stderr," k = %d node = %d x====%f\n",(scanpointsx[i].node)%n, (scanpointsx[i].node), (scanpointsx[i].x));
#endif
k = (scanpointsx[i].node)%n;
if (scanpointsx[i].status == INTV_OPEN){
#ifdef DEBUG_RBTREE
fprintf(stderr, "inserting...");
treey->PrintKey(&(scanpointsy[k]));
#endif
RBTreeInsert(treey, &(scanpointsy[k]), NULL); /* add both open and close int for y */
#ifdef DEBUG_RBTREE
fprintf(stderr, "inserting2...");
treey->PrintKey(&(scanpointsy[k+n]));
#endif
RBTreeInsert(treey, &(scanpointsy[k+n]), NULL);
} else {
assert(scanpointsx[i].node >= n);
newNode = newNode0 = RBExactQuery(treey, &(scanpointsy[k + n]));
#ifdef DEBUG_RBTREE
fprintf(stderr, "poping..%d....", scanpointsy[k + n].node);
treey->PrintKey(newNode->key);
#endif
assert(treey->nil != newNode);
while ((newNode) && ((newNode = TreePredecessor(treey, newNode)) != treey->nil) && ((scan_point *)newNode->key)->node != k){
neighbor = (((scan_point *)newNode->key)->node)%n;
A = SparseMatrix_coordinate_form_add_entries(A, 1, &neighbor, &k, &one);
#ifdef DEBUG_RBTREE
fprintf(stderr,"%d %d\n",k,neighbor);
#endif
}
#ifdef DEBUG_RBTREE
fprintf(stderr, "deleteing...");
treey->PrintKey(newNode0->key);
#endif
if (newNode0) RBDelete(treey,newNode0);
if (newNode != treey->nil && newNode != newNode0) {
#ifdef DEBUG_RBTREE
fprintf(stderr, "deleting2...");
treey->PrintKey(newNode->key)
#endif
if (newNode0) RBDelete(treey,newNode);
}
}
}
