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;
}
