int main(int argc, string argv[]) { string *datafields, *bodyfields, times, ifmt, rfmt; stream istr; bodyptr btab = NULL; int nbody; real tnow; string intags[MaxBodyFields]; initparam(argv, defv); istr = stropen(getparam("in"), "r"); get_history(istr); datafields = burststring(getparam("fields"), ", "); if (set_member(datafields, TimeTag)) bodyfields = set_diff(datafields, set_cons(TimeTag, NULL)); else bodyfields = datafields; layout_body(bodyfields, Precision, NDIM); times = getparam("times"); ifmt = getparam("ifmt"); rfmt = getparam("rfmt"); print_header(datafields, getparam("hfmt"), getparam("keyhead"), burststring(getparam("auxhead"), ", ")); while (get_snap_t(istr, &btab, &nbody, &tnow, intags, FALSE, times)) { if (! set_subset(intags, bodyfields)) error("%s: one or more required fields not found\n", getargv0()); print_data(btab, nbody, tnow, datafields, ifmt, rfmt); skip_history(istr); } return (0); }
int main(int argc, char *argv[]) { int i, size = 100, *x; struct set *s, *t, *u; if (argc > 1) size = atoi(argv[1]); srand(time(NULL)); s = set_create(size, sizeof(int), cmpint); t = set_create(size, sizeof(int), cmpint); if (s == NULL || t == NULL){ printf("Unable to create the test set\n"); return 1; } printf("Inserting into first set...\n"); for (i = 0; i < size; i++){ int y = rand() % size; printf("%d ", y); set_insert(s, &y); } printf("\n\n"); printf("The set contains:\n"); for (set_reset(s), x = set_next(s); x != NULL; x = set_next(s)) printf("%d ", *x); printf("\n\n"); printf("Inserting into second set...\n"); for (i = 0; i < size; i++){ int y = rand() % size; printf("%d ", y); set_insert(t, &y); } printf("\n\n"); printf("The set contains:\n"); for (set_reset(t), x = set_next(t); x != NULL; x = set_next(t)) printf("%d ", *x); printf("\n\n"); u = set_union(s, t); printf("The union of the two sets is:\n"); for (set_reset(u), x = set_next(u); x != NULL; x = set_next(u)) printf("%d ", *x); printf("\n\n"); set_destroy(u); u = set_diff(s, t); printf("The difference of the two sets is:\n"); for (set_reset(u), x = set_next(u); x != NULL; x = set_next(u)) printf("%d ", *x); printf("\n\n"); return 0; }
/* cofactor -- compute the cofactor of a cover with respect to a cube */ pcube *cofactor(pset *T, register pset c) { pcube temp = cube.temp[0], *Tc_save, *Tc, *T1; register pcube p; int listlen; listlen = CUBELISTSIZE(T) + 5; /* Allocate a new list of cube pointers (max size is previous size) */ Tc_save = Tc = ALLOC(pcube, listlen); /* pass on which variables have been cofactored against */ *Tc++ = set_or(new_cube(), T[0], set_diff(temp, cube.fullset, c)); Tc++; /* Loop for each cube in the list, determine suitability, and save */ for(T1 = T+2; (p = *T1++) != NULL; ) { if (p != c) { #ifdef NO_INLINE if (! cdist0(p, c)) goto false; #else {register int w,last;register unsigned int x;if((last=cube.inword)!=-1) {x=p[last]&c[last];if(~(x|x>>1)&cube.inmask)goto false;for(w=1;w<last;w++) {x=p[w]&c[w];if(~(x|x>>1)&DISJOINT)goto false;}}}{register int w,var,last; register pcube mask;for(var=cube.num_binary_vars;var<cube.num_vars;var++){ mask=cube.var_mask[var];last=cube.last_word[var];for(w=cube.first_word[var ];w<=last;w++)if(p[w]&c[w]&mask[w])goto nextvar;goto false;nextvar:;}} #endif *Tc++ = p; false: ; } }
range* range_from_diff(range_request* rr, const range* r1, const range* r2) { range* r3 = range_new(rr); apr_pool_t* pool = range_request_pool(rr); r3->nodes = set_diff(pool, r1->nodes, r2->nodes); r3->quoted = r1->quoted || r2->quoted; return r3; }
STATIC mp_obj_t set_binary_op(int op, mp_obj_t lhs, mp_obj_t rhs) { mp_obj_t args[] = {lhs, rhs}; switch (op) { case RT_BINARY_OP_OR: return set_union(lhs, rhs); case RT_BINARY_OP_XOR: return set_symmetric_difference(lhs, rhs); case RT_BINARY_OP_AND: return set_intersect(lhs, rhs); case RT_BINARY_OP_SUBTRACT: return set_diff(2, args); case RT_BINARY_OP_INPLACE_OR: return set_union(lhs, rhs); case RT_BINARY_OP_INPLACE_XOR: return set_symmetric_difference(lhs, rhs); case RT_BINARY_OP_INPLACE_AND: return set_intersect(lhs, rhs); case RT_BINARY_OP_INPLACE_SUBTRACT: return set_diff(2, args); case RT_BINARY_OP_LESS: return set_issubset_proper(lhs, rhs); case RT_BINARY_OP_MORE: return set_issuperset_proper(lhs, rhs); case RT_BINARY_OP_EQUAL: return set_equal(lhs, rhs); case RT_BINARY_OP_LESS_EQUAL: return set_issubset(lhs, rhs); case RT_BINARY_OP_MORE_EQUAL: return set_issuperset(lhs, rhs); case RT_BINARY_OP_NOT_EQUAL: return MP_BOOL(set_equal(lhs, rhs) == mp_const_false); case RT_BINARY_OP_IN: { mp_obj_set_t *o = lhs; mp_obj_t elem = mp_set_lookup(&o->set, rhs, MP_MAP_LOOKUP); return MP_BOOL(elem != NULL); } default: // op not supported return NULL; } }
void get_difficult(){ while(1){ int key = read_key(); if(key == 49){ set_diff(0); break; } else if(key == 50){ set_diff(1); break; } else if(key == 51){ set_diff(2); break; } else if(key == 52){ set_diff(3); break; } } }
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); }
/* else return FALSE. */ bool Is_Any_Connect(pcover WSS, pcover P) { register int i, ind; register pset q, x=new_cube(), r=new_cube(); int pos_p; foreachi_set(P, i, q){ ind = Get_Var_Ind(q, 0); set_copy(x, GETSET(WSS, ind)); set_diff(r, x, q); if (!setp_empty(r)) return TRUE; }
static bool primes_consensus_special_cases(pset *T, pset_family *Tnew) /* will be disposed if answer is determined */ /* returned only if answer determined */ { register pcube *T1, p, ceil, cof=T[0]; pcube last; pcover A; /* Check for no cubes in the cover */ if (T[2] == NULL) { *Tnew = new_cover(0); free_cubelist(T); return TRUE; } /* Check for only a single cube in the cover */ if (T[3] == NULL) { *Tnew = sf_addset(new_cover(1), set_or(cof, cof, T[2])); free_cubelist(T); return TRUE; } /* Check for a row of all 1's (implies function is a tautology) */ for(T1 = T+2; (p = *T1++) != NULL; ) { if (full_row(p, cof)) { *Tnew = sf_addset(new_cover(1), cube.fullset); free_cubelist(T); return TRUE; } } /* Check for a column of all 0's which can be factored out */ ceil = set_save(cof); for(T1 = T+2; (p = *T1++) != NULL; ) { INLINEset_or(ceil, ceil, p); } if (! setp_equal(ceil, cube.fullset)) { p = new_cube(); (void) set_diff(p, cube.fullset, ceil); (void) set_or(cof, cof, p); free_cube(p); A = primes_consensus(T); foreach_set(A, last, p) { INLINEset_and(p, p, ceil); }
void checktags(string *otags, string *produce) { string *missing, *mp; char buf[512]; missing = set_diff(produce, otags); if (set_length(missing) > 0) { buf[0] = (char) NULL; for (mp = missing; *mp != NULL; mp++) { if (mp != missing) strcat(buf, ","); strcat(buf, *mp); } error("%s: missing %s data\n", getargv0(), buf); } free(missing); }
SEXP checkVars(SEXP DT, SEXP id, SEXP measure, Rboolean verbose) { int i, ncol=LENGTH(DT), targetcols=0, protecti=0, u=0, v=0; SEXP thiscol, idcols = R_NilValue, valuecols = R_NilValue, tmp, booltmp, unqtmp, ans; SEXP dtnames = getAttrib(DT, R_NamesSymbol); if (isNull(id) && isNull(measure)) { for (i=0; i<ncol; i++) { thiscol = VECTOR_ELT(DT, i); if ((isInteger(thiscol) || isNumeric(thiscol) || isLogical(thiscol)) && !isFactor(thiscol)) targetcols++; } PROTECT(idcols = allocVector(INTSXP, ncol-targetcols)); protecti++; PROTECT(valuecols = allocVector(INTSXP, targetcols)); protecti++; for (i=0; i<ncol; i++) { thiscol = VECTOR_ELT(DT, i); if ((isInteger(thiscol) || isNumeric(thiscol) || isLogical(thiscol)) && !isFactor(thiscol)) { INTEGER(valuecols)[u++] = i+1; } else INTEGER(idcols)[v++] = i+1; } warning("To be consistent with reshape2's melt, id.vars and measure.vars are internally guessed when both are 'NULL'. All non-numeric/integer/logical type columns are conisdered id.vars, which in this case are columns '%s'. Consider providing at least one of 'id' or 'measure' vars in future.", CHAR(STRING_ELT(concat(dtnames, idcols), 0))); } else if (!isNull(id) && isNull(measure)) { switch(TYPEOF(id)) { case STRSXP : PROTECT(tmp = chmatch(id, dtnames, 0, FALSE)); protecti++; break; case REALSXP : PROTECT(tmp = coerceVector(id, INTSXP)); protecti++; break; case INTSXP : PROTECT(tmp = id); protecti++; break; default : error("Unknown 'id.var' type %s, must be character or integer vector", type2char(TYPEOF(id))); } PROTECT(booltmp = duplicated(tmp, FALSE)); protecti++; for (i=0; i<length(tmp); i++) { if (INTEGER(tmp)[i] <= 0) error("Column '%s' not found in 'data'", CHAR(STRING_ELT(id, i))); else if (INTEGER(tmp)[i] > ncol) error("id.var value exceeds ncol(data)"); else if (!LOGICAL(booltmp)[i]) targetcols++; else continue; } PROTECT(unqtmp = allocVector(INTSXP, targetcols)); protecti++; u = 0; for (i=0; i<length(booltmp); i++) { if (!LOGICAL(booltmp)[i]) { INTEGER(unqtmp)[u++] = INTEGER(tmp)[i]; } } PROTECT(valuecols = set_diff(unqtmp, ncol)); protecti++; PROTECT(idcols = tmp); protecti++; if (verbose) Rprintf("'measure.var' is missing. Assigning all columns other than 'id.var' columns which are %s as 'measure.var'.\n", CHAR(STRING_ELT(concat(dtnames, idcols), 0))); } else if (isNull(id) && !isNull(measure)) { switch(TYPEOF(measure)) { case STRSXP : PROTECT(tmp = chmatch(measure, dtnames, 0, FALSE)); protecti++; break; case REALSXP : PROTECT(tmp = coerceVector(measure, INTSXP)); protecti++; break; case INTSXP : PROTECT(tmp = measure); protecti++; break; default : error("Unknown 'measure.var' type %s, must be character or integer vector", type2char(TYPEOF(measure))); } PROTECT(booltmp = duplicated(tmp, FALSE)); protecti++; for (i=0; i<length(tmp); i++) { if (INTEGER(tmp)[i] <= 0) error("Column '%s' not found in 'data'", CHAR(STRING_ELT(id, i))); else if (INTEGER(tmp)[i] > ncol) error("measure.var value exceeds ncol(data)"); else if (!LOGICAL(booltmp)[i]) targetcols++; else continue; } PROTECT(unqtmp = allocVector(INTSXP, targetcols)); protecti++; u = 0; for (i=0; i<length(booltmp); i++) { if (!LOGICAL(booltmp)[i]) { INTEGER(unqtmp)[u++] = INTEGER(tmp)[i]; } } PROTECT(idcols = set_diff(unqtmp, ncol)); protecti++; PROTECT(valuecols = tmp); protecti++; if (verbose) Rprintf("'id.var' is missing. Assigning all columns other than 'measure.var' columns as 'id.var'. Assigned 'id.var's are %s.\n", CHAR(STRING_ELT(concat(dtnames, idcols), 0))); } else if (!isNull(id) && !isNull(measure)) { switch(TYPEOF(id)) { case STRSXP : PROTECT(tmp = chmatch(id, dtnames, 0, FALSE)); protecti++; break; case REALSXP : PROTECT(tmp = coerceVector(id, INTSXP)); protecti++; break; case INTSXP : PROTECT(tmp = id); protecti++; break; default : error("Unknown 'id.var' type %s, must be character or integer vector", type2char(TYPEOF(id))); } for (i=0; i<length(tmp); i++) { if (INTEGER(tmp)[i] <= 0) error("Column '%s' or not found in 'data'", CHAR(STRING_ELT(id, i))); else if (INTEGER(tmp)[i] > ncol) error("measure.var value exceeds ncol(data)"); } PROTECT(idcols = allocVector(INTSXP, length(tmp))); protecti++; idcols = tmp; switch(TYPEOF(measure)) { case STRSXP : PROTECT(tmp = chmatch(measure, dtnames, 0, FALSE)); protecti++; break; case REALSXP : PROTECT(tmp = coerceVector(measure, INTSXP)); protecti++; break; case INTSXP : PROTECT(tmp = measure); protecti++; break; default : error("Unknown 'measure.var' type %s, must be character or integer vector", type2char(TYPEOF(measure))); } for (i=0; i<length(tmp); i++) { if (INTEGER(tmp)[i] <= 0) error("Column '%s' not found in 'data'", CHAR(STRING_ELT(id, i))); else if (INTEGER(tmp)[i] > ncol) error("measure.var value exceeds ncol(data)"); } PROTECT(valuecols = allocVector(INTSXP, length(measure))); protecti++; valuecols = tmp; } PROTECT(ans = allocVector(VECSXP, 2)); protecti++; SET_VECTOR_ELT(ans, 0, idcols); SET_VECTOR_ELT(ans, 1, valuecols); UNPROTECT(protecti); return(ans); }
#include "dryad_treap.h" _(logic \bool mutable_treap(BNode * x) = x != NULL ==> \mutable(x) && \writable(x)) _(dryad) BNode * treap_remove_root_rec(BNode * x) _(requires x != NULL) _(requires treap(x)) _(requires \intset_lt(treap_keys(x->left), treap_keys(x->right))) _(requires \intset_disjoint(treap_prios(x->left), treap_prios(x->right))) _(requires \intset_disjoint(treap_keys(x->left), treap_keys(x->right))) _(ensures treap(\result)) _(ensures \intset_subset(treap_prios(\result), \old(treap_prios(x)))) _(ensures treap_reach(\result) == \oset_diff(\old(treap_reach(x)), \oset_singleton(x))) _(ensures treap_keys(\result) == \intset_diff(\old(treap_keys(x)), \intset_singleton(x->key))) _(ensures treap_keys(\result) == \intset_union(\old(treap_keys(x->left)), \old(treap_keys(x->right)))) _(ensures treap_prios(\result) == \intset_union(\old(treap_prios(x->left)), \old(treap_prios(x->right)))) { _(assume mutable_treap(x)) _(assume \malloc_root(x)) if(x->left == NULL && x->right == NULL) { free(x); return NULL; } else if (x->left == NULL) { BNode * right = x->right; free(x); return right; } else if (x->right == NULL) { BNode * left = x->left; free(x); return left;
int main(void) { char player1 = CROSS; char player2 = NOUGHT; char winner; char currnt_player = player1; char board[NUM_ALL]; char *br; bool ended = false; int nrounds = 0; int mode; int wplayer1 = 0; int wplayer2 = 0; int nreplays = 0; int nstalemates = 0; mode = select_mode(); if (mode == 1) { max_depth = set_diff(); } while (!ended) { if (nrounds == 0) { for (int i = 0; i < NUM_ALL; ++i) { board[i] = ' '; } br = &board[0]; simulate(br); } if (mode == 1) { if (currnt_player == player1) { human_turn(br, currnt_player, &nrounds); } else { computer_turn(br, player1, currnt_player, &nrounds); } } else { if (currnt_player == player1) { human_turn(br, currnt_player, &nrounds); } else { human_turn(br, currnt_player, &nrounds); } } currnt_player = player_next(currnt_player, player1, player2); simulate(br); winner = game_winner(br, player1, player2); ended = game_ended(winner, nrounds); if (ended) { ++nreplays; if (winner == player1) { ++wplayer1; } else if (winner == player2) { ++wplayer2; } else { ++nstalemates; } rover_stats(winner, player1, player2, wplayer1, wplayer2, nreplays, nstalemates, mode); if (restart()) { if (winner == CROSS) { if (player1 == CROSS) { currnt_player = player1; } else { currnt_player = player2; } } else if (winner == NOUGHT) { if (player1 == NOUGHT) { player1 = CROSS; player2 = NOUGHT; currnt_player = player1; } else { player1 = NOUGHT; player2 = CROSS; currnt_player = player2; } } else { if (player1 == CROSS) { currnt_player = player1; } else { currnt_player = player2; } } nround_announce(winner, player1, player2, currnt_player); nrounds = 0; winner = NO_MATCH; ended = false; } else { gover_stats(wplayer1, wplayer2, nreplays, nstalemates, mode); } } } return 0; }
static bool compl_special_cases(set **T, set_family_t **Tbar) { set **T1, *p, *ceil, *cof=T[0]; set_family_t *A, *ceil_compl; // Check for no cubes in the cover if (T[2] == NULL) { *Tbar = sf_addset(sf_new(1, CUBE.size), CUBE.fullset); free_cubelist(T); return TRUE; } // Check for only a single cube in the cover if (T[3] == NULL) { *Tbar = compl_cube(set_or(cof, cof, T[2])); free_cubelist(T); return TRUE; } // Check for a row of all 1's (implies complement is null) for (T1 = T+2; (p = *T1++) != NULL; ) { if (full_row(p, cof)) { *Tbar = sf_new(0, CUBE.size); free_cubelist(T); return TRUE; } } // Check for a column of all 0's which can be factored out ceil = set_save(cof); for (T1 = T+2; (p = *T1++) != NULL; ) { set_or(ceil, ceil, p); } if (! setp_equal(ceil, CUBE.fullset)) { ceil_compl = compl_cube(ceil); set_or(cof, cof, set_diff(ceil, CUBE.fullset, ceil)); set_free(ceil); *Tbar = sf_append(complement(T), ceil_compl); return TRUE; } set_free(ceil); // Collect column counts, determine unate variables, etc. massive_count(T); // If single active variable not factored out above, then tautology! if (CDATA.vars_active == 1) { *Tbar = sf_new(0, CUBE.size); free_cubelist(T); return TRUE; // Check for unate cover } else if (CDATA.vars_unate == CDATA.vars_active) { A = map_cover_to_unate(T); free_cubelist(T); A = unate_compl(A); *Tbar = map_unate_to_cover(A); sf_free(A); return TRUE; // Not much we can do about it } else { return MAYBE; } }
std::list<int> notExplored(int size) { std::list<int> range(size); std::iota(range.begin(), range.end(), 0); return set_diff(range, _shortTermMemory); }
void viewer_rt::load_xyz (boost::shared_ptr<pcl::PointCloud<pcl::PointXYZ> > cloud,int window, bool diff_in){ //Check if the cloud is empty if (cloud->empty ()) return; if (window > 4) window=4; if (diff_in) set_diff (); //Fork the program pid = fork(); vector_pid.push_back(pid); name_process.push_back("LOAD_XYZ"); if (pid == -1) std::cout << "[VIEWER_RT] ERROR MAKING FORK" << std::endl; //Child process else if (pid == 0) { if (vector_pid.size () >1) waitpid(vector_pid[vector_pid.size ()-1],&status,0); //Set pipe message int request=LOAD_XYZ_CLOUD+window; //Objects pcl::PCDWriter writer; //Request resources operation.sem_num = WRITE_PCD; operation.sem_op = -1; semop(semid,&operation,1); //Solicitation issued write(pipe_flags[1], &request, 1); writer.write<pcl::PointXYZ> ("temp.pcd", *cloud, false); //Request for the resorces of viewer operation.sem_num = 5; operation.sem_op = 1; semop(semid,&operation,1); //Wait for the load operation.sem_num = REQUEST_LOAD_CLOUD; operation.sem_op = -1; semop(semid,&operation,1); //Freeing resources operation.sem_num = WRITE_PCD; operation.sem_op = 1; semop(semid,&operation,1); //End execution exit(EXIT_SUCCESS); } return; }
static bool compl_special_cases(pset *T, pset_family *Tbar) /* will be disposed if answer is determined */ /* returned only if answer determined */ { register pcube *T1, p, ceil, cof=T[0]; pcover A, ceil_compl; /* Check for no cubes in the cover */ if (T[2] == NULL) { *Tbar = sf_addset(new_cover(1), cube.fullset); free_cubelist(T); return TRUE; } /* Check for only a single cube in the cover */ if (T[3] == NULL) { *Tbar = compl_cube(set_or(cof, cof, T[2])); free_cubelist(T); return TRUE; } /* Check for a row of all 1's (implies complement is null) */ for(T1 = T+2; (p = *T1++) != NULL; ) { if (full_row(p, cof)) { *Tbar = new_cover(0); free_cubelist(T); return TRUE; } } /* Check for a column of all 0's which can be factored out */ ceil = set_save(cof); for(T1 = T+2; (p = *T1++) != NULL; ) { INLINEset_or(ceil, ceil, p); } if (! setp_equal(ceil, cube.fullset)) { ceil_compl = compl_cube(ceil); (void) set_or(cof, cof, set_diff(ceil, cube.fullset, ceil)); set_free(ceil); *Tbar = sf_append(complement(T), ceil_compl); return TRUE; } set_free(ceil); /* Collect column counts, determine unate variables, etc. */ massive_count(T); /* If single active variable not factored out above, then tautology ! */ if (cdata.vars_active == 1) { *Tbar = new_cover(0); free_cubelist(T); return TRUE; /* Check for unate cover */ } else if (cdata.vars_unate == cdata.vars_active) { A = map_cover_to_unate(T); free_cubelist(T); A = unate_compl(A); *Tbar = map_unate_to_cover(A); sf_free(A); return TRUE; /* Not much we can do about it */ } else { return MAYBE; } }
pointer operator->() const { set_diff(); return &m_diff; }
STATIC mp_obj_t set_binary_op(mp_binary_op_t op, mp_obj_t lhs, mp_obj_t rhs) { mp_obj_t args[] = {lhs, rhs}; #if MICROPY_PY_BUILTINS_FROZENSET bool update = MP_OBJ_IS_TYPE(lhs, &mp_type_set); #else bool update = true; #endif if (op != MP_BINARY_OP_CONTAINS && !is_set_or_frozenset(rhs)) { // For all ops except containment the RHS must be a set/frozenset return MP_OBJ_NULL; } switch (op) { case MP_BINARY_OP_OR: return set_union(lhs, rhs); case MP_BINARY_OP_XOR: return set_symmetric_difference(lhs, rhs); case MP_BINARY_OP_AND: return set_intersect(lhs, rhs); case MP_BINARY_OP_SUBTRACT: return set_diff(2, args); case MP_BINARY_OP_INPLACE_OR: if (update) { set_update(2, args); return lhs; } else { return set_union(lhs, rhs); } case MP_BINARY_OP_INPLACE_XOR: if (update) { set_symmetric_difference_update(lhs, rhs); return lhs; } else { return set_symmetric_difference(lhs, rhs); } case MP_BINARY_OP_INPLACE_AND: rhs = set_intersect_int(lhs, rhs, update); if (update) { return lhs; } else { return rhs; } case MP_BINARY_OP_INPLACE_SUBTRACT: return set_diff_int(2, args, update); case MP_BINARY_OP_LESS: return set_issubset_proper(lhs, rhs); case MP_BINARY_OP_MORE: return set_issuperset_proper(lhs, rhs); case MP_BINARY_OP_EQUAL: return set_equal(lhs, rhs); case MP_BINARY_OP_LESS_EQUAL: return set_issubset(lhs, rhs); case MP_BINARY_OP_MORE_EQUAL: return set_issuperset(lhs, rhs); case MP_BINARY_OP_CONTAINS: { mp_obj_set_t *o = MP_OBJ_TO_PTR(lhs); mp_obj_t elem = mp_set_lookup(&o->set, rhs, MP_MAP_LOOKUP); return mp_obj_new_bool(elem != MP_OBJ_NULL); } default: return MP_OBJ_NULL; // op not supported } }
void test_set(void) { int i; void* S = set_create(100, NULL, NULL); fprintf(stdout, "call function : %s\n", __func__); set_object(S); fprintf(stdout, "\ntest function - set_insert ===>\n"); { srand((unsigned int)time(0)); for (i = 0; i < 5; ++i) { double* d = (double*)malloc(sizeof(double)); *d = (i + 1) * rand() % 1000 * 0.456; fprintf(stdout, "\tinsert {object=>0x%p, vlaue=>%.3f}\n", d, *d); set_insert(S, d); } set_object(S); set_for_each(S, set_member_show_double, NULL); set_for_each(S, set_member_destroy, NULL); set_object(S); set_clear(S); } set_object(S); fprintf(stdout, "\ntest function - set_remove ===>\n"); { double* remove_member = NULL; srand((unsigned int)time(0)); for (i = 0; i < 5; ++i) { double* d = (double*)malloc(sizeof(double)); *d = (i + 1) * rand() % 1000 * 0.456; fprintf(stdout, "\tinsert {object=>0x%p, vlaue=>%.3f}\n", d, *d); set_insert(S, d); if (0 == i) remove_member = d; } set_object(S); set_for_each(S, set_member_show_double, NULL); set_remove(S, remove_member); set_object(S); set_for_each(S, set_member_show_double, NULL); set_for_each(S, set_member_destroy, NULL); set_object(S); set_clear(S); } set_object(S); fprintf(stdout, "\ntest function - set_release ===>\n"); set_release(&S); set_object(S); fprintf(stdout, "\n\ntest function - set operations ===>\n"); { void* s = set_create(100, NULL, NULL); void* t = set_create(100, NULL, NULL); void* oper_s; for (i = 0; i < 7; ++i) { double* d = (double*)malloc(sizeof(double)); *d = (i + 1) * (i + 1) * 0.234; fprintf(stdout, "\tinsert s {object=>0x%p, value=>%.3f}\n", d, *d); if (i < 5) set_insert(s, d); set_insert(t, d); } fprintf(stdout, " show 's' set object:\n"); set_object(s); set_for_each(s, set_member_show_double, NULL); fprintf(stdout, " show 't' set object:\n"); set_object(t); set_for_each(t, set_member_show_double, NULL); /* set_union */ fprintf(stdout, " test function - set_union ===>\n"); oper_s = set_union(NULL, t); fprintf(stdout, " s = NULL, t = t:\n"); set_object(oper_s); set_for_each(oper_s, set_member_show_double, NULL); set_clear(oper_s); set_release(&oper_s); fprintf(stdout, " after release union(s=NULL,t=t):\n"); set_object(oper_s); /* *** */ oper_s = set_union(s, NULL); fprintf(stdout, " s = s, t = NULL:\n"); set_object(oper_s); set_for_each(oper_s, set_member_show_double, NULL); set_clear(oper_s); set_release(&oper_s); fprintf(stdout, " after release union(s=s,t=NULL):\n"); set_object(oper_s); /* *** */ oper_s = set_union(s, t); fprintf(stdout, " s = s, t = t:\n"); set_object(oper_s); set_for_each(oper_s, set_member_show_double, NULL); set_clear(oper_s); set_release(&oper_s); fprintf(stdout, " after release union(s=s,t=t):\n"); set_object(oper_s); /* set_inter */ fprintf(stdout, " test function - set_inter ===>\n"); oper_s = set_inter(NULL, t); fprintf(stdout, " s = NULL, t = t:\n"); set_object(oper_s); set_for_each(oper_s, set_member_show_double, NULL); set_clear(oper_s); set_release(&oper_s); fprintf(stdout, " after release inter(s=NULL,t=t):\n"); set_object(oper_s); /* *** */ oper_s = set_inter(s, NULL); fprintf(stdout, " s = s, t = NULL:\n"); set_object(oper_s); set_for_each(oper_s, set_member_show_double, NULL); set_clear(oper_s); set_release(&oper_s); fprintf(stdout, " after release inter(s=s,t=NULL):\n"); set_object(oper_s); /* *** */ oper_s = set_inter(s, t); fprintf(stdout, " s = s, t = t:\n"); set_object(oper_s); set_for_each(oper_s, set_member_show_double, NULL); set_clear(oper_s); set_release(&oper_s); fprintf(stdout, " after release inter(s=s,t=t):\n"); set_object(oper_s); /* set_minus */ fprintf(stdout, " test function - set_minus ===>\n"); oper_s = set_minus(NULL, t); fprintf(stdout, " s = NULL, t = t:\n"); set_object(oper_s); set_for_each(oper_s, set_member_show_double, NULL); set_clear(oper_s); set_release(&oper_s); fprintf(stdout, " after release minus(s=NULL,t=t):\n"); set_object(oper_s); /* *** */ oper_s = set_minus(s, NULL); fprintf(stdout, " s = s, t = NULL:\n"); set_object(oper_s); set_for_each(oper_s, set_member_show_double, NULL); set_clear(oper_s); set_release(&oper_s); fprintf(stdout, " after release minus(s=s,t=NULL):\n"); set_object(oper_s); /* *** */ oper_s = set_minus(s, t); fprintf(stdout, " s = s, t = t:\n"); set_object(oper_s); set_for_each(oper_s, set_member_show_double, NULL); set_clear(oper_s); set_release(&oper_s); fprintf(stdout, " after release minus(s=s,t=t):\n"); set_object(oper_s); /* set_diff */ fprintf(stdout, " test function - set_diff ===>\n"); oper_s = set_diff(NULL, t); fprintf(stdout, " s = NULL, t = t:\n"); set_object(oper_s); set_for_each(oper_s, set_member_show_double, NULL); set_clear(oper_s); set_release(&oper_s); fprintf(stdout, " after release diff(s=NULL,t=t):\n"); set_object(oper_s); /* *** */ oper_s = set_diff(s, NULL); fprintf(stdout, " s = s, t = NULL:\n"); set_object(oper_s); set_for_each(oper_s, set_member_show_double, NULL); set_clear(oper_s); set_release(&oper_s); fprintf(stdout, " after release diff(s=s,t=NULL):\n"); set_object(oper_s); /* *** */ oper_s = set_diff(s, t); fprintf(stdout, " s = s, t = t:\n"); set_object(oper_s); set_for_each(oper_s, set_member_show_double, NULL); set_clear(oper_s); set_release(&oper_s); fprintf(stdout, " after release diff(s=s,t=t):\n"); set_object(oper_s); fprintf(stdout, " release 's' and 't' object:\n"); set_for_each(t, set_member_destroy, NULL); set_clear(s); set_clear(t); set_release(&s); set_release(&t); fprintf(stdout, " show 's' set object:\n"); set_object(s); fprintf(stdout, " show 't' set object:\n"); set_object(t); } }
void test(string args) { args = splitArg(args, 1); if(streql(args, "") || streql(args, "-H")) { print("\nThis file is in charge of testing the data types embedded in Q-OS.",black); print("\nAccepted Arguments:\n-list\tTests the list.c file\n-set \ttests the set.c file", black); print("\n-strb\ttests the strbuilder.c file\n-y \tshould return the current year...",black); } else if(streql(args, "-LIST"))//For testing lists { newline(); list_t test_list = list_init(); test_list.autoShrink = true; for(uint8 i = 0; i < 4; i++) { list_add(&test_list, "1"); list_add(&test_list, "2"); list_add(&test_list, "3"); list_add(&test_list, "4"); list_add(&test_list, "5"); list_add(&test_list, "6"); list_add(&test_list, "7"); list_add(&test_list, "8"); list_add(&test_list, "9"); list_add(&test_list, "10"); list_add(&test_list, "11"); list_add(&test_list, "12"); list_add(&test_list, "13"); list_add(&test_list, "14"); list_add(&test_list, "15"); list_add(&test_list, "16"); } list_add(&test_list, "Pointless"); println("Done sizing up", white); printint(test_list.capt, white); element_t t; for(uint8 i = 0; i < 64; i++) { t = list_shift(&test_list); } println("\nLast item deleted should be \"16\"", white); println(t.udata.strdata, white); println("\nDeleting all but element \"Pointless\"", white); for(uint8 i = 0; i < test_list.size; i++) { println(list_get(test_list, i), white); } println("Done resizing up", white); printint(test_list.capt, white); list_destroy(&test_list); } else if(streql(args,"-SET")) { set_t test_set = set_init(); for(uint8 i = 0; i < 4; i++) { set_add(&test_set, "0"); set_add(&test_set, "1"); set_add(&test_set, "2"); set_add(&test_set, "3"); set_add(&test_set, "4"); set_add(&test_set, "5"); set_add(&test_set, "6"); set_add(&test_set, "7"); set_add(&test_set, "8"); set_add(&test_set, "9"); set_add(&test_set, "10"); set_add(&test_set, "11"); set_add(&test_set, "12"); set_add(&test_set, "13"); set_add(&test_set, "14"); set_add(&test_set, "15"); set_add(&test_set, "16"); print("\nIteration: ", white); printint(i, white); } println("\n\nInsertion::Output should be 17", white); printint(test_set.size, white); set_t tmp = set_init(); set_add(&tmp, "Union item"); set_union(&test_set, &tmp); println("\n\nUnion::Output should be 18", white); printint(test_set.size, white); set_intersect(&test_set, &tmp); println("\n\nIntersect::Output should be 1", white); printint(test_set.size, white); println("\n\nPreparing for diff test", white); set_add(&test_set, "1"); set_add(&test_set, "2"); set_add(&test_set, "3"); set_add(&tmp, "2"); set_add(&tmp, "3"); set_add(&tmp, "4"); set_diff(&test_set, &tmp); println("Diff::Output should be 2", white); printint(test_set.size, white); set_destroy(&tmp); set_destroy(&test_set); } else if(streql(args, "-STRB")) { static const string bak = "Hello, world "; static const uint32 bln = 13; strbuilder_t test_strb = strbuilder_init(); strbuilder_append(&test_strb, bak); strbuilder_append(&test_strb, "Hello, 2nd world"); println("\nTesting backup text. Output should 1", red); printint(streql(bak, test_strb.prevTxt), green); println("\nOutput should be \"Hello, world Hello, 2nd world\"", red); println(strbuilder_tostr(test_strb), green); println("\nRemoving greeters from first world", red); strbuilder_delete(&test_strb, 0, bln); println("\nOutput should be \"Hello, 2nd world\"", red); println(strbuilder_tostr(test_strb), green); strbuilder_flip(&test_strb); println("\nOutput should be \"dlrow dn2 ,olleH\"", red); println(strbuilder_tostr(test_strb), green); list_t tmp = strbuilder_split(test_strb, " "); println("\nOutput should be last str split by spaces", red); for(uint8 i = 0; i < tmp.size; i++) { println(list_get(tmp, i), white); } list_destroy(&tmp); strbuilder_destroy(&test_strb); } else if(streql(args,"-Y")) { //getTime() test printint(getTime("year"),white); } }
void setCover(Universe *Uni,int num_houses) { Heap *Q = createHeap(); set_t *covered = create_set(num_houses); for(int i=0;i<Uni->size_of_universe;i++) { insert_in_heap(Q,i,Uni->sets[i].covered_items,max_func); } while(covered->covered_items < num_houses) { if(isEmpty(Q)) { break; } HeapItem max = removeTop(Q,max_func); //updating the covered set for(int i=0;i<Uni->sets[max.dataIndex].covered_items;i++) { //if its not covered if(!covered->set[Uni->sets[max.dataIndex].set[i]]) { //set to the house being covered covered->set[Uni->sets[max.dataIndex].set[i]] = 1; //increment number of covered houses covered->covered_items++; } } //flag the current set to be covered Uni->sets[max.dataIndex].covered = 1; //update the other sets for(int i=0;i<Uni->size_of_universe;i++) { //if they are not already covered if(!Uni->sets[i].covered) { //find set diff and update the heap int diff = set_diff(&Uni->sets[i],covered); changeKey(Q,i,diff,max_func); } } } if(covered->covered_items < num_houses) { fprintf(stderr, "Not enough houses to cover all houses.\n"); exit(EXIT_FAILURE); } for(int i=0; i<Uni->size_of_universe;i++) { if(Uni->sets[i].covered) { printf("%d\n",i); } } destroyHeap(Q); free_set(covered); free_Universe(Uni); }
reference operator*() const { set_diff(); return m_diff; }