mga_target_event::mga_target_event( const kep_toolbox::plantes::planet_ptr start, const kep_toolbox::planet::planet_ptr end, const kep_toolbox::epoch t_end, double T_max, bool discount_launcher ):base(6), m_start(start), m_end(end), m_t_end(t_end), m_T_max(T_max), m_discount_launcher(discount_launcher) { // We check that all planets have equal central body if (start->get_mu_central_body() != end->get_mu_central_body()) { pagmo_throw(value_error,"The planets do not all have the same mu_central_body"); } // We check that T_max is positive if (T_max <= 0) { pagmo_throw(value_error,"T_max must be larger than zero"); } // Now setting the problem bounds decision_vector lb(6,0.0), ub(6,1.0); lb[0] = 1.; lb[5] = 1e-5; ub[0] = T_max; ub[2] = 12000.0; ub[5] = 1-1e-5; set_bounds(lb,ub); }

static int __mo_dimension__(const pagmo::problem::base &original_problem, const pagmo::problem::con2mo::method_type method) { if( method > 2 || method < 0) { pagmo_throw(value_error, "The constrained to multi-objective method must be set to OBJ_CSTRS for Coello type constrained to multi-objective, to OBJ_CSTRSVIO for COMOGO type constrained to nobj+1 objectives problem or to OBJ_EQVIO_INEQVIO for COMOGO type constrained to nobj+2 objectives problem."); } if(original_problem.get_c_dimension() <= 0){ pagmo_throw(value_error,"The original problem has no constraints."); } switch(method) { case pagmo::problem::con2mo::OBJ_CSTRS: { return original_problem.get_f_dimension() + original_problem.get_c_dimension(); break; } case pagmo::problem::con2mo::OBJ_CSTRSVIO: { return original_problem.get_f_dimension() + 1; break; } case pagmo::problem::con2mo::OBJ_EQVIO_INEQVIO: { return original_problem.get_f_dimension() + 2; break; } default: { return 0.; break; } } }

/** * Constructor using std::vector (for python exposition purposes) * * @param[in] p base::problem to be rotated * @param[in] rotation std::vector<std::vector<double> > expressing the problem rotation * * @see problem::base constructors. */ rotated::rotated(const base &p, const std::vector<std::vector<double> > &rotation): base_meta( p, p.get_dimension(), p.get_i_dimension(), p.get_f_dimension(), p.get_c_dimension(), p.get_ic_dimension(), p.get_c_tol()), m_Rotate(),m_normalize_translation(), m_normalize_scale() { if(!(rotation.size()==get_dimension())){ pagmo_throw(value_error,"The input matrix dimensions seem incorrect"); } if(p.get_i_dimension()>0){ pagmo_throw(value_error,"Input problem has an integer dimension. Cannot rotate it."); } m_Rotate.resize(rotation.size(),rotation.size()); for (base::size_type i = 0; i < rotation.size(); ++i) { if(!(rotation.size()==rotation[i].size())){ pagmo_throw(value_error,"The input matrix seems not to be square"); } for (base::size_type j = 0; j < rotation[i].size(); ++j) { m_Rotate(i,j) = rotation[i][j]; } } m_InvRotate = m_Rotate.transpose(); Eigen::MatrixXd check = m_InvRotate * m_Rotate; if(!check.isIdentity(1e-5)){ pagmo_throw(value_error,"The input matrix seems not to be orthonormal (to a tolerance of 1e-5)"); } configure_new_bounds(); }

// Write into retval the gradient of the continuous part of the objective function of prob calculated in input. void gsl_gradient::objfun_numdiff_central(gsl_vector *retval, const problem::base &prob, const decision_vector &input, const double &step_size) { if (input.size() != prob.get_dimension()) { pagmo_throw(value_error,"invalid input vector dimension in numerical differentiation of the objective function"); } if (prob.get_f_dimension() != 1) { pagmo_throw(value_error,"numerical differentiation of the objective function cannot work on multi-objective problems"); } // Size of the continuous part of the problem. const problem::base::size_type cont_size = prob.get_dimension() - prob.get_i_dimension(); // Structure to pass data to the wrapper. objfun_numdiff_wrapper_params pars; pars.x = input; pars.f.resize(1); pars.prob = &prob; // GSL function. gsl_function F; F.function = &objfun_numdiff_wrapper; F.params = (void *)&pars; double result, abserr; // Numerical differentiation component by component. for (problem::base::size_type i = 0; i < cont_size; ++i) { pars.coord = i; gsl_deriv_central(&F,input[i],step_size,&result,&abserr); gsl_vector_set(retval,i,result); } }

cstrs_self_adaptive::cstrs_self_adaptive(const base &problem): base_meta( problem, problem.get_dimension(), problem.get_i_dimension(), problem.get_f_dimension(), 0, 0, std::vector<double>()), m_apply_penalty_1(false), m_scaling_factor(0.0), m_c_scaling(problem.get_c_dimension(),0.0), m_f_hat_down(problem.get_f_dimension(),0.0), m_f_hat_up(problem.get_f_dimension(),0.0), m_f_hat_round(problem.get_f_dimension(),0.0), m_i_hat_down(0.0), m_i_hat_up(0.0), m_i_hat_round(0.0), m_map_fitness(), m_map_constraint(), m_decision_vector_hash() { population pop(*m_original_problem,0); if(m_original_problem->get_c_dimension() <= 0){ pagmo_throw(value_error,"The original problem has no constraints."); } // check that the dimension of the problem is 1 if (m_original_problem->get_f_dimension() != 1) { pagmo_throw(value_error,"The original fitness dimension of the problem must be one, multi objective problems can't be handled with self adaptive meta problem."); } update_penalty_coeff(pop); }

/** * Constructor of antibodies meta-problem * * Note: This problem is not intended to be used by itself. Instead use the * cstrs_immune_system algorithm if you want to solve constrained problems. * * @param[in] problem base::problem to be used to set up the boundaries * @param[in] method method_type to used for the distance computation. * Two posssibililties are available: HAMMING, EUCLIDEAN. */ antibodies_problem::antibodies_problem(const base &problem, const algorithm::cstrs_immune_system::distance_method_type method): base((int)problem.get_dimension(), problem.get_i_dimension(), problem.get_f_dimension(), 0, 0, 0.), m_original_problem(problem.clone()), m_pop_antigens(), m_method(method) { if(m_original_problem->get_c_dimension() <= 0){ pagmo_throw(value_error,"The original problem has no constraints."); } // check that the dimension of the problem is 1 if(m_original_problem->get_f_dimension() != 1) { pagmo_throw(value_error,"The original fitness dimension of the problem must be one, multi objective problems can't be handled with co-evolution meta problem."); } // encoding for hamming distance m_bit_encoding = 25; m_max_encoding_integer = int(std::pow(2., m_bit_encoding)); set_bounds(m_original_problem->get_lb(),m_original_problem->get_ub()); }

/** * Initialises the MPI environment with MPI_Init_thread. pagmo::mpi_environment objects should be created only in the main * thread of execution. * * @throws std::runtime_error if another instance of this class has already been created, * or if the MPI implementation does not support at least the MPI_THREAD_SERIALIZED thread level and this is the root node, * or if the world size is not at least 2. */ mpi_environment::mpi_environment() { if (m_initialised) { pagmo_throw(std::runtime_error,"cannot re-initialise the MPI environment"); } m_initialised = true; int thread_level_provided; MPI_Init_thread(NULL,NULL,MPI_THREAD_MULTIPLE,&thread_level_provided); if (thread_level_provided >= MPI_THREAD_MULTIPLE) { m_multithread = true; } if (get_rank()) { // If this is a slave, it will have to stop here, listen for jobs, execute them, and exit() // when signalled to do so. listen(); } // If this is the root node, it will need to be able to call MPI from multiple threads. if (thread_level_provided < MPI_THREAD_SERIALIZED && get_rank() == 0) { pagmo_throw(std::runtime_error,"the master node must support at least the MPI_THREAD_SERIALIZED thread level"); } // World sizes less than 2 are not allowed. if (get_size() < 2) { pagmo_throw(std::runtime_error,"the size of the MPI world must be at least 2"); } }

ipopt::ipopt( const int &max_iter, const double &constr_viol_tol, const double &dual_inf_tol, const double &compl_inf_tol, const bool &nlp_scaling_method, const double &obj_scaling_factor, const double &mu_init) : m_max_iter(max_iter),m_constr_viol_tol(constr_viol_tol), m_dual_inf_tol(dual_inf_tol), m_compl_inf_tol(compl_inf_tol), m_nlp_scaling_method(nlp_scaling_method), m_obj_scaling_factor(obj_scaling_factor), m_mu_init(mu_init) { if (max_iter < 0) { pagmo_throw(value_error,"number of maximum iterations cannot be negative"); } if (constr_viol_tol < 0) { pagmo_throw(value_error,"tolerance is not in ]0,1["); } if (dual_inf_tol < 0) { pagmo_throw(value_error,"obj_tol is not in ]0,1["); } if (compl_inf_tol < 0) { pagmo_throw(value_error,"obj_tol is not in ]0,1["); } if (mu_init <= 0) { pagmo_throw(value_error,"mu_init is not in ]0, inf["); } }

/** * Allows to specify in detail all the parameters of the algorithm. * * @param[in] iter number of iterations. * @param[in] limit number of tries after which a source of food is dropped if not improved * @throws value_error if number of iterations or limit are negative */ bee_colony::bee_colony(int iter, int limit):base(),m_iter(iter), m_limit(limit) { if (iter < 0) { pagmo_throw(value_error,"number of iterations must be nonnegative"); } if (limit < 0) { pagmo_throw(value_error,"limit value must be nonnegative"); } }

/** * Allows to specify all the parameters needed to initialise a GSL minimiser without derivatives, as specified in the GSL documentation. * Will fail if max_iter is negative or if at least one of the other parameters is negative. * * @param[in] max_iter maximum number of iterations the algorithm will be allowed to perform. * @param[in] tol desired tolerance in the localisation of the minimum. * @param[in] step_size initial step size for the simplex. */ gsl_derivative_free::gsl_derivative_free(int max_iter, const double &tol, const double &step_size): base_gsl(),m_max_iter(boost::numeric_cast<std::size_t>(max_iter)),m_tol(tol),m_step_size(step_size) { if (step_size <= 0) { pagmo_throw(value_error,"step size must be positive"); } if (tol <= 0) { pagmo_throw(value_error,"tolerance must be positive"); } }

/** * Allows to specify in detail all the parameters of the algorithm. * * @param[in] gen Number of generations to evolve. * @param[in] ri Probability of performing a random invert (mutation probability) */ inverover::inverover(int gen, double ri, initialization_type ini_type) :base(),m_gen(gen),m_ri(ri),m_ini_type(ini_type) { if (gen < 0) { pagmo_throw(value_error,"number of generations must be nonnegative"); } if (ri > 1 || ri < 0) { pagmo_throw(value_error,"random invert probability must be in the [0,1] range"); } }

/** * Build a BA network with clustering mechanism applied. The initial kernel has size m0 and the elements * being inserted after the construction of the kernel is completed are connected randomly to a maximum of m nodes. These nodes * are then connected to eachother with probability p. * Will fail if m0 < 2, if m < 1 or if m > m0 or if p < 0 or p > 1 * * @param[in] m0 size of the kernel * @param[in] m number of random connections to be established when a new node is added. * @param[in] p probability that a connection is established between two nodes that are adjacent to a new node. */ clustered_ba::clustered_ba(int m0, int m, double p): m_m0(boost::numeric_cast<std::size_t>(m0)),m_m(boost::numeric_cast<std::size_t>(m)), m_p(double(p)), m_drng(rng_generator::get<rng_double>()),m_urng(rng_generator::get<rng_uint32>()) { if (m0 < 2 || m < 1 || m > m0) { pagmo_throw(value_error,"the value of m and m0 must be at least 1 and 2, and m must not be greater than m0"); } if(p < 0 || p > 1) { pagmo_throw(value_error,"the value of p must be between 0 and 1"); } }

/** * Constructs a global optimization problem (box-bounded, continuous) representing an interplanetary trajectory modelled * as a Multiple Gravity Assist trajectory that allows one only Deep Space Manouvre between each leg. * * @param[in] seq std::vector of kep_toolbox::planet_ptr containing the encounter sequence for the trajectoty (including the initial planet) * @param[in] t0_l kep_toolbox::epoch representing the lower bound for the launch epoch * @param[in] t0_u kep_toolbox::epoch representing the upper bound for the launch epoch * @param[in] tof time-of-flight vector containing lower and upper bounds (in days) for the various legs time of flights * @param[in] Tmax maximum time of flight * @param[in] Dmin minimum distance from Jupiter (for radiation protection) * * @throws value_error if the planets in seq do not all have the same central body gravitational constant * @throws value_error if tof has a size different from seq.size() */ mga_incipit_cstrs::mga_incipit_cstrs( const std::vector<kep_toolbox::planets::planet_ptr> seq, const kep_toolbox::epoch t0_l, const kep_toolbox::epoch t0_u, const std::vector<std::vector<double> > tof, double Tmax, double Dmin) : base(4*seq.size(),0,1,2,2,1E-3), m_tof(tof), m_tmax(Tmax), m_dmin(Dmin) { // We check that all planets have equal central body std::vector<double> mus(seq.size()); for (std::vector<kep_toolbox::planets::planet_ptr>::size_type i = 0; i< seq.size(); ++i) { mus[i] = seq[i]->get_mu_central_body(); } if ((unsigned int)std::count(mus.begin(), mus.end(), mus[0]) != mus.size()) { pagmo_throw(value_error,"The planets do not all have the same mu_central_body"); } // We check the consistency of the time of flights if (tof.size() != seq.size()) { pagmo_throw(value_error,"The time-of-flight vector (tof) has the wrong length"); } for (size_t i = 0; i < tof.size(); ++i) { if (tof[i].size()!=2) pagmo_throw(value_error,"Each element of the time-of-flight vector (tof) needs to have dimension 2 (lower and upper bound)"); } // Filling in the planetary sequence data member. This requires to construct the polymorphic planets via their clone method for (std::vector<kep_toolbox::planets::planet_ptr>::size_type i = 0; i < seq.size(); ++i) { m_seq.push_back(seq[i]->clone()); } // Now setting the problem bounds size_type dim(4*m_tof.size()); decision_vector lb(dim), ub(dim); // First leg lb[0] = t0_l.mjd2000(); ub[0] = t0_u.mjd2000(); lb[1] = 0; lb[2] = 0; ub[1] = 1; ub[2] = 1; lb[3] = m_tof[0][0]; ub[3] = m_tof[0][1]; // Successive legs for (std::vector<kep_toolbox::planets::planet_ptr>::size_type i = 1; i < m_tof.size(); ++i) { lb[4*i] = - 2 * boost::math::constants::pi<double>(); ub[4*i] = 2 * boost::math::constants::pi<double>(); lb[4*i+1] = 1.1; ub[4*i+1] = 30; lb[4*i+2] = 1e-5; ub[4*i+2] = 1-1e-5; lb[4*i+3] = m_tof[i][0]; ub[4*i+3] = m_tof[i][1]; } // Adjusting the minimum and maximum allowed fly-by rp to the one defined in the kep_toolbox::planet class for (std::vector<kep_toolbox::planets::planet_ptr>::size_type i = 0; i < m_tof.size()-1; ++i) { lb[4*i+5] = m_seq[i]->get_safe_radius() / m_seq[i]->get_radius(); ub[4*i+5] = (m_seq[i]->get_radius() + 2000000) / m_seq[i]->get_radius(); //from gtoc6 problem description } set_bounds(lb,ub); }

/** * Allows to specify in detail the parameters of the algorithm. * * @param[in] iterations number of iterations. * @param[in] phmcr rate of choosing from memory. * @param[in] ppar_min minimum pitch adjustment rate. * @param[in] ppar_max maximum pitch adjustment rate. * @param[in] bw_min minimum distance bandwidth. * @param[in] bw_max maximum distance bandwidth. * @throws value_error if phmcr is not in the ]0,1[ interval, ppar min/max are not in the ]0,1[ interval, * min/max quantities are less than/greater than max/min quantities. */ ihs::ihs(int iterations, const double &phmcr, const double &ppar_min, const double &ppar_max, const double &bw_min, const double &bw_max): base(),m_gen(boost::numeric_cast<std::size_t>(iterations)),m_phmcr(phmcr),m_ppar_min(ppar_min),m_ppar_max(ppar_max),m_bw_min(bw_min),m_bw_max(bw_max) { if (phmcr > 1 || phmcr < 0 || ppar_min > 1 || ppar_min < 0 || ppar_max > 1 || ppar_max < 0) { pagmo_throw(value_error,"probability of choosing from memory and pitch adjustment rates must be in the [0,1] range"); } if (ppar_min > ppar_max) { pagmo_throw(value_error,"minimum pitch adjustment rate must not be greater than maximum pitch adjustment rate"); } if (bw_min <= 0 || bw_max < bw_min) { pagmo_throw(value_error,"bandwidth values must be positive, and minimum bandwidth must not be greater than maximum bandwidth"); } }

/** * Allows to specify some of the parameters of the SNOPT solver. * * @param[in] major Number of major iterations (refer to SNOPT manual). * @param[in] feas Feasibility tolerance (refer to SNOPT manual). * @param[in] opt Optimality tolerance (refer to SNOPT manual). * @throws value_error if major is not positive, and feas,opt are not in \f$]0,1[\f$ */ snopt::snopt(const int major,const double feas, const double opt) : m_major(major),m_feas(feas),m_opt(opt), m_file_out(false) { if (major < 0) { pagmo_throw(value_error,"number of major iterations cannot be negative"); } if (feas < 0 || feas > 1) { pagmo_throw(value_error,"feasibility cireria "); } if (opt < 0 || opt > 1) { pagmo_throw(value_error,"number of major iterations cannot be negative"); } }

/** * Verifies whether basic requirements are met for the initial set of points. * * @throws value_error if point size is empty or when the dimensions among the points differ */ void hypervolume::verify_after_construct() const { if ( m_points.size() == 0 ) { pagmo_throw(value_error, "Point set cannot be empty."); } fitness_vector::size_type f_dim = m_points[0].size(); if (f_dim <= 1) { pagmo_throw(value_error, "Points of dimension > 1 required."); } for (std::vector<fitness_vector>::size_type idx = 1 ; idx < m_points.size() ; ++idx) { if ( m_points[idx].size() != f_dim ) { pagmo_throw(value_error, "All point set dimensions must be equal."); } } }

/** * Remove the edge connecting n to m. Will fail if are_adjacent() returns false. * * @param[in] n index of the first vertex. * @param[in] m index of the second vertex. */ void base::remove_edge(const vertices_size_type &n, const vertices_size_type &m) { if (!are_adjacent(n,m)) { pagmo_throw(value_error,"cannot remove edge, vertices are not connected"); } boost::remove_edge(boost::vertex(n,m_graph),boost::vertex(m,m_graph),m_graph); }

cs::cs(const int& max_eval, const double &stop_range, const double &start_range, const double &reduction_coeff) :base(),m_stop_range(stop_range),m_start_range(start_range),m_reduction_coeff(reduction_coeff),m_max_eval(max_eval) { if (reduction_coeff >= 1 || reduction_coeff <=0) { pagmo_throw(value_error,"the reduction coefficient must be smaller than one and positive, You Fool!!"); } if (start_range > 1 || start_range <= 0) { pagmo_throw(value_error,"the starting range must be smaller than one and positive, You Fool!!"); } if (stop_range > 1 || stop_range <= 0 || stop_range>start_range) { pagmo_throw(value_error,"the minimum range must be smaller than one, positive and smaller than the starting range, (o44portebat studuisse)!!"); } if (max_eval < 0) { pagmo_throw(value_error,"Maximum number of function evaluations needs to be positive"); } }

void antibodies_problem::set_antigens(const std::vector<decision_vector> &pop_antigens) { if(pop_antigens.size() == 0) { pagmo_throw(value_error,"The size of the antigens population must be different from 0."); } m_pop_antigens = pop_antigens; }

/** * Allows to specify in detail all the parameters of the algorithm. * * @param[in] algorithm pagmo::algorithm for the multistarts * @param[in] starts number of multistarts * @throws value_error if starts is negative */ ms::ms(const base &algorithm, int starts):base(),m_starts(starts) { m_algorithm = algorithm.clone(); if (starts < 0) { pagmo_throw(value_error,"number of multistarts needs to be larger than zero"); } }

/** * Verifies whether reference point and the hypervolume method meet certain criteria. * * @param[in] r_point fitness vector describing the reference point * * @throws value_error if reference point's and point set dimension do not agree */ void hypervolume::verify_before_compute(const fitness_vector &r_point, hv_algorithm::base_ptr hv_algorithm) const { if ( m_points[0].size() != r_point.size() ) { pagmo_throw(value_error, "Point set dimensions and reference point dimension must be equal."); } hv_algorithm->verify_before_compute(m_points, r_point); }

static int __check__(int N){ if (N < 8 || (N) % 4) { pagmo_throw(value_error,"problem dimension N needs to be at least 8 and a multiple of 4"); } return N; }

/** * Configure parameters for the noise distribution * * param[in] param_first Mean of the Gaussian noise / Lower bound of the uniform noise * param[in] param_second Standard deviation of the Gaussian noise / Upper bound of the uniform noise * */ void noisy::set_noise_param(double param_first, double param_second) { if(m_noise_type == UNIFORM && param_first > param_second){ pagmo_throw(value_error, "Bounds specified for the uniform noise are not valid."); } m_param_first = param_first; m_param_second = param_second; }

/** * Verifies whether given algorithm suits the requested data. * * @param[in] points vector of points containing the d dimensional points for which we compute the hypervolume * @param[in] r_point reference point for the vector of points * * @throws value_error when trying to compute the hypervolume for the dimension other than 3 or non-maximal reference point */ void hv3d::verify_before_compute(const std::vector<fitness_vector> &points, const fitness_vector &r_point) const { if (r_point.size() != 3) { pagmo_throw(value_error, "Algorithm hv3d works only for 3-dimensional cases"); } base::assert_minimisation(points, r_point); }

/** * This setter changes the problem bounds as to define a minimum and a maximum allowed total time of flight * * @param[in] tof vector of times of flight */ void mga_incipit_cstrs::set_tof(const std::vector<std::vector<double> >& tof) { if (tof.size() != (m_seq.size())) { pagmo_throw(value_error,"The time-of-flight vector (tof) has the wrong length"); } m_tof = tof; for (size_t i=0; i< m_seq.size(); ++i) { set_bounds(3+4*i,tof[i][0],tof[i][1]); } }

/** * Allows to specify all the parameters needed to initialise a GSL minimiser with derivatives, as specified in the GSL documentation. * Will fail if max_iter is negative or if at least one of the other parameters is negative. * * @param[in] max_iter maximum number of iterations allowed. * @param[in] grad_tol tolerance when testing the norm of the gradient as stopping criterion. * @param[in] numdiff_step_size step size for the numerical computation of the gradient. * @param[in] tol accuracy of the line minimisation. * @param[in] step_size size of the first trial step. */ gsl_gradient::gsl_gradient(int max_iter, const double &grad_tol, const double &numdiff_step_size, const double &step_size, const double &tol): base_gsl(), m_max_iter(boost::numeric_cast<std::size_t>(max_iter)),m_grad_tol(grad_tol),m_numdiff_step_size(numdiff_step_size), m_step_size(step_size),m_tol(tol) { if (step_size <= 0) { pagmo_throw(value_error,"step size must be positive"); } if (tol <= 0) { pagmo_throw(value_error,"tolerance must be positive"); } if (numdiff_step_size <= 0) { pagmo_throw(value_error,"step size for numerical differentiation must be positive"); } if (grad_tol <= 0) { pagmo_throw(value_error,"gradient tolerance must be positive"); } }

/** * Will construct an n dimensional Levy problem. * * @param[in] n integer dimension of the problem. * * @see problem::base constructors. */ levy5::levy5(int n):base(n) { if (n < 2) { pagmo_throw(value_error,"the Levy5 problem's dimension must be at least 2"); } // Set bounds. set_lb(-100); set_ub(100); }

double worhp::get_param(const std::string name) const { // We check that the key exists auto el = m_param_map.find(name); if (el == m_param_map.end()) { pagmo_throw(value_error,"Unknown parameter name, cannot get it."); } // We make a copy for const correctness std::map<std::string, int> map_copy = m_param_map; double retval = 0; // According to the input we return the appropriate parameter switch ( map_copy[name] ) { case 1: retval = m_params.AcceptTolFeas; break; case 2: retval = m_params.AcceptTolOpti; break; case 3: retval = m_params.TolFeas; break; case 4: retval = m_params.TolComp; break; case 5: retval = m_params.TolOpti; break; case 6: retval = m_params.NLPprint; break; case 7: retval = m_params.InitialLMest; break; case 8: retval = m_params.MaxIter; break; default: pagmo_throw(value_error,"You should not be here!!"); } return retval; }

/** * Constructs a co-evolution adaptive algorithm * * @param[in] original_algo pagmo::algorithm to use as 'original' optimization method * @param[in] original_algo_penalties pagmo::algorithm to use as 'original' optimization method * for population representing the penaltiesweights * @param[in] pop_penalties_size population size for the penalty encoding population. * @param[in] gen number of generations. * @param[in] method the method used for the population 2. * Three possibililties are available: SIMPLE, SPLIT_NEQ_EQ and SPLIT_CONSTRAINTS. * The simple one is the original version of the Coello/He implementation. The SPLIT_NEQ_EQ, * splits the equalities and inequalities constraints in two different sets for the * penalty weigths, containing respectively inequalities and equalities weigths. The * SPLIT_CONSTRAINTS splits the constraints in M set of weigths with M the number of * constraints. * @param[in] pen_lower_bound the lower boundary used for penalty. * @param[in] pen_upper_bound the upper boundary used for penalty. * @param[in] ftol stopping criteria on the f tolerance. * @param[in] xtol stopping criteria on the x tolerance. * @throws value_error if stop is negative */ cstrs_co_evolution::cstrs_co_evolution(const base &original_algo, const base &original_algo_penalties, int pop_penalties_size, int gen,method_type method, double pen_lower_bound, double pen_upper_bound, double ftol, double xtol): base(),m_original_algo(original_algo.clone()), m_original_algo_penalties(original_algo_penalties.clone()), m_gen(gen),m_pop_penalties_size(pop_penalties_size),m_method(method), m_pen_lower_bound(pen_lower_bound),m_pen_upper_bound(pen_upper_bound),m_ftol(ftol),m_xtol(xtol) { if(gen < 0) { pagmo_throw(value_error,"number of generations must be nonnegative"); } if(pop_penalties_size <= 0) { pagmo_throw(value_error,"the population size of the penalty weights must be greater than 0"); } if(pen_lower_bound>=pen_upper_bound){ pagmo_throw(value_error,"Lower Bound of penalty coefficients must be smaller than Upper Bound"); } }

/** * Allows to specify in detail all the parameters of the algorithm. * * @param[in] niter number of total iterations. * @param[in] Ts starting temperature * @param[in] Tf final temperature * @param[in] niterT * @param[in] niterR * @param[in] range * @throws value_error niter is non positive, Ts is greater than Tf, Ts is non positive, Tf is non positive, * niterT or niterR are negative, range is not in the [0,1] interval */ sa_corana::sa_corana(int niter, const double &Ts, const double &Tf, int niterT, int niterR, const double &range): base(),m_niter(niter),m_Ts(Ts),m_Tf(Tf),m_step_adj(niterT),m_bin_size(niterR),m_range(range) { if (niter < 0) { pagmo_throw(value_error,"number of iterations must be nonnegative"); } if (Ts <= 0 || Tf <= 0 || Ts <= Tf) { pagmo_throw(value_error,"temperatures must be positive and Ts must be greater than Tf"); } if (niterT < 0) { pagmo_throw(value_error,"number of iteration before adjusting the temperature must be positive"); } if (niterR < 0) { pagmo_throw(value_error,"number of iteration before adjusting the neighbourhood must be positive"); } if (range < 0 || range >1) { pagmo_throw(value_error,"Initial range must be between 0 and 1"); } }