pcover reduce(pset_family F, pset_family D) { register pcube last, p, cunder, *FD; /* Order the cubes */ if (use_random_order) F = random_order(F); else { F = toggle ? sort_reduce(F) : mini_sort(F, (qsort_compare_func) descend); toggle = ! toggle; } /* Try to reduce each cube */ FD = cube2list(F, D); foreach_set(F, last, p) { cunder = reduce_cube(FD, p); /* reduce the cube */ if (setp_equal(cunder, p)) { /* see if it actually did */ SET(p, ACTIVE); /* cube remains active */ SET(p, PRIME); /* cube remains prime ? */ } else { if (debug & REDUCE) { printf("REDUCE: %s to %s %s\n", pc1(p), pc2(cunder), print_time(ptime())); } set_copy(p, cunder); /* save reduced version */ RESET(p, PRIME); /* cube is no longer prime */ if (setp_empty(cunder)) RESET(p, ACTIVE); /* if null, kill the cube */ else SET(p, ACTIVE); /* cube is active */ } free_cube(cunder); }
void expand1_gasp(pset_family F, pset_family D, pset_family R, pset_family Foriginal, int c1index, pset_family *G) { register int c2index; register pset p, last, c2under; pset RAISE, FREESET, temp, *FD, c2essential; pset_family F1; if (debug & 0x0008) { printf("\nEXPAND1_GASP: \t%s\n", pc1(((F)->data + (F)->wsize * ( c1index)))); } RAISE = set_clear(((unsigned int *) malloc(sizeof(unsigned int) * ( ((cube.size) <= 32 ? 2 : (((((cube.size)-1) >> 5) + 1) + 1))))), cube.size); FREESET = set_clear(((unsigned int *) malloc(sizeof(unsigned int) * ( ((cube.size) <= 32 ? 2 : (((((cube.size)-1) >> 5) + 1) + 1))))), cube.size); temp = set_clear(((unsigned int *) malloc(sizeof(unsigned int) * ( ((cube.size) <= 32 ? 2 : (((((cube.size)-1) >> 5) + 1) + 1))))), cube.size); R->active_count = R->count; for( p=R->data, last= p+R->count*R->wsize; p< last; p+=R->wsize) { (p[0] |= ( 0x2000)); } F->active_count = F->count; for( c2under=F->data, c2index=0; c2index<F->count; c2under+=F->wsize, c2index++) { if (c1index == c2index || (c2under[0] & ( 0x8000))) { F->active_count--; (c2under[0] &= ~ ( 0x2000)); } else { (c2under[0] |= ( 0x2000)); } } (void) set_copy(RAISE, ((F)->data + (F)->wsize * ( c1index))); (void) set_diff(FREESET, cube.fullset, RAISE); essen_parts(R, F, RAISE, FREESET); essen_raising(R, RAISE, FREESET); for( c2under=F->data, c2index=0; c2index<F->count; c2under+=F->wsize, c2index++) { if ((c2under[0] & ( 0x2000))) { if (setp_implies(c2under, RAISE) || feasibly_covered(R, c2under, RAISE, temp)) { F1 = sf_save(Foriginal); (void) set_copy(((F1)->data + (F1)->wsize * ( c1index)), ((F)->data + (F)->wsize * ( c1index))); FD = cube2list(F1, D); c2essential = reduce_cube(FD, ((F1)->data + (F1)->wsize * ( c2index))); ((FD[0]) ? (free((char *) (FD[0])), (FD[0]) = 0) : 0); ((FD) ? (free((char *) (FD)), (FD) = 0) : 0);; sf_free(F1); if (feasibly_covered(R, c2essential, RAISE, temp)) { (void) set_or(temp, RAISE, c2essential); (temp[0] &= ~ ( 0x8000)); *G = sf_addset(*G, temp); } ((c2essential) ? (free((char *) (c2essential)), (c2essential) = 0) : 0); } } } ((RAISE) ? (free((char *) (RAISE)), (RAISE) = 0) : 0); ((FREESET) ? (free((char *) (FREESET)), (FREESET) = 0) : 0); ((temp) ? (free((char *) (temp)), (temp) = 0) : 0); }
static pset_family reduce_gasp(pset_family F, pset_family D) { pset p, last, cunder, *FD; pset_family G; G = sf_new(F->count, cube.size); FD = cube2list(F, D); for( p=F->data, last= p+F->count*F->wsize; p< last; p+=F->wsize) { cunder = reduce_cube(FD, p); if (setp_empty(cunder)) { fatal("empty reduction in reduce_gasp, shouldn't happen"); } else if (setp_equal(cunder, p)) { (cunder[0] |= ( 0x8000)); G = sf_addset(G, p); } else { (cunder[0] &= ~ ( 0x8000)); G = sf_addset(G, cunder); } if (debug & 0x0010) { printf("REDUCE_GASP: %s reduced to %s\n", pc1(p), pc2(cunder)); } ((cunder) ? (free((char *) (cunder)), (cunder) = 0) : 0); } ((FD[0]) ? (free((char *) (FD[0])), (FD[0]) = 0) : 0); ((FD) ? (free((char *) (FD)), (FD) = 0) : 0);; return G; }