double handle_op_sum(stack_t **args, int *is_bad_formula)
{
if (*args == NULL)
goto error;
double result = 0.0, operand;
char *front = pop_copy(args);
while(front != NULL) {
operand = atof(front, cgc_strlen(front) + 1, is_bad_formula);
free(front);
if(*is_bad_formula)
goto error;
result += operand;
front = pop_copy(args);
}
goto done;
error:
*is_bad_formula = 1;
result = 0.0;
done:
return result;
}
double handle_op_count(stack_t **args, int *is_bad_formula)
{
size_t i = 0;
if (*args == NULL)
goto error;
double result = 0.0, operand;
char *front = pop_copy(args);
while(front != NULL) {
operand = atof(front, cgc_strlen(front) + 1, is_bad_formula);
free(front);
if(*is_bad_formula)
goto error;
front = pop_copy(args);
i++;
}
result = i;
goto done;
error:
clear_stack(args);
*is_bad_formula = 1;
result = 0.0;
done:
if (i == 0) {
i = 1;
goto error;
}
return result;
}
static int eval_function(operator_t *op, stack_t **values, char *val_str, size_t size)
{
if (op == NULL || val_str == NULL || size <= 2)
return -1;
double val = 0.0;
char *arg;
char *op_name = (char *) op->name;
size_t i, num_args = 0;
int is_bad_formula = 0;
operator_t *nested_op;
stack_t *args = NULL;
if (is_arg_arithmetic(op_name)) {
num_args = 2;
} else {
char *arg_count = pop_copy(values);
if (arg_count == NULL)
goto error;
num_args = strtol(arg_count, NULL, 10);
free(arg_count);
}
for (i = 0; i < num_args; i++) {
arg = pop_copy(values);
//printf("arg[%d]==%s\n", i, arg);
if (parsearg(arg) == FUNCTION) {
nested_op = get_op(arg);
free(arg);
if (eval_function(nested_op, values, val_str, size) == 0)
push_copy(&args, val_str, size);
else
goto error;
} else if (push(&args, arg) != 0) {
goto error;
}
}
val = op->function(&args, &is_bad_formula);
if (is_bad_formula)
goto error;
if (ftoa(val, val_str, size) == NULL)
goto error;
return 0;
error:
clear_stack(&args);
return -1;
}
double handle_op_power(stack_t **args, int *is_bad_formula)
{
if (*args == NULL)
goto error;
double result = 0.0, operand1, operand2;
char *front;
// Get first operand
front = pop_copy(args);
if (front == NULL)
goto error;
operand1 = atof(front, cgc_strlen(front) + 1, is_bad_formula);
free(front);
if(*is_bad_formula)
goto error;
// Get second operand
front = pop_copy(args);
if (front == NULL)
goto error;
operand2 = atof(front, cgc_strlen(front) + 1, is_bad_formula);
free(front);
if(*is_bad_formula)
goto error;
if (*args != NULL)
goto error; // Too many arguments
if (operand2 == 0.0)
result = 1.0;
else if (operand2 == 1.0)
result = operand1;
else if (isnan(operand2))
result = operand2;
else if (operand1 == 0 && operand2 > 0)
result = 0.0;
else if (operand1 < 0 && remainder(operand2, 1) == 0.0)
result = pow(-operand1, operand2) * (remainder(operand2, 2) == 0 ? 1 : -1);
else
result = pow(operand1, operand2);
goto done;
error:
clear_stack(args);
*is_bad_formula = 1;
result = 0.0;
done:
return result;
}
double handle_op_stddev(stack_t **args, int *is_bad_formula)
{
size_t i = 0;
if (*args == NULL)
goto error;
double result = 0.0, operand, mean = 0.0;
stack_t *tmp = *args;
while (tmp != NULL) {
operand = atof(tmp->data, cgc_strlen(tmp->data) + 1, is_bad_formula);
if(*is_bad_formula)
goto error;
mean += operand;
i++;
tmp = tmp->next;
}
if (i == 0)
goto done;
mean /= i;
i = 0;
char *front = pop_copy(args);
while(front != NULL) {
operand = atof(front, cgc_strlen(front) + 1, is_bad_formula);
free(front);
//TODO - Look into this, I don't know why pow is failing
//result += (pow((operand - mean), 2.0));
result += ((operand - mean) * (operand - mean));
front = pop_copy(args);
i++;
}
goto done;
error:
clear_stack(args);
*is_bad_formula = 1;
result = 0.0;
done:
if (i == 0) {
i = 1;
goto error;
}
return sqrt(result / (double) i);
}
double handle_op_sqrt(stack_t **args, int *is_bad_formula)
{
if (*args == NULL)
goto error;
double result = 0.0, operand1;
char *front;
// Get first operand
front = pop_copy(args);
if (front == NULL)
goto error;
operand1 = atof(front, cgc_strlen(front) + 1, is_bad_formula);
free(front);
if(*is_bad_formula)
goto error;
if (*args != NULL)
goto error; // Too many arguments
if (operand1 < 0)
goto error;
result = sqrt(operand1);
goto done;
error:
clear_stack(args);
*is_bad_formula = 1;
result = 0.0;
done:
return result;
}
double handle_op_max(stack_t **args, int *is_bad_formula)
{
size_t i = 0;
double max = 0.0;
if (*args == NULL)
goto error;
double operand;
char *front = pop_copy(args);
if (front != NULL) {
max = atof(front, cgc_strlen(front) + 1, is_bad_formula);
free(front);
if (*is_bad_formula)
goto error;
i++;
}
front = pop_copy(args);
while(front != NULL) {
operand = atof(front, cgc_strlen(front) + 1, is_bad_formula);
free(front);
if(*is_bad_formula)
goto error;
if (operand > max)
max = operand;
front = pop_copy(args);
i++;
}
goto done;
error:
clear_stack(args);
*is_bad_formula = 1;
max = 0.0;
done:
if (i == 0) {
i = 1;
goto error;
}
return max;
}
static queue_t *infixtorpn(char *infix, size_t size)
{
/* Use RPN */
int is_mismatched = 0;
int func_size = 16;
int func_idx = -1;
char *formula = malloc(size);
int *func_args = malloc(func_size * sizeof(int));
char *delims = "():,+-*/";
char *arg, *iter;
char delim;
char arith_op[2] = {'\0', '\0'};
char *value;
cell_type_e arg_type;
stack_t *operators = NULL;
queue_t *output_q = NULL;
cgc_memcpy(formula, infix, size);
if (sanitize_formula(formula, size) != 0)
goto cleanup;
arg = iter = formula;
size_t i = 0;
char prev_char = 0;
while ( i++ < size) {
if (strchr(delims, *iter) == NULL && *iter != '\0') {
prev_char = *iter;
iter++;
continue;
} else if (strchr(delims, *iter) != NULL) {
if (*iter == '-') {
if(i <= 1 || (prev_char != ')' && (prev_char < '0' || prev_char > '9'))) {
prev_char = *iter;
iter++;
continue;
}
}
}
prev_char = *iter;
delim = *iter;
*iter = '\0';
arg_type = parsearg(arg);
switch (arg_type) {
case DOUBLE:
case CELL_ID:
enqueue_copy(&output_q, arg, cgc_strlen(arg) + 1);
break;
case FUNCTION:
#ifdef PATCHED
if(func_idx == func_size-1) {
#else
if(func_idx == func_size) {
#endif
func_size *= 2;
int *temp = realloc(func_args, func_size * sizeof(int));
if (temp == NULL)
goto error;
func_args = temp;
}
func_args[++func_idx] = 0;
push_copy(&operators, arg, cgc_strlen(arg) + 1);
break;
case BAD_CELL:
break;
default:
goto error;
}
is_mismatched = 0;
switch(delim) {
case '(':
push_copy(&operators, "(", cgc_strlen("(") + 1);
break;
case ')':
is_mismatched = 1;
while (operators != NULL) {
if (strcmp(peek_top(operators), "(") == 0) {
value = pop_copy(&operators);
free(value);
is_mismatched = 0;
break;
} else {
enqueue(&output_q, pop_copy(&operators));
}
}
// handle parens without any operator
if (peek_top(operators) == NULL || func_idx < 0)
break;
char num_args_str[16];
if(strchr(delims, peek_top(operators)[0]) != NULL) {
break;
} else if (parsearg(peek_top(operators)) == FUNCTION) {
enqueue_copy(&output_q, itoa(func_args[func_idx--] + 1, num_args_str,
sizeof(num_args_str)), sizeof(num_args_str));
enqueue(&output_q, pop_copy(&operators));
}
break;
case ',':
is_mismatched = 1;
while (operators != NULL) {
if (strcmp(peek_top(operators), "(") == 0) {
if (func_idx >= 0)
func_args[func_idx]++;
is_mismatched = 0;
break;
} else {
enqueue(&output_q, pop_copy(&operators));
}
}
break;
case '+':
case '-':
//TODO - FIXME - precedence is broken
//TODO - FIXME - negative is still broken
// 4/5-5
arith_op[0] = delim;
while (operators != NULL) {
if (strcmp(peek_top(operators), "-") == 0 || strcmp(peek_top(operators), "+") == 0 ||
strcmp(peek_top(operators), "+") == 0 || strcmp(peek_top(operators), "/") == 0)
enqueue(&output_q, pop_copy(&operators));
else
break;
}
push_copy(&operators, arith_op, cgc_strlen(arith_op)+1);
break;
case '*':
case '/':
//TODO - FIXME - precedence is broken
arith_op[0] = delim;
while (operators != NULL) {
if (strcmp(peek_top(operators), "/") == 0 || strcmp(peek_top(operators), "*") == 0)
enqueue(&output_q, pop_copy(&operators));
else
break;
}
push_copy(&operators, arith_op, cgc_strlen(arith_op)+1);
break;
case '\0':
goto finish;
default:
goto error;
}
if (is_mismatched)
goto error;
arg = ++iter;
}
finish:
while (operators != NULL) {
if (strcmp(peek_top(operators), "(") == 0 || strcmp(peek_top(operators), ")") == 0)
goto error;
enqueue(&output_q, pop_copy(&operators));
}
goto cleanup;
error:
clear_queue(&output_q);
clear_stack(&operators);
cleanup:
free(formula);
free(func_args);
return output_q;
}
static double eval_formula(char *formula, int *is_bad_formula, stack_t **cir_ref, int id)
{
char val_str[TMP_STR_SIZE];
char tmp_id_str[TMP_STR_SIZE];
size_t size = TMP_STR_SIZE;
double val = 0.0;
double result = 0.0;
*is_bad_formula = 0;
cell_type_e cell_type;
char *arg;
if(itoa(id, tmp_id_str, size) == NULL)
goto error;
push_copy(cir_ref, tmp_id_str, cgc_strlen(tmp_id_str) + 1);
queue_t *rpn = infixtorpn(formula, cgc_strlen(formula) + 1);
queue_t *args = NULL;
stack_t *values = NULL;
stack_t *tmp = NULL;
operator_t *op = NULL;
while (rpn != NULL) {
arg = dequeue_copy(&rpn);
cell_type = parsearg(arg);
switch(cell_type) {
case DOUBLE:
push(&values, arg);
break;
case FUNCTION:
op = get_op(arg);
if (eval_function(op, &values, val_str, size) == -1) {
goto error;
}
push_copy(&values, val_str, size);
break;
case CELL_ID:
tmp = *cir_ref;
cell_t *cell = get_cell(arg);
if(cell == NULL)
goto error;
while (tmp != NULL) {
if(itoa(cell->id, tmp_id_str, size) == NULL)
goto error;
if (memcmp(tmp->data, tmp_id_str, cgc_strlen(tmp->data) + 1) == 0)
goto error; //Circular reference
tmp = tmp->next;
}
if (cell->cell_type == UNUSED) {
push_copy(&values, "0", sizeof("0"));
} else if (cell->cell_type == DOUBLE) {
push_copy(&values, cell->str, cgc_strlen(cell->str) + 1);
} else if(cell->cell_type == FORMULA) {
val = eval_formula(cell->formula, is_bad_formula, cir_ref, cell->id);
if(*is_bad_formula)
goto error;
ftoa(val, val_str, size);
push_copy(&values, val_str, size);
} else {
goto error;
}
break;
default:
goto error;
}
}
char *result_str = pop_copy(&values);
if (values != NULL)
goto error;
result = atof(result_str, size, is_bad_formula);
if (*is_bad_formula)
goto error;
goto cleanup;
error:
*is_bad_formula = 1;
val = 0.0;
clear_queue(&rpn);
clear_queue(&args);
clear_stack(&values);
cleanup:
free(pop_copy(cir_ref));
return result;
}
RTC::ReturnCode_t sh_MT::onExecute(RTC::UniqueId ec_id)
{
if(!m_input2In.isNew()){
return RTC::RTC_OK;
}
m_input2In.read();
//データの復元
printf("データの復元_インデックスの読み込み(MT)\n");
double c = m_input2.pop_length;//18522
double d = m_input2.pop_width;//28
printf("pop_x = %f pop_y = %f \n", c, d);//popのインデックス
double a = m_input2.ind_length;//2
double b = m_input2.ind_width;//4
printf("ind_x = %f ind_y = %f \n", a, b);//indのインデックス
printf("データの復元_popの読み込み(MT)\n");
double test=0;
int num = 0;
mwArray pop_copy(18522, 28, mxDOUBLE_CLASS);//pop_copyの入れ物の型宣言
///////////////////////////////////////////////////////////
double *data_copy_pop = new double [m_input2.pop_length * m_input2.pop_width];
for (num = 0; num < m_input2.pop_length * m_input2.pop_width ; num++) {
data_copy_pop[num] = m_input2.pop[num];
}
pop_copy.SetData(data_copy_pop, m_input2.pop_length * m_input2.pop_width);//pop
///////////////////////////////////////////////////////////
printf("データの復元_indの読み込み(MT)\n");
mwArray ind_copy(m_input2.ind_length, m_input2.ind_width, mxDOUBLE_CLASS);
///////////////////////////////////////////////////////////
double *data_copy_ind = new double [m_input2.pop_length * m_input2.pop_width];
for (num = 0; num < m_input2.ind_length * m_input2.ind_width ; num++) {
data_copy_ind[num] = m_input2.ind[num];
}
ind_copy.SetData(data_copy_ind, m_input2.ind_length * m_input2.ind_width);//ind
///////////////////////////////////////////////////////////
//pop,indの復元が終わったはず
printf("復元完了(MT)\n");
///////////////////////////////////////////////////////////
//デフォルトパラメータの読み込み
mwArray pars;
shPars(1, pars);//デフォルトパラメータを.matから読み込みparsに入れる
///////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////
//SHmodel本体_MT
//MT野の処理
mwArray output(1, 2, mxCELL_CLASS);//出力の入れ物
mwArray pop = pop_copy;
mwArray ind = ind_copy;
printf("モデル本体の処理開始(MT)\n");
mwArray inputMT_a(1, 3, mxCELL_CLASS);//出力の入れ物
inputMT_a.Get(1,1).Set(pop);//
inputMT_a.Get(1,2).Set(ind);//
inputMT_a.Get(1,3).Set(pars);//
shModelMtLinear(2, output, inputMT_a);
pop = output.Get(2, 1, 1);
ind = output.Get(2, 1, 2);
printf("MT野の処理shModelMtLinear終了(MT)\n");
mwArray inputMT_b(1, 3, mxCELL_CLASS);//出力の入れ物
inputMT_b.Get(1,1).Set(pop);//
inputMT_b.Get(1,2).Set(ind);//
inputMT_b.Get(1,3).Set(pars);//
shModelMtPreThresholdBlur(2, output, inputMT_b);
pop = output.Get(2, 1, 1);
ind = output.Get(2, 1, 2);
printf("MT野の処理shModelMtPreThresholdBlur終了(MT)\n");
mwArray inputMT_c(1, 3, mxCELL_CLASS);//出力の入れ物
inputMT_c.Get(1,1).Set(pop);//
inputMT_c.Get(1,2).Set(ind);//
inputMT_c.Get(1,3).Set(pars);//
shModelHalfWaveRectification(2, output, inputMT_c);
pop = output.Get(2, 1, 1);
ind = output.Get(2, 1, 2);
printf("MT野の処理shModelHalfWaveRectification終了(MT)\n");
mwArray inputMT_d(1, 3, mxCELL_CLASS);//出力の入れ物
inputMT_d.Get(1,1).Set(pop);//
inputMT_d.Get(1,2).Set(ind);//
inputMT_d.Get(1,3).Set(pars);//
shModelMtPostThresholdBlur(2, output, inputMT_d);
pop = output.Get(2, 1, 1);
ind = output.Get(2, 1, 2);
printf("MT野の処理shModelMtPostThresholdBlur終了(MT)\n");
mwArray inputMT_e(1, 3, mxCELL_CLASS);//出力の入れ物
inputMT_e.Get(1,1).Set(pop);//
inputMT_e.Get(1,2).Set(ind);//
inputMT_e.Get(1,3).Set(pars);//
mwArray outputMT(1, 4, mxCELL_CLASS);//出力の入れ物
mwArray nume;
mwArray deno;
shModelMtNormalization(4, outputMT, inputMT_e);
printf("MT野の処理shModelMtNormalization終了(MT)\n");
//計算結果の表示(仮)
a =0;
//////////////////////////////////////////////////////////////
printf("\npop(MT)\n");
mwArray pop2(outputMT.Get(2, 1, 1));//popの確保(2, 1, 2)がind_outputMT
printf("NumberOfDimensions(MT) : %d\n", pop2.NumberOfDimensions());
mwArray pop2_dims = pop2.GetDimensions();
int pop2_dim1 = pop2_dims.Get(1, 1);//int型に変換する必要あり
int pop2_dim2 = pop2_dims.Get(1, 2);
printf("1 : (MT)%d\n", pop2_dim1);//378
printf("2 : (MT)%d\n", pop2_dim2);//19
printf("NumberOfElements(MT) : %d\n", pop2.NumberOfElements());
for(int y = 1; y <= pop2_dim2; y++) {
for(int x = 1; x <= pop2_dim1; x++) {
//縦長に保存されている
a = pop2.Get((mwSize)2, x, y);//mwArrayの呼び出し
}
}
printf("pop_last(MT) = %f\n", a);
printf("\n");
///////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////
printf("ind(MT)\n");
mwArray ind2(outputMT.Get(2, 1, 2));//indの確保_outputMT
printf("NumberOfDimensions(MT) : %d\n", ind2.NumberOfDimensions());
mwArray ind2_dims = ind2.GetDimensions();
int ind2_dim1 = ind2_dims.Get(1, 1);//int型に変換する必要あり
int ind2_dim2 = ind2_dims.Get(1, 2);
printf("1 : (MT)%d\n", ind2_dim1);//378
printf("2 : (MT)%d\n", ind2_dim2);//19
printf("NumberOfElements(MT) : %d\n", ind2.NumberOfElements());
for(int y = 1; y <= ind2_dim2; y++) {
//printf("\n");
for(int x = 1; x <= ind2_dim1; x++) {
a = ind2.Get((mwSize)2, x, y);//mwArrayの呼び出し
printf("%f ", a);
}
printf("\n");
}
printf("\n");
///////////////////////////////////////////////////////////////
//出力部分
m_output2.pop_length = pop2_dim1;/////////////////////
m_output2.pop_width = pop2_dim2;/////////////////////////
m_output2.pop.length(pop2_dim1 * pop2_dim2);//popの配列の確保
num = 0;
double *data_copy_pop2 = new double [pop2_dim1 * pop2_dim2];
pop.GetData(data_copy_pop2, pop2_dim1 * pop2_dim2);
for (num = 0; num < pop2_dim1 * pop2_dim2 ; num++) {
m_output2.pop[num] = data_copy_pop2[num];
}
//ind_2*4/
m_output2.ind_length = ind2_dim1;////////////////
m_output2.ind_width = ind2_dim2;/////////////////
m_output2.ind.length(ind2_dim1 * ind2_dim2);//popの配列の確保
double *data_copy_ind2 = new double [ind2_dim1 * ind2_dim2];
ind.GetData(data_copy_ind2, ind2_dim1 * ind2_dim2);
for (num = 0; num < ind2_dim1 * ind2_dim2; num++) {
m_output2.ind[num] = data_copy_ind2[num];
}
m_output2Out.write();//書き出し_異常発生の場合接続カット
///////////////////////////////////////////////////////////////////////////////////////////////////////
printf("MT_end\n");
delete[] data_copy_pop;//data_copyのデリート
delete[] data_copy_ind;
return RTC::RTC_OK;
}
// Selection implementation.
std::vector<std::pair<population::size_type,std::vector<population::individual_type>::size_type> >
hv_fair_r_policy::select(const std::vector<population::individual_type> &immigrants, const population &dest) const
{
// Fall back to fair_r_policy when facing a single-objective problem.
if (dest.problem().get_f_dimension() == 1) {
return fair_r_policy(m_rate, m_type).select(immigrants, dest);
}
std::vector<population::individual_type> filtered_immigrants;
filtered_immigrants.reserve(immigrants.size());
// Keeps information on the original indexing of immigrants after we filter out the duplicates
std::vector<unsigned int> original_immigrant_indices;
original_immigrant_indices.reserve(immigrants.size());
// Remove the duplicates from the set of immigrants
std::vector<population::individual_type>::iterator im_it = (const_cast<std::vector<population::individual_type> &>(immigrants)).begin();
unsigned int im_idx = 0;
for( ; im_it != immigrants.end() ; ++im_it) {
decision_vector im_x((*im_it).cur_x);
bool equal = true;
for ( unsigned int idx = 0 ; idx < dest.size() ; ++idx ) {
decision_vector isl_x(dest.get_individual(idx).cur_x);
equal = true;
for (unsigned int d_idx = 0 ; d_idx < im_x.size() ; ++d_idx) {
if (im_x[d_idx] != isl_x[d_idx]) {
equal = false;
break;
}
}
if (equal) {
break;
}
}
if (!equal) {
filtered_immigrants.push_back(*im_it);
original_immigrant_indices.push_back(im_idx);
}
++im_idx;
}
// Computes the number of immigrants to be selected (accounting for the destination pop size)
const population::size_type rate_limit = std::min<population::size_type>(get_n_individuals(dest), boost::numeric_cast<population::size_type>(filtered_immigrants.size()));
// Defines the retvalue
std::vector<std::pair<population::size_type, std::vector<population::individual_type>::size_type> > result;
// Skip the remaining computation if there's nothing to do
if (rate_limit == 0) {
return result;
}
// Makes a copy of the destination population
population pop_copy(dest);
// Merge the immigrants to the copy of the destination population
for (population::size_type i = 0; i < rate_limit; ++i) {
pop_copy.push_back(filtered_immigrants[i].cur_x);
}
// Population fronts stored as indices of individuals.
std::vector< std::vector<population::size_type> > fronts_i = pop_copy.compute_pareto_fronts();
// Population fronts stored as fitness vectors of individuals.
std::vector< std::vector<fitness_vector> > fronts_f (fronts_i.size());
// Nadir point is established manually later, first point is a first "safe" candidate.
fitness_vector refpoint(pop_copy.get_individual(0).cur_f);
// Fill fronts_f with fitness vectors and establish the nadir point
for (unsigned int f_idx = 0 ; f_idx < fronts_i.size() ; ++f_idx) {
fronts_f[f_idx].resize(fronts_i[f_idx].size());
for (unsigned int p_idx = 0 ; p_idx < fronts_i[f_idx].size() ; ++p_idx) {
fronts_f[f_idx][p_idx] = fitness_vector(pop_copy.get_individual(fronts_i[f_idx][p_idx]).cur_f);
// Update the nadir point manually for efficiency.
for (unsigned int d_idx = 0 ; d_idx < fronts_f[f_idx][p_idx].size() ; ++d_idx) {
refpoint[d_idx] = std::max(refpoint[d_idx], fronts_f[f_idx][p_idx][d_idx]);
}
}
}
// Epsilon is added to nadir point
for (unsigned int d_idx = 0 ; d_idx < refpoint.size() ; ++d_idx) {
refpoint[d_idx] += m_nadir_eps;
}
// Vector for maintaining the original indices of points for augmented population as 0 and 1
std::vector<unsigned int> g_orig_indices(pop_copy.size(), 1);
unsigned int no_discarded_immigrants = 0;
// Store which front we process (start with the last front) and the number of processed individuals.
unsigned int front_idx = fronts_i.size(); // front_idx is equal to the size, since it's decremented right in the main loop
unsigned int processed_individuals = 0;
// Pairs of (islander index, islander exclusive hypervolume)
// Second item is updated later
std::vector<std::pair<unsigned int, double> > discarded_islanders;
std::vector<std::pair<unsigned int, double> > point_pairs;
// index of currently processed point in the point_pair vector.
// Initiated to its size (=0) in order to enforce the initial computation on penultimate front.
unsigned int current_point = point_pairs.size();
// Stops when we reduce the augmented population to the size of the original population or when the number of discarded islanders reaches the limit
while (processed_individuals < filtered_immigrants.size() && discarded_islanders.size() < rate_limit) {
// if current front was exhausted, load next one
if (current_point == point_pairs.size()) {
--front_idx;
// Compute contributions
std::vector<double> c;
// If there exist a dominated front for front at index front_idx
if (front_idx + 1 < fronts_f.size()) {
std::vector<fitness_vector> merged_front;
// Reserve the memory and copy the fronts
merged_front.reserve(fronts_f[front_idx].size() + fronts_f[front_idx + 1].size());
copy(fronts_f[front_idx].begin(), fronts_f[front_idx].end(), back_inserter(merged_front));
copy(fronts_f[front_idx + 1].begin(), fronts_f[front_idx +1].end(), back_inserter(merged_front));
hypervolume hv(merged_front, false);
c = hv.contributions(refpoint);
} else {
hypervolume hv(fronts_f[front_idx], false);
c = hv.contributions(refpoint);
}
// Initiate the pairs and sort by second item (exclusive volume)
point_pairs.resize(fronts_f[front_idx].size());
for(unsigned int i = 0 ; i < fronts_f[front_idx].size() ; ++i) {
point_pairs[i] = std::make_pair(i, c[i]);
}
current_point = 0;
std::sort(point_pairs.begin(), point_pairs.end(), sort_point_pairs_asc);
}
unsigned int orig_lc_idx = fronts_i[front_idx][point_pairs[current_point].first];
if (orig_lc_idx < dest.size()) {
discarded_islanders.push_back(std::make_pair(orig_lc_idx, 0.0));
} else {
++no_discarded_immigrants;
}
// Flag given individual as discarded
g_orig_indices[orig_lc_idx] = 0;
++processed_individuals;
++current_point;
}
// Number of non-discarded immigrants
unsigned int no_available_immigrants = boost::numeric_cast<unsigned int>(filtered_immigrants.size() - no_discarded_immigrants);
// Pairs of (immigrant index, immigrant exclusive hypervolume)
// Second item is updated later
std::vector<std::pair<unsigned int, double> > available_immigrants;
available_immigrants.reserve(no_available_immigrants);
for(unsigned int idx = dest.size() ; idx < pop_copy.size() ; ++idx) {
// If the immigrant was not discarded add it to the available set
if ( g_orig_indices[idx] == 1 ) {
available_immigrants.push_back(std::make_pair(idx, 0.0));
}
}
// Aggregate all points to establish the hypervolume contribution of available immigrants and discarded islanders
std::vector<fitness_vector> merged_fronts;
merged_fronts.reserve(pop_copy.size());
for(unsigned int idx = 0 ; idx < pop_copy.size() ; ++idx) {
merged_fronts.push_back(pop_copy.get_individual(idx).cur_f);
}
hypervolume hv(merged_fronts, false);
std::vector<std::pair<unsigned int, double> >::iterator it;
for(it = available_immigrants.begin() ; it != available_immigrants.end() ; ++it) {
(*it).second = hv.exclusive((*it).first, refpoint);
}
for(it = discarded_islanders.begin() ; it != discarded_islanders.end() ; ++it) {
(*it).second = hv.exclusive((*it).first, refpoint);
}
// Sort islanders and immigrants according to exclusive hypervolume
sort(available_immigrants.begin(), available_immigrants.end(), hv_fair_r_policy::ind_cmp);
sort(discarded_islanders.begin(), discarded_islanders.end(), hv_fair_r_policy::ind_cmp);
// Number of exchanges is the minimum of the number of non discarded immigrants and the number of discarded islanders
unsigned int no_exchanges = std::min(boost::numeric_cast<unsigned int>(available_immigrants.size()), boost::numeric_cast<unsigned int>(discarded_islanders.size()));
it = available_immigrants.begin();
std::vector<std::pair<unsigned int, double> >::reverse_iterator r_it = discarded_islanders.rbegin();
// Match the best immigrant (forward iterator) with the worst islander (reverse iterator) no_exchanges times.
for(unsigned int i = 0 ; i < no_exchanges ; ++i) {
// Break if any islander is better than an immigrant
if ((*r_it).second > (*it).second) {
break;
}
// Push the pair (islander_idx, fixed_immigrant_idx) to the results
result.push_back(std::make_pair((*r_it).first, original_immigrant_indices[(*it).first - dest.size()]));
++r_it;
++it;
}
return result;
}
double handle_op_median(stack_t **args, int *is_bad_formula)
{
size_t i = 0;
stack_t *sorted, *tmp, *prev;
#ifdef PATCHED
sorted = NULL;
#endif
if (*args == NULL)
goto error;
sorted = NULL;
double median = 0.0, operand, temp;
char *front = pop_copy(args);
operand = atof(front, cgc_strlen(front) + 1, is_bad_formula);
if(*is_bad_formula) {
free(front);
goto error;
} else {
push(&sorted, front);
i++;
}
front = pop_copy(args);
while(front != NULL) {
operand = atof(front, cgc_strlen(front) + 1, is_bad_formula);
if(*is_bad_formula)
goto error;
//using stack as linked list
tmp = sorted;
int passed_first = 0, is_inserted = 0;
stack_t *elem = NULL;
while (tmp != NULL) {
temp = atof(tmp->data, cgc_strlen(tmp->data) + 1, is_bad_formula);
if (operand <= temp) {
if (!passed_first) {
push(&sorted, front);
} else {
elem = malloc(sizeof(stack_t));
elem->data = front;
elem->next = tmp;
prev->next = elem;
}
is_inserted = 1;
break;
} else {
prev = tmp;
tmp = tmp->next;
passed_first++;
}
}
if (!is_inserted) {
tmp = sorted;
while (tmp->next != NULL)
tmp = tmp->next;
elem = malloc(sizeof(stack_t));
elem->data = front;
elem->next = NULL;
tmp->next = elem;
}
front = pop_copy(args);
i++;
}
tmp = sorted;
int j = 0;
if (i % 2 == 0) {
for(j = 0; j < (i / 2) - 1; j++)
tmp = tmp->next;
median += atof(tmp->data, cgc_strlen(tmp->data) + 1, is_bad_formula);
tmp = tmp->next;
median += atof(tmp->data, cgc_strlen(tmp->data) + 1, is_bad_formula);
median /= 2;
} else {
for(j = 0; j < (i / 2); j++)
tmp = tmp->next;
median += atof(tmp->data, cgc_strlen(tmp->data) + 1, is_bad_formula);
}
goto done;
error:
clear_stack(args);
*is_bad_formula = 1;
median = 0.0;
done:
if (i == 0) {
i = 1;
goto error;
}
clear_stack(&sorted);
return median;
}
