/******************************************************************************
* MAIN
******************************************************************************/
int main(int argc, char * argv[])
{
int A[MAX_NUM_NR];
char * filename_unsorted = get_filename(argc, argv);
char * filename_sorted = get_sorted_filename(filename_unsorted);
int n = get_A(A, MAX_NUM_NR, filename_unsorted);
print_A(A, n, "original:");
heap_sort(A, n);
print_A(A, n, "sorted:");
assert(verify_A(A, n, filename_sorted));
/* priority queue */
int heapsize = n;
build_max_heap(A, heapsize);
______________________________(A, n, heapsize, "===============\\nafter build_max_heap\\n===============");
printf("heap_maximum: %d\n", heap_maximum(A, heapsize));
printf("heap_extract_max: %d\n", heap_extract_max(A, &heapsize));
print_A(A, heapsize, "after heap_extract_max");
______________________________(A, n, heapsize, "===============\\nafter heap_extract_max\\n===============");
heap_increase_key(A, heapsize, 3, 88);
print_A(A, heapsize, "after heap_increase_key");
______________________________(A, n, heapsize, "===============\\nafter heap_increase_key\\n===============");
max_heap_insert(A, n, &heapsize, 97);
print_A(A, heapsize, "after max_heap_insert");
______________________________(A, n, heapsize, "===============\\nafter max_heap_insert\\n===============");
return 0;
}
int test_datastructure_rbtree_map(void)
{
int ret = 0;
rbtree_map_pos_t it,next,end;
rbtree_map_t *map;
allocator_t *allocator = allocator_get_default_alloc();
pair_t *pair;
struct rbtree_map_node *mnode;
int key_len = 2;
struct A t1 = {1,2};
struct A t2 = {2,2};
struct A t3 = {3,2};
struct A t4 = {4,2};
struct A t5 = {5,2};
dbg_str(DBG_DETAIL,"rbtree allocator addr:%p",allocator);
map = rbtree_map_create(allocator,0);
rbtree_map_init(map,key_len,sizeof(struct A) + key_len,NULL);
dbg_str(DBG_DETAIL,"create_pair");
pair = create_pair(key_len,sizeof(struct A));
make_pair(pair,"44",&t4);
rbtree_map_insert(map,pair->data);
make_pair(pair,"33",&t3);
rbtree_map_insert(map,pair->data);
make_pair(pair,"22",&t2);
rbtree_map_insert(map,pair->data);
make_pair(pair,"11",&t1);
rbtree_map_insert(map,pair->data);
dbg_str(DBG_DETAIL,"foreach ordinal print");
for( rbtree_map_begin(map,&it),rbtree_map_pos_next(&it,&next);
!rbtree_map_pos_equal(&it,rbtree_map_end(map,&end));
it = next,rbtree_map_pos_next(&it,&next))
{
mnode = rb_entry(it.rb_node_p,struct rbtree_map_node,node);
dbg_buf(DBG_DETAIL,"key:",mnode->key,mnode->value_pos);
print_A((struct A*)rbtree_map_pos_get_pointer(&it));
}
dbg_str(DBG_DETAIL,"search node key = 22");
rbtree_map_search(map, (void *)"22",&it);
print_A((struct A*)rbtree_map_pos_get_pointer(&it));
/*
*dbg_str(DBG_DETAIL,"delte node key = 11");
*container_delete(map,&it);
*/
rbtree_map_destroy(map);
allocator_destroy(allocator);
dbg_str(DBG_DETAIL,"map addr =%p",map);
return ret;
}
/******************************************************************************
* main
******************************************************************************/
int main(int argc, char * argv[])
{
int A[MAX_NUM_NR];
char * filename_unsorted = get_filename(argc, argv);
char * filename_sorted = get_sorted_filename(filename_unsorted);
int n = get_A(A, MAX_NUM_NR, filename_unsorted);
print_A(A, n, "original:");
insertion_sort(A, n);
print_A(A, n, "sorted:");
assert(verify_A(A, n, filename_sorted));
return 0;
}
int main(int argc, char *argv[])
{
printf("The first four letters of the alphabet:\n");
print_A();
print_B();
print_C();
print_D();
return(RETVALUE);
}
/******************************************************************************
* main
******************************************************************************/
int main(int argc, char * argv[])
{
int n;
int A[MAX_NUM_NR];
char * filename_unsorted = get_filename(argc, argv);
char * filename_sorted = get_sorted_filename(filename_unsorted);
int i;
for (i = 0; i < 2; i++) {
n = get_A(A, MAX_NUM_NR, filename_unsorted);
print_A(A, n, "original:");
merge_sort(A, n, i == 0 ? normal : sentinel);
print_A(A, n, "sorted (merge sort, %s merge):",
i == 0 ? "normal" : "sentinel");
assert(verify_A(A, n, filename_sorted));
}
return 0;
}
int main(int argc, char **argv) {
/* Prototype functions*/
void gauss();
MPI_Init(&argc, &argv);
/* Get my process rank */
MPI_Comm_rank(MPI_COMM_WORLD, &my_rank);
/* Find out how many processes are being used */
MPI_Comm_size(MPI_COMM_WORLD, &p);
printf("\nProcess number %d of %d says hi\n",
my_rank+1, p);
/* Every process reads the parameters to prepare dimension */
parameters(argc, argv);
/* Every process must allocate memory for the arrays */
allocate_memory();
if ( my_rank == SOURCE ) {
/* Initialize A and B */
initialize_inputs();
/* Print input matrices */
print_inputs();
}
/*printf("\nProcess number %d of %d says hi\n",
my_rank+1, p);*/
gauss();
if ( my_rank == SOURCE ) {
/* Print input matrices */
print_A();
print_B();
print_X();
}
/* The barrier prevents any process to reach the finalize before the others have finished their communications */
MPI_Barrier(MPI_COMM_WORLD);
/* Free memory used for the arrays that we allocated previously */
free_memory();
MPI_Finalize();
}
int main()
{
msg_count_login = 0;
user_count = 0;
bad_login_count = 0;
A_menu:
while (1)
{
print_A();
if (handle_A_input() == 2)
goto B_menu;
}
B_menu:
while (1)
{
print_B();
if (handle_B_input() == 2)
goto A_menu;
}
return 0;
}
int main(int argc, char * argv[])
{
int A[MAX_NUM_NR];
char * filename_unsorted = 0;
int r = 0;
opterr = 0;
while (1) {
int c;
static struct option long_options[] = {
{"verbose", required_argument, 0, 'v'},
{"radix", required_argument, 0, 'r'},
{"file", required_argument, 0, 'f'},
{0, 0, 0, 0}
};
/* getopt_long stores the option index here. */
int option_index = 0;
c = getopt_long(argc, argv, "v:r:f:",
long_options, &option_index);
/* Detect the end of the options. */
if (c == -1)
break;
switch (c) {
case 0:
/* If this option set a flag, do nothing else now. */
if(long_options[option_index].flag != 0)
break;
printf("option %s", long_options[option_index].name);
if(optarg)
printf(" with arg %s", optarg);
printf("\n");
break;
case 'v':
verbose = atoi_or_abort(optarg);
printf("%sverbose:%d%s\n", GREEN_B, verbose, NOCOLOR);
break;
case 'r':
r = atoi_or_abort(optarg);
printf("%sr:%d%s\n", GREEN_B, r, NOCOLOR);
break;
case 'f':
filename_unsorted = optarg;
break;
case '?':
/* getopt_long already printed an error message. */
printf("%sbad arg. %s%s\n", RED_B, argv[optind-1], NOCOLOR);
break;
default:
abort();
}
}
/* Print any remaining command line arguments (not options). */
if (optind < argc)
{
printf("these ARGV-elements will be ignored: %s", RED);
while (optind < argc)
printf ("%s ", argv[optind++]);
printf("%s\n", NOCOLOR);
}
if (!filename_unsorted) {
printf("%sNo test case file given, abort.%s\n", RED_B, NOCOLOR);
print_usage(argv[0]);
abort();
}
if (!r) {
printf("%sNo radix is given, abort.%s\n", RED_B, NOCOLOR);
print_usage(argv[0]);
abort();
}
char * filename_sorted = get_sorted_filename(filename_unsorted);
int n = get_A(A, MAX_NUM_NR, filename_unsorted);
print_A(A, n, "original:");
radix_sort(A, n, 32, r);
/* counting_sort(A, n, r, 0); */
print_A(A, n, "sorted:");
assert(verify_A(A, n, filename_sorted));
return 0;
}
