void test_il_remove_index_range_1(CuTest* tc) {
il* lst = il_new(4);
il_append(lst, 0);
il_append(lst, 1);
il_append(lst, 2);
il_append(lst, 3);
il_append(lst, 4);
il_append(lst, 5);
il_remove_index_range(lst, 2, 2);
// [0 1 2 3 4 5] -> [0 1 4 5]
CuAssertIntEquals(tc, 4, il_size(lst));
CuAssertIntEquals(tc, 4, il_get(lst, 2));
}
static void dualtree_rs_recurse(kdtree_t* xtree, kdtree_t* ytree,
il* xnodes, il* xleaves,
bl* xnodebbs, bl* xleafbbs,
int ynode,
ttype* ybb,
double maxd2,
rangesearch_callback cb, void* baton) {
int leafmarker;
il* childnodes;
int i, N;
ttype oldbbval;
ttype splitval;
uint8_t splitdim;
// if the query node is a leaf...
if (KD_IS_LEAF(ytree, ynode)) {
// ... then run the result function on each x node
/*
if (callbacks->start_results)
callbacks->start_results(callbacks->start_extra, ytree, ynode);
*/
if (cb) {
// non-leaf nodes
N = il_size(xnodes);
for (i=0; i<N; i++)
dtrs_nodes(xtree, ytree, il_get(xnodes, i), ynode, maxd2, cb, baton);
// leaf nodes
N = il_size(xleaves);
for (i=0; i<N; i++)
dtrs_nodes(xtree, ytree, il_get(xleaves, i), ynode, maxd2, cb, baton);
}
/*
if (callbacks->end_results)
callbacks->end_results(callbacks->end_extra, ytree, ynode);
*/
return;
}
// if there are search leaves but no search nodes, run the result
// function on each leaf. (Note that the query node is not a leaf!)
if (!il_size(xnodes)) {
/*
result_function result = callbacks->result;
void* result_extra = callbacks->result_extra;
if (callbacks->start_results)
callbacks->start_results(callbacks->start_extra, ytree, ynode);
*/
// leaf nodes
if (result) {
N = il_size(xleaves);
for (i=0; i<N; i++)
dtrs_nodes(xtree, ytree, il_get(xleaves, i), ynode, maxd2, cb, baton);
//result(result_extra, xtree, il_get(leaves, i), ytree, ynode);
}
/*
if (callbacks->end_results)
callbacks->end_results(callbacks->end_extra, ytree, ynode);
*/
return;
}
leafmarker = il_size(leaves);
childnodes = il_new(256);
#define BBLO(bb, d) ((bb)[2*(d)])
#define BBHI(bb, d) ((bb)[(2*(d))+1])
N = il_size(xnodes);
for (i=0; i<N; i++) {
int child1, child2;
int xnode = il_get(xnodes, i);
ttype* xbb = bl_access(xnodebbs, i);
ttype* leftbb;
ttype* rightbb;
/*
node-node range...
if (!decision(decision_extra, xtree, xnode, ytree, ynode))
continue;
*/
split_dim_and_value(xtree, xnode, &splitdim, &splitval);
child1 = KD_CHILD_LEFT(xnode);
if (KD_IS_LEAF(xtree, child1)) {
il_append(xleaves, child1);
il_append(xleaves, child2);
leftbb = bl_append(xleafbbs, xbb);
rightbb = bl_append(xleafbbs, xbb);
} else {
il_append(childnodes, child1);
il_append(childnodes, child2);
leftbb = bl_append(xnodebbs, xbb);
rightbb = bl_append(xnodebbs, xbb);
}
BBHI(leftbb, splitdim) = splitval;
BBLO(rightbb, splitdim) = splitval;
}
printf("dualtree: start left child of y node %i: %i\n", ynode, KD_CHILD_LEFT(ynode));
// recurse on the Y children!
split_dim_and_value(ytree, ynode, &splitdim, &splitval);
// update y bb for the left child: max(splitdim) = splitval
oldbbval = BBHI(ybb, splitdim);
BBHI(ybb, splitdim) = splitval;
dualtree_recurse(xtree, ytree, childnodes, leaves,
KD_CHILD_LEFT(ynode), callbacks);
BBHI(ybb, splitdim) = oldbbval;
printf("dualtree: done left child of y node %i: %i\n", ynode, KD_CHILD_LEFT(ynode));
printf("dualtree: start right child of y node %i: %i\n", ynode, KD_CHILD_RIGHT(ynode));
// update y bb for the right child: min(splitdim) = splitval
oldbbval = BBLO(ybb, splitdim);
BBLO(ybb, splitdim) = splitval;
dualtree_recurse(xtree, ytree, childnodes, leaves,
KD_CHILD_RIGHT(ynode), callbacks);
BBLO(ybb, splitdim) = oldbbval;
printf("dualtree: done right child of y node %i: %i\n", ynode, KD_CHILD_LEFT(ynode));
// put the "leaves" list back the way it was...
il_remove_index_range(leaves, leafmarker, il_size(leaves)-leafmarker);
il_free(childnodes);
}
