Doxygen Source Code Documentation
Simplexx.c File Reference
Go to the source code of this file.
Functions | |
void | allocate_arrays (float ***simplex, float **centroid, float **response, float **step_size, float **test1, float **test2) |
void | deallocate_arrays (float ***simplex, float **centroid, float **response, float **step_size, float **test1, float **test2) |
void | eval_vertices (float *response, int *worst, int *next, int *best) |
void | restart (float **simplex, float *response, float *step_size) |
void | calc_centroid (float **simplex, int worst, float *centroid) |
void | calc_reflection (float **simplex, float *centroid, int worst, float coef, float *vertex) |
void | replace (float **simplex, float *response, int index, float *vertex, float resp) |
float | calc_good_fit (float *response) |
void | simplex_initialize (float *parameters, float **simplex, float *response, float *step_size) |
void | simplex_optimization (float *parameters, float *sse) |
Variables | |
int | count = 0 |
int | number_restarts = 0 |
Function Documentation
|
Definition at line 39 of file Simplexx.c. References i, malloc, and test1(). Referenced by simplex_optimization().
00042 { 00043 int i; 00044 00045 *centroid = (float *) malloc (sizeof(float) * DIMENSION); 00046 *response = (float *) malloc (sizeof(float) * (DIMENSION+1)); 00047 *step_size = (float *) malloc (sizeof(float) * DIMENSION); 00048 *test1 = (float *) malloc (sizeof(float) * DIMENSION); 00049 *test2 = (float *) malloc (sizeof(float) * DIMENSION); 00050 00051 *simplex = (float **) malloc (sizeof(float *) * (DIMENSION+1)); 00052 00053 for (i = 0; i < DIMENSION+1; i++) 00054 (*simplex)[i] = (float *) malloc (sizeof(float) * DIMENSION); 00055 00056 } |
|
Definition at line 157 of file Simplexx.c. References i. Referenced by simplex_optimization().
00158 { 00159 int i, j; 00160 00161 for (i = 0; i < DIMENSION; i++) 00162 { 00163 centroid[i] = 0.0; 00164 00165 /* add each vertex, except the worst */ 00166 for (j = 0; j < DIMENSION+1; j++) 00167 if (j != worst) 00168 centroid[i] += simplex[j][i]; 00169 } 00170 00171 /* divide by the number of vertices */ 00172 for (i = 0; i < DIMENSION; i++) 00173 centroid[i] /= DIMENSION; 00174 } |
|
Definition at line 214 of file Simplexx.c. Referenced by simplex_optimization().
00215 { 00216 int i; 00217 00218 float avg, sd, tmp; 00219 00220 /* average the response values */ 00221 avg = 0.0; 00222 for (i = 0; i < DIMENSION+1; i++) 00223 avg += response[i]; 00224 avg /= DIMENSION+1; 00225 00226 /* compute standard deviation of response */ 00227 sd = 0.0; 00228 for (i = 0; i < DIMENSION+1; i++) 00229 { 00230 tmp = response[i] - avg; 00231 sd += tmp*tmp; 00232 } 00233 sd /= DIMENSION; 00234 00235 return (sqrt(sd)); 00236 } |
|
Definition at line 182 of file Simplexx.c. References i. Referenced by simplex_optimization().
|
|
Definition at line 61 of file Simplexx.c. References free, i, and test1(). Referenced by simplex_optimization().
00064 { 00065 int i; 00066 00067 free (*centroid); *centroid = NULL; 00068 free (*response); *response = NULL; 00069 free (*step_size); *step_size = NULL; 00070 free (*test1); *test1 = NULL; 00071 free (*test2); *test2 = NULL; 00072 00073 for (i = 0; i < DIMENSION+1; i++) 00074 { 00075 free ((*simplex)[i]); 00076 (*simplex)[i] = NULL; 00077 } 00078 00079 free (*simplex); *simplex = NULL; 00080 00081 } |
|
Definition at line 86 of file Simplexx.c. References i. Referenced by restart(), simplex_initialize(), and simplex_optimization().
00087 { 00088 int i; 00089 00090 /* initialize values */ 00091 *worst = 0; 00092 *best = 0; 00093 00094 /* find the best and worst */ 00095 for (i = 1; i < DIMENSION+1; i++) 00096 { 00097 if (response[i] > response[*worst]) 00098 *worst = i; 00099 if (response[i] < response[*best]) 00100 *best = i; 00101 } 00102 00103 /* find the next worst index */ 00104 if (*worst == 0) 00105 *next = 1; 00106 else 00107 *next = 0; 00108 00109 for (i = 0; i < DIMENSION+1; i++) 00110 if ((i != *worst) && (response[i] > response[*next])) 00111 *next = i; 00112 } |
|
Definition at line 197 of file Simplexx.c. References i. Referenced by simplex_initialize(), and simplex_optimization().
|
|
Definition at line 117 of file Simplexx.c. References calc_error(), eval_vertices(), i, maxval, and rand_uniform(). Referenced by simplex_optimization().
00119 { 00120 const float STEP_FACTOR = 0.9; 00121 int i, j; 00122 int worst, next, best; 00123 float minval, maxval; 00124 00125 00126 /* find the current best vertex */ 00127 eval_vertices (response, &worst, &next, &best); 00128 00129 /* set the first vertex to the current best */ 00130 for (i = 0; i < DIMENSION; i++) 00131 simplex[0][i] = simplex[best][i]; 00132 00133 /* decrease step size */ 00134 for (i = 0; i < DIMENSION; i++) 00135 step_size[i] *= STEP_FACTOR; 00136 00137 /* set up remaining vertices of simplex using new step size */ 00138 for (i = 1; i < DIMENSION+1; i++) 00139 for (j = 0; j < DIMENSION; j++) 00140 { 00141 minval = simplex[0][j] - step_size[j]; 00142 maxval = simplex[0][j] + step_size[j]; 00143 simplex[i][j] = rand_uniform (minval, maxval); 00144 } 00145 00146 /* initialize response for each vector */ 00147 for (i = 0; i < DIMENSION+1; i++) 00148 response[i] = calc_error (simplex[i]); 00149 } |
|
Definition at line 244 of file Simplexx.c. References calc_error(), eval_vertices(), i, maxval, rand_uniform(), and replace(). Referenced by simplex_optimization().
00246 { 00247 int i, j; 00248 int worst, next, best; 00249 float resp; 00250 float minval, maxval; 00251 00252 00253 for (j = 0; j < DIMENSION; j++) 00254 { 00255 simplex[0][j] = parameters[j]; 00256 step_size[j] = 0.5 * parameters[j]; 00257 } 00258 00259 for (i = 1; i < DIMENSION+1; i++) 00260 for (j = 0; j < DIMENSION; j++) 00261 { 00262 minval = simplex[0][j] - step_size[j]; 00263 maxval = simplex[0][j] + step_size[j]; 00264 simplex[i][j] = rand_uniform (minval, maxval); 00265 } 00266 00267 for (i = 0; i < DIMENSION+1; i++) 00268 response[i] = calc_error (simplex[i]); 00269 00270 for (i = 1; i < 500; i++) 00271 { 00272 for (j = 0; j < DIMENSION; j++) 00273 { 00274 minval = simplex[0][j] - step_size[j]; 00275 maxval = simplex[0][j] + step_size[j]; 00276 parameters[j] = rand_uniform (minval, maxval); 00277 } 00278 00279 resp = calc_error (parameters); 00280 eval_vertices (response, &worst, &next, &best); 00281 if (resp < response[worst]) 00282 replace (simplex, response, worst, parameters, resp); 00283 } 00284 } |
|
Definition at line 294 of file Simplexx.c. References allocate_arrays(), calc_centroid(), calc_error(), calc_good_fit(), calc_reflection(), deallocate_arrays(), eval_vertices(), fit, i, number_restarts, replace(), restart(), simplex_initialize(), and test1(). Referenced by calc_full_model(), estpdf(), estpdf_float(), and estpdf_short().
00295 { 00296 const int MAX_ITERATIONS = 100; 00297 const int MAX_RESTARTS = 25; 00298 const float EXPANSION_COEF = 2.0; 00299 const float REFLECTION_COEF = 1.0; 00300 const float CONTRACTION_COEF = 0.5; 00301 const float TOLERANCE = 1.0e-10; 00302 00303 float ** simplex = NULL; 00304 float * centroid = NULL; 00305 float * response = NULL; 00306 float * step_size = NULL; 00307 float * test1 = NULL; 00308 float * test2 = NULL; 00309 float resp1, resp2; 00310 int i, worst, best, next; 00311 int num_iter, num_restarts; 00312 int done; 00313 float fit; 00314 00315 00316 allocate_arrays (&simplex, ¢roid, &response, &step_size, &test1, &test2); 00317 00318 simplex_initialize (parameters, simplex, response, step_size); 00319 00320 /* start loop to do simplex optimization */ 00321 num_iter = 0; 00322 num_restarts = 0; 00323 done = 0; 00324 00325 while (!done) 00326 { 00327 /* find the worst vertex and compute centroid of remaining simplex, 00328 discarding the worst vertex */ 00329 eval_vertices (response, &worst, &next, &best); 00330 calc_centroid (simplex, worst, centroid); 00331 00332 /* reflect the worst point through the centroid */ 00333 calc_reflection (simplex, centroid, worst, 00334 REFLECTION_COEF, test1); 00335 resp1 = calc_error (test1); 00336 00337 /* test the reflection against the best vertex and expand it if the 00338 reflection is better. if not, keep the reflection */ 00339 if (resp1 < response[best]) 00340 { 00341 /* try expanding */ 00342 calc_reflection (simplex, centroid, worst, EXPANSION_COEF, test2); 00343 resp2 = calc_error (test2); 00344 if (resp2 <= resp1) /* keep expansion */ 00345 replace (simplex, response, worst, test2, resp2); 00346 else /* keep reflection */ 00347 replace (simplex, response, worst, test1, resp1); 00348 } 00349 else if (resp1 < response[next]) 00350 { 00351 /* new response is between the best and next worst 00352 so keep reflection */ 00353 replace (simplex, response, worst, test1, resp1); 00354 } 00355 else 00356 { 00357 /* try contraction */ 00358 if (resp1 >= response[worst]) 00359 calc_reflection (simplex, centroid, worst, 00360 -CONTRACTION_COEF, test2); 00361 else 00362 calc_reflection (simplex, centroid, worst, 00363 CONTRACTION_COEF, test2); 00364 resp2 = calc_error (test2); 00365 00366 /* test the contracted response against the worst response */ 00367 if (resp2 > response[worst]) 00368 { 00369 /* new contracted response is worse, so decrease step size 00370 and restart */ 00371 num_iter = 0; 00372 num_restarts += 1; 00373 restart (simplex, response, step_size); 00374 } 00375 else /* keep contraction */ 00376 replace (simplex, response, worst, test2, resp2); 00377 } 00378 00379 /* test to determine when to stop. 00380 first, check the number of iterations */ 00381 num_iter += 1; /* increment iteration counter */ 00382 if (num_iter >= MAX_ITERATIONS) 00383 { 00384 /* restart with smaller steps */ 00385 num_iter = 0; 00386 num_restarts += 1; 00387 restart (simplex, response, step_size); 00388 } 00389 00390 /* limit the number of restarts */ 00391 if (num_restarts == MAX_RESTARTS) done = 1; 00392 00393 /* compare relative standard deviation of vertex responses 00394 against a defined tolerance limit */ 00395 fit = calc_good_fit (response); 00396 if (fit <= TOLERANCE) done = 1; 00397 00398 /* if done, copy the best solution to the output array */ 00399 if (done) 00400 { 00401 eval_vertices (response, &worst, &next, &best); 00402 for (i = 0; i < DIMENSION; i++) 00403 parameters[i] = simplex[best][i]; 00404 *sse = response[best]; 00405 } 00406 00407 } /* while (!done) */ 00408 00409 number_restarts = num_restarts; 00410 deallocate_arrays (&simplex, ¢roid, &response, &step_size, 00411 &test1, &test2); 00412 00413 } |
Variable Documentation
|
Definition at line 33 of file Simplexx.c. |
|
Definition at line 34 of file Simplexx.c. Referenced by simplex_optimization(). |