void rb_tree_destroy_with_keys(rb_tree *t)
{
rb_node *n = rb_tree_min(t);
while (n) {
free(n->k); n->k = NULL;
n = rb_tree_succ(n);
}
rb_tree_destroy(t);
}
// mm_destroy - free mm and mm internal fields
void
mm_destroy(struct mm_struct *mm) {
if (mm->mmap_tree != NULL) {
rb_tree_destroy(mm->mmap_tree);
}
while (!list_empty(&(mm->mmap_list))) {
list_entry_t *le = list_next(&(mm->mmap_list));
list_del(le);
vma_destroy(le2vma(le, list_link));
}
kfree(mm);
}
// mm_destroy - free mm and mm internal fields
void
mm_destroy(struct mm_struct *mm) {
assert(mm_count(mm) == 0);
if (mm->mmap_tree != NULL) {
rb_tree_destroy(mm->mmap_tree);
}
list_entry_t *list = &(mm->mmap_list), *le;
while ((le = list_next(list)) != list) {
list_del(le);
vma_destroy(le2vma(le, list_link));
}
kfree(mm);
}
int main()
{
int i;
rb_tree_t tree;
rb_node_t *node;
rb_tree_create(&tree, NULL);
for (i = 0; i < MAX; i++)
rb_insert(&tree, i, NULL);
rb_clear(&tree);
for (i = 0; i < MAX; i+=2)
rb_insert(&tree, i, NULL);
for (i = 0; i < MAX; i+=4)
{
node = rb_find(&tree, i);
rb_delete(&tree, node, FALSE);
}
rb_tree_destroy(&tree);
return 0;
}
static void crs_destroy(crs_data *d)
{
nlopt_sobol_destroy(d->s);
rb_tree_destroy(&d->t);
free(d->ps);
}
void
check_rb_tree(void) {
rb_tree *tree = rb_tree_create(check_compare1);
assert(tree != NULL);
rb_node *nil = tree->nil, *root = tree->root;
assert(!nil->red && root->left == nil);
int total = 1000;
struct check_data **all = check_safe_kmalloc(sizeof(struct check_data *) * total);
long i;
for (i = 0; i < total; i ++) {
all[i] = check_safe_kmalloc(sizeof(struct check_data));
all[i]->data = i;
}
int *mark = check_safe_kmalloc(sizeof(int) * total);
memset(mark, 0, sizeof(int) * total);
for (i = 0; i < total; i ++) {
mark[all[i]->data] = 1;
}
for (i = 0; i < total; i ++) {
assert(mark[i] == 1);
}
for (i = 0; i < total; i ++) {
int j = (rand() % (total - i)) + i;
struct check_data *z = all[i];
all[i] = all[j];
all[j] = z;
}
memset(mark, 0, sizeof(int) * total);
for (i = 0; i < total; i ++) {
mark[all[i]->data] = 1;
}
for (i = 0; i < total; i ++) {
assert(mark[i] == 1);
}
for (i = 0; i < total; i ++) {
rb_insert(tree, &(all[i]->rb_link));
check_tree(tree, root->left);
}
rb_node *node;
for (i = 0; i < total; i ++) {
node = rb_search(tree, check_compare2, (void *)(all[i]->data));
assert(node != NULL && node == &(all[i]->rb_link));
}
for (i = 0; i < total; i ++) {
node = rb_search(tree, check_compare2, (void *)i);
assert(node != NULL && rbn2data(node)->data == i);
rb_delete(tree, node);
check_tree(tree, root->left);
}
assert(!nil->red && root->left == nil);
long max = 32;
if (max > total) {
max = total;
}
for (i = 0; i < max; i ++) {
all[i]->data = max;
rb_insert(tree, &(all[i]->rb_link));
check_tree(tree, root->left);
}
for (i = 0; i < max; i ++) {
node = rb_search(tree, check_compare2, (void *)max);
assert(node != NULL && rbn2data(node)->data == max);
rb_delete(tree, node);
check_tree(tree, root->left);
}
assert(rb_tree_empty(tree));
for (i = 0; i < total; i ++) {
rb_insert(tree, &(all[i]->rb_link));
check_tree(tree, root->left);
}
rb_tree_destroy(tree);
for (i = 0; i < total; i ++) {
kfree(all[i]);
}
kfree(mark);
kfree(all);
}
int main() {
// stk_stack* enumResult;
int option=0;
int newKey,newKey2;
int* newInt;
red_black_node_struct* newNode;
red_black_tree_struct* tree;
tree=rb_tree_create(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;
rb_tree_insert(tree,newInt,0);
}
break;
case 2:
{
printf("type key of node to remove\n");
scanf("%i",&newKey);
if ( ( newNode=rb_exact_query(tree,&newKey ) ) ) rb_delete(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 = rb_exact_query(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 = rb_exact_query(tree,&newKey) ) ) {/*assignment*/
newNode=tree_predecessor(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 = rb_exact_query(tree,&newKey) ) ) {
newNode=tree_successor(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:
{
rb_tree_print(tree);
}
break;
case 8:
{
red_black_node_struct *ss ;//= (red_black_node_struct*)start( tree);
for ( ss= start( tree) ; ss != NULL ; ss = next(tree) ){
printf("%d\n",*(int*)ss->key);
}
rb_tree_destroy(tree);
return 0;
}
break;
default:
printf("Invalid input; Please try again.\n");
}
}
}
return 0;
}
/* Internal version of nldrmd_minimize, intended to be used as
a subroutine for the subplex method. Three differences compared
to nldrmd_minimize:
*minf should contain the value of f(x) (so that we don't have to
re-evaluate f at the starting x).
if psi > 0, then it *replaces* xtol and ftol in stop with the condition
that the simplex diameter |xl - xh| must be reduced by a factor of psi
... this is for when nldrmd is used within the subplex method; for
ordinary termination tests, set psi = 0.
scratch should contain an array of length >= (n+1)*(n+1) + 2*n,
used as scratch workspace.
On output, *fdiff will contain the difference between the high
and low function values of the last simplex. */
nlopt_result nldrmd_minimize_(int n, nlopt_func f, void *f_data,
const double *lb, const double *ub, /* bounds */
double *x, /* in: initial guess, out: minimizer */
double *minf,
const double *xstep, /* initial step sizes */
nlopt_stopping *stop,
double psi, double *scratch,
double *fdiff)
{
double *pts; /* (n+1) x (n+1) array of n+1 points plus function val [0] */
double *c; /* centroid * n */
double *xcur; /* current point */
rb_tree t; /* red-black tree of simplex, sorted by f(x) */
int i, j;
double ninv = 1.0 / n;
nlopt_result ret = NLOPT_SUCCESS;
double init_diam = 0;
pts = scratch;
c = scratch + (n+1)*(n+1);
xcur = c + n;
rb_tree_init(&t, simplex_compare);
*fdiff = HUGE_VAL;
/* initialize the simplex based on the starting xstep */
memcpy(pts+1, x, sizeof(double)*n);
pts[0] = *minf;
if (*minf < stop->minf_max) { ret=NLOPT_MINF_MAX_REACHED; goto done; }
for (i = 0; i < n; ++i) {
double *pt = pts + (i+1)*(n+1);
memcpy(pt+1, x, sizeof(double)*n);
pt[1+i] += xstep[i];
if (pt[1+i] > ub[i]) {
if (ub[i] - x[i] > fabs(xstep[i]) * 0.1)
pt[1+i] = ub[i];
else /* ub is too close to pt, go in other direction */
pt[1+i] = x[i] - fabs(xstep[i]);
}
if (pt[1+i] < lb[i]) {
if (x[i] - lb[i] > fabs(xstep[i]) * 0.1)
pt[1+i] = lb[i];
else {/* lb is too close to pt, go in other direction */
pt[1+i] = x[i] + fabs(xstep[i]);
if (pt[1+i] > ub[i]) /* go towards further of lb, ub */
pt[1+i] = 0.5 * ((ub[i] - x[i] > x[i] - lb[i] ?
ub[i] : lb[i]) + x[i]);
}
}
if (close(pt[1+i], x[i])) { ret=NLOPT_FAILURE; goto done; }
pt[0] = f(n, pt+1, NULL, f_data);
CHECK_EVAL(pt+1, pt[0]);
}
restart:
for (i = 0; i < n + 1; ++i)
if (!rb_tree_insert(&t, pts + i*(n+1))) {
ret = NLOPT_OUT_OF_MEMORY;
goto done;
}
while (1) {
rb_node *low = rb_tree_min(&t);
rb_node *high = rb_tree_max(&t);
double fl = low->k[0], *xl = low->k + 1;
double fh = high->k[0], *xh = high->k + 1;
double fr;
*fdiff = fh - fl;
if (init_diam == 0) /* initialize diam. for psi convergence test */
for (i = 0; i < n; ++i) init_diam += fabs(xl[i] - xh[i]);
if (psi <= 0 && nlopt_stop_ftol(stop, fl, fh)) {
ret = NLOPT_FTOL_REACHED;
goto done;
}
/* compute centroid ... if we cared about the perfomance of this,
we could do it iteratively by updating the centroid on
each step, but then we would have to be more careful about
accumulation of rounding errors... anyway n is unlikely to
be very large for Nelder-Mead in practical cases */
memset(c, 0, sizeof(double)*n);
for (i = 0; i < n + 1; ++i) {
double *xi = pts + i*(n+1) + 1;
if (xi != xh)
for (j = 0; j < n; ++j)
c[j] += xi[j];
}
for (i = 0; i < n; ++i) c[i] *= ninv;
/* x convergence check: find xcur = max radius from centroid */
memset(xcur, 0, sizeof(double)*n);
for (i = 0; i < n + 1; ++i) {
double *xi = pts + i*(n+1) + 1;
for (j = 0; j < n; ++j) {
double dx = fabs(xi[j] - c[j]);
if (dx > xcur[j]) xcur[j] = dx;
}
}
for (i = 0; i < n; ++i) xcur[i] += c[i];
if (psi > 0) {
double diam = 0;
for (i = 0; i < n; ++i) diam += fabs(xl[i] - xh[i]);
if (diam < psi * init_diam) {
ret = NLOPT_XTOL_REACHED;
goto done;
}
}
else if (nlopt_stop_x(stop, c, xcur)) {
ret = NLOPT_XTOL_REACHED;
goto done;
}
/* reflection */
if (!reflectpt(n, xcur, c, alpha, xh, lb, ub)) {
ret=NLOPT_XTOL_REACHED; goto done;
}
fr = f(n, xcur, NULL, f_data);
CHECK_EVAL(xcur, fr);
if (fr < fl) { /* new best point, expand simplex */
if (!reflectpt(n, xh, c, gamm, xh, lb, ub)) {
ret=NLOPT_XTOL_REACHED; goto done;
}
fh = f(n, xh, NULL, f_data);
CHECK_EVAL(xh, fh);
if (fh >= fr) { /* expanding didn't improve */
fh = fr;
memcpy(xh, xcur, sizeof(double)*n);
}
}
else if (fr < rb_tree_pred(high)->k[0]) { /* accept new point */
memcpy(xh, xcur, sizeof(double)*n);
fh = fr;
}
else { /* new worst point, contract */
double fc;
if (!reflectpt(n,xcur,c, fh <= fr ? -beta : beta, xh, lb,ub)) {
ret=NLOPT_XTOL_REACHED; goto done;
}
fc = f(n, xcur, NULL, f_data);
CHECK_EVAL(xcur, fc);
if (fc < fr && fc < fh) { /* successful contraction */
memcpy(xh, xcur, sizeof(double)*n);
fh = fc;
}
else { /* failed contraction, shrink simplex */
rb_tree_destroy(&t);
rb_tree_init(&t, simplex_compare);
for (i = 0; i < n+1; ++i) {
double *pt = pts + i * (n+1);
if (pt+1 != xl) {
if (!reflectpt(n,pt+1, xl,-delta,pt+1, lb,ub)) {
ret = NLOPT_XTOL_REACHED;
goto done;
}
pt[0] = f(n, pt+1, NULL, f_data);
CHECK_EVAL(pt+1, pt[0]);
}
}
goto restart;
}
}
high->k[0] = fh;
rb_tree_resort(&t, high);
}
done:
rb_tree_destroy(&t);
return ret;
}
int main(int argc, char **argv)
{
int N, M;
int *k;
double kd;
rb_tree t;
rb_node *n;
int i, j;
if (argc < 2) {
fprintf(stderr, "Usage: redblack_test Ntest [rand seed]\n");
return 1;
}
N = atoi(argv[1]);
k = (int *) malloc(N * sizeof(int));
rb_tree_init(&t, comp);
srand((unsigned) (argc > 2 ? atoi(argv[2]) : time(NULL)));
for (i = 0; i < N; ++i) {
double *newk = (double *) malloc(sizeof(double));
*newk = (k[i] = rand() % N);
if (!rb_tree_insert(&t, newk)) {
fprintf(stderr, "error in rb_tree_insert\n");
return 1;
}
if (!rb_tree_check(&t)) {
fprintf(stderr, "rb_tree_check_failed after insert!\n");
return 1;
}
}
if (t.N != N) {
fprintf(stderr, "incorrect N (%d) in tree (vs. %d)\n", t.N, N);
return 1;
}
for (i = 0; i < N; ++i) {
kd = k[i];
if (!rb_tree_find(&t, &kd)) {
fprintf(stderr, "rb_tree_find lost %d!\n", k[i]);
return 1;
}
}
n = rb_tree_min(&t);
for (i = 0; i < N; ++i) {
if (!n) {
fprintf(stderr, "not enough successors %d\n!", i);
return 1;
}
printf("%d: %g\n", i, n->k[0]);
n = rb_tree_succ(n);
}
if (n) {
fprintf(stderr, "too many successors!\n");
return 1;
}
n = rb_tree_max(&t);
for (i = 0; i < N; ++i) {
if (!n) {
fprintf(stderr, "not enough predecessors %d\n!", i);
return 1;
}
printf("%d: %g\n", i, n->k[0]);
n = rb_tree_pred(n);
}
if (n) {
fprintf(stderr, "too many predecessors!\n");
return 1;
}
for (M = N; M > 0; --M) {
int knew = rand() % N; /* random new key */
j = rand() % M; /* random original key to replace */
for (i = 0; i < N; ++i)
if (k[i] >= 0)
if (j-- == 0)
break;
if (i >= N)
abort();
kd = k[i];
if (!(n = rb_tree_find(&t, &kd))) {
fprintf(stderr, "rb_tree_find lost %d!\n", k[i]);
return 1;
}
n->k[0] = knew;
if (!rb_tree_resort(&t, n)) {
fprintf(stderr, "error in rb_tree_resort\n");
return 1;
}
if (!rb_tree_check(&t)) {
fprintf(stderr, "rb_tree_check_failed after change %d!\n", N - M + 1);
return 1;
}
k[i] = -1 - knew;
}
if (t.N != N) {
fprintf(stderr, "incorrect N (%d) in tree (vs. %d)\n", t.N, N);
return 1;
}
for (i = 0; i < N; ++i)
k[i] = -1 - k[i]; /* undo negation above */
for (i = 0; i < N; ++i) {
rb_node *le, *gt;
double lek, gtk;
kd = 0.01 * (rand() % (N * 150) - N * 25);
le = rb_tree_find_le(&t, &kd);
gt = rb_tree_find_gt(&t, &kd);
n = rb_tree_min(&t);
lek = le ? le->k[0] : -HUGE_VAL;
gtk = gt ? gt->k[0] : +HUGE_VAL;
printf("%g <= %g < %g\n", lek, kd, gtk);
if (n->k[0] > kd) {
if (le) {
fprintf(stderr, "found invalid le %g for %g\n", lek, kd);
return 1;
}
if (gt != n) {
fprintf(stderr, "gt is not first node for k=%g\n", kd);
return 1;
}
} else {
rb_node *succ = n;
do {
n = succ;
succ = rb_tree_succ(n);
} while (succ && succ->k[0] <= kd);
if (n != le) {
fprintf(stderr, "rb_tree_find_le gave wrong result for k=%g\n", kd);
return 1;
}
if (succ != gt) {
fprintf(stderr, "rb_tree_find_gt gave wrong result for k=%g\n", kd);
return 1;
}
}
}
for (M = N; M > 0; --M) {
j = rand() % M;
for (i = 0; i < N; ++i)
if (k[i] >= 0)
if (j-- == 0)
break;
if (i >= N)
abort();
kd = k[i];
if (!(n = rb_tree_find(&t, &kd))) {
fprintf(stderr, "rb_tree_find lost %d!\n", k[i]);
return 1;
}
n = rb_tree_remove(&t, n);
free(n->k);
free(n);
if (!rb_tree_check(&t)) {
fprintf(stderr, "rb_tree_check_failed after remove!\n");
return 1;
}
k[i] = -1 - k[i];
}
if (t.N != 0) {
fprintf(stderr, "nonzero N (%d) in tree at end\n", t.N);
return 1;
}
rb_tree_destroy(&t);
free(k);
printf("SUCCESS.\n");
return 0;
}
