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;
}
