/**
 * @brief main Example used for testing the algorithm, the correct usage ./isort max cnt. 
 * This creates a random array of size max constrained to -cnt to +cnt
 *
 * @return 
 */
int main ( int argc, char *argv[] )
{
	size_t len;
	uint32_t i;
	int32_t *src;
	int32_t max;
	if(argc < 3){
		printf("Correct Usage isort len max\n");
		perror("Incorrect isort.c usage");
		return EXIT_FAILURE;
	}
	srand(time(NULL));
	len = (size_t) atoi(argv[1]);
	max = (int32_t) atoi(argv[2]);
	printf("Creating random array of input %d and constrained to %d\n",
		(int) len, (int) max);
	src = cr_rnd_arr(len, max);
	print_arr(src,len);
	printf("Printing UP SORTED array\n");
	isort(src, len, ISORT_UP);
	print_arr(src, len);
	printf("Printing DOWN SORTED array\n");
	isort(src, len, ISORT_DOWN);
	print_arr(src,len);
	free(src);
	return EXIT_SUCCESS;
}

// 使用辅助数组 L[LEN], R[LEN]
void solve_1()
{
	int L[LEN], R[LEN];
	int i, _max = 0;

	for (i = 0;i < LEN;i++)
	{
		_max = max(_max, arr[i]);
		L[i] = _max;
	}

	_max = 0;
	for (i = LEN - 1;i >= 0;i--)
	{
		_max = max(_max, arr[i]);
		R[i] = _max;
	}

	print_arr(arr, LEN);
	print_arr(L, LEN);
	print_arr(R, LEN);

	int water_tol = 0;

	for (i = 1;i < LEN - 1;i++)
	{
		water_tol += max(0, (min(L[i - 1], R[i + 1]) - arr[i]));
	}
	printf("water_tol: %d\n", water_tol);
}

int main()
{
	int arr[] = {1, 20 ,6, 4, 5};
	print_arr(arr, 0, 4);
	merge_sort(arr, 5);
	print_arr(arr, 0, 4);
}

int main()
{
    int arr[] = {5, 2, 4, 6, 1, 3};
    print_arr(arr, 6);
    merge_sort (arr, 0, 5);
    print_arr(arr, 6);
    return 0;
}

int main()
{
        int* arr = createArr(10, INT);
        print_arr(arr, 10);
        mergeSort(arr, 0 , 9);
        print_arr(arr, 10);
        free(arr);
        return 0;
}

int main(int argc, char* argv[]) {
	const int N_SIZE = 10;
	int n[N_SIZE] = { 9,8,7,6,5,4,3,2,1,0 };
	insertion_sort(n, N_SIZE);
	print_arr(n, N_SIZE);
	int n2[N_SIZE] = {-9,-8, -7, -6, -5, -4, -3, -2, -1, 0};
	insertion_sort(n2, N_SIZE);
	print_arr(n2, N_SIZE);
}

int main(int argc, char* argv[])
{
	clock_t start, stop;
	int i, j;
	int N;
	double* a;
	double* b;
	double* c;
	if(argc < 2)
	{
		printf("Enter matrix size N=");
		//please enter small number first to ensure that the 
		//multiplication is correct! and then you may enter 
		//a "reasonably" large number say like 500 or even 1000
		scanf("%d",&N);
	}
	else
	{
		N = atoi(argv[1]);
	}
	
	a=(double*) malloc( sizeof(double)*N*N );
	b=(double*) malloc( sizeof(double)*N*N );
	c=(double*) malloc( sizeof(double)*N*N );

	init_arr(N,a);
	init_arr(N,b);

	//DGEMM Multiply
	//reallocate to force cash to be flushed
	a=(double*) malloc( sizeof(double)*N*N );
	b=(double*) malloc( sizeof(double)*N*N );
	c=(double*) malloc( sizeof(double)*N*N );
	init_arr(N,a);
	init_arr(N,b);

	start = clock();
	//for(i=0;i<1000;i++)
	Dgemm_multiply(a,b,c,N);
	stop = clock();

	printf("Dgemm_multiply(). Elapsed time = %g seconds\n",
		((double)(stop - start)) / CLOCKS_PER_SEC);
	//print simple test case of data to be sure multiplication is correct
	if (N < 7) {
		print_arr(N,"a", a);
		print_arr(N,"b", b);
		print_arr(N,"c", c);
	}

	free(a);
	free(b);
	free(c);

	return 0;
}

void insertion_sort(int* arr, int s)  {
  int V = *(arr + s - 1);
  int idx = s - 2;
  while ( -1 < idx && V < *(arr + idx) )  {
    *(arr + idx + 1) = *(arr + idx);
    print_arr(arr, s);
    --idx;
  }
  *(arr + idx + 1) = V;
  print_arr(arr, s);
}

int main(void)
{
	int arr[20];

	init_arr(arr, 20);
	print_arr(arr, 20);
	sort_arr(arr, 20);
	print_arr(arr, 20);
	
	return 0;
}

void map() {
	int* arr;


	double dt = 0.01;
	int N = 100000;
	Quadrotor* r = new Quadrotor(dt, N);

	VQPoles(r);

	int choices = 5;
	int repeat = 3;
	//int len = pow(choices, repeat);

	product(choices, repeat, arr);

	//double center[] = {10.0,  3.0,  7.0,  3.0};
	//double length[] = { 9.9,  2.9,  6.9,  2.9};

	double center[] = {-10.0, -10.0, -00.0};
	double length[] = {  5.0,   5.0,   0.0};

	double* coeff = new double[choices * repeat];

	printf("map start\n");

	for(int b = 0; b < 20; b++) {
		int a = -1;

		set_coeff(center, length, choices, repeat, coeff);
		a = sub1(r, arr, coeff, choices, repeat);

		if(a == -1) {
			printf("failed\n");
			return;
		}	

		for(int c = 0; c < repeat; c++) {
			center[c] = coeff[c*choices + arr[a*repeat + c]];
			length[c] = length[c] * 0.8;
		}



		printf("center length\n");
		print_arr(center, repeat);
		print_arr(length, repeat);

		//printf("a %i\n",a);
	}



}

int main(int argc, char **argv)
{
	int i,array[N];
	srand((unsigned)time(NULL));
	for(i = 0; i < N; i++)
		array[i] = rand() % 100;  //取随机数赋值
	print_arr(array,N);	
	bobsort(array,N);
	print_arr(array,N);
	return 0;
}

/*
 * Print an array of randomly-generated integers,
 * quicksort it, and then print it again
 *
 * Accept a command-line arg for the array length
 * and a -q flag to suppress output
 *
 * Sample input:
 * $ while true; do time quicksort -q 999999; done
 *
 * Spawn 4 background processes:
 * $ for i in {1..4}; do time quicksort -q 999999 & done
 */
int main(const int argc, const char *argv[])
{
    size_t arg, length = 0;
    int i, quiet = 0;
    int *numbers;

    /* Parse args */
    for (i = 1; i < argc; i++) {
        if (strncmp(argv[i], "-q", 2) == 0) {
            quiet = 1;
        } else {
            arg = strtoul(argv[i], NULL, 10);

            /* Use strtol in case sign is negative */
            if (strtol(argv[i], NULL, 10) < 2 || arg > MAX_LEN) {
                puts("ERROR: Invalid argument");
                printf("%s\n", argv[i]);
                return 1;
            }

            /* Set length if it isn't already set */
            if (length == 0)
                length = arg;
        }
    }

    /* No length set in parse args */
    if (length == 0)
        length = 64;

    /* No need to zero array with calloc, init_arr will init */
    numbers = malloc(length * sizeof(int));
    srandom(time(NULL));
    init_arr(numbers, length);

    if (! quiet) {
        puts("Array:");
        print_arr(numbers, length);
    }

    /* Pass first and last indices to quicksort */
    quicksort(numbers, 0, length - 1);

    if (! quiet) {
        puts("Quicksort:");
        print_arr(numbers, length);
    }

    /* Do the polite thing */
    free(numbers);

    return 0;
}

int
main()
{
    int nums[] = {21, 42, 50, 17, 12, 8, 54, 33, 22, 9, 10, 12, 3};
    int len = arr_len(nums);

    print_arr(nums, len);
    bucket_sort(nums, len);
    print_arr(nums, len);

    return 0;
}

int
main()
{
    int nums[] = {2, 4, 3, 1, 5, 9, 10, 8, 7, 6};
    int len = arr_len(nums);

    print_arr(nums, len);
    shell_sort(nums, len);
    print_arr(nums, len);

    return 0;
}

void InsertionSortWithSteps(int N, int *A)
{
    int j, pivot = A[N-1];
    for(j = N-2; j >= 0; j--)
        if(A[j] > pivot && (A[j+1] = A[j]))     //Same as if(A[j] > pivot){ A[j+1] = A[j]; print_arr(N, A); } else ..
            print_arr(N, A);
        else
            break;
            
    A[j+1] = pivot;
    print_arr(N, A);    
}

int main(void){
  ArrayUtil arr = create(4, 1);
  ArrayUtil arr2 = create(4, 3);
  areEqual(arr, arr2);
  arr = resize(arr, 7);
  print_arr(arr);
  int x = 20;
  *((int *)arr.base) = 20;
  printf("The index of %d is %d ", x, findIndex(arr, &x));
  print_arr(arr);
  dispose(arr);
  return 0;
};

int main(int argc, char *argv[])
{
  int *arr1, *arr2;
  int i;
  int num_element = atoi(argv[1]);
  int num_generation = atoi(argv[2]);
  /* Check command-line violations */
  if (argc > MaxArgc + 1 || num_element == 0 || num_generation == 0)
  {
    fprintf(stderr, "usage: %s #cells #generations\n", argv[0]);
    exit(1);
  }
  arr1 = initial_array(num_element);
  print_arr(arr1, num_element);
  if (num_generation > 1) /* If there is 1 generation, loop does not work */
  {
    for (i = 1; i < num_generation; i++)
    {
      /* Alternate between arr1, arr2 to store the updated array */
      if (i % 2 == 1)
      {
        arr2 = update(arr1, num_element);
        print_arr(arr2, num_element);
        free(arr1);
      }
      else
      {
        arr1 = update(arr2, num_element);
        print_arr(arr1, num_element);
        free(arr2);
      }
    }
    /* Prevent memory leakage of the array used last */
    if (num_generation % 2 == 0)
    {
      free(arr2);
    }
    else
    {
      free(arr1);
    }
  }
  else
  {
    free(arr1);
  }
  print_memory_leaks();
  return 0;
}

int main(int argc, char **argv)
{

	int array[N];
	int i;
	srand((unsigned)time(NULL));
 	for(i = 0; i < N; i++)
		array[i] = rand() % 100;
	print_arr(array,N);

	quicksort(array,N);
	print_arr(array,N);

	return 0;
}

int main(void)
{
    int i;
    int* arr = malloc(10 * sizeof(int));
    for (i = 0; i < 10; i++)
        arr[i] = i-5;

    print_arr(arr, 10);
    shuffle(arr, 0, 9);
    print_arr(arr, 10);

    free(arr);

    return 0;
}

int main() {
    add_elem('a');
    add_elem('b');
    add_elem('c');
    print_arr();
    printf("\nRemoved Elem: %c",remove_elem());
    printf("\nRemoved Elem: %c",remove_elem());
    add_elem('d');
    print_arr();
    add_elem('e');
    print_arr();
    add_elem('f');
    print_arr();
    return 0;
}