int main(void){
#if (DEBUGTYPE == SWDUMP)
volatile int KnuthN, KnuthA, KnuthB, KnuthRunTime, i;
#endif
SYSCTL_RCGCGPIO_R |= 0x20; // activate Port F
SysTick_Init(); // initialize SysTick timer, Program 4.7
GPIO_PORTF_DIR_R |= 0x04; // make PF2 out (built-in blue LED)
GPIO_PORTF_AFSEL_R &= ~0x04;// disable alt funct on PF2
GPIO_PORTF_DEN_R |= 0x04; // enable digital I/O on PF2
// configure PF2 as GPIO
GPIO_PORTF_PCTL_R = (GPIO_PORTF_PCTL_R&0xFFFFF0FF)+0x00000000;
GPIO_PORTF_AMSEL_R = 0; // disable analog functionality on PF
#if (DEBUGTYPE == HWPORT)
SYSCTL_RCGCGPIO_R |= 0x08; // activate Port D
while((SYSCTL_PRGPIO_R&0x08) == 0){};// allow time to finish activating
GPIO_PORTD_DIR_R |= 0x0F; // make PD3-0 out
GPIO_PORTD_AFSEL_R &= ~0x0F;// disable alt funct on PD3-0
GPIO_PORTD_DEN_R |= 0x0F; // enable digital I/O on PD3-0
// configure PD3-0 as GPIO
GPIO_PORTD_PCTL_R = (GPIO_PORTD_PCTL_R&0xFFFF0000)+0x00000000;
GPIO_PORTD_AMSEL_R &= ~0x0F;// disable analog functionality on PD3-0
#endif
// ****************insertion sort************************
before = NVIC_ST_CURRENT_R;
sort_insertion(keys, sorted, 16); // insertion sort into array 'sorted'
elapsed = (before - NVIC_ST_CURRENT_R - 7)&0x00FFFFFF;
// the number 7 depends on the instructions before and after test
// if you remove the call to sort, elapsed measures 0
#if (DEBUGTYPE == SWDUMP)
KnuthN = 16; // number of items to be sorted
KnuthA = 0; // number of moves
KnuthB = 0; // number of changes in the left-to-right minimum
i = 1;
while((i < DEBUG_LENGTH) && (Debug_place[i] != 0)){
if(Debug_place[i] == 2){
KnuthB = KnuthB + 1;
if(Debug_place[i+1] == 1){ // possible array out-of-bounds error if DEBUG_LENGTH is too small
KnuthA = KnuthA + 1;
}
}
i = i + 1;
}
KnuthRunTime = 9*KnuthB + 10*KnuthN - 3*KnuthA - 9; // expect 514 for his data
#endif
// *********************************************************
while(1){
Debug_Set(); // PF2=1
sort_insertion(keys, sorted, 16);// insertion sort into array 'sorted'
Debug_Clear(); // PF2=0
}
}
sortingAdapter(int *x, int n, int *y, int a, int b){
sort_obmen_1_2(x,n);
sort_selection_1_0(x,n);
sort_insertion(x,n);
MergeSort(x,n);
adapter_merge_sort(x,n);
}
static SORT_RET_E sort_quick_partition_median(unsigned int ui_low_index,
unsigned int ui_high_index,
unsigned int *pui_median_index)
{
unsigned int uia_key_index[3] = {0};
unsigned int ui_rand = 0;
unsigned int ui_i = 0;
SORT_RET_E e_ret = eSORT_FAILURE;
if(NULL == pui_median_index)
{
e_ret = eSORT_INVALID_ARG;
goto LBL_SORT_QUICK_PARTITION_MEDIAN_RET;
}
for(ui_i = 0 ; ui_i < 3 ; ui_i++)
{
ui_rand = (unsigned int)rand();
/*Rand % difference gives a random offset in the range hence must be added to the lower index*/
uia_key_index[ui_i] = ui_low_index + (ui_rand % (ui_high_index - ui_low_index + 1));
}
e_ret = sort_insertion(uia_key_index,
3,
sizeof(uia_key_index[0]),
eSORT_ASCENDING,
sort_quick_compare_unsigned_int);
if(eSORT_SUCCESS != e_ret)
{
e_ret = eSORT_FAILURE;
goto LBL_SORT_QUICK_PARTITION_MEDIAN_RET;
}
*pui_median_index = uia_key_index[1];
e_ret = eSORT_SUCCESS;
LBL_SORT_QUICK_PARTITION_MEDIAN_RET:
return e_ret;
}
int test_sort()
{
int i, result = 0, length, min_data_val, max_data_val;
int *temp_data;
int data[10];
test_msg_start("Test Selection Sort - Preset Array");
sort_set_array(data);
sort_selection(data, 0, 9);
result += test_sort_data(data, 0, 9);
result += test_sort_data_loc(data);
test_msg_end(result);
test_msg_start("Test Selection Sort - Random Data");
for(i = 0; i < SORT_TESTS; i++) {
random_seed();
min_data_val = random_int(INT_MIN+1, (INT_MAX/2)-1);
max_data_val = random_int(min_data_val, (INT_MAX/2)-1);
length = random_int(500, 1000); /* get length of a new array */
temp_data = malloc(sizeof(int) * length);
sort_rnd_data_fill(temp_data, length, min_data_val, max_data_val);
sort_selection(temp_data, 0, length);
result += test_sort_data(temp_data, 0, length);
free(temp_data);
temp_data = NULL;
}
test_msg_end(result);
test_msg_start("Test Insertion Sort - Preset Array");
sort_set_array(data);
sort_insertion(data, 0, 9);
result += test_sort_data(data, 0, 9);
result += test_sort_data_loc(data);
test_msg_end(result);
test_msg_start("Test Insertion Sort - Random Data");
for(i = 0; i < SORT_TESTS; i++) {
random_seed();
min_data_val = random_int(INT_MIN+1, (INT_MAX/2)-1);
max_data_val = random_int(min_data_val, (INT_MAX/2)-1);
length = random_int(500, 1000); /* get length of a new array */
temp_data = malloc(sizeof(int) * length);
sort_rnd_data_fill(temp_data, length, min_data_val, max_data_val);
sort_insertion(temp_data, 0, length);
result += test_sort_data(temp_data, 0, length);
free(temp_data);
temp_data = NULL;
}
test_msg_end(result);
test_msg_start("Test Quick Sort (Recursive) - Preset Array");
sort_set_array(data);
sort_quick(data, 0, 9);
result += test_sort_data(data, 0, 9);
result += test_sort_data_loc(data);
test_msg_end(result);
test_msg_start("Test Quick Sort (Recursive) - Random Data");
for(i = 0; i < SORT_TESTS; i++) {
random_seed();
min_data_val = random_int(INT_MIN+1, (INT_MAX/2)-1);
max_data_val = random_int(min_data_val, (INT_MAX/2)-1);
length = random_int(500, 1000); /* get length of a new array */
temp_data = malloc(sizeof(int) * length);
sort_rnd_data_fill(temp_data, length, min_data_val, max_data_val);
sort_quick(temp_data, 0, length);
result += test_sort_data(temp_data, 0, length);
free(temp_data);
temp_data = NULL;
}
test_msg_end(result);
test_msg_start("Test Quick Sort - Preset Array");
sort_set_array(data);
sort_quick_norecurse(data, 0, 9);
result += test_sort_data(data, 0, 9);
result += test_sort_data_loc(data);
test_msg_end(result);
test_msg_start("Test Quick Sort - Random Data");
for(i = 0; i < SORT_TESTS; i++) {
random_seed();
min_data_val = random_int(INT_MIN+1, (INT_MAX/2)-1);
max_data_val = random_int(min_data_val, (INT_MAX/2)-1);
length = random_int(500, 1000); /* get length of a new array */
temp_data = malloc(sizeof(int) * length);
sort_rnd_data_fill(temp_data, length, min_data_val, max_data_val);
sort_quick_norecurse(temp_data, 0, length);
result += test_sort_data(temp_data, 0, length);
free(temp_data);
temp_data = NULL;
}
test_msg_end(result);
return result;
}
maina()
{
int i = 0;
int *task_array;
int selected_sort = 1, selected_array = 1, selected_size = 1, size_of_array = 0,
rand_min = 0, rand_max = 100;
int command;
int *array_selected = 0;
bool recalled = FALSE;
long double *ld_array, sum, variance, avg;
setlocale(LC_ALL, "Korean");
{
printf("\t정렬 알고리즘 정밀 측정기\n\n");
RE_COLE1:
printf("\t알고리즘 선택\n\t1. 선택\t\t2. 삽입\t3. 거품\t4. 쉘\t5. 퀵\t6. 퀵(비재귀)\n\t7. 퀵(랜덤)\t8. 퀵(부분)\t9. 퀵(가운데)\n"
"\t10. 기수\t11. 버킷\t12. 힙\t13. 병합\n\t14. 자동생성\n선택 : ");
scanf_s("%d", &selected_sort);
if (selected_sort < 1 || selected_sort > 14) {
printf("다시 선택하세요.\n");
goto RE_COLE1;
}
else if (selected_sort == 14) {
printf("\n\t오류가 심한 버킷알고리즘은 제외하고 생성합니다.\n\t시작하려면 아무키나 눌러주세요...");
_getch();
printf("\n");
report_auto();
}
if (recalled)
goto RECALLED;
RE_COLE2:
printf("\n\t배열 선택\n\t1. 순배열\t2. 역순배열\t3. 중복없는 임의배열\n\t4. 중복있는 임의배열\n선택 : ");
scanf_s("%d", &selected_array);
if (selected_array < 1 || selected_array > 4) {
printf("다시 선택하세요.\n");
goto RE_COLE2;
}
if (selected_array > 2) {
RE_SET1:
printf("랜덤최소 숫자 : ");
scanf_s("%d", &rand_min);
printf("랜덤최고 숫자 : ");
scanf_s("%d", &rand_max);
if (rand_min >= rand_max || rand_min < 0) {
printf("다시 맞춰라\n");
goto RE_SET1;
}
}
if (recalled)
goto RECALLED;
RE_COLE3:
printf("\n\t배열 크기 선택\n\t1. 10\t2. 100\t3. 1,000\t4. 10,000\t5. 100,000\n\t6. 1,000,000\t7. 직접입력\n선택 : ");
scanf_s("%d", &selected_size);
if (selected_size < 1 || selected_size > 7) {
printf("다시 선택하세요.\n");
goto RE_COLE3;
}
if (selected_size == 7) {
printf("횟수 입력 : ");
scanf_s("%d", &size_of_array);
}
else
size_of_array = pow(10, selected_size);
if (recalled)
goto RECALLED;
}
recalled = TRUE;
{
RECALLED:
fast_cls();
while (TRUE) {
wprintf(L"\t선택된 알고리즘: %s\n\t선택된 배 열: %s\n\t선택된 배열크기: %s\n",
sort_name[selected_sort - 1], array_name[selected_array - 1], commasput(size_of_array));
if (selected_array > 2) {
printf("\t숫 자 범 위: %d ~ %d", rand_min, rand_max);
}
printf("\n\n");
printf("\t1. 알고리즘변경\t\t2. 배열변경\t3. 크기변경");
if (selected_array > 2) {
printf("\t4. 범위변경\n\t5. 실험시작");
}
else printf("\t4. 실험시작");
printf("\n>> ");
scanf_s("%d", &command);
if (selected_array > 2 && command == 4)
goto RE_SET1;
else if (command == 1)
goto RE_COLE1;
else if (command == 2)
goto RE_COLE2;
else if (command == 3)
goto RE_COLE3;
else if (command == 4 || (selected_array > 2 && command == 5))
{
RAND_MIN = rand_min;
RAND_SECTION = rand_max - rand_min + 1;
SIZE_OF_ARRAY = size_of_array;
array_direct = (int *)malloc(sizeof(int)*size_of_array);
array_reverse = (int *)malloc(sizeof(int)*size_of_array);
array_random = (int *)malloc(sizeof(int)*size_of_array);
array_overlap = (int *)malloc(sizeof(int)*size_of_array);
fast_cls();
printf("진행횟수? ");
scanf_s("%d", &command);
fast_cls();
selected_array_g = selected_array;
task_array = (int *)malloc(sizeof(int) * SIZE_OF_ARRAY);
ld_array = (long double *)malloc(sizeof(long double) * command);
for (i = 0; i < command; i++) {
init_array();
if (selected_array == 1)
array_selected = array_direct;
else if (selected_array == 2)
array_selected = array_reverse;
else if (selected_array == 3)
array_selected = array_random;
else if (selected_array == 4)
array_selected = array_overlap;
switch (selected_sort) {
case 1:
timer_start();
sort_selection (array_selected, SIZE_OF_ARRAY);
timer_finish();
break;
case 2:
timer_start();
sort_insertion (array_selected, SIZE_OF_ARRAY);
timer_finish();
break;
case 3:
timer_start();
sort_bubble (array_selected, SIZE_OF_ARRAY);
timer_finish();
break;
case 4:
timer_start();
sort_shell (array_selected, SIZE_OF_ARRAY);
timer_finish();
break;
case 5:
timer_start();
sort_quick0 (array_selected, SIZE_OF_ARRAY);
timer_finish();
break;
case 6:
timer_start();
sort_quick1 (array_selected, SIZE_OF_ARRAY);
timer_finish();
break;
case 7:
timer_start();
sort_quick2 (array_selected, SIZE_OF_ARRAY);
timer_finish();
break;
case 8:
timer_start();
sort_quick3 (array_selected, SIZE_OF_ARRAY);
timer_finish();
break;
case 9:
timer_start();
sort_quick4 (array_selected, SIZE_OF_ARRAY);
timer_finish();
break;
case 10:
timer_start();
radix_sort (array_selected, SIZE_OF_ARRAY);
timer_finish();
break;
case 11:
timer_start();
sort_bucket (array_selected, SIZE_OF_ARRAY, task_array);
timer_finish();
break;
case 12:
timer_start();
sort_heap (array_selected, SIZE_OF_ARRAY);
timer_finish();
break;
case 13:
timer_start();
sort_merge (array_selected, SIZE_OF_ARRAY, task_array);
timer_finish();
break;
}
ld_array[i] = timer_getns();
}
free(task_array);
printf("\n\n--------------실험 결과--------------\n");
sum = 0.0f;
for (i = 0; i < command; i++) {
printf("%.12lf ns\n", ld_array[i]);
sum += ld_array[i];
}
avg = sum / command;
variance = 0.0f;
for (i = 0; i < command; i++) {
variance += pow(ld_array[i] - avg, 2);
}
variance /= command;
printf("-------------------------------------\n");
printf("합계 : %.12lf ns\n평균 : %.12lf ns\n분산 : %.12lf\t표준편차 : %.12lf\n\n", sum, avg, variance, sqrt(variance));
getchar();
}
else
printf("없는 명령입니다.");
}
}
return 0;
}
void report_auto()
{
TCHAR appData[MAX_PATH];
FILE *fp;
int algorithm, array, count, i;
int size_of_array = 0;
int *task_array;
int *array_selected = 0;
bool recalled = FALSE;
int cxt = 0;
long double *ld_array, sum, variance, avg;
char addr[256];
RAND_MIN = 0;
RAND_SECTION = 10000000 - 0 + 1;
/*if (SUCCEEDED(SHGetFolderPath(NULL,
CSIDL_LOCAL_APPDATA | CSIDL_FLAG_CREATE,
NULL,
SHGFP_TYPE_CURRENT,
appData)))
{*/
//sprintf_s(addr, 256, "%s%s%d%s", appData, "\\report_", (int)time(NULL), ".log");
//sprintf_s(addr, 256, "%s%s", "C:", "\\report_.log");
_wfopen_s(&fp, _T("C:\\rollrat\\report_sort.log"), _T("w+"));
/*fwprintf(fp, _T("정렬 알고리즘 정밀 측정기으로부터 자동으로 생성되었음.\n\n"));
fwprintf(fp, _T("[알고리즘] [배열] [횟수] 순으로 알고리즘 목록이 생성되며, 바로 밑에 합계, 평균, 분산, 표준편차가 기제됩니다. 최대 횟수는 십만번이며, ")
_T("천 개 이하의 자료개수에서만 중복없는 임의배열이 적용됩니다. 랜덤최소 값은 0이며 최대값은 10000으로 설정됩니다. 횟수는 모두 10회입니다.\n\n"));*/
for (algorithm = 1; algorithm < 14; algorithm++)
{
if (algorithm == 11 || algorithm == 7 || algorithm == 8 || algorithm == 9)
continue; // 버킷 알고리즘 사용안함
for (array = 0; array < 4; array++)
{
for (count = 1; count < 5; count++)
{
//if (count > 3 && array == 2)
// break; // 중복없는 임의배열 적용안함
size_of_array = pow(10, count);//(double)((double)count / 2));
SIZE_OF_ARRAY = size_of_array;
task_array = (int *)malloc(sizeof(int) * size_of_array);
array_direct = (int *)malloc(sizeof(int)*size_of_array);
array_reverse = (int *)malloc(sizeof(int)*size_of_array);
array_random = (int *)malloc(sizeof(int)*size_of_array);
array_overlap = (int *)malloc(sizeof(int)*size_of_array);
#define _MAX_COUNT 30
ld_array = (long double *)malloc(sizeof(long double) * _MAX_COUNT);
for (i = 0; i < _MAX_COUNT; i++) {
selected_array_g = array + 1;
init_array();
if (array == 0)
array_selected = array_direct;
else if (array == 1)
array_selected = array_reverse;
else if (array == 2)
array_selected = array_random;
else if (array == 3)
array_selected = array_overlap;
switch (algorithm) {
case 1:
timer_start();
sort_selection(array_selected, SIZE_OF_ARRAY);
timer_finish();
break;
case 2:
timer_start();
sort_insertion(array_selected, SIZE_OF_ARRAY);
timer_finish();
break;
case 3:
timer_start();
sort_bubble(array_selected, SIZE_OF_ARRAY);
timer_finish();
break;
case 4:
timer_start();
sort_shell(array_selected, SIZE_OF_ARRAY);
timer_finish();
break;
case 5:
timer_start();
sort_quick0(array_selected, SIZE_OF_ARRAY);
timer_finish();
break;
case 6:
timer_start();
sort_quick1(array_selected, SIZE_OF_ARRAY);
timer_finish();
break;
case 7:
timer_start();
sort_quick2(array_selected, SIZE_OF_ARRAY);
timer_finish();
break;
case 8:
timer_start();
sort_quick3(array_selected, SIZE_OF_ARRAY);
timer_finish();
break;
case 9:
timer_start();
sort_quick4(array_selected, SIZE_OF_ARRAY);
timer_finish();
break;
case 10:
timer_start();
radix_sort(array_selected, SIZE_OF_ARRAY);
timer_finish();
break;
case 11:
timer_start();
sort_bucket(array_selected, SIZE_OF_ARRAY, task_array);
timer_finish();
break;
case 12:
timer_start();
sort_heap(array_selected, SIZE_OF_ARRAY);
timer_finish();
break;
case 13:
timer_start();
sort_merge(array_selected, SIZE_OF_ARRAY, task_array);
timer_finish();
break;
}
ld_array[i] = timer_getns();
}
sum = 0.0f;
for (i = 0; i < _MAX_COUNT; i++) {
sum += ld_array[i];
}
avg = sum / _MAX_COUNT;
variance = 0.0f;
for (i = 0; i < _MAX_COUNT; i++) {
variance += pow(ld_array[i] - avg, 2);
}
variance /= _MAX_COUNT;
fwprintf(fp, _T("[%s] [%s] [%s]\n"), sort_name[algorithm - 1], array_name[array], commasput(size_of_array));
fwprintf(fp, _T("합계 : %.12lf ns\n평균 : %.12lf ns\n분산 : %.12lf\n표준편차 : %.12lf\n\n"), sum, avg, variance, sqrt(variance));
printf("[%d/216]완료됨\n", ++cxt);
// 오래걸리고 많이하면 과부하걸려서 걍 없앰
/*free(ld_array);
free(array_overlap);
free(array_random);
free(array_reverse);
free(array_direct);
free(task_array);*/
}
}
}
fwprintf(fp, _T("end"));
fclose(fp);
//}
printf("C:\\rollrat\\report_sort.log에 성공적으로 생성하였습니다.");
}
/// Parse resource path.
///
/// Tags are sorted by hash value.
/// Returns false if the given path is malformed.
bool resource::parse_path(
StringRef const& path,
ResourcePathParts& pp
) {
enum : unsigned {
NOT_FOUND = ~0u,
};
pp.type_hash = RES_TYPE_NULL;
pp.name_hash = RES_NAME_NULL;
pp.type = StringRef{};
pp.name = StringRef{};
fixed_array::clear(pp.tags);
unsigned ext_i = NOT_FOUND;
unsigned tag_i = NOT_FOUND;
unsigned tag_first = NOT_FOUND;
ResourcePathParts::Tag tag;
for (unsigned i = 0; i < path.size; ++i) {
if (path[i] == '.') {
if (ext_i == NOT_FOUND) {
ext_i = i;
} else {
return false;
}
} else if (path[i] == '#') {
if (tag_i == NOT_FOUND) {
tag_first = i;
} else if (tag_i == i || fixed_array::space(pp.tags) == 0) {
return false;
} else {
tag.name = {
path.data + tag_i,
i - tag_i
};
tag.hash = resource::hash_tag(tag.name);
fixed_array::push_back(pp.tags, tag);
}
tag_i = i + 1;
}
}
unsigned const last_index = path.size - 1;
unsigned const type_first = ext_i + 1;
unsigned const type_last = min(tag_first, path.size);
if (
ext_i == NOT_FOUND || ext_i == 0 || ext_i == last_index ||
ext_i > tag_first || type_last - type_first == 0 ||
tag_i == path.size ||
path[ext_i - 1] == '/' ||
path[ext_i - 1] == '\\'
) {
return false;
}
pp.type = StringRef{path.data + type_first, type_last - type_first};
pp.name = StringRef{path.data, ext_i};
pp.type_hash = resource::hash_type(pp.type);
pp.name_hash = resource::hash_name(pp.name);
if (tag_i < path.size) {
if (fixed_array::space(pp.tags) == 0) {
return false;
}
tag.name = {
path.data + tag_i,
path.size - tag_i
};
tag.hash = resource::hash_tag(tag.name);
fixed_array::push_back(pp.tags, tag);
}
sort_insertion(begin(pp.tags), end(pp.tags), TagLessThan{});
pp.tag_glob_hash = resource::hash_tag_glob(
begin(pp.tags),
fixed_array::size(pp.tags)
);
return true;
}
