int main(int argc, char *argv[])
{
vector<HeuristicChooseReversal *> hcr_seq;
/* Set random seed */
unsigned long seed = mix(clock(), time(NULL), getpid());
/* Set random seed */
srand(seed);
/* Exact Unitaty Parameters */
ofstream fout;
/* Time results */
timestamp_t time_begin;
timestamp_t time_end;
time_begin = get_timestamp();
/* Log result file */
ostream *logOut = NULL;
ostream *logTime = NULL;
/* Check essential parameters */
// TODO: start to use parameter names instead of parameter sequence, ex: -p 1,2,4...
if (argc < 7) {
printf("Usage:\n");
printf("lwr_test_metaheuristic permutation number_of_iteration inversion_limit frame_limit is_signed cost_function {-r=[[...]]}.\n\n");
printf("Parameters description:\n");
printf(" 1. permutation: the input permutation.\n\n");
printf(" 2. number_of_iteration: number of iterations that will\n");
printf("be performed by the Metaheuristic.\n\n");
printf(" 3. inversion_limit: limit (upper bound) for the number of inversions\n");
printf("that will be selected at each iteration of the heuristic for building solutions.\n\n");
printf(" 4. frame_limit: percentege (in the interval (0,100]) of frames that \n");
printf("will be selected at each iteration of the Metaheuristic.\n\n");
printf(" 5. is_signed: 1 if the input permutation is signed, 0 otherwise.\n\n");
printf(" 6. cost_function: 1 for linear function, 2 for quadratic function and 3 logaritmic function.\n\n");
printf(" 7. -r=[[...]]: Optional parameter to give a seed solution as a input parameter\n");
return 0;
}
/* Seed result */
Result seed_result;
/* Permutation parameters */
parameter perm_param;
/* Exact Unitary parameters */
parameter exactP;
/* Improve parameters */
parameter improveP;
/* ChooseHeuristic parameters*/
parameter hcrP;
/* list of solvers for choose reversals */
vector<Solver *> solver_hcr;
string intervalMethod = "WINDOW";
string heuristicReversalsName = "BenefitLoss";
/* -------------------Read the parameters From terminal----------------- */
int p_read = 1;
// Read the permutation's sequence
vector<ll> perm_seq = read_seq(argv[p_read++]);
int num_it;
sscanf(argv[p_read++], "%d", &num_it);
int inv_limit;
sscanf(argv[p_read++], "%d", &inv_limit);
double frame_limit;
sscanf(argv[p_read++], "%lf", &frame_limit);
int is_signed;
sscanf(argv[p_read++], "%d", &is_signed);
int cost_function;
sscanf(argv[p_read++], "%d", &cost_function);
/* Construct the permutation */
if (is_signed) {
perm_param = getSignedParameters();
} else {
perm_param = getUnsignedGraspParameters();
}
Permutation perm = Permutation(perm_param, perm_seq);
// makes a copy from the original input permutation and set the normal mode
Permutation perm_orig = perm;
// Look for a input solution
Result input_seed_result;
bool has_input_seed_result = false;
if (p_read < argc) {
string solution = string(argv[p_read++]);
if (solution.substr(0, 2) == "-r") {
// in this caseheuristicName is supposed to be like -r=[[...]]
string str_result = solution.substr(3);
// Alterado por Ulisses
input_seed_result = Util::getResultFromStr(str_result.c_str(), cost_function);
has_input_seed_result = true;
Permutation perm_copy = perm;
bool valid = Solver::validateResult(perm_copy, input_seed_result, cout);
if (!valid) {
cout<<"Invalid input solution."<<endl;
exit(1);
}
}
}
/* -------------Check if the permutation is already sorted--------------- */
if (perm.isSorted(1, perm.size())) {
Result::printResult(seed_result, cout);
cout<<endl;
return 0;
}
/* ----------------------- Set Default Parameters ----------------------- */
parameter default_parameters = getDefaultParameters();
/* Set the output for results logging */
if (p_read < argc) {
logOut = new ofstream(argv[p_read++], std::ofstream::out|ofstream::app);
}
if (p_read < argc) {
logTime = new ofstream(argv[p_read++], std::ofstream::out|ofstream::app);
}
/* Look for Parameters */
string type;
parameter::iterator it;
for (it = default_parameters.begin(); it != default_parameters.end(); it++) {
pair<string, string> p = getParameterPair(it->F);
string type = p.F;
string name = p.S;
double value = it->S;
// get Num selected rev
if (type == "HCR") {
hcrP[name] = value;
} else if (type == "IMP") {
improveP[name] = value;
} else if (type == "BUILD_SOLUTION") {
exactP[name] = value;
}
p_read++;
}
/* Look for the unsigned mode */
improveP["UNSIGNED"] = !is_signed;
/* Create log file */
//ofstream log_out("log_test_signed.txt",ios_base::app);
/* ----------------------Set Parameters from terminal---------------------- */
hcrP["COST_FUNCTION"] = cost_function;
improveP["COST_FUNCTION"] = cost_function;
exactP["COST_FUNCTION"] = cost_function;
improveP["NUM_ROUND"] = num_it;
exactP["NUM_SELECTED_REV"] = inv_limit;
if (frame_limit <= 0 || frame_limit > 100) {
cerr<<"Error: frame_limit must be in the interval (0, 100]"<<endl;
exit(1);
}
improveP["ROLETTE_PERCENT_DISCARD"] = (100.0 - frame_limit);
/*---------------- Build the Choosen reversal Heuristic -------------------*/
hcr_seq = build_hcr_seq(
intervalMethod,
improveP,
hcrP,
exactP,
heuristicReversalsName
);
if (improveP["EXACT_UNITATY_LS"]) {
solver_hcr.push_back(new ExactUnitary(exactP, hcr_seq));
} else if (improveP["GRASP_HEURISTIC_LS"]) {
solver_hcr.push_back(new GRASPHeuristic(exactP, hcr_seq));
}
/*---------------------- Build The seed solution -------------------------*/
if (has_input_seed_result) {
seed_result = input_seed_result;
} else if (is_signed){
// Alterado por Ulisses
seed_result = sortByGRIMM(perm, true, cost_function);
} else {
seed_result = sortByGRIMMUnsigned(perm, NUM_IT_GRIMM_UNSIGNED, true, cost_function);
}
/*--------------------- Build Improvement Metaheuristic ------------------*/
ImproveReversals * ir = new ImproveReversals(
solver_hcr,
intervalMethod,
improveP,
logOut
);
/*-------------------------- Try improve the result ----------------------*/
Result r_improved = tryImprove(
seed_result,
ir,
perm_orig,
cost_function
);
/*----------------------- Validate result --------------------------------*/
bool valid = Solver::validateResult(perm_orig, r_improved, cout);
Result seedR = seed_result;
//seedR.reversals = seed_result;
seedR = Solver::calcTotalCost(seedR, cost_function);
/*------------------------- Print the result -----------------------------*/
if (valid) {
Result::printResult(r_improved, cout);
cout<<endl;
} else {
cout<<"ERROR";
return 1;
}
/*------------------------- Print time -----------------------------------*/
time_end = get_timestamp();
double time_sec = get_interval_time(time_begin, time_end);
if (logTime != NULL)
*(logTime)<<time_sec<<endl;
/* Clean all resources */
for (size_t i = 0; i < solver_hcr.size(); i++) {
delete solver_hcr[i];
}
solver_hcr.clear();
if (logOut != NULL)
delete logOut;
delete ir;
cleanResources();
return valid;
}
void rgblight_task(void) {
if (rgblight_status.timer_enabled) {
effect_func_t effect_func = rgblight_effect_dummy;
uint16_t interval_time = 2000; // dummy interval
uint8_t delta = rgblight_config.mode - rgblight_status.base_mode;
animation_status.delta = delta;
// static light mode, do nothing here
if ( 1 == 0 ) { //dummy
}
#ifdef RGBLIGHT_EFFECT_BREATHING
else if (rgblight_status.base_mode == RGBLIGHT_MODE_BREATHING) {
// breathing mode
interval_time = get_interval_time(&RGBLED_BREATHING_INTERVALS[delta], 1, 100);
effect_func = rgblight_effect_breathing;
}
#endif
#ifdef RGBLIGHT_EFFECT_RAINBOW_MOOD
else if (rgblight_status.base_mode == RGBLIGHT_MODE_RAINBOW_MOOD) {
// rainbow mood mode
interval_time = get_interval_time(&RGBLED_RAINBOW_MOOD_INTERVALS[delta], 5, 100);
effect_func = rgblight_effect_rainbow_mood;
}
#endif
#ifdef RGBLIGHT_EFFECT_RAINBOW_SWIRL
else if (rgblight_status.base_mode == RGBLIGHT_MODE_RAINBOW_SWIRL) {
// rainbow swirl mode
interval_time = get_interval_time(&RGBLED_RAINBOW_SWIRL_INTERVALS[delta / 2], 1, 100);
effect_func = rgblight_effect_rainbow_swirl;
}
#endif
#ifdef RGBLIGHT_EFFECT_SNAKE
else if (rgblight_status.base_mode == RGBLIGHT_MODE_SNAKE) {
// snake mode
interval_time = get_interval_time(&RGBLED_SNAKE_INTERVALS[delta / 2], 1, 200);
effect_func = rgblight_effect_snake;
}
#endif
#ifdef RGBLIGHT_EFFECT_KNIGHT
else if (rgblight_status.base_mode == RGBLIGHT_MODE_KNIGHT) {
// knight mode
interval_time = get_interval_time(&RGBLED_KNIGHT_INTERVALS[delta], 5, 100);
effect_func = rgblight_effect_knight;
}
#endif
#ifdef RGBLIGHT_EFFECT_CHRISTMAS
else if (rgblight_status.base_mode == RGBLIGHT_MODE_CHRISTMAS) {
// christmas mode
interval_time = RGBLIGHT_EFFECT_CHRISTMAS_INTERVAL;
effect_func = (effect_func_t)rgblight_effect_christmas;
}
#endif
#ifdef RGBLIGHT_EFFECT_RGB_TEST
else if (rgblight_status.base_mode == RGBLIGHT_MODE_RGB_TEST) {
// RGB test mode
interval_time = pgm_read_word(&RGBLED_RGBTEST_INTERVALS[0]);
effect_func = (effect_func_t)rgblight_effect_rgbtest;
}
#endif
#ifdef RGBLIGHT_EFFECT_ALTERNATING
else if (rgblight_status.base_mode == RGBLIGHT_MODE_ALTERNATING){
interval_time = 500;
effect_func = (effect_func_t)rgblight_effect_alternating;
}
#endif
if (animation_status.restart) {
animation_status.restart = false;
animation_status.last_timer = timer_read() - interval_time - 1;
animation_status.pos16 = 0; // restart signal to local each effect
}
if (timer_elapsed(animation_status.last_timer) >= interval_time) {
#if defined(RGBLIGHT_SPLIT) && !defined(RGBLIGHT_SPLIT_NO_ANIMATION_SYNC)
static uint16_t report_last_timer = 0;
static bool tick_flag = false;
uint16_t oldpos16;
if (tick_flag) {
tick_flag = false;
//dprintf("rgblight animation tick\n");
if (timer_elapsed(report_last_timer) >= 30000) {
report_last_timer = timer_read();
dprintf("rgblight animation tick report to slave\n");
RGBLIGHT_SPLIT_ANIMATION_TICK;
}
}
oldpos16 = animation_status.pos16;
//dprintf("call effect function\n");
#endif
animation_status.last_timer += interval_time;
effect_func(&animation_status);
#if defined(RGBLIGHT_SPLIT) && !defined(RGBLIGHT_SPLIT_NO_ANIMATION_SYNC)
//dprintf("pos16, oldpos16 = %d %d\n",
// animation_status.pos16,oldpos16);
if (animation_status.pos16 == 0 && oldpos16 != 0) {
//dprintf("flag on\n");
tick_flag = true;
}
#endif
}
}
}
