int main(int argc, char** argv) { /* Retrieve problem size. */ int length = LENGTH; int tsteps = TSTEPS; /* Variable declaration/allocation. */ DATA_TYPE out; POLYBENCH_3D_ARRAY_DECL(sum_c,DATA_TYPE,LENGTH,LENGTH,LENGTH,length,length,length); POLYBENCH_2D_ARRAY_DECL(c,DATA_TYPE,LENGTH,LENGTH,length,length); POLYBENCH_2D_ARRAY_DECL(W,DATA_TYPE,LENGTH,LENGTH,length,length); /* Initialize array(s). */ init_array (length, POLYBENCH_ARRAY(c), POLYBENCH_ARRAY(W)); /* Start timer. */ polybench_start_instruments; /* Run kernel. */ kernel_dynprog (tsteps, length, POLYBENCH_ARRAY(c), POLYBENCH_ARRAY(W), POLYBENCH_ARRAY(sum_c), &out); /* Stop and print timer. */ polybench_stop_instruments; polybench_print_instruments; /* Prevent dead-code elimination. All live-out data must be printed by the function call in argument. */ polybench_prevent_dce(print_array(out)); /* Be clean. */ POLYBENCH_FREE_ARRAY(sum_c); POLYBENCH_FREE_ARRAY(c); POLYBENCH_FREE_ARRAY(W); return 0; }
int main(int argc, char** argv) { /* Retrieve problem size. */ int n = N; int m = M; /* Variable declaration/allocation. */ DATA_TYPE float_n; POLYBENCH_2D_ARRAY_DECL(data,DATA_TYPE,M,N,m,n); POLYBENCH_2D_ARRAY_DECL(symmat,DATA_TYPE,M,M,m,m); POLYBENCH_1D_ARRAY_DECL(mean,DATA_TYPE,M,m); /* Initialize array(s). */ init_array (m, n, &float_n, POLYBENCH_ARRAY(data)); /* Start timer. */ polybench_start_instruments; /* Run kernel. */ kernel_covariance (m, n, float_n, POLYBENCH_ARRAY(data), POLYBENCH_ARRAY(symmat), POLYBENCH_ARRAY(mean)); /* Stop and print timer. */ polybench_stop_instruments; polybench_print_instruments; /* Prevent dead-code elimination. All live-out data must be printed by the function call in argument. */ polybench_prevent_dce(print_array(m, POLYBENCH_ARRAY(symmat))); /* Be clean. */ POLYBENCH_FREE_ARRAY(data); POLYBENCH_FREE_ARRAY(symmat); POLYBENCH_FREE_ARRAY(mean); return 0; }
static void switch_on_type(struct mlist *mlp, struct tdesc *tdp, char *format, int level) { switch (tdp->type) { case INTRINSIC: print_intrinsic(mlp, tdp, format, level); break; case POINTER: print_pointer(mlp, tdp, format, level); break; case ARRAY: print_array(mlp, tdp, format, level); break; case FUNCTION: print_function(mlp, tdp, format, level); break; case UNION: print_union(mlp, tdp, format, level); break; case ENUM: print_enum(mlp, tdp, format, level); break; case FORWARD: print_forward(mlp, tdp, format, level); break; case TYPEOF: print_typeof(mlp, tdp, format, level); break; case STRUCT: print_struct(mlp, tdp, format, level); break; case VOLATILE: print_volatile(mlp, tdp, format, level); break; default: fprintf(stderr, "Switch to Unknown type\n"); error = B_TRUE; break; } }
int main(int argc, char** argv) { /* Retrieve problem size. */ int w = W; int h = H; /* Variable declaration/allocation. */ DATA_TYPE alpha; POLYBENCH_2D_ARRAY_DECL(imgIn, DATA_TYPE, W, H, w, h); POLYBENCH_2D_ARRAY_DECL(imgOut, DATA_TYPE, W, H, w, h); POLYBENCH_2D_ARRAY_DECL(y1, DATA_TYPE, W, H, w, h); POLYBENCH_2D_ARRAY_DECL(y2, DATA_TYPE, W, H, w, h); /* Initialize array(s). */ init_array (w, h, &alpha, POLYBENCH_ARRAY(imgIn), POLYBENCH_ARRAY(imgOut)); /* Start timer. */ polybench_start_instruments; /* Run kernel. */ kernel_deriche (w, h, alpha, POLYBENCH_ARRAY(imgIn), POLYBENCH_ARRAY(imgOut), POLYBENCH_ARRAY(y1), POLYBENCH_ARRAY(y2)); /* Stop and print timer. */ polybench_stop_instruments; polybench_print_instruments; /* Prevent dead-code elimination. All live-out data must be printed by the function call in argument. */ polybench_prevent_dce(print_array(w, h, POLYBENCH_ARRAY(imgOut))); /* Be clean. */ POLYBENCH_FREE_ARRAY(imgIn); POLYBENCH_FREE_ARRAY(imgOut); POLYBENCH_FREE_ARRAY(y1); POLYBENCH_FREE_ARRAY(y2); return 0; }
int find_max_plus(int a[], int sz) { // /*int*/ a = merge_sort(a,0,sz-1,1); // print_array(a2,sz); // print_array(a,sz); int** mat = (int**)malloc(sizeof(int*)*(sz-1)); int i,j,k = 0; for(i=0;i<(sz-1);i++) { mat[i] = (int*)malloc(sizeof(int)*(i+1)); } for(i=0;i<=(sz-1-1);i++) { for(j=0;j<(i+1);j++) { mat[i][j] = a[i+1] + a[j]; printf("%d ",mat[i][j]); } printf("\n"); } int* arr = (int*) malloc(sizeof(int)*(sz)*(sz-1)/2); for(i=0;i<=(sz-1-1);i++) for(j=0;j<(i+1);j++) arr[k++] = mat[i][j]; printf("\n"); print_array(arr,sz*(sz-1)/2); // arr = merge_sort(arr,0,sizeof(arr)/sizeof(int)-1,1); k = -99999999; for(i=0;i<sz*(sz-1)/2;i++) { // printf("arr[%d] = %d\n",i,arr[i]); if( (k < arr[i]) && (in_array(a,sz,arr[i])==1) ) k = arr[i]; } return k; }
void combination_gen( int current_arr_pos ){ if( current_arr_pos > (r-1) ) return ; if( current_arr_pos == (r-1 ) ){ /*this is last position in array, so print till 'n' */ int i; for( i=arr[current_arr_pos] ; i<=n ; i++ ){ print_array(arr); arr[current_arr_pos]++; } printf("**\n"); } else{ while( arr[current_arr_pos] <= ( n-r+current_arr_pos+1 ) ){ arr[current_arr_pos+1]=arr[current_arr_pos]+1; combination_gen( current_arr_pos+1); arr[current_arr_pos]++; } } }
int main(int argc, char** argv) { /* Retrieve problem size. */ int n = N; /* Variable declaration/allocation. */ PENCILBENCH_2D_ARRAY_DECL(A, DATA_TYPE, N, N, n, n); printf("\n Problem Size : \n n= %d",n); fflush(stdout); /* Initialize array(s). */ init_array (n, A); /* Start timer. */ pencilbench_timer_start(); printf("\n Kernel Start"); /* Run kernel. */ kernel_lu(n,A); /* Stop and print timer. */ printf("\n Kernel End"); fflush(stdout); pencilbench_timer_stop(); printf("\n Execution time :"); fflush(stdout); pencilbench_timer_print(); printf("\n\n"); /* Prevent dead-code elimination. All live-out data must be printed by the function call in argument. */ pencilbench_prevent_dce(print_array(n,A)); /* Free arrays. */ PENCILBENCH_FREE_ARRAY(A); return 0; }
int main(int argc, char** argv) { /* Retrieve problem size. */ int n = N; int tsteps = TSTEPS; /* Variable declaration/allocation. */ POLYBENCH_2D_ARRAY_DECL(u, DATA_TYPE, N, N, n, n); POLYBENCH_2D_ARRAY_DECL(v, DATA_TYPE, N, N, n, n); POLYBENCH_2D_ARRAY_DECL(p, DATA_TYPE, N, N, n, n); POLYBENCH_2D_ARRAY_DECL(q, DATA_TYPE, N, N, n, n); /* Initialize array(s). */ init_array (n, POLYBENCH_ARRAY(u)); /* Start timer. */ polybench_start_instruments; /* Run kernel. */ kernel_adi (tsteps, n, POLYBENCH_ARRAY(u), POLYBENCH_ARRAY(v), POLYBENCH_ARRAY(p), POLYBENCH_ARRAY(q)); /* Stop and print timer. */ polybench_stop_instruments; polybench_print_instruments; /* Prevent dead-code elimination. All live-out data must be printed by the function call in argument. */ polybench_prevent_dce(print_array(n, POLYBENCH_ARRAY(u))); /* Be clean. */ POLYBENCH_FREE_ARRAY(u); POLYBENCH_FREE_ARRAY(v); POLYBENCH_FREE_ARRAY(p); POLYBENCH_FREE_ARRAY(q); return 0; }
int main(int argc,char **argv) { int i; int j; int k; int n = 1024; /* Initialize array. */ init_array(); /* Start timer. */ #pragma scop #pragma live - out A { int ub1; int lb1; int c5; int c3; int c1; if (n >= 2) { for (c1 = 0; c1 <= n + -2; ++c1) { for (c3 = c1 + 1; c3 <= n + -1; ++c3) { (A[c1])[c3] = (((A[c1])[c3]) / ((A[c1])[c1])); } for (c3 = c1 + 1; c3 <= n + -1; ++c3) { for (c5 = c1 + 1; c5 <= n + -1; ++c5) { (A[c3])[c5] = (((A[c3])[c5]) - (((A[c3])[c1]) * ((A[c1])[c5]))); } } } } } #pragma endscop /* Stop and print timer. */ print_array(argc,argv); return 0; }
int main() { FILE *fp; int num[MAX_LINE][MAX_LINE] = {{0}}; if ((fp = fopen("EulerProject18.data", "r")) == NULL) { perror("fopen"); exit(1); } for (int i=0; i<MAX_LINE; i++) { for (int j=0; j<=i; j++) { fscanf(fp, "%d", &num[i][j]); } } for (int i=1; i<MAX_LINE; i++) { for (int j=0; j<=i; j++) { if (j == 0) { num[i][j] = num[i][j] + num[i-1][j]; continue; } num[i][j] = num[i][j] + max(num[i-1][j-1], num[i-1][j]); } } print_array(num); int max = 0; for (int i=0; i<MAX_LINE; i++) { if (num[MAX_LINE-1][i] > max) { max = num[MAX_LINE-1][i]; } } printf("Answer: %d\n", max); fclose(fp); return 0; }
int main(int argc, char* argv[]) { int c, d, swap; monitor *m; int n = ARRAY_SIZE; int *array; array = malloc(n * sizeof(int)); make_array(array, n, ARRAY_ALGO); NOTIFY(print_array(array, n, OUT_LINE_SIZE)); m = monitor_init(SELF); monitor_start(m); NOTIFY("entering sorting algo\n"); for (c = 0 ; c < ( n - 1 ); c++) { for (d = 0 ; d < n - c - 1; d++) { if (array[d] > array[d+1]) /* For decreasing order use < */ { swap = array[d]; array[d] = array[d+1]; array[d+1] = swap; } } } monitor_end(m); assert(verify(array, n)); /* print_array(&array, n, OUT_LINE_SIZE); */ monitor_print_stats(m, VERBOSE); return 0; }
int main(int argc, char** argv) { if (argc < 2) { printf("Invalid arguments.\n"); return 0; } /* Retrieve problem size. */ int n = N; int tsteps = TSTEPS; numThreads = atoi(argv[1]); /* Variable declaration/allocation. */ POLYBENCH_2D_ARRAY_DECL(A, DATA_TYPE, N, N, n, n); POLYBENCH_2D_ARRAY_DECL(B, DATA_TYPE, N, N, n, n); /* Initialize array(s). */ init_array (n, POLYBENCH_ARRAY(A), POLYBENCH_ARRAY(B)); /* Start timer. */ polybench_start_instruments; /* Run kernel. */ kernel_jacobi_2d(tsteps, n, POLYBENCH_ARRAY(A), POLYBENCH_ARRAY(B)); /* Stop and print timer. */ polybench_stop_instruments; polybench_print_instruments; /* Prevent dead-code elimination. All live-out data must be printed by the function call in argument. */ polybench_prevent_dce(print_array(n, POLYBENCH_ARRAY(A))); /* Be clean. */ POLYBENCH_FREE_ARRAY(A); POLYBENCH_FREE_ARRAY(B); return 0; }
int main(int argc, char** argv) { fid = fopen("memory.txt", "w+t"); /* Retrieve problem size. */ int n = N; int tsteps = TSTEPS; /* Variable declaration/allocation. */ POLYBENCH_2D_ARRAY_DECL(X, DATA_TYPE, N, N, n, n); POLYBENCH_2D_ARRAY_DECL(A, DATA_TYPE, N, N, n, n); POLYBENCH_2D_ARRAY_DECL(B, DATA_TYPE, N, N, n, n); /* Initialize array(s). */ init_array (n, POLYBENCH_ARRAY(X), POLYBENCH_ARRAY(A), POLYBENCH_ARRAY(B)); /* Start timer. */ polybench_start_instruments; /* Run kernel. */ kernel_adi (tsteps, n, POLYBENCH_ARRAY(X), POLYBENCH_ARRAY(A), POLYBENCH_ARRAY(B)); /* Stop and print timer. */ polybench_stop_instruments; polybench_print_instruments; /* Prevent dead-code elimination. All live-out data must be printed by the function call in argument. */ print_array(n, POLYBENCH_ARRAY(X)); /* Be clean. */ POLYBENCH_FREE_ARRAY(X); POLYBENCH_FREE_ARRAY(A); POLYBENCH_FREE_ARRAY(B); return 0; }
int main(void) { myInt a = 20; int i = 0; //int b[10]; array10 b; array10 bb[3] = { 0 }; array10* p = NULL; //int(*p)[10] = NULL; for (i = 0; i < 10; i++) { b[i] = i; } printf("-----\n"); print_array(bb, 3); return 0; }
int main() { double start_time, end_time; DATA_TYPE (*A)[N][1] = (DATA_TYPE (*)[N][1]) malloc(N * sizeof(DATA_TYPE)); init_data(*A, N); /* pencil_saxpy_nn */ start_time = get_time(); pencil_cscal_n(N, 10.0, 10.0, 1, *A); end_time = get_time(); #ifdef BENCHMARK_TIME fprintf(TIME_OUTPUT_FILE, "%0.6lf", end_time - start_time); fprintf(TIME_OUTPUT_FILE, "\n"); #endif #ifdef BENCHMARK_DUMP_ARRAYS print_array(*A, N); #endif return 0; }
int main(int argc, char* argv[]) { int n = ARRAY_SIZE; int array[ARRAY_SIZE]; monitor *m; make_array(&array, n, ARRAY_ALGO); NOTIFY(print_array(&array, n, OUT_LINE_SIZE)); m = monitor_init(SELF); monitor_start(m); bsort(&array, n); monitor_end(m); assert(verify(&array, n)); /* print_array(&array, n, OUT_LINE_SIZE); */ monitor_print_stats(m, VERBOSE); return 0; }
int main() { // 1. init interpreter ruby_init(); ruby_init_loadpath(); //ruby_script("embed.rb"); // 2. load global objects Init_SysInfo(); // 3. run script // int state = eval_buffer("puts \"kamin babo\"\nprint $hardware"); // int state = eval_file("/Users/yielding/test/rb/embed/embed.rb"); int state = eval_file("embed.rb"); if (state) printf("error\n"); print_array(hardware_list); // 4. finalize // ruby_finalize(); ruby_cleanup(0); }
int main() { int len, i; // int array[] = {6,1,8,3,5,7,2,4}; // int array[] = {7,6,5,4,3,2,1,0}; // int array[] = {6,5,4,3,2,1,0}; // int array[] = {6,1,5,6,-3,2,1,0}; // len = 8; len = 2000000; len = 20; int array[len]; for(i = 0; i < len; ++i) array[i] = len - i; // int *for_merging = (int *) malloc(len * sizeof(int)); void *heap_array = malloc(len * sizeof(int)); int *for_merging = (int *) heap_array; merge_sort(array, len, for_merging); free(heap_array); print_array(array, len); return 0; }
/*simple loop*/ int binarySearch2(int a[],int needle,int n) { print_array(a,n); printf("needle:%d\n",needle); int start = 0; int end = n-1; int middle; while(start <= end) { middle = (start+end)/2; printf("start:%d\n",start); printf("end:%d\n",end); printf("middle:%d\n",middle); if(needle < a[middle]) end = middle-1; else if(needle > a[middle]) start = middle+1; else if(needle == a[middle]) return middle; } return -1; }
int main(int argc,char *argv[]) { int N=atoi(argv[1]); item_t *array=malloc(N*sizeof(*array)); int i,j; int step; srand((unsigned)time(NULL)); for(i=0;i<=M;i++){ count_sub[i]=0; } for(i=0;i<N;i++){ array[i]=rand()%N; } quick_sort(array,0,N-1); printf("subfile size for insertion:\n"); print_array(count_sub,M+1); putchar('\n'); for(i=0;i<=M;i++){ printf("%2d:\t",i); step=N/1000; step=(step==0)?1:step; for(j=0;j<count_sub[i];j+=step){ printf("*"); } putchar('\n'); } free(array); return(0); }
void nb_unit_test_case() { srand((unsigned int)(time(NULL))); const int kMaxSize = 10; const int kMaxValue = 100; int buffer[kMaxSize]; int dst_sum = 15; printf("sum equal [%d], sequences are : \n", dst_sum); get_sequence_with_sum(dst_sum); for (int k = 0; k < kMaxSize; k++) { buffer[k] = rand() % kMaxValue; printf("%d ", buffer[k]); } printf("\n"); rearrage_array(buffer, kMaxSize); print_array(buffer); int arr[5] = { 1, 2, 3, 2, 1 }; int res = arr[0]; for (int iter = 1; iter < 5; iter++) { res ^= arr[iter]; } printf("res = %d\n", res); // c_mod_test(); float_point_test(); is_little_endian(); }
int main(int argc, char** argv) { /* Retrieve problem size. */ int n = N; /* Variable declaration/allocation. */ #ifdef POLYBENCH_HEAP_ARRAYS /* Heap arrays use variable 'n' for the size. */ DATA_TYPE POLYBENCH_2D_ARRAY_DECL(C, n, n); C = POLYBENCH_ALLOC_2D_ARRAY(n, n, DATA_TYPE); #else /* Stack arrays use the numerical value 'N' for the size. */ DATA_TYPE POLYBENCH_2D_ARRAY_DECL(C,N,N); #endif /* Initialize array(s). */ init_array (n, POLYBENCH_ARRAY(C)); /* Start timer. */ polybench_start_instruments; /* Run kernel. */ kernel_template (n, POLYBENCH_ARRAY(C)); /* Stop and print timer. */ polybench_stop_instruments; polybench_print_instruments; /* Prevent dead-code elimination. All live-out data must be printed by the function call in argument. */ polybench_prevent_dce(print_array(n, POLYBENCH_ARRAY(C))); /* Be clean. */ POLYBENCH_FREE_ARRAY(C); return 0; }
int main() { /* Test sum */ int a[3] = {1, 2, 3}; printf("1. sum returned %d. Expecting 6.\n", sum(a, 3)); int b[1] = {10}; printf("2. sum returned %d. Expecting 10.\n", sum(b, 1)); /* Test biggest */ printf("3. biggest returned %d. Expecting 3.\n", biggest(a, 3)); printf("4. biggest returned %d. Expecting 10\n", biggest(b, 1)); int c[4] = {4, -1, 0, 3}; printf("5. biggest returned %d. Expecting 4\n", biggest(c, 1)); int d[3] = {-4, -1, -5}; printf("6. biggest returned %d. Expecting -1\n", biggest(d, 3)); /* Test average */ printf("7. average returned %f. Expecting 2.0\n", average(a, 3)); printf("8. average returned %f. Expecting 10.0\n", average(b, 1)); printf("9. average returned %f. Expecting 1.5\n", average(c, 4)); printf("10. average returned %f. Expecting -3.3333\n", average(d, 3)); /* Test reverse */ printf("Reversing d - original: "); print_array(d, 3); printf(" reversed: "); reverse(d, 3); print_array(d, 3); printf("Reversing c - original: "); print_array(c, 4); printf(" reversed: "); reverse(c, 4); print_array(c, 4); printf("Reversing b - original: "); print_array(b, 1); printf(" reversed: "); reverse(b, 1); print_array(b, 1); return 0; }
int tests_SparseArray_getMin(int test_number) { int n_tests = 7; // If test_number is out of range, then... if(test_number < 0 || test_number >= n_tests) { //return how many distinct test-cases we have. return n_tests; } // Assume failure unless otherwise noted int success = FALSE; printf("Testing: SparseNode_getMin(a%d)\n", test_number); SparseNode * sol_node = NULL; //build the array to be searched sol_node = make_array(test_number); printf("Built array a%d:\n", test_number); print_array(sol_node, 0); int stu = SparseArray_getMin(sol_node); int sol = SparseArray_getMin_sol(sol_node); printf("Student getMin: %d\n", stu); printf("Solution getMin: %d\n", sol); if(stu == sol) { success = TRUE; } // Cleanup if(sol_node) { SparseArray_destroy_sol(sol_node); } return success; }
int main(int argc, char** argv) { int tmax = TMAX; int nx = NX; int ny = NY; double(*ex)[NX][NY]; ex = (double(*)[NX][NY])polybench_alloc_data((NX) * (NY), sizeof(double)); double(*ey)[NX][NY]; ey = (double(*)[NX][NY])polybench_alloc_data((NX) * (NY), sizeof(double)); double(*hz)[NX][NY]; hz = (double(*)[NX][NY])polybench_alloc_data((NX) * (NY), sizeof(double)); double(*_fict_)[TMAX]; _fict_ = (double(*)[TMAX])polybench_alloc_data(TMAX, sizeof(double)); init_array(tmax, nx, ny, *ex, *ey, *hz, *_fict_); polybench_timer_start(); kernel_fdtd_2d(tmax, nx, ny, *ex, *ey, *hz, *_fict_); polybench_timer_stop(); polybench_timer_print(); if (argc > 42 && !strcmp(argv[0], "")) print_array(nx, ny, *ex, *ey, *hz) free((void*)ex); free((void*)ey); free((void*)hz); free((void*)_fict_); return 0; }
int main(int argc, char * argv[]) { // Deal with args if (argc < 2) { printf("\nUSAGE: %s ARRAY_SIZE\n\n", argv[0]); return 1; } int length = atoi(argv[1]); // Header stdout printf("\n -- %s --\n", argv[0]); printf("\nSorting an array of length %d\n", length); // Generate the array srand(time(NULL)); int * array = generate_array(length); print_array(array, length); // Sort the array // All done terminate(array); return 0; }
int quick_sort(int array[], int length) { if (length > 1) { int i = 0, j = length - 2; int median = get_median(array, length); print_array(array, length); while (1) { while (array[++i] < median) { } while (array[--j] > median) { } if (i < j) { swap(array, i, j); } else { break; } } swap(array, i, length - 1); quick_sort(array, i); quick_sort(array + i + 1, length - i - 1); } return 0; }
void merge_in_place(int* a, int len) { int left = 0; int right = len/2; // printf("a[len/2] = %d\n", a[len/2]); // print_array(a, len); int insert = 0; while (left < len && right < len) { if (left == right) { if (left >= len/2) { break; } left = insert; } int temp = a[insert]; if (a[left] <= a[right]) { a[insert] = a[left]; a[left] = temp; insert++; left = insert; } else // right < left { a[insert] = a[right]; a[right] = temp; left = right; right++; insert++; } print_array(a, len); } }
/********************************************** p指向一个玩家数组,有 player_count 个玩家(ddz中是3). 每一个玩家有一个指向一手牌的指针数组,每一个指针指向一张牌, 共有 num 张牌(ddz中是17张),每个玩家只发17张牌 pcard 指向一副牌的指针,这副牌依次从1到14(共54张牌,第55、56无效) 玩家: player0 player2 player1 返回值:谁是地主?0,1,2 同时,把底牌存入dipai指向的一个pcd数组,每一个元素是一个指针 *************************************************/ int fapai(pplayer p, int player_count, int num, pcd pcard, pcd *dipai) { int i, j, dz, dizhi[54], *pdizhi; /*dizhi[54]中保存1 - 54之间的随机数,前17张牌是第一个玩家的*/ pcd ppai = pcard; pdizhi = dizhi; printf("fapai start:\n"); srand( (unsigned)time( NULL ) ); dz = rand() % 3; /*产生一个 0 - 2 之间的随机数,标志谁是地主*/ shuffle(dizhi); /*洗牌*/ print_array(dizhi, 54); for(i = 0; i < player_count; i++) { for(j = 0; j < num; j++) { p->pai[j] = ppai + *pdizhi - 1; /*p指向一个玩家player,该玩家是一个结构,他有一副牌pai[]*/ /*这副牌是20个指向Card的指针, pcard是一个指针,指向整副牌*/ /*一定要减1, 因为是 1 - 54 的数*/ pdizhi++; } p++; } for(i = 0; i < 3; i++) { *dipai = ppai + *pdizhi - 1; /*底牌*/ dipai++; pdizhi++; } printf("fapai OK!\n"); return dz; }
int main(int argc, char **argv) { /* Retrieve problem size. */ int nr = NR; int nq = NQ; int np = NP; /* Variable declaration/allocation. */ POLYBENCH_3D_ARRAY_DECL(A, DATA_TYPE, NR, NQ, NP, nr, nq, np); POLYBENCH_1D_ARRAY_DECL(sum, DATA_TYPE, NP, np); POLYBENCH_2D_ARRAY_DECL(C4, DATA_TYPE, NP, NP, np, np); /* Initialize array(s). */ init_array(nr, nq, np, POLYBENCH_ARRAY(A), POLYBENCH_ARRAY(C4)); /* Start timer. */ polybench_start_instruments; /* Run kernel. */ kernel_doitgen(nr, nq, np, POLYBENCH_ARRAY(A), POLYBENCH_ARRAY(C4), POLYBENCH_ARRAY(sum)); /* Stop and print timer. */ polybench_stop_instruments; polybench_print_instruments; /* Prevent dead-code elimination. All live-out data must be printed by the function call in argument. */ polybench_prevent_dce(print_array(nr, nq, np, POLYBENCH_ARRAY(A))); /* Be clean. */ POLYBENCH_FREE_ARRAY(A); POLYBENCH_FREE_ARRAY(sum); POLYBENCH_FREE_ARRAY(C4); return 0; }