void run_sort_algorithms(t_info *info)
{
t_algo *best;
t_algo *b_sort;
t_algo *s_sort;
t_algo *d_sort;
b_sort = new_algo(info);
s_sort = new_algo(info);
d_sort = new_algo(info);
info->in_count = dumb_sort(d_sort, info);
compress_ops(d_sort->operations, &info->in_count);
best = d_sort;
bubble_sort(b_sort, info);
compress_ops(b_sort->operations, &b_sort->op_count);
if (b_sort->op_count < best->op_count && stack_sorted(b_sort->stack_a))
best = b_sort;
split_sort(s_sort, info);
print_stacks(s_sort->stack_a, s_sort->stack_b, info);
print_steps(s_sort->operations);
compress_ops(s_sort->operations, &s_sort->op_count);
if (s_sort->op_count < best->op_count && stack_sorted(s_sort->stack_a))
best = s_sort;
run_test2(best, info);
delete_algo(&b_sort);
delete_algo(&s_sort);
delete_algo(&d_sort);
}
struct OrderedPointArray* split_sort(struct OrderedPointArray *input){
if(input->x_ordered->length == 1){
return input;
}else{
struct PointArraySplitted *split_array = split_point_array(input->x_ordered);
struct OrderedPointArray *ordered1 = malloc(sizeof(struct OrderedPointArray));
ordered1->x_ordered = split_array->array1;
ordered1->y_ordered = split_array->array1;
struct OrderedPointArray *arr1 = split_sort(ordered1);
int p=0;
struct OrderedPointArray *ordered2 = malloc(sizeof(struct OrderedPointArray));
ordered2->x_ordered = split_array->array2;
ordered2->y_ordered = split_array->array2;
struct OrderedPointArray *arr2 = split_sort(ordered2);
struct OrderedPointArray *array_ordered = merge_point_array(arr1, arr2);
return array_ordered;
}
}
struct PointArray* closest_pair(char *filename){
struct Connection *conn = File_open(filename, "rt");
struct PointArray *point_array = Connection_process(conn);
Connection_close(conn);
struct PointArraySplitted *split_array = split_point_array(point_array);
struct OrderedPointArray *ordered1 = malloc(sizeof(struct OrderedPointArray));
ordered1->x_ordered = split_array->array1;
ordered1->y_ordered = split_array->array1;
struct OrderedPointArray *ordered2 = malloc(sizeof(struct OrderedPointArray));
ordered2->x_ordered = split_array->array2;
ordered2->y_ordered = split_array->array2;
struct PointArray *result;
struct OrderedPointArray *result1 = split_sort(ordered1);
struct OrderedPointArray *result2 = split_sort(ordered2);
struct OrderedPointArray *result_merged = merge_point_array(result1, result2);
divide_conquer(result_merged->x_ordered, result_merged->y_ordered);
return result;
}
/**
* @memberof class ABWT< ABSequence<std::string> >
* @brief 建構式與程式主體
* @param sequence ABSequence<std::string> 原始待排序序列
* @param dcs_size uint32_t dcs 參數，攸關dcs大小速度
* @param interval_size uint32_t 在建abwt表時所使用的間隔參數，越小越快，記憶體使用越大
*/
ABWT (SeqType &sequence, uint32_t dcs_size=512, uint32_t interval_size=64, std::string prefixName="")
:seq(sequence), len_seq(seq.size()) , dcs_v(dcs_size), abwtt(interval_size), split_size(30000000), _prefixName {prefixName}
{
//part 1
/// @brief 測試
start = clock();
// make dcs table
DIFFERENCE_COVER < SeqType, PreSortType > dcs(seq, dcs_v);
std::function<bool(INTTYPE, INTTYPE)> dcs_compare_func = std::bind( &DIFFERENCE_COVER < SeqType, PreSortType >::compare, dcs, std::placeholders::_1, std::placeholders::_2);
stop = clock();
std::clog << "===================================" << std::endl;
std::clog << "Create dcs table, time:" << double(stop - start) / CLOCKS_PER_SEC << std::endl;
std::clog << "===================================" << std::endl;
//part 2
start = clock();
// sort suffix using split sort
std::cout << "split_size : " << split_size << std::endl;
//new split sort obj
Split_sort< SeqType, std::vector< INTTYPE >, MainSortType > split_sort (seq,dcs_v);
//setting
split_sort.getTableV = [](INTTYPE& a){
return a;
};
split_sort.dcs_compare = dcs_compare_func;
//start split sort
split_sort.split_by_size_init(split_size);
// copy sorted result to seq_table(bwt)
//seq_table.reserve( seq.size() );
//seq_table.swap(split_sort.Results);
std::vector<std::string> filenames = split_sort.archive_name;
//release dcs memory
std::cout << "release dcs..." << std::endl;
dcs.release();
std::cout << "release split sort..." << std::endl;
split_sort.release();
stop = clock();
std::clog << "===================================" << std::endl;
std::clog << "Create BWT, time:" << double(stop - start) / CLOCKS_PER_SEC << std::endl;
std::clog << "===================================" << std::endl;
//part 3
start = clock();
// save abwt table
abwtt.createAllTable(seq, filenames);
//abwtt.saveBWT("t_bwt.bwt");
//abwtt.saveTable("t_table.bwt");
//abwtt.saveSEQ("t_seq.bwt", seq);
abwtt.saveBWT( _prefixName + "t_bwt.bwt");
abwtt.saveTable( _prefixName + "t_table.bwt");
abwtt.saveSEQ( _prefixName + "t_seq.bwt", seq);
stop = clock();
std::clog << "===================================" << std::endl;
std::clog << "Create abwt Table, time:" << double(stop - start) / CLOCKS_PER_SEC << std::endl;
std::clog << "===================================" << std::endl;
split_sort.clean_up ();
return ;
}
