static VALUE rb_gsl_fminimizer_x(VALUE obj) { gsl_multimin_fminimizer *gmf = NULL; gsl_vector *x = NULL; Data_Get_Struct(obj, gsl_multimin_fminimizer, gmf); x = gsl_multimin_fminimizer_x(gmf); return Data_Wrap_Struct(cgsl_vector_view_ro, 0, NULL, x); }
CAMLprim value ml_gsl_multimin_fminimizer_minimum(value ox, value T) { gsl_multimin_fminimizer *t=GSLMULTIMINFMINIMIZER_VAL(T); if(Is_block(ox)) { value x=Unoption(ox); _DECLARE_VECTOR(x); _CONVERT_VECTOR(x); gsl_vector_memcpy(&v_x, gsl_multimin_fminimizer_x(t)); } return copy_double(gsl_multimin_fminimizer_minimum(t)); }
double GSLOptimizer::optimize(unsigned int iter, const gsl_multimin_fminimizer_type*t, double ms, double mxs) { fis_= get_optimized_attributes(); best_score_=std::numeric_limits<double>::max(); unsigned int n= get_dimension(); if (n ==0) { IMP_LOG(TERSE, "Nothing to optimize" << std::endl); return get_scoring_function()->evaluate(false); } gsl_multimin_fminimizer *s=gsl_multimin_fminimizer_alloc (t, n); gsl_vector *x= gsl_vector_alloc(get_dimension()); update_state(x); gsl_vector *ss= gsl_vector_alloc(get_dimension()); gsl_vector_set_all(ss, mxs); gsl_multimin_function f= internal::create_f_function_data(this); gsl_multimin_fminimizer_set (s, &f, x, ss); try { int status; do { --iter; //update_state(x); status = gsl_multimin_fminimizer_iterate(s); if (status) { IMP_LOG(TERSE, "Ending optimization because of state " << s << std::endl); break; } double sz= gsl_multimin_fminimizer_size(s); status= gsl_multimin_test_size(sz, ms); update_states(); if (status == GSL_SUCCESS) { IMP_LOG(TERSE, "Ending optimization because of small size " << sz << std::endl); break; } } while (status == GSL_CONTINUE && iter >0); } catch (AllDone){ } gsl_vector *ret=gsl_multimin_fminimizer_x (s); best_score_=gsl_multimin_fminimizer_minimum (s); write_state(ret); gsl_multimin_fminimizer_free (s); gsl_vector_free (x); return best_score_; }
static PyObject* multimin_multimin_x(PyObject *self, PyObject *args ) { gsl_vector* result; PyObject* py_result; size_t i; if ( ((multimin_multiminObject*)self)->min==NULL || ((multimin_multiminObject*)self)->func==NULL) { PyErr_SetString(PyExc_RuntimeError,"no function specified!"); return NULL; } result=gsl_multimin_fminimizer_x(((multimin_multiminObject*)self)->min); if (result==NULL) { return NULL; } py_result=PyTuple_New(result->size); if (py_result==NULL) { return NULL; } for (i=0; i<result->size; i++) PyTuple_SetItem(py_result,i,PyFloat_FromDouble(gsl_vector_get(result,i))); return py_result; }
int FC_FUNC_(oct_minimize_direct, OCT_MINIMIZE_DIRECT) (const int *method, const int *dim, double *point, const double *step, const double *toldr, const int *maxiter, funcn f, const print_f_fn_ptr write_info, double *minimum) { int iter = 0, status, i; double size; const gsl_multimin_fminimizer_type *T = NULL; gsl_multimin_fminimizer *s = NULL; gsl_vector *x, *ss; gsl_multimin_function my_func; param_fn_t p; p.func = f; my_func.f = &fn; my_func.n = *dim; my_func.params = (void *) &p; /* Set the initial vertex size vector */ ss = gsl_vector_alloc (*dim); gsl_vector_set_all (ss, *step); /* Starting point */ x = gsl_vector_alloc (*dim); for(i=0; i<*dim; i++) gsl_vector_set (x, i, point[i]); switch(*method){ case 6: T = gsl_multimin_fminimizer_nmsimplex; break; } s = gsl_multimin_fminimizer_alloc (T, *dim); gsl_multimin_fminimizer_set (s, &my_func, x, ss); do { iter++; status = gsl_multimin_fminimizer_iterate(s); if(status) break; *minimum = gsl_multimin_fminimizer_minimum(s); for(i=0; i<*dim; i++) point[i] = gsl_vector_get(gsl_multimin_fminimizer_x(s), i); size = gsl_multimin_fminimizer_size (s); status = gsl_multimin_test_size (size, *toldr); write_info(&iter, dim, minimum, &size, point); } while (status == GSL_CONTINUE && iter < *maxiter); if(status == GSL_CONTINUE) status = 1025; gsl_vector_free(x); gsl_vector_free(ss); gsl_multimin_fminimizer_free(s); return status; }
void minimd(density_t * ndft){ int status; int i; double stepmin, minimum, g_initial; char * output_string; gsl_vector *ss; const gsl_multimin_fminimizer_type *T; gsl_multimin_fminimizer *s; gsl_multimin_function my_func; size_t iter; params_gsl_multimin_function_t params; switch(gradient_free_mode){ case SIMPLEX : output_string = (char *) malloc(25*sizeof(char)); params.nDFT = density_get_val(ndft); my_func.n = ipf.npar; my_func.f = my_f; my_func.params = (void *) (¶ms); /* Initial step sizes */ ss = gsl_vector_alloc (ipf.npar); gsl_vector_set_all(ss, 0.1); /* We use the Simplex algorithm from thee GNU Scientific Library (GSL) in its optimized version nmsimplex2 */ T = gsl_multimin_fminimizer_nmsimplex2; messages_basic("\n\n\nStarting the optimization.\n\n\n"); g_initial = my_f(ipf.gamma, ¶ms); if(g_initial < epsilon_gvalue){ if(myid == 0) printf("The value of G for the starting gamma is %.12lg,\n", g_initial); if(myid == 0) printf("which is already below the requested threshold of %.12lg\n", epsilon_gvalue); parallel_end(EXIT_SUCCESS); } if(myid == 0) printf(" Starting from gamma = "); if(myid == 0) {for(i = 0; i < ipf.npar; i++) printf ("%.5f ", gsl_vector_get (ipf.gamma, i));} if(myid == 0) printf("\n G(gamma) = %.12lg\n", g_initial); /* Initialization of the minimizer s for the function my_func starting at the x point */ messages_basic("\n\nInitialization of the minimizer.\n\n\n"); s = gsl_multimin_fminimizer_alloc (T, ipf.npar); gsl_multimin_fminimizer_set (s, &my_func, ipf.gamma, ss); minimum = g_initial; iter = 0; do { iter++; if(myid == 0) printf(" Iter = %d\n", (int)iter); if(myid == 0) printf(" gamma = "); if(myid == 0) {for(i = 0; i < ipf.npar; i++) printf ("%.5f ", gsl_vector_get (gsl_multimin_fminimizer_x(s), i));} if(myid == 0) printf("\n starting G(gamma) = %15.10lg\n", minimum); /* We make an iteration of the minimizer s */ status = gsl_multimin_fminimizer_iterate (s); minimum = gsl_multimin_fminimizer_minimum(s); if (status){ if(myid == 0) printf(" Breaking. Reason: %s\n", gsl_strerror(status)); break; } if(myid == 0) printf(" G(gamma) = %15.10f\n", minimum); stepmin = gsl_multimin_fminimizer_size (s); status = gsl_multimin_test_size (stepmin, 1e-2); } while (status == GSL_CONTINUE && iter < 100); if(myid == 0) printf("\n\nFinished optimization. status = %d (%s)\n", status, gsl_strerror(status)); if(myid == 0) printf(" Final gamma = "); if(myid == 0) {for(i = 0; i < ipf.npar; i++) printf ("%.5f ", gsl_vector_get (gsl_multimin_fminimizer_x(s), i));} if(myid == 0) printf("\n With value: G(gamma) = %.12lg\n\n", gsl_multimin_fminimizer_minimum(s)); gsl_vector_memcpy(ipf.gamma, gsl_multimin_fminimizer_x(s)); sprintf(output_string, "pot"); ipf_write(ipf, ipf_ref, output_string); gsl_multimin_fminimizer_free (s); fflush(stdout); gsl_vector_free(ss); break; case GENETIC_ALGORITHM : output_string = (char *) malloc(75*sizeof(char)); sprintf(output_string, "python ga.py %f %f %f %f %f %f %d %d %d", grid.l, grid.step, extpot.alpha, extpot.Lmin, extpot.Lmax, extpot.delta, extpot.npotex, ipf.npar, ipf.poten_selector); system(output_string); free(output_string); break; } }
void GslOptimizer::minimize_no_gradient( unsigned int dim, OptimizerMonitor* monitor ) { // Set initial point gsl_vector* x = gsl_vector_alloc(dim); for (unsigned int i = 0; i < dim; i++) { gsl_vector_set(x, i, (*m_initialPoint)[i]); } // Tell GSL which solver we're using const gsl_multimin_fminimizer_type* type = NULL; switch(m_solver_type) { case(NELDER_MEAD): type = gsl_multimin_fminimizer_nmsimplex; break; case(NELDER_MEAD2): type = gsl_multimin_fminimizer_nmsimplex2; break; case(NELDER_MEAD2_RAND): type = gsl_multimin_fminimizer_nmsimplex2rand; break; case(FLETCHER_REEVES_CG): case(POLAK_RIBIERE_CG): case(BFGS): case(BFGS2): case(STEEPEST_DESCENT): default: // Wat?! queso_error(); } // Init solver gsl_multimin_fminimizer* solver = gsl_multimin_fminimizer_alloc(type, dim); // Point GSL at the right functions gsl_multimin_function minusLogPosterior; minusLogPosterior.n = dim; minusLogPosterior.f = &c_evaluate; minusLogPosterior.params = (void *)(this); // Needed for these gradient free algorithms. gsl_vector* step_size = gsl_vector_alloc(dim); for(unsigned int i = 0; i < dim; i++) { gsl_vector_set(step_size, i, m_fstep_size[i]); } gsl_multimin_fminimizer_set(solver, &minusLogPosterior, x, step_size); int status; size_t iter = 0; double size = 0.0; do { iter++; status = gsl_multimin_fminimizer_iterate(solver); if (status) { if( m_objectiveFunction.domainSet().env().fullRank() == 0 ) { std::cerr << "Error while GSL does optimisation. " << "See below for GSL error type." << std::endl; std::cerr << "Gsl error: " << gsl_strerror(status) << std::endl; } break; } size = gsl_multimin_fminimizer_size(solver); status = gsl_multimin_test_size (size, this->getTolerance()); if(monitor) { gsl_vector* x = gsl_multimin_fminimizer_x(solver); std::vector<double> x_min(dim); for( unsigned int i = 0; i < dim; i++) x_min[i] = gsl_vector_get(x,i); double f = gsl_multimin_fminimizer_minimum(solver); monitor->append( x_min, f, size ); } } while ((status == GSL_CONTINUE) && (iter < this->getMaxIterations())); for (unsigned int i = 0; i < dim; i++) { (*m_minimizer)[i] = gsl_vector_get(solver->x, i); } // We're being good human beings and cleaning up the memory we allocated gsl_vector_free(step_size); gsl_multimin_fminimizer_free(solver); gsl_vector_free(x); return; }
void simplex(struct s_best *p_best, struct s_data *p_data, void *p_params_simplex, double (*f_simplex)(const gsl_vector *, void *), double CONVERGENCE_STOP_SIMPLEX, int M, enum plom_print print_opt) { /* simplex algo using GSL. Straightforward adaptation of the GSL doc example */ char str[255]; FILE *p_file_trace = NULL; if(print_opt & PLOM_PRINT_BEST) { p_file_trace = plom_fopen(SFR_PATH, GENERAL_ID, "trace", "w", header_trace, p_data); } double log_like = 0.0; const gsl_multimin_fminimizer_type *T = gsl_multimin_fminimizer_nmsimplex2; gsl_multimin_fminimizer *simp = NULL; gsl_multimin_function minex_func; int iter = 0; int status; double size; gsl_vector *x = gsl_vector_alloc(p_best->n_to_be_estimated); gsl_vector *jump_sizes = gsl_vector_alloc(p_best->n_to_be_estimated); int k; for (k=0; k<p_best->n_to_be_estimated; k++) { gsl_vector_set(x, k, gsl_vector_get(p_best->mean, p_best->to_be_estimated[k])); gsl_vector_set(jump_sizes, k, sqrt(gsl_matrix_get(p_best->var, p_best->to_be_estimated[k], p_best->to_be_estimated[k]))); //note the sqrt !! } /* Initialize method and iterate */ minex_func.n = p_best->n_to_be_estimated; minex_func.f = f_simplex; minex_func.params = p_params_simplex; simp = gsl_multimin_fminimizer_alloc(T, p_best->n_to_be_estimated ); gsl_multimin_fminimizer_set(simp, &minex_func, x, jump_sizes); do { #if FLAG_JSON //for the webApp, we block at every iterations to prevent the client to be saturated with msg block(); #endif iter++; status = gsl_multimin_fminimizer_iterate(simp); if (status) break; size = gsl_multimin_fminimizer_size(simp); status = gsl_multimin_test_size(size, CONVERGENCE_STOP_SIMPLEX); log_like = - gsl_multimin_fminimizer_minimum(simp); if (!(print_opt & PLOM_QUIET)) { if (status == GSL_SUCCESS) { print_log ("converged to maximum !"); } sprintf(str, "%5d logLike = %12.5f size = %.14f", iter, log_like, size); print_log(str); } transfer_estimated(p_best, gsl_multimin_fminimizer_x(simp), p_data); if(print_opt & PLOM_PRINT_BEST){ print_trace(p_file_trace, iter-1, p_best, p_data, log_like); } } while (status == GSL_CONTINUE && iter < M); if(!(print_opt & PLOM_PRINT_BEST)){ p_file_trace = plom_fopen(SFR_PATH, GENERAL_ID, "trace", "w", header_trace, p_data); print_trace(p_file_trace, iter-1, p_best, p_data, log_like); } plom_fclose(p_file_trace); gsl_multimin_fminimizer_free(simp); gsl_vector_free(x); gsl_vector_free(jump_sizes); }
int main (int argc, char **argv) { struct experiment_params params; double dx, dy; double speed, angle; gsl_vector *solution; int c; double compute_start, delta; while ((c = getopt (argc, argv, "v")) != EOF) { switch (c) { case 'v': vflag = 1; break; default: usage (); } } memset (¶ms, 0, sizeof params); params.observed_hit[0] = 0; params.observed_hit[1] = 0; params.observed_hit[2] = 1; params.observed_bounce[0] = 25; params.observed_bounce[1] = 0; params.observed_bounce[2] = 0; params.observed_secs = 1.359; dx = params.observed_bounce[0] - params.observed_hit[0]; dy = params.observed_bounce[1] - params.observed_hit[1]; params.observed_dist = hypot (dy, dx); params.simulator_dimen = 4; params.odesys.function = sim_func; params.odesys.dimension = params.simulator_dimen; params.odesys.params = ¶ms; params.stepper = gsl_odeiv_step_alloc (gsl_odeiv_step_rk8pd, params.simulator_dimen); params.controller = gsl_odeiv_control_y_new (1e-6, 0.0); params.evolver = gsl_odeiv_evolve_alloc (params.simulator_dimen); params.minimizer_dimen = 2; params.starting_point = gsl_vector_alloc (params.minimizer_dimen); params.minimizer_step_sizes = gsl_vector_alloc (params.minimizer_dimen); params.minimizer = gsl_multimin_fminimizer_alloc (gsl_multimin_fminimizer_nmsimplex2, params.minimizer_dimen); gsl_vector_set_all (params.starting_point, 0); gsl_vector_set_all (params.minimizer_step_sizes, 1.0); if (0) { graph_error_func (¶ms); } compute_start = get_secs (); solve_by_simulation (¶ms); delta = get_secs () - compute_start; solution = gsl_multimin_fminimizer_x (params.minimizer); speed = gsl_vector_get (solution, 0); angle = gsl_vector_get (solution, 1); printf ("speed = %8.3f angle = %8.3f; compute time %.3fms\n", speed * METERS_PER_SEC_TO_MPH, RTOD (angle), delta * 1000); return (0); }