simplex_t *simplex_alloc(int m) { int i; simplex_t *s; unsigned char *buf; if (m <= N) return NULL; s = (simplex_t *) malloc(sizeof(simplex_t) + m * sizeof(vertex_t *)); if (!s) return NULL; s->len = m; buf = (unsigned char *) malloc(m * sizeof_vertex); for (i = 0; i < m; ++i) { s->vertex[i] = (vertex_t *)(buf + i * sizeof_vertex); s->vertex[i]->perf = hperf_alloc(P); if (!s->vertex[i]->perf) return NULL; vertex_reset(s->vertex[i]); } return s; }
int vertex_regrid(vertex_t *v) { int i; if (vertex_outofbounds(v)) return -1; for (i = 0; i < N; ++i) { switch (range[i].type) { case HVAL_INT: v->term[i] = hrange_int_nearest(&range[i].bounds.i, v->term[i]); break; case HVAL_REAL: v->term[i] = hrange_real_nearest(&range[i].bounds.r, v->term[i]); break; case HVAL_STR: if (v->term[i] < 0.0) v->term[i] = 0.0; if (v->term[i] > range[i].bounds.s.set_len - 1) v->term[i] = range[i].bounds.s.set_len - 1; v->term[i] = (unsigned long)(v->term[i] + 0.5); break; default: return -1; } } vertex_reset(v); return 0; }
int internal_vertex_max(vertex_t *v) { int i; vertex_reset(v); for (i = 0; i < N; ++i) { int idx = hrange_max_idx(&range[i]); switch (range[i].type) { case HVAL_INT: v->term[i] = hrange_int_value(&range[i].bounds.i, idx); break; case HVAL_REAL: if (range[i].bounds.r.step > 0.0) v->term[i] = hrange_real_value(&range[i].bounds.r, idx); else v->term[i] = range[i].bounds.r.max; break; case HVAL_STR: v->term[i] = range[i].bounds.s.set_len - 1; break; default: return -1; } } return 0; }
int internal_vertex_min(vertex_t *v) { int i; vertex_reset(v); for (i = 0; i < N; ++i) { switch (range[i].type) { case HVAL_INT: v->term[i] = range[i].bounds.i.min; break; case HVAL_REAL: v->term[i] = range[i].bounds.r.min; break; case HVAL_STR: v->term[i] = 0.0; break; default: return -1; } } return 0; }
struct graph *graph_new(unsigned long (*hash_fn) (void *), int (*cmp_fn) (const void *, const void *)) { struct graph *graph; graph = xcalloc(1, sizeof(struct graph)); graph->nr = 0; graph->sz = GRAPH_INIT_VERTICES; graph->vertices = xcalloc(GRAPH_INIT_VERTICES, sizeof(struct vertex)); graph->vidx = hash_new(VINDEX, hash_fn, cmp_fn); int i; for (i = 0; i < GRAPH_INIT_VERTICES; ++i) { vertex_reset(&graph->vertices[i]); } return graph; }
/* * Invoked once on strategy load. */ int strategy_init(hsignature_t *sig) { if (libvertex_init(sig) != 0) { session_error("Could not initialize vertex library."); return -1; } if (!base) { const char *cfgval; /* One time memory allocation and/or initialization. */ cfgval = session_getcfg(CFGKEY_SIMPLEX_SIZE); if (cfgval) simplex_size = atoi(cfgval); /* Make sure the simplex size is N+1 or greater. */ if (simplex_size < sig->range_len + 1) simplex_size = sig->range_len + 1; init_point = vertex_alloc(); if (!init_point) { session_error("Could not allocate memory for initial point."); return -1; } test = simplex_alloc(simplex_size); if (!test) { session_error("Could not allocate memory for candidate simplex."); return -1; } base = simplex_alloc(simplex_size); if (!base) { session_error("Could not allocate memory for reference simplex."); return -1; } /* The best point and trial counter should only be initialized once, * and thus be retained across a restart. */ best = HPOINT_INITIALIZER; best_perf = INFINITY; next_id = 1; } /* Initialization for subsequent calls to strategy_init(). */ vertex_reset(init_point); simplex_reset(test); simplex_reset(base); reported = 0; send_idx = 0; coords = sig->range_len; if (strategy_cfg(sig) != 0) return -1; switch (init_method) { case SIMPLEX_INIT_CENTER: vertex_center(init_point); break; case SIMPLEX_INIT_RANDOM: vertex_rand_trim(init_point, init_percent); break; case SIMPLEX_INIT_POINT: vertex_from_string(session_getcfg(CFGKEY_INIT_POINT), sig, init_point); break; default: session_error("Invalid initial search method."); return -1; } simplex_from_vertex(init_point, init_percent, base); if (session_setcfg(CFGKEY_STRATEGY_CONVERGED, "0") != 0) { session_error("Could not set " CFGKEY_STRATEGY_CONVERGED " config variable."); return -1; } state = SIMPLEX_STATE_INIT; if (pro_next_simplex(test) != 0) { session_error("Could not initiate the simplex."); return -1; } return 0; }
void simplex_reset(simplex_t *s) { int i; for (i = 0; i < s->len; ++i) vertex_reset(s->vertex[i]); }
static void vertex_init(struct vertex *vertex) { vertex_reset(vertex); vertex->adj = xcalloc(VERTEX_ADJ_INIT_SZ, sizeof(int)); vertex->sz = VERTEX_ADJ_INIT_SZ; }