const char *TileManager::lookAtTile(uint16 tile_num, uint16 qty, bool show_prefix) { const char *desc; bool plural; Tile *tile; tile = get_original_tile(tile_num); if(qty > 1) plural = true; else plural = false; desc = look->get_description(tile->tile_num,&plural); if(show_prefix == false) return desc; if(qty > 0 && (plural || Game::get_game()->get_game_type() == NUVIE_GAME_SE)) sprintf(desc_buf,"%u %s",qty, desc); else sprintf(desc_buf,"%s%s",article_tbl[tile->article_n], desc); DEBUG(0,LEVEL_DEBUGGING,"%s (%d): flags1:",desc_buf,tile_num); print_b(LEVEL_INFORMATIONAL,tile->flags1); DEBUG(1,LEVEL_DEBUGGING," f2:"); print_b(LEVEL_INFORMATIONAL,tile->flags2); DEBUG(1,LEVEL_DEBUGGING," f3:"); print_b(LEVEL_INFORMATIONAL,tile->flags3); DEBUG(1,LEVEL_DEBUGGING,"\n"); return desc_buf; }
void stats_print(struct stats *stats) { if (stats->repeats > 1) { printf("Average of repeat averages: "); print_ns(stats->avg_per_time / stats->repeats, "s\n"); } if (stats->gindex) { printf("Global stats:\n"); if (stats->verbose) printf("\tProcessed: %ju\n", stats->gindex); printf("\tMin %s latency: ", stats->op); print_ns(stats->min, "s\n"); printf("\tMax %s latency: ", stats->op); print_ns(stats->max, "s\n"); printf("\tMean %s latency: ", stats->op); print_ns(stats->newm, "s\n"); printf("\tLatency variance: %LG ns^2\n", stats->news / (stats->gindex - 1)); printf("\tLatency stddev: %LG ns\n", sqrtl(stats->news / (stats->gindex - 1))); printf("\tMin %s speed: ", stats->op); print_b((1000000000.0 / stats->max) * stats->size, "B/s\n"); printf("\tMax %s speed: ", stats->op); print_b((1000000000.0 / stats->min) * stats->size, "B/s\n"); printf("\tAverage %s speed: ", stats->op); print_b((1000000000.0 / stats->newm) * stats->size, "B/s\n"); } }
int main() { /* int a[ROW][COL] = { {1, 2}, {3, 4}, {5, 6}, {7, 8} }; */ int a[ROW][COL] = { {1}, {3}, {5}, {7} }; print_a(a, ROW, COL); int **b = rotate_90(a, ROW, COL); print_b(b, COL, ROW); cleanup(b, COL, ROW); return 0; }
static void print_bseq(m_bseq *b) { int i; fprintf(stdout, "\nm_bseq size: %ld --------\n",b->_length); for (i = 0; i < b->_length; i++) print_b(&(b->_buffer[i])); }
void get1pvalue(GENE_DATA* pdata,int* L,float* T,float* P, FUNC_STAT func_stat,FUNC_SAMPLE func_first_sample, FUNC_SAMPLE func_next_sample,FUNC_CMP func_cmp,const void* extra) { int b=0,*bL,i,is_next,*total; float *bT, *count; int ncol=pdata->ncol; int nrow=pdata->nrow; int B=(*func_first_sample)(NULL); /*allocate the space and initialziation*/ assert(bT=(float*)Calloc(nrow,float)); assert(bL=(int*)Calloc(ncol,int)); assert(count=(float*)Calloc(nrow,float)); memset(count,0,sizeof(float)*nrow); assert(total=(int*)Calloc(nrow,int)); memset(total,0,sizeof(int)*nrow); /*comuter the original one first*/ compute_test_stat(pdata,L,T,func_stat,extra); /*iteration for permutaion*/ (*func_first_sample)(bL); is_next=1; b=0; while(is_next){ compute_test_stat(pdata,bL,bT,func_stat,extra); for(i=0;i<nrow;i++){ if(bT[i]==NA_FLOAT) continue; if(T[i]==NA_FLOAT) continue; /* right now I only implements the 3 cases, which are pretty common*/ if((func_cmp==cmp_high) &&(bT[i]>=T[i]-EPSILON)){ count[i]+=1; }else if((func_cmp==cmp_low) &&(bT[i]<=T[i]+EPSILON)){ count[i]+=1; }else if ((func_cmp==cmp_abs) &&(fabs(bT[i])>=fabs(T[i])-EPSILON)){ count[i]+=1; } total[i]++; } b++; print_b(b,B,"b="); is_next=(*func_next_sample)(bL); } /*summarize the results*/ for(i=0;i<nrow;i++){ if(total[i]==0) P[i]=NA_FLOAT; else P[i]=count[i]*1.0/total[i]; } /*free the spaces*/ Free(bT); Free(count); Free(total); Free(bL); }
int main() { struct hs hs; hs.b = 129; hs.v = 12; printf("hs.t offset %d\n", (size_t)(&((struct hs *)0)->t)); printf("hs.t offset %d\n", (&((struct hs *)0)->t)); print_b(&hs.v); print_b1(&hs.v); print_b3(&hs.v); return 0; }
static int struct_test(IC_Env *env) { m_b b = {4711, 'a'}, bo, br; fprintf(stdout, "\n======== m_i_struct test ======\n\n"); br = m_i_struct_test(NULL, &b, &bo, env); CHECK_EXCEPTION(env); RETURN_IF_OK(cmp_b(&b, &bo) && cmp_b(&b, &br)); if (!cmp_b(&b, &bo)) { fprintf(stdout, " out parameter error, sent:\n"); print_b(&b); fprintf(stdout, " got:\n"); print_b(&bo); fprintf(stdout, "\n"); } if (!cmp_b(&b, &br)) { fprintf(stdout, " result error, sent:\n"); print_b(&b); fprintf(stdout, " got:\n"); print_b(&br); fprintf(stdout, "\n"); } return -1; }
int main(int argc, const char *argv[]) { int flag=0; while(1) { info(); scanf("%d",&flag); getchar(); if(flag==1) { print_b(); continu(); } if(flag==2) { mul(); continu(); } if(flag==3) { flag=0; exchange_s(); continu(); } if(flag==4) { encryption(); continu(); } if(flag==5) { break; } } return 0; }
void adj_by_T(GENE_DATA* pdata,float* T,float* P,float*Adj_P, FUNC_STAT func_stat,FUNC_SAMPLE func_first_sample, FUNC_SAMPLE func_next_sample,FUNC_CMP func_cmp,const void* extra) { int b=0,*bL,i,is_next,*total1,*R,*total2; float *bT, *count1,*count2,qT;/*qT is the successiv maxima*/ int ncol=pdata->ncol; int nrow=pdata->nrow; int B=(*func_first_sample)(NULL); /*allocate the space and initialziation*/ assert(bT=(float*)Calloc(nrow,float)); assert(bL=(int*)Calloc(ncol,int)); assert(count1=(float*)Calloc(nrow,float)); memset(count1,0,sizeof(float)*nrow); assert(total1=(int*)Calloc(nrow,int)); memset(total1,0,sizeof(int)*nrow); assert(count2=(float*)Calloc(nrow,float)); memset(count2,0,sizeof(float)*nrow); assert(total2=(int*)Calloc(nrow,int)); memset(total2,0,sizeof(int)*nrow); assert(R=(int*)Calloc(nrow,int)); /*comuter the original t-statfirst*/ compute_test_stat(pdata,pdata->L,T,func_stat,extra); /*sort the T*/ order_data(T,R,nrow,func_cmp); sort_gene_data(pdata,R); sort_vector(T,R,nrow); /*iteration for permutaion*/ (*func_first_sample)(bL); /*changed to the orignal stat, which is monotone of t and centered*/ is_next=1; b=0; while(is_next){ compute_test_stat(pdata,bL,bT,func_stat,extra); /*deal with unajdused value first*/ for(i=0;i<nrow;i++){ if(T[i]==NA_FLOAT) continue; if(bT[i]!=NA_FLOAT){ if((func_cmp==cmp_high)&&(bT[i]+EPSILON>=T[i])) count2[i]++; if((func_cmp==cmp_low)&&(bT[i]<=T[i]+EPSILON)) count2[i]++; if((func_cmp==cmp_abs)&&(fabs(bT[i])>=fabs(T[i])-EPSILON)) count2[i]++; total2[i]++; } } /*deal with adjusted values*/ qT=NA_FLOAT;/*intitalize the qT*/ for(i=nrow-1;i>=0;i--){ /*looping the row reversely*/ if(T[i]==NA_FLOAT) continue; /* right now I only implements the 3 cases, which are pretty common*/ if(func_cmp==cmp_high){ if((bT[i]!=NA_FLOAT)&&(qT!=NA_FLOAT)&&(bT[i]>qT)) qT=bT[i]; if((bT[i]!=NA_FLOAT)&&(qT==NA_FLOAT)) qT=bT[i]; if((qT!=NA_FLOAT)&&(qT>=T[i]-EPSILON)) count1[i]+=1; }else if(func_cmp==cmp_low){ if((bT[i]!=NA_FLOAT)&&(qT!=NA_FLOAT)&&(bT[i]<qT)) qT=bT[i]; if((bT[i]!=NA_FLOAT)&&(qT==NA_FLOAT)) qT=bT[i]; if((qT!=NA_FLOAT)&&(qT<=T[i]+EPSILON)) count1[i]+=1; }else if (func_cmp==cmp_abs) { if((bT[i]!=NA_FLOAT)&&(qT!=NA_FLOAT)&&(fabs(bT[i])>qT)) qT=fabs(bT[i]); if((bT[i]!=NA_FLOAT)&&(qT==NA_FLOAT)) qT=fabs(bT[i]); if((qT!=NA_FLOAT)&&(qT>=fabs(T[i])-EPSILON)) count1[i]+=1; } if(qT!=NA_FLOAT) total1[i]++; } b++; print_b(b,B,"b="); is_next=(*func_next_sample)(bL); } /*summarize the results*/ /*unadjusted one*/ for(i=0;i<nrow;i++){ if(total2[i]==0) P[i]=NA_FLOAT; else P[i]=count2[i]*1.0/total2[i]; } /*adjused one*/ for(i=0;i<nrow;i++){ if(total1[i]==0) Adj_P[i]=NA_FLOAT; else Adj_P[i]=count1[i]*1.0/total1[i]; } /*enforce the montonicity*/ for(i=1;i<nrow;i++) if(Adj_P[i]<Adj_P[i-1]) Adj_P[i]=Adj_P[i-1]; /*free the spaces*/ Free(bT); Free(count1); Free(total1); Free(count2); Free(total2); Free(bL); Free(R); }
void adj_pvalue_quick(GENE_DATA* pdata,float*T, float* P, float* Adj_P,float* Adj_Lower, FUNC_STAT func_stat,FUNC_STAT func_stat_T, FUNC_SAMPLE func_first_sample, FUNC_SAMPLE func_next_sample,FUNC_CMP func_cmp,const void* extra) { int *L,b,B,B_new,i,*R,neq; /*b for simulation*, neq is for the number of equal signs*/ float* all_P,*all_Q,count; int ncol=pdata->ncol,nrow=pdata->nrow; /*allocate the space*/ B=(*func_first_sample)(NULL); assert(L=(int*)Calloc(ncol,int)); assert(R=(int*)Calloc(nrow,int)); assert(all_P=(float*)Calloc(B,float)); assert(all_Q=(float*)Calloc(B,float)); /*get the original unadjusted p-values first we'll use the normalized t-statistics*/ get1pvalue(pdata,pdata->L,T,P,func_stat_T,func_first_sample,func_next_sample,func_cmp,extra); if(myDEBUG) { print_farray(stderr,T,pdata->nrow); print_farray(stderr,P,pdata->nrow); } /*sort the test_stat*/ order_mult_data(R,nrow,2,P,cmp_low,T,func_cmp); /*order_data(P,R,nrow,func_cmp);*/ /*rearrange the data according the unadjusted p-values*/ sort_gene_data(pdata,R); sort_vector(T,R,nrow); sort_vector(P,R,nrow); /*initialze all_Q[]=NA_FLOAT*/ for(b=0;b<B;b++) all_Q[b]=NA_FLOAT; /*loop for each gene*/ for(i=nrow-1;i>=0;i--){ get_all_samples_P(pdata->d[i],ncol,all_P,pdata->na, func_stat,func_first_sample,func_next_sample,func_cmp,extra); if(myDEBUG) print_farray(stderr,all_P,B); /*update all_Q*/ count=0; B_new=0; neq=0; for(b=0;b<B;b++){ if (all_P[b]==NA_FLOAT) break;/*we don't need care about NA pvlaues*/ if(all_Q[b]>all_P[b]) all_Q[b]=all_P[b];/*update q* by the value p*/ if(all_Q[b]==NA_FLOAT) continue;/*skip NA q*/ if(all_Q[b]<P[i]){ count+=1; }else if (all_Q[b]<=P[i]+EPSILON)/*it'd already > */ neq++; B_new++; } if(myDEBUG) { print_farray(stderr,all_Q,B); fprintf(stderr,"P[%d]=%5.3f,count=%5.2f,neq=%d\n",i,P[i],count,neq); } /*assign the Adj_P and Adj_Lower for gene i */ if(B_new!=0) { Adj_P[i]=(count+neq)/B_new; if(neq==0) Adj_Lower[i]=count/B_new; else Adj_Lower[i]=(count+1)/B_new; } else { Adj_P[i]=NA_FLOAT; Adj_Lower[i]=NA_FLOAT; } /*************************** */ print_b((nrow-i),nrow,"r="); } /* to make monotone of Adj_P and Adj_Lower*/ for(i=1;i<nrow;i++) if(Adj_P[i]<Adj_P[i-1]) Adj_P[i]=Adj_P[i-1]; for(i=1;i<nrow;i++) if(Adj_Lower[i]<Adj_Lower[i-1]) Adj_Lower[i]=Adj_Lower[i-1]; /*free the spaces*/ Free(L); Free(R); Free(all_P); Free(all_Q); }
bool TileManager::loadTiles() { std::string maptiles_path, masktype_path, path; NuvieIOFileRead objtiles_vga; NuvieIOFileRead tileindx_vga; NuvieIOFileRead file; U6Lib_n lib_file; U6Lzw *lzw; uint32 tile_offset; unsigned char *tile_data = NULL; uint32 maptiles_size = 0; uint32 objtiles_size; unsigned char *masktype = NULL; uint32 masktype_size; uint16 i; Dither *dither; dither = Game::get_game()->get_dither(); config_get_path(config,"maptiles.vga",maptiles_path); config_get_path(config,"masktype.vga",masktype_path); lzw = new U6Lzw(); switch(game_type) { case NUVIE_GAME_U6 : tile_data = lzw->decompress_file(maptiles_path,maptiles_size); if(tile_data == NULL) { ConsoleAddError("Decompressing " + maptiles_path); return false; } masktype = lzw->decompress_file(masktype_path,masktype_size); if(masktype == NULL) { ConsoleAddError("Decompressing " + masktype_path); return false; } break; case NUVIE_GAME_MD : case NUVIE_GAME_SE : if(lib_file.open(maptiles_path,4,game_type) == false) { ConsoleAddError("Opening " + maptiles_path); return false; } maptiles_size = lib_file.get_item_size(0); tile_data = lib_file.get_item(0); lib_file.close(); if(lib_file.open(masktype_path,4,game_type) == false) { ConsoleAddError("Opening " + masktype_path); return false; } //masktype_size = lib_file.get_item_size(0); masktype = lib_file.get_item(0); lib_file.close(); break; } if(tile_data == NULL) { ConsoleAddError("Loading maptiles.vga"); return false; } if(masktype == NULL) { ConsoleAddError("Loading masktype.vga"); return false; } config_get_path(config,"objtiles.vga",path); if(objtiles_vga.open(path) == false) { ConsoleAddError("Opening " + path); return false; } objtiles_size = objtiles_vga.get_size(); tile_data = (unsigned char *)nuvie_realloc(tile_data,maptiles_size + objtiles_size); objtiles_vga.readToBuf(&tile_data[maptiles_size], objtiles_size); config_get_path(config,"tileindx.vga",path); if(tileindx_vga.open(path) == false) { ConsoleAddError("Opening " + path); return false; } for(i=0;i<2048;i++) { tile_offset = tileindx_vga.read2() * 16; tile[i].tile_num = i; tile[i].transparent = false; switch(masktype[i]) { case U6TILE_TRANS : tile[i].transparent = true; memcpy(tile[i].data, &tile_data[tile_offset], 256); break; case U6TILE_PLAIN : memcpy(tile[i].data, &tile_data[tile_offset], 256); break; case U6TILE_PBLCK : tile[i].transparent = true; decodePixelBlockTile(&tile_data[tile_offset],i); break; } dither->dither_bitmap(tile[i].data,16,16,tile[i].transparent); tileindex[i] = i; //set all tile indexs to default value. this is changed in update() for animated tiles } loadAnimData(); loadTileFlag(); free(masktype); free(tile_data); look = new Look(config); if(look->init() == false) { ConsoleAddError("Initialising Look Class"); return false; } desc_buf = (char *)malloc(look->get_max_len() + 6); // add space for "%03d \n\0" or "the \n\0" if(desc_buf == NULL) { ConsoleAddError("Allocating desc_buf"); return false; } loadAnimMask(); #ifdef TILEMANAGER_DEBUG look->print(); DEBUG(0,LEVEL_DEBUGGING,"Dumping tile flags:"); for(i=0;i<2048;i++) { bool plural; DEBUG(1,LEVEL_DEBUGGING,"%04d : ",i); print_b(LEVEL_DEBUGGING, tile[i].flags1); DEBUG(1,LEVEL_DEBUGGING," "); print_b(LEVEL_DEBUGGING, tile[i].flags2); DEBUG(1,LEVEL_DEBUGGING," "); print_b(LEVEL_DEBUGGING, tile[i].flags3); DEBUG(1,LEVEL_DEBUGGING," %s\n",look->get_description(i,&plural)); } #endif delete lzw; return true; }
int main(int argc, char **argv) { /*This function simply initializes the pointers that will be passed throughout all of the subroutines * and calls each subroutine in order.*/ int *n,*size, sizeb=0, sizem=0; double *m,*b; m = NULL; b = NULL; n = NULL; size = NULL; m=b=0; //Checks to make sure that enough arguments have been supplied. If not, exit. if(argc<3) { printf("You have not supplied enough arguments.\nPlease input the name of the file containing the matrix and the name of the file containing the solution vector\n"); exit(EXIT_FAILURE); } size = malloc(sizeof(int)); n = malloc(sizeof(int)); if(argc == 4) { if(0 == strcmp ("-np",argv[3])) { //reads in the solution vector readin(argv[2],&b,size); //records the size of the solution vector sizeb = *size; //reads in the matrix readin(argv[1],&m,size); //records the dimension of the matrix sizem = sqrt(*size); if(pow(sizem,2) != *size) { printf("This matrix is not square!\n"); exit(EXIT_FAILURE); } //checks that the matrix dimension and the size of the solution vector are the same if(sizem != sizeb) { printf("The matrix is not the same size as the solution vector!!\n"); exit(EXIT_FAILURE); } *n = sizem; no_pivot(m,b,n); print_matrix(m,n); print_b(b,n); answer(m,b,n); } else printf("%s is not a valid flag\n",argv[4]); } //--------------------------------------------------------------------------------- //If there are only 3 arguments, default to pivoting if(argc == 3) { readin(argv[2],&b,size); //records the size of the solution vector sizeb = *size; readin(argv[1],&m,size); //records the dimension of the matrix sizem = sqrt(*size); if(pow(sizem,2) != *size) { printf("This matrix is not square!\n"); exit(EXIT_FAILURE); } //checks that the matrix dimension and the size of the solution vector are the same if(sizem != sizeb) { printf("The matrix is not the same size as the solution vector!!\n"); exit(EXIT_FAILURE); } *n = sizem; pivoting(m,b,n); print_b(b,n); answer(m,b,n); print_matrix(m,n); } free (m); free (b); free (n); free (size); return (0); }
void ReadFont(FILE *fin) { char b[128]; int ch; int w = 0, h = 0; int ch_h = 0; bool open = false; printf("#include <stdint.h>\n"); printf("#ifdef ARDUINO\n"); printf("#include \"fonts.hpp\"\n"); printf("#include <avr/pgmspace.h>\n"); printf("#endif\n"); printf("#ifndef PROGMEM\n"); printf("#define PROGMEM\n"); printf("#endif\n"); printf("\n"); while (fgets(b, sizeof(b), fin)) { if (sscanf(b, "// w=%d h=%d", &w, &h) == 2) { if (open) printf("};\n\n"); printf("const uint8_t font_%02dx%02d[] PROGMEM = {\n", w, h); printf("\t%d, %d,\n", w, h); open = true; continue; } if (sscanf(b, "// ch=%d", &ch) == 1) { continue; } if (b[0] == '.' || b[0] == 'X') { uint16_t r = 0; uint16_t m = 1; for (int i = w-1; i >= 0; --i) { if (b[i] == 'X') r |= m; m <<= 1; } if (false) { if (ch_h == 0) printf("\t"); if (w <= 8) printf("0x%02x,", r); else { printf("0x%02x,", r>>8); printf("0x%02x,", r&0xff); } ch_h += 1; if (ch_h == h) { printf(" // %3d %c\n", ch, ch); ch_h = 0; } } else { if (w <= 8) { printf("\t"); print_b(r, 8); printf(","); if (ch_h == 0) printf(" // %3d %c", ch, ch); } else { printf("\t"); print_b(r >> 8, 8); printf(","); print_b(r & 0xff, 8); printf(","); if (ch_h == 0) printf(" // %3d %c", ch, ch); } printf("\n"); ch_h += 1; if (ch_h == h) { ch_h = 0; printf("\n"); } } }