int count_nodes(item* root){ if(!root) return 0; if(!root->left && !root->right) return 1; return 1 + count_nodes(root->left) + count_nodes(root->right); }
unsigned int redblacktree::count_nodes(const rbtnode *start)const{ //Rekurencyjne zliczanie ilosci wezlow unsigned int counter = 0; if(start!=this->getsentinel()){ counter = 1+ count_nodes(start->getleft()) + count_nodes(start->getright()); } return counter; }
void count_nodes(TreeNode *X, int *counter){ if(X == NULL){ return; } count_nodes(X->right_sibling, counter); //printf("%d ", X->item); (*counter) ++; count_nodes(X->first_child, counter); }
static size_t count_nodes(struct mtree_trie_node *u) { size_t count; count = 0; if (u->left != NULL && u->left->bit > u->bit) count += count_nodes(u->left); if (u->right != NULL && u->right->bit > u->bit) count += count_nodes(u->right); return (count + 1); }
void count_nodes_local(){ uint16_t local_node_count=0; node_ptr start; start=get_root(); local_node_count=count_nodes(start); printf("number of keys: %d\n",local_node_count); }
int imbalanced_p(item* root){ /* * If the tree is left side heavy, this returns -1 * If the tree is right side heavy, this return 1 * If balanced, returns 0 */ if(!root) return 0; int left = count_nodes(root->left); int right = count_nodes(root->right); if(left > (right+1)) return -1; if(right > (left+1)) return 1; return 0; }
/* * Count number of items in the tree. */ size_t mtree_trie_count(struct mtree_trie *trie) { assert(trie != NULL); return (trie->top->left == trie->top ? 0 : count_nodes(trie->top->left)); }
void get_avg_local(){ uint16_t total; uint16_t count; uint16_t avg; total=get_total(get_root()); count=count_nodes(get_root()); avg=total/count; printf("the average is : %d\n",avg); }
int tree::count_nodes(node* n) { for (int i = 0; i < n->childs.size(); ++i) { ++node_num; count_nodes(n->childs[i]); } return 1; }
/*================================================= * count_nodes -- count descendent nodes *===============================================*/ static void count_nodes (NODE node, INT gen, INT maxgen, INT * count) { (*count)++; if (gen < maxgen) { NODE child; for (child = nchild(node); child; child = nsibling(child)) { count_nodes(child, gen+1, maxgen, count); } } }
/*========================================================= * pedigree_draw_gedcom -- print out gedcom node tree * Created: 2001/01/27, Perry Rapp *=======================================================*/ void pedigree_draw_gedcom (RECORD rec, INT gdvw, CANVASDATA canvas, BOOLEAN reuse) { INT count=0, gen=0, row=canvas->rect->top; INT indent = get_indent(); if (gdvw == GDVW_TEXT) { draw_gedcom_text(rec, canvas, reuse, indent); return; } count_nodes(nztop(rec), gen, Gens, &count); set_scroll_max(canvas, count); check_scroll_max(canvas); /* preorder traversal */ trav_pre_print_nod(nztop(rec), &row, gen, indent, canvas, gdvw); }
void display_list(_node *head) { int value = 1; _node *temp = head; if(head == NULL) { printf("nothing to display"); return; } else { printf("displaying the list\n"); while(head) { printf("value of node value %d = %d\n",value,head->value); head = head->next; value++; } int count = count_nodes(temp); printf(" number of nodes = %d\n",count); return; } }
struct network * check_repeated_nodes(struct network *newlist,struct network *oldlist) { #ifdef DEBUG printf("Entering function: check_repeated_nodes\n"); #endif struct network * oldnode; struct network * newnode; struct network * checknode; //1 _WE GET THE ADDRESS OF THE NODE WITH THE SAME MAC oldnode = oldlist; while (oldnode!= NULL) { //WE SEARCH BY MAC, "checknode" checknode = search_mac(newlist,oldnode->info->mac); //IN CASE WE CAN'T FIND A REPEATED NODE => INSERT if(checknode==NULL) { newnode = create_node(oldnode->info, count_nodes(newlist) + 1); newlist = insert_node(newnode,newlist); newlist = sort(newlist); //CHANGES WERE MADE data_changed = 1; } else { #ifdef DEBUG printf("Repeated Node, won't be inserted\n"); #endif } oldnode = oldnode->next; } //4 _ RETURN THE LIST WITH THE NODES INSERTED #ifdef DEBUG printf("Exiting function: check_repeated_nodes\n"); #endif return newlist; }
str_grid_node_data_t* str_grid_node_data_with_buffer(str_grid_t* grid, int num_components, void* buffer) { ASSERT(num_components > 0); // Allocate storage. int num_patches = str_grid_num_patches(grid); size_t patches_size = sizeof(str_grid_patch_t*) * num_patches; size_t node_data_size = sizeof(str_grid_node_data_t) + patches_size; str_grid_node_data_t* node_data = polymec_malloc(node_data_size); node_data->grid = grid; node_data->nc = num_components; str_grid_get_extents(grid, &node_data->nx, &node_data->ny, &node_data->nz); node_data->patches = int_ptr_unordered_map_new(); node_data->patch_offsets = polymec_malloc(sizeof(int) * (num_patches+1)); node_data->buffer = NULL; // Now populate the patches (with NULL buffers). int px, py, pz; str_grid_get_patch_size(grid, &px, &py, &pz); node_data->patch_lx = 1.0 / node_data->nx; node_data->patch_ly = 1.0 / node_data->ny; node_data->patch_lz = 1.0 / node_data->nz; int pos = 0, i, j, k, l = 0; while (str_grid_next_patch(grid, &pos, &i, &j, &k)) { int index = patch_index(node_data, i, j, k); int_ptr_unordered_map_insert_with_v_dtor(node_data->patches, index, str_grid_patch_with_buffer(px+1, py+1, pz+1, num_components, 0, NULL), DTOR(str_grid_patch_free)); ++l; } count_nodes(node_data); // Set the buffer. str_grid_node_data_set_buffer(node_data, buffer, false); return node_data; }
/* * return a relative path from @from to @to * result should be freed */ char * relative_path_to(char *from, char *to, int *err) { int from_nodes, common; char *to_absolute, *from_absolute; char *up, *common_target_path, *relative_path; *err = 0; up = NULL; to_absolute = NULL; from_absolute = NULL; relative_path = NULL; if (strnlen(to, MAX_NAME_LEN) == MAX_NAME_LEN || strnlen(from, MAX_NAME_LEN) == MAX_NAME_LEN) { EPRINTF("invalid input; max path length is %d\n", MAX_NAME_LEN); *err = -ENAMETOOLONG; return NULL; } to_absolute = realpath(to, NULL); if (!to_absolute) { EPRINTF("failed to get absolute path of %s\n", to); *err = -errno; goto out; } from_absolute = realpath(from, NULL); if (!from_absolute) { EPRINTF("failed to get absolute path of %s\n", from); *err = -errno; goto out; } if (strnlen(to_absolute, MAX_NAME_LEN) == MAX_NAME_LEN || strnlen(from_absolute, MAX_NAME_LEN) == MAX_NAME_LEN) { EPRINTF("invalid input; max path length is %d\n", MAX_NAME_LEN); *err = -ENAMETOOLONG; goto out; } /* count nodes in source path */ from_nodes = count_nodes(from_absolute); /* count nodes in common */ common = count_common_nodes(to_absolute + 1, from_absolute + 1); if (common < 0) { EPRINTF("failed to count common nodes of %s and %s: %d\n", to_absolute, from_absolute, common); *err = common; goto out; } /* move up to common node */ up = up_nodes(from_nodes - common - 1); if (!up) { EPRINTF("failed to allocate relative path for %s: %d\n", from_absolute, -ENOMEM); *err = -ENOMEM; goto out; } /* get path from common node to target */ common_target_path = node_offset(to_absolute, common + 1); if (!common_target_path) { EPRINTF("failed to find common target path to %s: %d\n", to_absolute, -EINVAL); *err = -EINVAL; goto out; } /* get relative path */ if (asprintf(&relative_path, "%s%s", up, common_target_path) == -1) { EPRINTF("failed to construct final path %s%s: %d\n", up, common_target_path, -ENOMEM); relative_path = NULL; *err = -ENOMEM; goto out; } out: sfree(up); sfree(to_absolute); sfree(from_absolute); return relative_path; }
int dt_node_count(decision_tree *dt) { return count_nodes(dt->root); }
int main(void){ int counts[31]; for(int i = 0; i < 31; i++){ counts[i] = 0; } int len; int month; int day; int year; char filename[STR_LEN]; char analysis[5]; LIST *data = list_create(); printf("Please enter file name containing data to analyze: \n"); scanf("%s", filename); FILE *data_file = fopen(filename, "r"); if(data_file == NULL){ fprintf(stderr, "There was an error opening the file. Make sure it exists.\n"); exit(0); } printf("How would you like the data to be analyzed?\n Enter \"day\" to analyze the rides per hour in a given day.\n Enter \"month\" to analyze the rides per day in a given month.\n Enter \"year\" to analyze the rides per month in a given year.\n"); scanf("%s", analysis); if(!(strcmp(analysis, "month")==0)){ if(!(strcmp(analysis, "day")==0)){ if(!(strcmp(analysis, "year")==0)){ fprintf(stderr, "Invalid Entry\n"); exit(0); } } } if(!strcmp(analysis, "day")){ len = 24; printf("Please enter the month (i.e. 02 for February), day (i.e. 15), and year (i.e. 2013) below\n"); printf("Please enter the month:\n"); scanf("%i", &month); if(month < 0 || month > 12){ fprintf(stderr, "Invalid Entry\n"); exit(0); } printf("Please enter the day:\n"); scanf("%i", &day); if(day < 0 || day > 31){ fprintf(stderr, "Invalid Entry\n"); exit(0); } printf("Please enter the year:\n"); scanf("%i", &year); if(year < 0 || year > 2099){ fprintf(stderr, "Invalid Entry\n"); exit(0); } read_by_day(data_file, data, month, day, year); count_nodes(data, counts, len); make_hist(counts, len, month, day, year); } if(!strcmp(analysis, "month")){ printf("Please enter the month (i.e. 02 for February), day (i.e. 15), and year (i.e. 2013) below\n"); printf("Please enter the month:\n"); scanf("%i", &month); if(month < 0 || month > 12){ fprintf(stderr, "Invalid Entry\n"); exit(0); } printf("Please enter the year:\n"); scanf("%i", &year); if(year < 0 || year > 2099){ fprintf(stderr, "Invalid Entry\n"); exit(0); } //setting value for months with 31 days if (month == 1 || month == 3 || month == 5 || month == 7 || month == 8 || month == 10 || month == 12){ len = 31; } //setting value for months with 30 days else if (month == 4 || month == 6 || month == 9 || month == 11){ len = 30; } //setting value for February in a leap year else if (month == 2 && year%4 == 0){ len = 29; } //setting value for non-leap year February else{ len = 28; } read_by_month(data_file, data, month, year); count_nodes(data, counts, len); make_hist(counts, len, month, day, year); } if(!strcmp(analysis, "year")){ len = 12; printf("Please enter the year:\n"); scanf("%i", &year); if(year < 0 || year > 2099){ fprintf(stderr, "Invalid Entry\n"); exit(0); } read_by_year(data_file, data, year); count_nodes(data, counts, len); make_hist(counts, len, month, day, year); } list_free(data); return 0; }
int main(int argc, char *argv[]){ char c; int n=0, m=0; init(); FILE *fp=NULL; fp=fopen(argv[1],"r"); //Anoigma tou arxeiou if(fp==NULL){ //Elegxos an to arxeio anoikse kanonika, alliws termatismos.. printf("\nProblem opening file. Program terminated...\n"); return -1; } //Diavasma xaraktira kai antistoixi leitourgia analoga me auton (Provlepsi gia grammi sxoliwn kai gia telos arxeiou) c=fgetc(fp); do{ if(c=='V' || c=='v'){ m++; creatVoltList(fp); } else if(c=='I' || c=='i'){ creatAmberList(fp); } else if(c=='R' || c=='r'){ creatResistanceList(fp); } else if(c=='C' || c=='c'){ creatCapacitorList(fp); } else if(c=='L' || c=='l'){ m++; creatInductorList(fp); } else if(c=='D' || c=='d'){ creatDiodeList(fp); } else if(c=='M' || c=='m'){ creatMOSList(fp); } else if(c=='B' || c=='b'){ creatBJTList(fp); } else if(c=='%'){ c=fgetc(fp); while(c!='\n'&&(c!=EOF)){c=fgetc(fp);}/*MOVE TO NEXT LINE*/ } else if(c=='.'){ analysis(fp); } else{ } if(c!=EOF){c=fgetc(fp);} }while(!feof(fp)); fclose(fp); if(ground==0) { printf("No ground node! Program terminated!"); return -1; } else { printVoltList(rootV); printAmperList(rootI); printResistanceList(rootR); printCapacitorList(rootC); printInductorList(rootL); printDiodeList(rootD); printMosList(rootM); printBjttList(rootB); } n=count_nodes(); printf("\n m=%d , n=%d \n\n", m, n); int size=0; size = (n-1)+m; if(sparse_option == 0){ gsl_matrix* pinakasA = gsl_matrix_calloc(size,size); gsl_vector* pinakasB = gsl_vector_calloc(size); fill_matrix_A(pinakasA, pinakasB, n); fill_matrix_B(pinakasB); printf(" O pinakas A einai o: \n"); print2DMatrix(pinakasA, size); printf("\n O pinakas B einai o: \n"); print1DMatrix(pinakasB,size); printf("\n"); if(use_lu==1){ if(found_iter==1){ call_bi_cg(pinakasA, pinakasB, size); } else{ luDecomp(pinakasA, pinakasB, size); } } else if (use_cholesky==1){ if (found_iter==1){ call_cg(pinakasA, pinakasB, size); } else{ choleskyDecomp(pinakasA, pinakasB, size); } } } else { int i; cs* pinakasA_sparse = cs_spalloc(size,size,4*sparse_elements,1,1); double* pinakasB_sparse = (double *)calloc(size,sizeof(double)); double* pinakasX_sparse = (double *)calloc(size,sizeof(double)); fill_sparse_matrix_A(pinakasA_sparse, pinakasB_sparse,n); cs* pinakasC_sparse = cs_compress(pinakasA_sparse); cs_spfree(pinakasA_sparse); cs_dupl(pinakasC_sparse); if(use_lu==1){ if(found_iter==1){ call_bi_cg_sparse(pinakasC_sparse, pinakasB_sparse, pinakasX_sparse, size); } else{ luDecomp_sparse(pinakasC_sparse, pinakasB_sparse, pinakasX_sparse, size); } } else if (use_cholesky==1){ if (found_iter==1){ call_cg_sparse(pinakasC_sparse, pinakasB_sparse, pinakasX_sparse, size); } else{ choleskyDecomp_sparse(pinakasC_sparse, pinakasB_sparse, pinakasX_sparse, size); } } } return 0; }
int main() { t_node *head; t_node *n1; t_node *n2; int *i1; int *i2; int *i3; int i; int j; int k; char *c1; char *c2; char *c3; char a; char b; char c; head = (t_node*)xmalloc(10*sizeof(t_node)); /*new_node*/ n1 = new_node("one\n", NULL); my_str(n1->elem);/*prints one*/ n1->elem = NULL; free(n1); n1 = new_node(NULL, NULL); if(!n1->elem) my_str("create NULL node ok\n"); else my_str("create NULL node FAIL!\n"); free(n1); n1 = new_node("a", NULL); n2 = new_node("b", n1); my_str(n2->elem); my_str((n2->next)->elem);/*prints ba*/ my_char('\n'); my_str("---------------------------------------------------------------------\n"); /*add_node*/ add_node(n1, &head); my_str((*head).elem);/*prints a*/ my_char('\n'); add_node(n2, &head); my_str((*head).elem);/*prints b*/ my_char('\n'); add_node(NULL, &head); if(strcmp((*head).elem, n2->elem) == 0) my_str("add NULL ok\n"); else my_str("add NULL FAIL!\n"); add_node(new_node(NULL, NULL), &head); if(strcmp((*head).elem, n2->elem) == 0) my_str("add NULL node ok\n"); else my_str("add NULL node FAIL!\n"); add_node(new_node("something", NULL), NULL);/*if this line doesn't segfault then we're good!*/ my_str("---------------------------------------------------------------------\n"); /*traversals*/ empty_list(&head); i = 3; i1 = &i; add_node(new_node(i1, NULL), &head); j = 2; i2 = &j; add_node(new_node(i2, NULL), &head); k = 1; i3 = &k; add_node(new_node(i3, NULL), &head); traverse_int(head);/*prints 1 2 3 */ my_char('\n'); head->next->elem = NULL; traverse_int(head);/*prints 1 NULL 3*/ my_char('\n'); traverse_int(NULL);/*prints The list is empty!*/ empty_list(&head); c = 'c'; c1 = &c; add_node(new_node(c1, NULL), &head); b = 'b'; c2 = &b; add_node(new_node(c2, NULL), &head); a = 'a'; c3 = &a; add_node(new_node(c3, NULL), &head); traverse_char(head);/*prints a b c */ my_char('\n'); head->elem = NULL; traverse_char(head);/*prints NULL b c*/ my_char('\n'); traverse_char(NULL);/*prints The list is empty!*/ empty_list(&head); add_node(new_node("third", NULL), &head); add_node(new_node("second", NULL), &head); add_node(new_node("first", NULL), &head); traverse_string(head);/*prints first second third */ my_char('\n'); head->next->next->elem = NULL; traverse_string(head);/*prints first second NULL*/ my_char('\n'); traverse_string(NULL);/*prints The list is empty!*/ empty_list(&head); my_str("---------------------------------------------------------------------\n"); /*add_elem*/ add_elem("a", &head); add_elem("b", &head); add_elem("c", &head); my_str(head->elem);/*prints c*/ my_char('\n'); add_elem(NULL, &head); if(strcmp(head->elem, "c") == 0) my_str("add NULL elem ok\n"); else my_str("add NULL elem FAIL!\n"); my_str("---------------------------------------------------------------------\n"); /*append*/ append(new_node("z", NULL), &head); traverse_string(head);/*prints c b a z*/ my_char('\n'); append(NULL, &head); traverse_string(head);/*prints c b a z*/ my_char('\n'); append(new_node("stuff", NULL), NULL);/*if this line doesn't segfault then we're good!*/ my_str("---------------------------------------------------------------------\n"); /*add_node_at*/ add_node_at(new_node("d", NULL), &head, 0); traverse_string(head);/*prints d c b a z*/ my_char('\n'); add_node_at(new_node("y", NULL), &head, 42); traverse_string(head);/*prints d c b a z y*/ my_char('\n'); add_node_at(new_node("0", NULL), &head, 4); traverse_string(head);/*prints d c b a 0 z y*/ my_char('\n'); add_node_at(NULL, &head, 2); traverse_string(head);/*prints d c b a 0 z y*/ my_char('\n'); add_node_at(new_node(NULL, NULL), &head, 1); traverse_string(head);/*prints d c b a 0 z y*/ my_char('\n'); add_node_at(new_node("something", NULL), NULL, 7);/*if this line doesn't segfault then we're good!*/ my_str("---------------------------------------------------------------------\n"); /*remove_node*/ my_str(remove_node(&head));/*prints d*/ my_str(": "); traverse_string(head); my_char('\n'); if(!remove_node(NULL)) my_str("remove node from NULL ok\n"); else my_str("remove node from NULL FAIL!\n"); my_str("---------------------------------------------------------------------\n"); /*remove_node_at*/ my_str(remove_node_at(&head, 0));/*prints c*/ my_str(": "); traverse_string(head); my_char('\n'); my_str(remove_node_at(&head, 42));/*prints y*/ my_str(": "); traverse_string(head); my_char('\n'); my_str(remove_node_at(&head, 2));/*prints 0*/ my_str(": "); traverse_string(head); my_char('\n'); if(!remove_node_at(NULL, 100)) my_str("remove node from NULL ok\n"); else my_str("remove node from NULL FAIL!\n"); my_str("---------------------------------------------------------------------\n"); /*remove_last*/ my_str(remove_last(&head));/*prints z*/ my_str(": "); traverse_string(head); my_char('\n'); if(!remove_last(NULL)) my_str("remove last from NULL ok\n"); else my_str("remove last from NULL FAIL!\n"); my_str("---------------------------------------------------------------------\n"); /*count_nodes*/ my_int(count_nodes(head));/*prints 2*/ my_char('\n'); my_int(count_nodes(NULL));/*prints 0*/ my_char('\n'); my_str("---------------------------------------------------------------------\n"); /*node_at*/ my_str((node_at(head, 1))->elem);/*prints a*/ my_char('\n'); my_str((node_at(head, 0))->elem);/*prints b*/ my_char('\n'); my_str((node_at(head, 42))->elem);/*prints a*/ my_char('\n'); if(!node_at(NULL, 12)) my_str("node at with NULL ok\n"); else my_str("node at with NULL FAIL!\n"); my_str("---------------------------------------------------------------------\n"); /*elem_at*/ my_str(elem_at(head, 0));/*prints b*/ my_char('\n'); my_str(elem_at(head, 1));/*prints a*/ my_char('\n'); my_str(elem_at(head, 42));/*prints a*/ my_char('\n'); if(!elem_at(NULL, 3)) my_str("elem at with NULL ok\n"); else my_str("elem at with NULL FAIL!\n"); my_str("---------------------------------------------------------------------\n"); /*empty_list*/ my_int(count_nodes(head));/*prints 2*/ my_char('\n'); empty_list(&head); my_int(count_nodes(head));/*prints 0*/ my_char('\n'); empty_list(NULL);/*if this doesn't segfault then we're good!*/ my_str("---------------------------------------------------------------------\n"); free(head); return 0; }
int main(int argc, char *argv[]){ struct timeval start_time, end_time; /* structs for timer */ struct timezone zone; long int sec = 0, usec = 0; /* sec & microsec for the timer */ long int time_total_sec = 0; double time_total_msec = 0; long int time_total_usec = 0; int numTrans, pid, numItems, item, count, i , j; FILE *f_input, *f_utility, *f_output; int sizeDB; double minshare; int MV = 0; int ML = 0; int tempML = 0; if(argc != 7){ fprintf(stderr, "Usage: %s transactionDB utilityTable outputFile min_util MAXITEMS MAXCANDIDATES\n", argv[0]); exit(0); } f_input = fopen(argv[1], "r"); f_utility = fopen(argv[2], "r"); f_output = fopen(argv[3], "w"); minshare = atof(argv[4]); MAXITEMS = atoi(argv[5]); MAXITEMSETS = atoi(argv[6]); if((f_input == NULL) || (f_utility == NULL) || (f_output == NULL)){ fprintf( stdout, "ERROR[%s]: Can't open %s or %s or %s\n", argv[0], argv[1], argv[2], argv[3] ); fprintf( stderr, "ERROR[%s]: Can't open %s or %s or %s\n", argv[0], argv[1], argv[2], argv[3] ); fprintf( stderr, "ERROR[%s]: Can't open %s or %s or %s\n", argv[0], argv[1], argv[2], argv[3] ); exit( 0 ); } TreeNode *rootCk; rootCk = create_new_node(ROOT); TreeNode *rootRc; rootRc = create_new_node(ROOT); TreeNode *rootF; //the tree for frequent itemsets rootF = create_new_node(ROOT); TreeNode *setRc[MAXITEMSETS + 1]; TreeNode *setCk[MAXITEMSETS + 1]; TreeNode *setF[MAXITEMSETS + 1]; int sizeRc = 0; int sizeCk = 0; int sizeF = 0; double utility[MAXITEMS + 1]; double TutilItem[MAXITEMS + 1]; int items[MAXITEMS + 1]; double lmv[MAXITEMS + 1]; double TutilDB = 0; float cost; for(i = 1; i <= MAXITEMS; i ++){ utility[i] = 0; TutilItem[i] = 0; items[i] = 0; lmv[i] = 0; } printf("===== %s %s %s %f =====\n\n", argv[0], argv[1], argv[2], minshare); //record the time for the first db scan if(gettimeofday(&start_time, &zone) == -1){ fprintf(stderr, "gettimeofday error\n"); } fscanf(f_utility, "%d ", &numItems); for(i = 1; i <= numItems; i ++){ fscanf(f_utility, "%d %f ", &item, &cost); utility[item] = cost; } fscanf(f_input, "%d ", &numTrans); double transUtil = 0; //read the whole db once to get candidate 1-itemsets for(i = 1; i <= numTrans; i ++){ fscanf(f_input, "%d ", &pid); fscanf(f_input, "%d ", &numItems); //printf("\n%d %d ", pid, numItems); for(j = 1; j <= numItems; j ++){ fscanf(f_input, "%d %d ", &item, &count); //printf("item %d count %d ", item, count); transUtil += count * utility[item]; items[item] = 1; if(count > MV){ MV = count; } tempML ++; //printf("\nitem: %d count: %d", item, count); lmv[item] += count; } for(j = 1; j <= MAXITEMS; j ++){ if(items[j] == 1){ TutilItem[j] += transUtil; items[j] = 0; } } if(tempML > ML){ ML = tempML; } TutilDB += transUtil; transUtil = 0; tempML = 0; } sizeDB = numTrans; if(gettimeofday(&end_time, &zone) == 0){ if(end_time.tv_usec >= start_time.tv_usec){ sec = end_time.tv_sec - start_time.tv_sec; usec = end_time.tv_usec - start_time.tv_usec; }else{ sec = end_time.tv_sec - start_time.tv_sec - 1; usec = end_time.tv_usec - start_time.tv_usec + 1000000; } time_total_sec += sec; time_total_usec += usec; fprintf(stdout, "\n[FUM] Total runtime for first db scan is %ld sec. %.3f msec\n", sec, usec/1000.0); f_output = fopen( argv[3], "a" ); fprintf(f_output, "\n[FUM] Total runtime for first db scan is %ld sec. %.3f msec\n", sec, usec/1000.0); fclose( f_output ); } if(DEBUG){ for(i = 1; i <= MAXITEMS; i ++){ printf("\nutil item (%d): %f", i, utility[i]); } printf("\n"); for(i = 1; i <= MAXITEMS; i ++){ printf("\nitem (%d) has Tutil: %f", i, TutilItem[i]); } printf("\n\nTutilDB: %f Min_Lutil: %f\n", TutilDB, MIN_LUTIL(TutilDB, minshare)); printf("\nMV: %d ML: %d", MV, ML); } int isolated_itemsets[MAXITEMS + 1]; int size = 0; //get candidate 1-itemsets for(i = 1; i <= MAXITEMS; i ++){ if(utility[i] > 0){ if(TutilItem[i] >= MIN_LUTIL(TutilDB, minshare)){ Itemset I; init_itemset(&I); I.itemset[i] = 1; double lutil = (lmv[i] * utility[i]); insert(I.itemset, rootRc, 1, &sizeRc, i, setRc, lutil); free_itemset(&I); } else{ isolated_itemsets[size] = i; size ++; } } } //int k_prime = 1; //needed for other version of critical function int c; for(c = 0; c < sizeRc; c ++){ TreeNode *X = setRc[c]; if(X->lutil >= MIN_LUTIL(TutilDB, minshare)){ Itemset I; to_itemset(&I, X); insert(I.itemset, rootF, 1, &sizeF, 1, setF, X->lutil); free_itemset(&I); } //printf("\nCF: %f", CF(X->lutil, 1, MV, ML, k_prime)); //if(CF(X->lutil, 1, MV, ML, k_prime) < MIN_LUTIL(TutilDB, minshare)){ if(TutilItem[X->item] < MIN_LUTIL(TutilDB, minshare)){ remove_itemset(X, setRc, c); } } adjust_set(setRc, &sizeRc); if(PRT_CNT){ printf("\n\nIteration (%d)", 0); printf("\n|Ck| = %d", sizeCk); printf("\n|Rc| = %d", sizeRc); printf("\n|Fk| = %d", sizeF); } int k; int counterF = 0; boolean stop = false; int num_false_positives[MAXITEMSETS + 1]; int sizeFP = 0; //record the time for mining if(gettimeofday(&start_time, &zone) == -1){ fprintf(stderr, "gettimeofday error\n"); } for(k = 1; sizeRc > 0 && stop == false; k ++){ //apriori join + apriori prune generate(rootRc, setRc, sizeRc, setCk, &sizeCk, rootCk, k); if(PRT_MEM){ printf("\n\nIteration (%d)", k); int mem_counterCk = 0; count_nodes(rootCk, &mem_counterCk); printf("\nNode Count = [%d]", mem_counterCk); printf("\nNode Size = [%ld bytes]", sizeof(TreeNode)); printf("\nMemory space required for candidate tree = %ld bytes", mem_counterCk * sizeof(TreeNode)); } if(sizeCk > 0){ double TransUtil; rewind(f_input); fscanf(f_input, "%d ", &numTrans); for(i = 1; i <= numTrans; i ++){ fscanf(f_input, "%d ", &pid); fscanf(f_input, "%d ", &numItems); Transaction T; init_transaction(&T); for(j = 1; j <= numItems; j ++){ fscanf(f_input, "%d %d ", &item, &count); if(is_isolated_item(item, isolated_itemsets, size) == false){ T.itemset[item] += count; T.total_count += (count * utility[item]); } } TransUtil = T.total_count; for(j = 0; j < sizeCk; j ++){ TreeNode *X = setCk[j]; boolean in_transaction = true; double Lutil = 0; while(is_root(X) == false && in_transaction == true){ //first check if itemset in transaction if(T.itemset[X->item] == 0){ in_transaction = false; } Lutil += (T.itemset[X->item] * utility[X->item]); X = X->parent; } if(in_transaction){ TreeNode *last_node = setCk[j]; last_node->lutil += Lutil; last_node->CF += TransUtil; } } free_transaction(&T); } if(PRT_CNT){ printf("\n\nIteration (%d)", k); printf("\n|Ck| = %d", sizeCk); } if(PRT_FALSE_POS){ num_false_positives[k] = sizeCk; sizeFP ++; } for(c = 0; c < sizeCk; c ++){ TreeNode *X = setCk[c]; //print_itemset(X); //printf(" lutil: %f minlutil: %f\n", X->lutil, MIN_LUTIL(TutilDB, minshare)); if(X->lutil >= MIN_LUTIL(TutilDB, minshare)){ counterF ++; Itemset I; to_itemset(&I, X); insert(I.itemset, rootF, 1, &sizeF, 1, setF, X->lutil); free_itemset(&I); } if(X->CF < MIN_LUTIL(TutilDB, minshare)){ //if(CF(X->lutil, 1, MV, ML, k_prime) < MIN_LUTIL(TutilDB, minshare)){ remove_itemset(X, setCk, c); } } adjust_set(setCk, &sizeCk); copy_tree(rootCk, setCk, &sizeCk, rootRc, setRc, &sizeRc); if(PRT_CNT){ printf("\n|Rc| = %d", sizeRc); printf("\n|Fk| = %d", counterF); } if(PRT_FALSE_POS){ num_false_positives[k] -= counterF; printf("\nFalse Positives Iteration (%d): %d", k, num_false_positives[k]); } } else{ stop = true; } counterF = 0; } if(gettimeofday(&end_time, &zone) == 0){ if(end_time.tv_usec >= start_time.tv_usec){ sec = end_time.tv_sec - start_time.tv_sec; usec = end_time.tv_usec - start_time.tv_usec; }else{ sec = end_time.tv_sec - start_time.tv_sec - 1; usec = end_time.tv_usec - start_time.tv_usec + 1000000; } time_total_sec += sec; time_total_usec += usec; fprintf(stdout, "\n[FUM] Total runtime for mining is %ld sec. %.3f msec\n", sec, usec/1000.0); f_output = fopen( argv[3], "a" ); fprintf(f_output, "\n[FUM] Total runtime for mining is %ld sec. %.3f msec\n", sec, usec/1000.0); fclose( f_output ); } f_output = fopen(argv[3], "a"); if(PRT_FALSE_POS){ int total_FP = 0; for(k = 1; k <= sizeFP; k ++){ total_FP += num_false_positives[k]; } printf("\nTotal False Positives: %d", total_FP); } if(PRT_FP){ printf("\n\nFound (%d) ShFrequent Itemsets:", sizeF); fprintf(f_output, "\n\nFound (%d) ShFrequent Itemsets:", sizeF); print_frequent_itemset(setF, sizeF, f_output); } if(PRT_MEM){ int mem_counterF = 0; count_nodes(rootF, &mem_counterF); printf("\n\nNode Count = [%d]", mem_counterF); printf("\nNode Size = [%ld bytes]", sizeof(TreeNode)); printf("\nMemory space required for frequent itemset tree = %ld bytes", mem_counterF * sizeof(TreeNode)); } time_total_msec = time_total_usec / 1000.0; if(time_total_msec >= 1000){ time_total_sec += floor(time_total_msec/1000); time_total_msec = time_total_usec % 1000; } //printf("\ntime sec: %ld time msec: %.3lf time usec: %ld", time_total_sec, time_total_msec, time_total_usec); fprintf(stdout, "\n\n[FUM] Total (aggregate) runtime is %ld sec. %.3lf msec\n", time_total_sec, time_total_msec); fprintf(f_output, "\n\n[FUM] Total (aggregate) runtime is %ld sec. %.3lf msec\n", time_total_sec, time_total_msec); free_tree(setRc, &sizeRc); free_tree(setCk, &sizeCk); free_tree(setF, &sizeF); fclose(f_input); fclose(f_output); fclose(f_utility); printf("\n\nProcessing Complete\n"); return 0; }
tree::tree(FILE* f) { node_num = 0; Root = new node; if (!f) {printf("Err: can't read from file\n"); exit(1);} char c = fgetc(f); while (c != '>' && !feof(f)) c = fgetc(f); if (c == '>') { fscanf(f,"%d", &num); } else { return; } while (c != '(' && !feof(f)) {c = fgetc(f);} Root->childs.erase(Root->childs.begin(), Root->childs.end()); if (!feof(f)) add_subtree(f, Root); else {printf("Last tree readed\n"); return;} c = fgetc(f); if (c == ';') { // printf("SUCCESS; %lu\n", Root->childs.size()); } else {printf("ERR: ; ?\n"), exit(1);} printf("OK\n"); DeleteNullEdges(Root); SetClades(Root); FixClades(Root); // printf("OK1\n"); if (Root->childs.size() == 2) { if (Root->childs[0]->edge > 0 && Root->childs[1]->edge > 0) { if (Root->childs[0]->childs.size() > 0) { for (int i = 0; i < Root->childs[0]->childs.size(); ++i) { Root->childs[0]->childs[i]->parent = Root; Root->childs.push_back(Root->childs[0]->childs[i]); } Root->childs.erase(Root->childs.begin()); } else if (Root->childs[1]->childs.size() > 0) { node n = *Root->childs[1]; Root->childs.erase(Root->childs.begin()+1); for (int i = 0; i < Root->childs[1]->childs.size(); ++i) { n.childs[i]->parent = Root; Root->childs.push_back(n.childs[i]); } } } } count_nodes(Root); // printf("Root childs size %lu\n", Root->childs.size()); Tree2Newick("test"); // int i; // for (i = 0; i < Root->childs.size(); ++i) // { // printf("%lu;\n", Root->childs[i]->clade.size()); // } }
void linkedlist_to_file(char *path,struct network *list){ #ifdef DEBUG printf("Entering function: linkedlist_to_file\n"); #endif /* check if the file is well opened*/ if ((file = fopen(path, "w")) == NULL){ printf("It's impossible to open the file\n"); printf("Maybe the filename could be wrong. Check it!\n"); #ifdef DEBUG printf("Exiting function: linkedlist_to_file\n\n"); #endif return ; } /* auxiliary structure to work with*/ network aux = list; /** NUMBER OF NODES**/ /* SIZE=4*/ int number_of_nodes=count_nodes(list); int *number_of_nodes_ptr = &number_of_nodes; #ifdef DEBUG printf("Function returns %d\n",number_of_nodes); #endif fwrite(number_of_nodes_ptr,sizeof(int),1,file); /*Copy Nodes*/ while(aux!=NULL) { #ifdef DEBUG printf(" Writting node to file ..."); #endif size=0; /** MAC**/ size=sizeof(aux->info->mac[0]); for(i = 0; i < MAC_SIZE; i++) { fwrite(&aux->info->mac[i],size,1,file); } /** ESSID SIZE**/ /* SIZE=4*/ size = strlen(aux->info->essid); int *size_ptr = &size; fwrite(size_ptr,sizeof(int),1,file); /** ESSID**/ /* SIZE specified before*/ fwrite(aux->info->essid,size,1,file); /** MODE**/ size=sizeof(enum network_mode); fwrite(&aux->info->mode,size,1,file); /** CHANNEL**/ /* SIZE specified before */ size=sizeof(int); fwrite(&aux->info->channel,size,1,file); /** ENCRYPTED**/ /* SIZE specified before */ size=sizeof(unsigned short); fwrite(&aux->info->encrypted,size,1,file); /** QUALITY **/ size=sizeof(unsigned int); for(j=0 ; j< 2 ; j++) { fwrite(&aux->info->quality[j],size,1,file); } #ifdef DEBUG printf(" Done\n");; #endif aux = aux->next; } //All data is saved data_changed=0; if (fclose(file) != 0){ #ifdef DEBUG printf(" Closing the file\n"); #endif printf("[ERROR]: It's impossible to close the file\n"); printf(" Maybe the file is wrong. Check it!\n"); return ; } }
struct network * file_to_linkedlist(char *path) { #ifdef DEBUG printf(" Entering file_to_linkedlist\n"); #endif struct ap_scan_info *node_info; struct network * node; int bytes_read; int listsize; // SIZE OF THE LIST (BYTES) node = NULL; network mainlist = NULL; //STEP 1_ CHECK IF THE GIVEN FILE ALREADY EXISTS //1.1 THE FILE DOES NOT EXIST -> RECALL THE FUNCTION if (file_check(path)==0) { printf(" File %s does not exist.\n",path); printf(" Perharps you wrote a wrong path.\n"); } //1.2 THE FILE DOES EXIST -> THE PROCCESS PROCEEDS else if (file_check(path)==1) { file = fopen(path, "r"); #ifdef DEBUG printf(" Opening the file %s\n",path); #endif //STEP 2_ LOOK HOW MANY NODES THE LIST HAS bytes_read = fread(&listsize,sizeof(int),1,file); //STEP 3_ CREATE AND INSERT (list_size) number of NODES for(i = 0; i < listsize ; i++) { node_info = (struct ap_scan_info*)malloc(sizeof(struct ap_scan_info)); //3.1 READ THE FIELD "mac" for (j =0 ; j < MAC_SIZE ; j++) { bytes_read = fread(&(node_info->mac[j]),sizeof(char),1,file); } //3.2 READ THE FIELD "essid" bytes_read = fread(&size,sizeof(int),1,file); node_info -> essid = (char*)calloc((sizeof(char)*size + 1),size); bytes_read = fread(node_info -> essid,sizeof(char),size,file); //3.3 READ THE FIELD enum network_mode mode; size=sizeof(enum network_mode); fread(&node_info->mode,size,1,file); //3.4 READ THE FIELD channel; //bytes_read = fread(&size,sizeof(int),1,file); bytes_read = fread(&(node_info -> channel),sizeof(int),1,file); //3.5 READ THE FIELD encrypted bytes_read = fread(&(node_info -> encrypted),sizeof(unsigned short),1,file); //ONLY READS 1 BYTE //3.6 READ THE FIELD quality for(k = 0 ; k < 2 ; k++) { bytes_read = fread(&(node_info -> quality[k]),sizeof(unsigned int),1,file); } //3.7 CREATE NODE node = create_node(node_info, count_nodes(mainlist) + 1); free(node_info); //3.8 INSERT NODE mainlist = insert_node(node , mainlist); //3.9 SORT THE NEW LIST mainlist = sort(mainlist); } if (fclose(file)!=0) { #ifdef DEBUG printf(" Closing the file\n"); #endif printf("[ERROR]: It's impossible to close the file\n"); } } //1.3 UNNEXPECTED ERROR -> END else printf(" Unexpected Error.\n"); #ifdef DEBUG printf(" Exiting file_to_linkedlist\n"); #endif return mainlist; }
// this is a private function that recursively prunes nodes top-down // and only accepts a pruning if it increases the prediction score of the // validation data // returns the number of nodes successfully pruned int prune_node(decision_tree *dt, dt_node *node, data_set *validation_data) { // the score with both subtrees still attached float primary_score = dt_score(dt, validation_data); // save subtrees so that we can restore them if classification score // didn't improve dt_node *left = node->left; dt_node *right = node->right; int right_prune_count = 0; int left_prune_count = 0; if(left != NULL) { node->left = NULL; // score the decision tree with the missing subtree float left_prune_score = dt_score(dt, validation_data); if(left_prune_score >= primary_score) { // found a good prune! left_prune_count = count_nodes(left); float diff = left_prune_score - primary_score; if(diff > 0.0002 || left_prune_count > 10) { printf("Improved score by %.4f, dropped %d nodes\n", diff, left_prune_count); } // throw away the subtree now that we don't need it dt_free_node(left); } else { // prune was no good, so restore the subtree and recurse node->left = left; left_prune_count = prune_node(dt, node->left, validation_data); } } if(right != NULL) { // basically the same as above, but for the right subtree node->right = NULL; float right_prune_score = dt_score(dt, validation_data); if(right_prune_score >= primary_score) { right_prune_count = count_nodes(right); float diff = right_prune_score - primary_score; if(diff > 0.0002 || right_prune_count > 10) { printf("Improved score by %.4f, dropped %d nodes\n", diff, right_prune_count); } dt_free_node(right); } else { node->right = right; right_prune_count = prune_node(dt, node->right, validation_data); } } // need to see if we're a leaf now if(node->left == NULL && node->right == NULL) { node->prediction_value = guess_node_class(dt, node); node->is_leaf = 1; } return left_prune_count + right_prune_count; }
static int put_tree_into_comb(struct ged *gedp, struct rt_comb_internal *comb, struct directory *dp, const char *old_name, const char *new_name, const char *imstr) { int i; int done; char *line; char *ptr; char relation; char *name; struct rt_tree_array *rt_tree_array; struct line_list *llp; int node_count = 0; int tree_index = 0; union tree *tp; matp_t matrix; struct bu_vls vls = BU_VLS_INIT_ZERO; char *str; if (imstr == (char *)NULL) return GED_ERROR; BU_LIST_INIT(&HeadLines.l); /* duplicate the immutable str (from argv) for strtok style mutation */ str = bu_strdup(imstr); /* break str into lines */ line = str; ptr = strchr(str, '\n'); if (ptr != NULL) *ptr = '\0'; while (line != (char *)NULL) { int n; bu_vls_strcpy(&vls, line); if ((n = count_nodes(gedp, bu_vls_addr(&vls))) < 0) { bu_vls_free(&vls); bu_list_free(&HeadLines.l); bu_free(str, "dealloc bu_strdup str"); return GED_ERROR; } else if (n > 0) { BU_ALLOC(llp, struct line_list); BU_LIST_INSERT(&HeadLines.l, &llp->l); llp->line = line; node_count += n; } /* else blank line */ if (ptr != NULL && *(ptr+1) != '\0') { /* leap frog past EOS */ line = ptr + 1; ptr = strchr(line, '\n'); if (ptr != NULL) *ptr = '\0'; } else { line = NULL; } } bu_vls_free(&vls); /* build tree list */ if (node_count) rt_tree_array = (struct rt_tree_array *)bu_calloc(node_count, sizeof(struct rt_tree_array), "tree list"); else rt_tree_array = (struct rt_tree_array *)NULL; for (BU_LIST_FOR (llp, line_list, &HeadLines.l)) { done = 0; ptr = strtok(llp->line, _delims); while (!done) { if (!ptr) break; /* First non-white is the relation operator */ relation = (*ptr); if (relation == '\0') break; /* Next must be the member name */ ptr = strtok((char *)NULL, _delims); if (ptr == (char *)NULL) { bu_list_free(&HeadLines.l); if (rt_tree_array) bu_free((char *)rt_tree_array, "red: tree list"); bu_log("no name specified\n"); bu_free(str, "dealloc bu_strdup str"); return GED_ERROR; } name = ptr; /* Eliminate trailing white space from name */ i = (int)strlen(ptr); while (isspace((int)name[--i])) name[i] = '\0'; /* Check for existence of member */ if ((db_lookup(gedp->ged_wdbp->dbip, name, LOOKUP_QUIET)) == RT_DIR_NULL) bu_log("\tWARNING: ' %s ' does not exist\n", name); /* get matrix */ ptr = strtok((char *)NULL, _delims); if (ptr == (char *)NULL) { matrix = (matp_t)NULL; done = 1; } else if (*ptr == 'u' || (*ptr == '-' && *(ptr+1) == '\0') || (*ptr == '+' && *(ptr+1) == '\0')) { /* assume another relational operator */ matrix = (matp_t)NULL; } else { int k; matrix = (matp_t)bu_calloc(16, sizeof(fastf_t), "red: matrix"); matrix[0] = atof(ptr); for (k = 1; k < 16; k++) { ptr = strtok((char *)NULL, _delims); if (!ptr) { bu_log("incomplete matrix for member %s - No changes made\n", name); bu_free((char *)matrix, "red: matrix"); if (rt_tree_array) bu_free((char *)rt_tree_array, "red: tree list"); bu_list_free(&HeadLines.l); bu_free(str, "dealloc bu_strdup str"); return GED_ERROR; } matrix[k] = atof(ptr); } if (bn_mat_is_identity(matrix)) { bu_free((char *)matrix, "red: matrix"); matrix = (matp_t)NULL; } ptr = strtok((char *)NULL, _delims); if (ptr == (char *)NULL) done = 1; } /* Add it to the combination */ switch (relation) { case '+': rt_tree_array[tree_index].tl_op = OP_INTERSECT; break; case '-': rt_tree_array[tree_index].tl_op = OP_SUBTRACT; break; default: if (relation != 'u') { bu_log("unrecognized relation (assume UNION)\n"); } rt_tree_array[tree_index].tl_op = OP_UNION; break; } BU_ALLOC(tp, union tree); RT_TREE_INIT(tp); rt_tree_array[tree_index].tl_tree = tp; tp->tr_l.tl_op = OP_DB_LEAF; tp->tr_l.tl_name = bu_strdup(name); tp->tr_l.tl_mat = matrix; tree_index++; } } bu_list_free(&HeadLines.l); i = make_tree(gedp, comb, dp, node_count, old_name, new_name, rt_tree_array, tree_index); bu_free(str, "dealloc bu_strdup str"); return i; }
// private function, returns a count of all children of the specified node plus // the node itself (children + 1) int count_nodes(dt_node *node) { if(node == NULL) { return 0; } return 1 + count_nodes(node->left) + count_nodes(node->right); }