/* To print the statistics of the solution */ void print_summary(solution_t *soln) { job_t *jobs = soln->jobs; int *jobs_order = soln->jobs_order; int first_job, last_job; printf("-----------------\n"); printf("SUMMARY\n"); printf("-----------------\n"); first_job = jobs_order[0]; last_job = jobs_order[numnodes]; printf("Time span: %f\n", get_end_time(last_job, soln)-get_start_time(first_job, soln)); printf("Objective function: %f\n", objective_function(soln)); printf("\n"); printf("Number of late jobs: %d\n", get_num_late_jobs(soln)); printf("Sum of all tardiness: %f\n", get_total_lateness(soln)); printf("Max tardiness: %f\n", get_max_lateness(soln)); printf("Average tardiness: %f\n", get_average_lateness(soln)); printf("Variance of tardiness: %f\n", get_variance_lateness(soln)); printf("Standard deviation of tardiness: %f\n", get_standard_deviation_lateness(soln)); printf("\n"); printf("Number of early jobs: %d\n", get_num_early_jobs(soln)); printf("Sum of all earliness: %f\n", get_total_earliness(soln)); printf("Average earliness: %f\n", get_average_earliness(soln)); printf("\n"); printf("Total travelling time: %f\n", get_total_travelling_time(soln)); printf("Total waiting time: %f\n", get_total_waiting_time(soln)); printf("-----------------\n"); }
int main(int argc, char *argv[]) { std::vector<double> min_p = {-1000, -2000}; std::vector<double> max_p = {1000, 4000}; std::vector<double> wts(2000, 0.6); // each of 2000 iterations have weight 0.6 // perform ppso auto ret = ppso::Particle_Swarm{ objective_function(), 2, // number of dimensions min_p, // vector of minimum values for each dimension max_p, // vector of maximum values for each dimension std::max(std::thread::hardware_concurrency(), (unsigned int)2), // number of groups (threads) 20, // number of particles 2000.0, // maximum velocity wts, // vector of weights for each iteration 2, // personal influence constant 2, // group influence constant 4, // every 4 iterations, communication strategy 1 8, // every 8 iterations, communication strategy 2 2000 // 2000 iterations }.run(); // print x* std::cout << std::fixed << "x* = [ "; for (double x: ret.first) { std::cout << x << " "; } std::cout << "]'\n"; // print f(x*) std::cout << "f(x*) = " << ret.second << std::endl; return 0; }
void evaluate_fitness(Population * population, mySlimTree* SlimTree, TCity * queryObject, stDistance range) { double x, y; long i; for( i = 0; i < POPULATION_SIZE; ++i) { decoder(&population->individuals[i]); if(MAXIMIZATION) { population->individuals[i].fitness = objective_function(population->individuals[i].phenotype, SlimTree, queryObject, range); } else { population->individuals[i].fitness = (-1 * objective_function(population->individuals[i].phenotype, SlimTree, queryObject, range)); } } }
void get_fitness( int n_pop, int n_dim, double *position, double *fitness ) { int p; for( p=0; p<n_pop; p++ ) { fitness[p] = objective_function( n_dim, &position[p*n_dim] ); } }
void MySimulation::measure() { bool is_past_burnin=(istep_>=burnin_); if (verbose_) { std::cout << istep_ << " " << is_past_burnin << " " << x_ << " " << y_ << "\n"; } if (!is_past_burnin) return; measurements["objective"] << objective_function(x_,y_); }
static double Maximize_Quality_Golden_Section(MVertex *ver, double xTarget, double yTarget, double zTarget, const std::vector<MElement *> <, double const tol, double &q) { const double lambda = 0.5 * (std::sqrt(5.0) - 1.0); const double mu = 0.5 * (3.0 - std::sqrt(5.0)); // = 1 - lambda double a = 0.0; double b = 2.0; double x1 = b - lambda * (b - a); double x2 = a + lambda * (b - a); double fx1 = objective_function(x1, ver, xTarget, yTarget, zTarget, lt); double fx2 = objective_function(x2, ver, xTarget, yTarget, zTarget, lt); if(tol < 0.0) return fx1 > fx2 ? x1 : x2; while(!Stopping_Rule(a, b, tol)) { // printf("GOLDEN : %g %g (%12.5E,%12.5E)\n",a,b,fa,fb); if(fx1 < fx2) { a = x1; if(Stopping_Rule(a, b, tol)) break; x1 = x2; fx1 = fx2; x2 = b - mu * (b - a); fx2 = objective_function(x2, ver, xTarget, yTarget, zTarget, lt); } else { b = x2; if(Stopping_Rule(a, b, tol)) break; x2 = x1; fx2 = fx1; x1 = a + mu * (b - a); fx1 = objective_function(x1, ver, xTarget, yTarget, zTarget, lt); } } // printf("finally : %g %g (%12.5E,%12.5E)\n",a,b,fa,fb); q = std::min(fx1, fx2); return a; }
static void _relocateVertexOfPyramid(MVertex *ver, const std::vector<MElement *> <, double relax) { if(ver->onWhat()->dim() != 3) return; double x = 0.0, y = 0.0, z = 0.0; int N = 0; MElement *pyramid = NULL; for(std::size_t i = 0; i < lt.size(); i++) { double XCG = 0.0, YCG = 0.0, ZCG = 0.0; if(lt[i]->getNumVertices() == 5) pyramid = lt[i]; else { for(std::size_t j = 0; j < lt[i]->getNumVertices(); j++) { XCG += lt[i]->getVertex(j)->x(); YCG += lt[i]->getVertex(j)->y(); ZCG += lt[i]->getVertex(j)->z(); } x += XCG; y += YCG; z += ZCG; N += lt[i]->getNumVertices(); } } x /= N; y /= N; z /= N; if(pyramid) { MFace q = pyramid->getFace(4); double A = q.approximateArea(); SVector3 n = q.normal(); n.normalize(); SPoint3 c = q.barycenter(); SVector3 d(x - c.x(), y - c.y(), z - c.z()); if(dot(n, d) < 0) n = n * (-1.0); double H = .5 * sqrt(fabs(A)); double XOPT = c.x() + relax * H * n.x(); double YOPT = c.y() + relax * H * n.y(); double ZOPT = c.z() + relax * H * n.z(); double FULL_MOVE_OBJ = objective_function(1.0, ver, XOPT, YOPT, ZOPT, lt, true); // printf("relax %g obj %g\n",relax,FULL_MOVE_OBJ); if(FULL_MOVE_OBJ > 0.1) { ver->x() = XOPT; ver->y() = YOPT; ver->z() = ZOPT; return; } } }
main() { // nevaluations = 0; float values[nov] ; float cost , penalty; values[0] = 1 ; values[1] = 3 ; penalty = 0.0; cost = objective_function( values, &penalty); printf(" ofn = %15.15f , sumconstr = %6.8f ", cost,penalty); }
static void _relocateVertexGolden(MVertex *ver, const std::vector<MElement *> <, double relax, double tol) { if(ver->onWhat()->dim() != 3) return; double x = 0.0, y = 0.0, z = 0.0; int N = 0; for(std::size_t i = 0; i < lt.size(); i++) { // TODO C++11 use std::accumulate instead double XCG = 0.0, YCG = 0.0, ZCG = 0.0; for(std::size_t j = 0; j < lt[i]->getNumVertices(); j++) { XCG += lt[i]->getVertex(j)->x(); YCG += lt[i]->getVertex(j)->y(); ZCG += lt[i]->getVertex(j)->z(); } x += XCG; y += YCG; z += ZCG; N += lt[i]->getNumVertices(); } double NO_MOVE_OBJ = objective_function(0.0, ver, x / N, y / N, z / N, lt); if(NO_MOVE_OBJ > 0.1) return; double FULL_MOVE_OBJ = objective_function(1.0, ver, x / N, y / N, z / N, lt); if(FULL_MOVE_OBJ > NO_MOVE_OBJ) { ver->x() = x / N; ver->y() = y / N; ver->z() = z / N; return; } double q; double xi = relax * Maximize_Quality_Golden_Section(ver, x / N, y / N, z / N, lt, tol, q); ver->x() = (1. - xi) * ver->x() + xi * x / N; ver->y() = (1. - xi) * ver->y() + xi * y / N; ver->z() = (1. - xi) * ver->z() + xi * z / N; }
static double Maximize_Quality_Golden_Section(MVertex *ver, GFace *gf, SPoint3 &p1, SPoint3 &p2, const std::vector<MElement *> <, double tol, double &worst) { const double lambda = 0.5 * (std::sqrt(5.0) - 1.0); const double mu = 0.5 * (3.0 - std::sqrt(5.0)); // = 1 - lambda double a = 0.0; double b = 1.0; worst = objective_function(0.0, ver, gf, p1, p2, lt); if(worst > 0.5) return 0.0; double x1 = b - lambda * (b - a); double x2 = a + lambda * (b - a); double fx1 = objective_function(x1, ver, gf, p1, p2, lt); double fx2 = objective_function(x2, ver, gf, p1, p2, lt); if(tol < 0.0) return fx1 > fx2 ? x1 : x2; while(!Stopping_Rule(a, b, tol)) { // printf("GOLDEN : %g %g (%12.5E,%12.5E)\n",a,b,fa,fb); if(fx1 < fx2) { a = x1; if(Stopping_Rule(a, b, tol)) break; x1 = x2; fx1 = fx2; x2 = b - mu * (b - a); fx2 = objective_function(x2, ver, gf, p1, p2, lt); } else { b = x2; if(Stopping_Rule(a, b, tol)) break; x2 = x1; fx2 = fx1; x1 = a + mu * (b - a); fx1 = objective_function(x1, ver, gf, p1, p2, lt); } } double final = objective_function(a, ver, gf, p1, p2, lt); if(final < worst) return 0.0; worst = final; // printf("finally : %g %g (%12.5E,%12.5E)\n",a,b,fa,fb); return a; }
// Set the objective function and gradients for GSL minimizer void set_functions(const gsl_vector *x, void *params, double *f, gsl_vector *g) { *f = objective_function(x, params); get_gradients(x, params, g); }
double* minimize(double x[], double y[], int n, int k) { double **simplex=create_simplex(n); /* create a new simplex */ double *function_values=(double*)malloc((n+1)*sizeof(double)); /* function values for a new simplex */ function_values=call_functions(x,y,simplex,n,k); /* store function values for every vertex of a simplex in an array */ int worst, second_worst, best; /* variable to store indecies for worst, second_word and best vortex */ double min, max; /* max and min values for function values */ int i,j; /* indecies for for loop */ double* centroid=(double*)malloc(n*sizeof(double)); /* centroid */ double alpha=1, beta=0.5, gamma=2, delta=0.5; /* scalar parameteras */ double *vertex_r=(double*)malloc(n*sizeof(double)); /* reflection point */ double f_r; /* function value at the reflection point */ double *vertex_e=(double*)malloc(n*sizeof(double)); /* expansion point */ double f_e; /* function value at the expansion point */ double *vertex_c=(double*)malloc(n*sizeof(double)); /* contraction point */ double f_c; /* function value at the contraction point */ int intterations_max=5000; int itteration=0; double conv_test; /* check every 42 itterations if function has changde less than 0.01% */ double diff=42.0; do { /* 1. step Ordering*/ worst=0, second_worst=0, best=0; min=function_values[0], max=function_values[0]; for(i=1;i<(n+1);i++) { if(min>=function_values[i]) { min=function_values[i]; best=i; } if(max<=function_values[i]) { max=function_values[i]; second_worst=worst; worst=i; } } /* 2. step Centroid */ for(i=0;i<n;i++) centroid[i]=0.0; for (i=0; i<n; i++) { for(j=0;j<(n+1);j++) { if(j!=worst) { centroid[i]+=simplex[j][i]; } } centroid[i]=centroid[i]/n; } /* 3. Step Transformation */ /* Reflect */ for(i=0;i<n;i++) { vertex_r[i]=centroid[i]+alpha*(centroid[i]-simplex[worst][i]); } f_r=objective_function(x,y,vertex_r,n,k); if(function_values[best]<=f_r && f_r<function_values[second_worst]) { for(i=0;i<n;i++) { simplex[worst][i]=vertex_r[i]; } function_values[worst]=f_r; } else if (f_r<function_values[best]) /* Expand */ { for(i=0;i<n;i++) { vertex_e[i]=centroid[i]+gamma*(vertex_r[i]-centroid[i]); } f_e=objective_function(x,y,vertex_e,n,k); if(f_e<f_r) { for(i=0;i<n;i++) { simplex[worst][i]=vertex_e[i]; } function_values[worst]=f_e; } else if(f_e>=f_r) { for(i=0;i<n;i++) { simplex[worst][i]=vertex_e[i]; } function_values[worst]=f_e; } } else if (f_r>=function_values[second_worst]) /* Contract */ { if(function_values[second_worst]<=f_r && f_r<function_values[worst]) /* Outside */ { for(i=0;i<n;i++) { vertex_c[i]=centroid[i]+beta*(vertex_r[i]-centroid[i]); } f_c=objective_function(x,y,vertex_c,n,k); if(f_c<=f_r) { for(i=0;i<n;i++) { simplex[worst][i]=vertex_c[i]; } function_values[worst]=f_c; } } else if(f_r>=function_values[worst]) /* Inside */ { for(i=0;i<n;i++) { vertex_c[i]=centroid[i]+beta*(simplex[worst][i]-centroid[i]); } f_c=objective_function(x,y,vertex_c,n,k); if(f_c<function_values[worst]) { for(i=0;i<n;i++) { simplex[worst][i]=vertex_c[i]; } function_values[worst]=f_c; } } else /* Shrink */ { for(i=0;i<(n+1);i++) { if(i!=best) { for(j=0;i<n;j++) { simplex[i][j]=simplex[best][j]+delta*(simplex[i][j]-simplex[best][j]); } } } function_values=call_functions(x,y,simplex,n,k); } } if(itteration%42==0) { if(itteration>0) { diff=fabs(conv_test-function_values[best]); } conv_test=function_values[best]; } itteration++; } while (itteration<intterations_max && diff>0.0001); if(itteration==intterations_max) { printf("The algorithm has not converge.\n"); } return simplex[best]; }