Context Navigation

source: trunk/packages/optimizer/src/plugin_pgapack.c @ 1202

Last change on this file since 1202 was 1202, checked in by liveletlive, 16 years ago
Changes made to include the following items: 1) Hard restart 2) SBX 3) Random population replacement proportion 4) Definitions and macros for the above functions in pgapack.h
File size: 38.0 KB

Line
1	/*
2	* ----------------------------------------------------------------------
3	* OPTIMIZER PLUG-IN: Pgapack
4	*
5	* This code connects Pgapack into the Rappture Optimization
6	* infrastructure.
7	*
8	* ======================================================================
9	* AUTHOR: Michael McLennan, Purdue University
10	* Copyright (c) 2008 Purdue Research Foundation
11	*
12	* See the file "license.terms" for information on usage and
13	* redistribution of this file, and for a DISCLAIMER OF ALL WARRANTIES.
14	* ======================================================================
15	*/
16	#include "pgapack.h"
17	#include "rp_optimizer.h"
18
19	typedef struct PgapackData {
20	int operation; /* operation <=> PGA_MINIMIZE/PGA_MAXIMIZE */
21	int maxRuns; /* maximum runs <=> PGASetMaxGAIterValue() */
22	int popSize; /* population size <=> PGASetPopSize() */
23	int popRepl; /* replacement <=> PGASetPopReplacementType() */
24	int numReplPerPop; /* number of new strings created per population, the rest are the best strings from the previous population*/
25	int stpcriteria; /stoppage criteria <=> PGASetStoppingRuleType()/
26	int randnumseed; /Random Number Seed <=> PGASetRandomSeed()/
27	double mutnrate; /Mutation Rate <=> PGASetMutationProb()/
28	double mutnValue; /use this value while mutating/
29	double crossovrate; /Crossover Rate <=> PGASetCrossoverProb();/
30	int crossovtype; /Crossover Type <=> UNIFORM/SBX (SBX Defined from Deb and Kumar 1995)/
31	int allowdup; /Allow duplicate strings in the population or not/
32	int mutnandcrossover;/By default strings that do not undergo crossover undergo mutation, this option allows strings to crossover and be mutated/
33	double randReplProp; /By default, random replacement is off, therefore randReplaceProp is zero by default, /
34	/a nonzero replacement value causes random generation of individuals in later generations/
35	} PgapackData;
36
37	RpCustomTclOptionGet RpOption_GetStpCriteria;
38	RpCustomTclOptionParse RpOption_ParseStpCriteria;
39	RpTclOptionType RpOption_StpCriteria = {
40	"pga_stpcriteria", RpOption_ParseStpCriteria,RpOption_GetStpCriteria,NULL
41	};
42
43	RpCustomTclOptionParse RpOption_ParseOper;
44	RpCustomTclOptionGet RpOption_GetOper;
45	RpTclOptionType RpOption_Oper = {
46	"pga_operation", RpOption_ParseOper, RpOption_GetOper, NULL
47	};
48
49	RpCustomTclOptionParse RpOption_ParseCrossovType;
50	RpCustomTclOptionGet RpOption_GetCrossovType;
51	RpTclOptionType RpOption_CrossovType = {
52	"pga_crossovtype", RpOption_ParseCrossovType,RpOption_GetCrossovType,NULL
53	};
54
55	RpCustomTclOptionParse RpOption_ParsePopRepl;
56	RpCustomTclOptionGet RpOption_GetPopRepl;
57	RpTclOptionType RpOption_PopRepl = {
58	"pga_poprepl", RpOption_ParsePopRepl, RpOption_GetPopRepl, NULL
59	};
60
61
62	typedef struct PgapackRuntimeDataTable{
63	double *data; /Actual data per sample, like values of the genes, fitness of a sample, etc*/
64	int num_of_rows; /Number of rows alloced..should be constant for a run/
65	int no_of_samples_evaled; /Number of samples evaluated so far/
66	int no_of_columns; /Number of columns allocated to the data table so far/
67	}PgapackRuntimeDataTable;
68
69	RpTclOption PgapackOptions[] = {
70	{"-maxruns", RP_OPTION_INT, Rp_Offset(PgapackData,maxRuns)},
71	{"-operation", &RpOption_Oper, Rp_Offset(PgapackData,operation)},
72	{"-poprepl", &RpOption_PopRepl, Rp_Offset(PgapackData,popRepl)},
73	{"-numReplPerPop",RP_OPTION_INT,Rp_Offset(PgapackData,numReplPerPop)},
74	{"-popsize", RP_OPTION_INT, Rp_Offset(PgapackData,popSize)},
75	{"-mutnrate",RP_OPTION_DOUBLE,Rp_Offset(PgapackData,mutnrate)},
76	{"-mutnValue",RP_OPTION_DOUBLE,Rp_Offset(PgapackData,mutnValue)},
77	{"-crossovrate",RP_OPTION_DOUBLE,Rp_Offset(PgapackData,crossovrate)},
78	{"-crossovtype",&RpOption_CrossovType,Rp_Offset(PgapackData,crossovtype)},
79	{"-randnumseed",RP_OPTION_INT,Rp_Offset(PgapackData,randnumseed)},
80	{"-stpcriteria",&RpOption_StpCriteria,Rp_Offset(PgapackData,stpcriteria)},
81	{"-allowdup",RP_OPTION_BOOLEAN,Rp_Offset(PgapackData,allowdup)},
82	{"-mutnandcrossover",RP_OPTION_BOOLEAN,Rp_Offset(PgapackData,mutnandcrossover)},
83	{"-randReplProp",RP_OPTION_DOUBLE,Rp_Offset(PgapackData,randReplProp)},
84	{NULL, NULL, 0}
85	};
86
87	static double PgapEvaluate _ANSI_ARGS_((PGAContext *ctx, int p, int pop));
88	static void PgapCreateString _ANSI_ARGS_((PGAContext *ctx, int, int, int));
89	static int PgapMutation _ANSI_ARGS_((PGAContext *ctx, int, int, double));
90	static void PgapCrossover _ANSI_ARGS_((PGAContext *ctx, int, int, int,
91	int, int, int));
92	static void PgapPrintString _ANSI_ARGS_((PGAContext ctx, FILE, int, int));
93	static void PgapCopyString _ANSI_ARGS_((PGAContext *ctx, int, int, int, int));
94	static int PgapDuplicateString _ANSI_ARGS_((PGAContext *ctx, int, int, int, int));
95	static MPI_Datatype PgapBuildDT _ANSI_ARGS_((PGAContext *ctx, int, int));
96
97	static void PgapLinkContext2Env _ANSI_ARGS_((PGAContext *ctx,
98	RpOptimEnv *envPtr));
99	static RpOptimEnv* PgapGetEnvForContext _ANSI_ARGS_((PGAContext *ctx));
100	static void PgapUnlinkContext2Env _ANSI_ARGS_((PGAContext *ctx));
101	void PGARuntimeDataTableInit _ANSI_ARGS_((RpOptimEnv *envPtr));
102	void PGARuntimeDataTableDeInit();
103	void GetSampleInformation _ANSI_ARGS_((char *buffer, int sampleNumber));
104	void PGARuntimeDataTableSetSampleValue _ANSI_ARGS_((RpOptimParam *chrom, double fitness));
105	static PgapackRuntimeDataTable table;
106	/*
107	* ----------------------------------------------------------------------
108	* PgapackInit()
109	*
110	* This routine is called whenever a new optimization object is created
111	* to initialize Pgapack. Returns a pointer to PgapackData that is
112	* used in later routines.
113	* ----------------------------------------------------------------------
114	*/
115	ClientData
116	PgapackInit()
117	{
118	PgapackData *dataPtr;
119
120	dataPtr = (PgapackData*)malloc(sizeof(PgapackData));
121	dataPtr->operation = PGA_MINIMIZE;
122	dataPtr->maxRuns = 10000;
123	dataPtr->popRepl = PGA_POPREPL_BEST;
124	dataPtr->crossovtype = PGA_CROSSOVER_UNIFORM;
125	dataPtr->popSize = 200;
126	dataPtr->numReplPerPop = (dataPtr->popSize)/10; /10% replaced by default, change to whatever value you need/
127	dataPtr->crossovrate = 0.85;
128	dataPtr->mutnrate = 0.05; /by default in PGAPack 1/stringlength/
129	dataPtr->mutnValue = 0.01;/value of this number will be changed by plus/minus hundredth of its current value/
130	dataPtr->randnumseed = 1; /should be a number greater than one, PGAPack requires it/
131	dataPtr->stpcriteria = PGA_STOP_NOCHANGE;
132	dataPtr->allowdup = PGA_FALSE; /Do not allow duplicate strings by default/
133	dataPtr->mutnandcrossover = PGA_FALSE;/do not allow mutation and crossover to take place on the same string by default/
134	dataPtr->randReplProp = 0; /0 randomly generated individuals after initialization, per generation/
135	return (ClientData)dataPtr;
136	}
137
138	int pgapack_abort = 0;
139	int pgapack_restart_user_action = 0;
140
141	/*
142	* ----------------------------------------------------------------------
143	* PgapackRun()
144	*
145	* This routine is called to kick off an optimization run. Sets up
146	* a PGApack context and starts invoking runs.
147	* ----------------------------------------------------------------------
148	*/
149	RpOptimStatus
150	PgapackRun(envPtr, evalProc, fitnessExpr)
151	RpOptimEnv envPtr; / optimization environment */
152	RpOptimEvaluator evalProc; / call this proc to run tool */
153	char fitnessExpr; / fitness function in string form */
154	{
155	PgapackData dataPtr =(PgapackData)envPtr->pluginData;
156	PGAContext *ctx;
157
158	/* pgapack requires at least one arg -- the executable name */
159	/* fake it here by just saying something like "rappture" */
160	int argc = 1; char *argv[] = {"rappture"};
161
162	pgapack_abort = 0; /* FALSE */
163	PGASetAbortVar(&pgapack_abort);
164	PGASetRestartUserAction(&pgapack_restart_user_action);
165
166	ctx = PGACreate(&argc, argv, PGA_DATATYPE_USER, envPtr->numParams,
167	dataPtr->operation);
168
169	PGASetMaxGAIterValue(ctx, dataPtr->maxRuns);
170	PGASetPopSize(ctx, dataPtr->popSize);
171	PGASetPopReplaceType(ctx, dataPtr->popRepl);
172	PGASetStoppingRuleType(ctx, dataPtr->stpcriteria);
173	PGASetMutationProb(ctx,dataPtr->mutnrate);
174	PGASetMutationRealValue(ctx,dataPtr->mutnValue);
175	PGASetCrossoverProb(ctx,dataPtr->crossovrate);
176	PGASetRandomSeed(ctx,dataPtr->randnumseed);
177	PGASetCrossoverType(ctx, dataPtr->crossovtype);
178	PGASetNoDuplicatesFlag(ctx,!(dataPtr->allowdup));
179	PGASetMutationAndCrossoverFlag(ctx,dataPtr->mutnandcrossover);
180	PGASetNumReplaceValue(ctx,dataPtr->numReplPerPop);
181	PGASetRandReplProp(ctx,dataPtr->randReplProp);
182
183
184	PGASetUserFunction(ctx, PGA_USERFUNCTION_CREATESTRING, PgapCreateString);
185	PGASetUserFunction(ctx, PGA_USERFUNCTION_MUTATION, PgapMutation);
186	PGASetUserFunction(ctx, PGA_USERFUNCTION_CROSSOVER, PgapCrossover);
187	PGASetUserFunction(ctx, PGA_USERFUNCTION_PRINTSTRING, PgapPrintString);
188	PGASetUserFunction(ctx, PGA_USERFUNCTION_COPYSTRING, PgapCopyString);
189	PGASetUserFunction(ctx, PGA_USERFUNCTION_DUPLICATE, PgapDuplicateString);
190	PGASetUserFunction(ctx, PGA_USERFUNCTION_BUILDDATATYPE, PgapBuildDT);
191
192	envPtr->evalProc = evalProc; /* plug these in for later during eval */
193	envPtr->fitnessExpr = fitnessExpr;
194
195	/*
196	* We need a way to convert from a PGAContext to our RpOptimEnv
197	* data. This happens when Pgapack calls routines like
198	* PgapCreateString, passing in the PGAContext, but nothing else.
199	* Call PgapLinkContext2Env() here, so later on we can figure
200	* out how many parameters, names, types, etc.
201	*/
202	PgapLinkContext2Env(ctx, envPtr);
203
204	PGASetUp(ctx);
205	PGARun(ctx, PgapEvaluate);
206	PGADestroy(ctx);
207	PgapUnlinkContext2Env(ctx);
208
209	if (pgapack_abort) {
210	return RP_OPTIM_ABORTED;
211	}
212	return RP_OPTIM_SUCCESS;
213	}
214
215	/*
216	* ----------------------------------------------------------------------
217	* PgapackEvaluate()
218	*
219	* Called by PGApack whenever a set of input values needs to be
220	* evaluated. Passes the values on to the underlying Rappture tool,
221	* launches a run, and computes the value of the fitness function.
222	* Returns the value for the fitness function.
223	* ----------------------------------------------------------------------
224	*/
225	double
226	PgapEvaluate(ctx, p, pop)
227	PGAContext ctx; / pgapack context for this optimization */
228	int p; /* sample #p being run */
229	int pop; /* identifier for this population */
230
231	{
232	double fit = 0.0;
233	RpOptimEnv *envPtr;
234	RpOptimParam *paramPtr;
235	RpOptimStatus status;
236	envPtr = PgapGetEnvForContext(ctx);
237	paramPtr = (RpOptimParam*)PGAGetIndividual(ctx, p, pop)->chrom;
238	status = (*envPtr->evalProc)(envPtr, paramPtr, envPtr->numParams, &fit);
239
240	if (pgapack_abort) {
241	fprintf(stderr, "==WARNING: run aborted!");
242	return 0.0;
243	}
244
245	if (status != RP_OPTIM_SUCCESS) {
246	fprintf(stderr, "==WARNING: run failed!");
247	PgapPrintString(ctx, stderr, p, pop);
248	}
249
250	/populate the table with this sample/
251	PGARuntimeDataTableSetSampleValue(paramPtr,fit);
252	return fit;
253	}
254
255	/*
256	* ----------------------------------------------------------------------
257	* PgapackCleanup()
258	*
259	* This routine is called whenever an optimization object is deleted
260	* to clean up data associated with the object. Frees the data
261	* allocated in PgapackInit.
262	* ----------------------------------------------------------------------
263	*/
264	void
265	PgapackCleanup(cdata)
266	ClientData cdata; /* data from to be cleaned up */
267	{
268	PgapackData dataPtr = (PgapackData)cdata;
269	free(dataPtr);
270	}
271
272	/*
273	* ======================================================================
274	* ROUTINES FOR MANAGING DATA STRINGS
275	* ======================================================================
276	* PgapCreateString()
277	*
278	* Called by pgapack to create the so-called "string" of data used for
279	* an evaluation.
280	* ----------------------------------------------------------------------
281	*/
282	void
283	PgapCreateString(ctx, p, pop, initFlag)
284	PGAContext ctx; / pgapack context for this optimization */
285	int p; /* sample #p being run */
286	int pop; /* identifier for this population */
287	int initFlag; /* non-zero => fields should be initialized */
288	{
289	int n, ival;
290	double dval;
291	RpOptimEnv *envPtr;
292	RpOptimParam oldParamPtr, newParamPtr;
293	PGAIndividual *newData;
294	RpOptimParamNumber *numPtr;
295	RpOptimParamString *strPtr;
296
297	envPtr = PgapGetEnvForContext(ctx);
298
299	newData = PGAGetIndividual(ctx, p, pop);
300	newData->chrom = malloc(envPtr->numParams*sizeof(RpOptimParam));
301	newParamPtr = (RpOptimParam*)newData->chrom;
302
303	for (n=0; n < envPtr->numParams; n++) {
304	oldParamPtr = envPtr->paramList[n];
305	newParamPtr[n].name = oldParamPtr->name;
306	newParamPtr[n].type = oldParamPtr->type;
307	switch (oldParamPtr->type) {
308	case RP_OPTIMPARAM_NUMBER:
309	newParamPtr[n].value.dval = 0.0;
310	break;
311	case RP_OPTIMPARAM_STRING:
312	newParamPtr[n].value.sval.num = -1;
313	newParamPtr[n].value.sval.str = NULL;
314	break;
315	default:
316	panic("bad parameter type in PgapCreateString()");
317	}
318	}
319
320	if (initFlag) {
321	for (n=0; n < envPtr->numParams; n++) {
322	switch (newParamPtr[n].type) {
323	case RP_OPTIMPARAM_NUMBER:
324	numPtr = (RpOptimParamNumber*)envPtr->paramList[n];
325	if(numPtr->randdist == RAND_NUMBER_DIST_UNIFORM){
326	dval = PGARandom01(ctx,0);
327	newParamPtr[n].value.dval = (numPtr->max - numPtr->min)*dval + numPtr->min;
328	}else if(numPtr->randdist == RAND_NUMBER_DIST_GAUSSIAN){
329	dval = PGARandomGaussian(ctx,numPtr->mean,numPtr->stddev);
330	if(numPtr->strictmax){
331	if(dval>numPtr->max){
332	dval = numPtr->max;
333	}
334	}
335	if(numPtr->strictmin){
336	if(dval<numPtr->min){
337	dval = numPtr->min;
338	}
339	}
340	newParamPtr[n].value.dval = dval;
341	}else{
342	panic("Incorrect Random Number distribution option in PgapcreateString()");
343	}
344	break;
345	case RP_OPTIMPARAM_STRING:
346	strPtr = (RpOptimParamString*)envPtr->paramList[n];
347	ival = (int)floor(PGARandom01(ctx,0) * strPtr->numValues);
348	envPtr->paramList[n]->value.sval.num = ival;
349	envPtr->paramList[n]->value.sval.str = strPtr->values[ival];
350	break;
351	default:
352	panic("bad parameter type in PgapCreateString()");
353	}
354	}
355	}
356	}
357
358	/*
359	* ----------------------------------------------------------------------
360	* PgapMutation()
361	*
362	* Called by pgapack to perform random mutations on the input data
363	* used for evaluation.
364	* ----------------------------------------------------------------------
365	*/
366	int
367	PgapMutation(ctx, p, pop, mr)
368	PGAContext ctx; / pgapack context for this optimization */
369	int p; /* sample #p being run */
370	int pop; /* identifier for this population */
371	double mr; /* probability of mutation for each gene */
372	{
373	int count = 0; /* number of mutations */
374
375	int n, ival,tempmr;
376	double mutnVal;
377	RpOptimEnv *envPtr;
378	RpOptimParam *paramPtr;
379	RpOptimParamNumber *numPtr;
380	RpOptimParamString *strPtr;
381
382	envPtr = PgapGetEnvForContext(ctx);
383	paramPtr = (RpOptimParam*)PGAGetIndividual(ctx, p, pop)->chrom;
384
385	for (n=0; n < envPtr->numParams; n++) {
386
387
388	switch (paramPtr[n].type) {
389	case RP_OPTIMPARAM_NUMBER:
390	numPtr = (RpOptimParamNumber*)envPtr->paramList[n];
391	if(numPtr->mutnrate!=PARAM_NUM_UNSPEC_MUTN_RATE){
392	tempmr = numPtr->mutnrate;
393	mutnVal = numPtr->mutnValue;
394	}else{
395	tempmr = mr;
396	mutnVal = PGAGetMutationRealValue(ctx);
397	}
398	if (PGARandomFlip(ctx, tempmr)) {
399	/* won the coin toss -- change this parameter */
400	count++;
401
402	/* bump the value up/down a little, randomly */
403	if (PGARandomFlip(ctx, 0.5)) {
404	paramPtr[n].value.dval += mutnValparamPtr[n].value.dval; /Made the mutation amount configurable*/
405	} else {
406	paramPtr[n].value.dval -= mutnVal*paramPtr[n].value.dval;
407	}
408	/* make sure the resulting value is still in bounds */
409	if(numPtr->randdist == RAND_NUMBER_DIST_UNIFORM \|\|
410	(numPtr->randdist == RAND_NUMBER_DIST_GAUSSIAN && numPtr->strictmax)){
411	if (paramPtr[n].value.dval > numPtr->max) {
412	paramPtr[n].value.dval = numPtr->max;
413	}
414	}
415	/also make sure it obeys configured parameters when gaussian/
416	if(numPtr->randdist == RAND_NUMBER_DIST_UNIFORM \|\|
417	(numPtr->randdist == RAND_NUMBER_DIST_GAUSSIAN && numPtr->strictmin)){
418	if (paramPtr[n].value.dval < numPtr->min) {
419	paramPtr[n].value.dval = numPtr->min;
420	}
421	}
422
423	}
424	break;
425
426
427	case RP_OPTIMPARAM_STRING:
428	if (PGARandomFlip(ctx, mr)) {
429	/* won the coin toss -- change this parameter */
430	count++;
431
432	ival = paramPtr[n].value.sval.num;
433	if (PGARandomFlip(ctx, 0.5)) {
434	ival += 1;
435	} else {
436	ival -= 1;
437	}
438	strPtr = (RpOptimParamString*)envPtr->paramList[n];
439	if (ival < 0) ival = 0;
440	if (ival >= strPtr->numValues) ival = strPtr->numValues-1;
441	paramPtr[n].value.sval.num = ival;
442	paramPtr[n].value.sval.str = strPtr->values[ival];
443	}
444
445	break;
446
447	default:
448	panic("bad parameter type in PgapMutation()");
449	}
450
451	}
452	return count;
453	}
454
455	/*
456	* ----------------------------------------------------------------------
457	* PgapCrossover()
458	*
459	* Called by pgapack to perform cross-over mutations on the input data
460	* used for evaluation.
461	* ----------------------------------------------------------------------
462	*/
463	void
464	PgapCrossover(ctx, p1, p2, pop1, c1, c2, pop2)
465	PGAContext ctx; / pgapack context for this optimization */
466	int p1; /* sample # for parent of input string1 */
467	int p2; /* sample # for parent of input string2 */
468	int pop1; /* population containing p1 and p2 */
469	int c1; /* sample # for child of input string1 */
470	int c2; /* sample # for child of input string2 */
471	int pop2; /* population containing c1 and c2 */
472	{
473	int n;
474	RpOptimEnv *envPtr;
475	RpOptimParam parent1, parent2, child1, child2;
476	double pu;
477	PgapackData *dataPtr;
478	/declare variables for SBX/
479	double ui,beta,eta,powVal;
480
481	envPtr = PgapGetEnvForContext(ctx);
482	parent1 = (RpOptimParam*)PGAGetIndividual(ctx, p1, pop1)->chrom;
483	parent2 = (RpOptimParam*)PGAGetIndividual(ctx, p2, pop1)->chrom;
484	child1 = (RpOptimParam*)PGAGetIndividual(ctx, c1, pop2)->chrom;
485	child2 = (RpOptimParam*)PGAGetIndividual(ctx, c2, pop2)->chrom;
486
487	pu = PGAGetCrossoverProb(ctx);
488	dataPtr =(PgapackData*)envPtr->pluginData;
489
490	for (n=0; n < envPtr->numParams; n++) {
491	if (PGARandomFlip(ctx, pu)) {
492	/* crossover */
493	switch(dataPtr->crossovtype){
494	case PGA_CROSSOVER_UNIFORM:
495	memcpy(&child1[n], &parent2[n], sizeof(RpOptimParam));
496	memcpy(&child2[n], &parent1[n], sizeof(RpOptimParam));
497	break;
498	case PGA_CROSSOVER_SBX:
499	/Implement a Simulated Binary Crossover for Real Encoding/
500	/From Deb and Agrawal, 1995; Deb and Kumar, 1995)/
501	switch(parent1[n].type){
502	case RP_OPTIMPARAM_NUMBER:
503	ui = PGARandom01(ctx,0);
504	eta = 1.5;/We can adjust eta later....keeping it 1.5 for now/
505	powVal = 1/(eta+1);
506	if(ui<=0.5){
507	beta = pow(2*ui,powVal);
508	}else{
509	beta = pow(0.5/(1-ui),powVal);
510	}
511	child1[n].value.dval = 0.5((1+beta)(parent1[n].value.dval) + (1-beta)*(parent2[n].value.dval));
512	child2[n].value.dval = 0.5((1-beta)(parent1[n].value.dval) + (1+beta)*(parent2[n].value.dval));
513	break;
514	default:
515	panic("Bad Optim Param Type in PgapCrossover()");
516	}
517	break;
518	default:
519	panic("bad parameter type in PgapCrossover()");
520	}
521	} else {
522	/* child inherits from parent */
523	memcpy(&child1[n], &parent1[n], sizeof(RpOptimParam));
524	memcpy(&child2[n], &parent2[n], sizeof(RpOptimParam));
525	}
526	}
527
528
529	}
530
531	/*
532	* ----------------------------------------------------------------------
533	* PgapPrintString()
534	*
535	* Called by pgapack to format the values for a particular string of
536	* input data.
537	* ----------------------------------------------------------------------
538	*/
539	void
540	PgapPrintString(ctx, fp, p, pop)
541	PGAContext ctx; / pgapack context for this optimization */
542	FILE fp; / write to this file pointer */
543	int p; /* sample #p being run */
544	int pop; /* identifier for this population */
545	{
546	int n;
547	RpOptimEnv *envPtr;
548	RpOptimParam *paramPtr;
549
550	envPtr = PgapGetEnvForContext(ctx);
551	paramPtr = (RpOptimParam*)PGAGetIndividual(ctx, p, pop)->chrom;
552
553	for (n=0; n < envPtr->numParams; n++) {
554	fprintf(fp, "#%4d: ", n);
555	switch (paramPtr[n].type) {
556	case RP_OPTIMPARAM_NUMBER:
557	fprintf(fp, "[%11.7g] (%s)\n", paramPtr[n].value.dval,
558	paramPtr[n].name);
559	break;
560	case RP_OPTIMPARAM_STRING:
561	fprintf(fp, "[%d]=\"%s\" (%s)\n", paramPtr[n].value.sval.num,
562	paramPtr[n].value.sval.str, paramPtr[n].name);
563	break;
564	default:
565	panic("bad parameter type in PgapPrintString()");
566	}
567	}
568	}
569
570	/*
571	* ----------------------------------------------------------------------
572	* PgapCopyString()
573	*
574	* Called by pgapack to copy one input string to another.
575	* ----------------------------------------------------------------------
576	*/
577	void
578	PgapCopyString(ctx, p1, pop1, p2, pop2)
579	PGAContext ctx; / pgapack context for this optimization */
580	int p1; /* source sample # being run */
581	int pop1; /* population containing p1 */
582	int p2; /* destination sample # being run */
583	int pop2; /* population containing p1 */
584	{
585	int n;
586	RpOptimEnv *envPtr;
587	RpOptimParam src, dst;
588
589	envPtr = PgapGetEnvForContext(ctx);
590	src = (RpOptimParam*)PGAGetIndividual(ctx, p1, pop1)->chrom;
591	dst = (RpOptimParam*)PGAGetIndividual(ctx, p2, pop2)->chrom;
592
593	for (n=0; n < envPtr->numParams; n++) {
594	dst[n].type = src[n].type;
595	switch (src[n].type) {
596	case RP_OPTIMPARAM_NUMBER:
597	dst[n].value.dval = src[n].value.dval;
598	break;
599	case RP_OPTIMPARAM_STRING:
600	dst[n].value.sval.num = src[n].value.sval.num;
601	dst[n].value.sval.str = src[n].value.sval.str;
602	break;
603	default:
604	panic("bad parameter type in PgapCopyString()");
605	}
606	}
607	}
608
609	/*
610	* ----------------------------------------------------------------------
611	* PgapDuplicateString()
612	*
613	* Called by pgapack to compare two input strings. Returns non-zero if
614	* the two are duplicates and 0 otherwise.
615	* ----------------------------------------------------------------------
616	*/
617	int
618	PgapDuplicateString(ctx, p1, pop1, p2, pop2)
619	PGAContext ctx; / pgapack context for this optimization */
620	int p1; /* sample #p being run */
621	int pop1; /* population containing p1 */
622	int p2; /* sample #p being run */
623	int pop2; /* population containing p1 */
624	{
625	int n;
626	RpOptimEnv *envPtr;
627	RpOptimParam param1, param2;
628
629	envPtr = PgapGetEnvForContext(ctx);
630	param1 = (RpOptimParam*)PGAGetIndividual(ctx, p1, pop1)->chrom;
631	param2 = (RpOptimParam*)PGAGetIndividual(ctx, p2, pop2)->chrom;
632
633	for (n=0; n < envPtr->numParams; n++) {
634	if (param1[n].type != param2[n].type) {
635	return 0; /* different! */
636	}
637	switch (param1[n].type) {
638	case RP_OPTIMPARAM_NUMBER:
639	if (param1[n].value.dval != param2[n].value.dval) {
640	return 0; /* different! */
641	}
642	break;
643	case RP_OPTIMPARAM_STRING:
644	if (param1[n].value.sval.num != param2[n].value.sval.num) {
645	return 0; /* different! */
646	}
647	break;
648	default:
649	panic("bad parameter type in PgapDuplicateString()");
650	}
651	}
652	return 1;
653	}
654
655
656
657	/*
658	* ----------------------------------------------------------------------
659	* PgapCopyString()
660	*
661	* Called by pgapack to copy one input string to another.
662	* ----------------------------------------------------------------------
663	*/
664	MPI_Datatype
665	PgapBuildDT(ctx, p, pop)
666	PGAContext ctx; / pgapack context for this optimization */
667	int p; /* sample # being run */
668	int pop; /* population containing sample */
669	{
670	panic("MPI support not implemented!");
671	return NULL;
672	}
673
674	/*
675	* ======================================================================
676	* OPTION: -operation <=> PGA_MINIMIZE / PGA_MAXIMIZE
677	* ======================================================================
678	*/
679	int
680	RpOption_ParseOper(interp, valObj, cdata, offset)
681	Tcl_Interp interp; / interpreter handling this request */
682	Tcl_Obj valObj; / set option to this new value */
683	ClientData cdata; /* save in this data structure */
684	int offset; /* save at this offset in cdata */
685	{
686	int ptr = (int)(cdata+offset);
687	char val = Tcl_GetStringFromObj(valObj, (int)NULL);
688	if (strcmp(val,"minimize") == 0) {
689	*ptr = PGA_MINIMIZE;
690	}
691	else if (strcmp(val,"maximize") == 0) {
692	*ptr = PGA_MAXIMIZE;
693	}
694	else {
695	Tcl_AppendStringsToObj(Tcl_GetObjResult(interp),
696	"bad value \"", val, "\": should be minimize, maximize",
697	(char*)NULL);
698	return TCL_ERROR;
699	}
700	return TCL_OK;
701	}
702
703	int
704	RpOption_GetOper(interp, cdata, offset)
705	Tcl_Interp interp; / interpreter handling this request */
706	ClientData cdata; /* get from this data structure */
707	int offset; /* get from this offset in cdata */
708	{
709	int ptr = (int)(cdata+offset);
710	switch (*ptr) {
711	case PGA_MINIMIZE:
712	Tcl_SetResult(interp, "minimize", TCL_STATIC);
713	break;
714	case PGA_MAXIMIZE:
715	Tcl_SetResult(interp, "maximize", TCL_STATIC);
716	break;
717	default:
718	Tcl_SetResult(interp, "???", TCL_STATIC);
719	break;
720	}
721	return TCL_OK;
722	}
723
724
725	/*
726	* ======================================================================
727	* OPTION: -crossovtype <=> PGA_CROSSOVER_UNIFORM / PGA_CROSSOVER_SBX
728	* ======================================================================
729	*/
730	int
731	RpOption_ParseCrossovType(interp, valObj, cdata, offset)
732	Tcl_Interp interp; / interpreter handling this request */
733	Tcl_Obj valObj; / set option to this new value */
734	ClientData cdata; /* save in this data structure */
735	int offset; /* save at this offset in cdata */
736	{
737	int ptr = (int)(cdata+offset);
738	char val = Tcl_GetStringFromObj(valObj, (int)NULL);
739	if (strcmp(val,"uniform") == 0) {
740	*ptr = PGA_CROSSOVER_UNIFORM;
741	}
742	else if (strcmp(val,"sbx") == 0) {
743	*ptr = PGA_CROSSOVER_SBX;
744	}
745	else {
746	Tcl_AppendStringsToObj(Tcl_GetObjResult(interp),
747	"bad value \"", val, "\": should be either 'uniform' or 'sbx'",
748	(char*)NULL);
749	return TCL_ERROR;
750	}
751	return TCL_OK;
752	}
753
754	int
755	RpOption_GetCrossovType(interp, cdata, offset)
756	Tcl_Interp interp; / interpreter handling this request */
757	ClientData cdata; /* get from this data structure */
758	int offset; /* get from this offset in cdata */
759	{
760	int ptr = (int)(cdata+offset);
761	switch (*ptr) {
762	case PGA_CROSSOVER_UNIFORM:
763	Tcl_SetResult(interp, "uniform", TCL_STATIC);
764	break;
765	case PGA_CROSSOVER_SBX:
766	Tcl_SetResult(interp, "sbx", TCL_STATIC);
767	break;
768	default:
769	Tcl_SetResult(interp, "???", TCL_STATIC);
770	break;
771	}
772	return TCL_OK;
773	}
774
775
776
777
778	/*
779	* ======================================================================
780	* OPTION: -poprepl <=> PGASetPopReplacementType()
781	* ======================================================================
782	*/
783	int
784	RpOption_ParsePopRepl(interp, valObj, cdata, offset)
785	Tcl_Interp interp; / interpreter handling this request */
786	Tcl_Obj valObj; / set option to this new value */
787	ClientData cdata; /* save in this data structure */
788	int offset; /* save at this offset in cdata */
789	{
790	int ptr = (int)(cdata+offset);
791	char val = Tcl_GetStringFromObj(valObj, (int)NULL);
792	if (*val == 'b' && strcmp(val,"best") == 0) {
793	*ptr = PGA_POPREPL_BEST;
794	}
795	else if (*val == 'r' && strcmp(val,"random-repl") == 0) {
796	*ptr = PGA_POPREPL_RANDOM_REP;
797	}
798	else if (*val == 'r' && strcmp(val,"random-norepl") == 0) {
799	*ptr = PGA_POPREPL_RANDOM_NOREP;
800	}
801	else {
802	Tcl_AppendStringsToObj(Tcl_GetObjResult(interp),
803	"bad value \"", val, "\": should be best, random-norepl,"
804	" or random-repl", (char*)NULL);
805	return TCL_ERROR;
806	}
807	return TCL_OK;
808	}
809
810	int
811	RpOption_GetPopRepl(interp, cdata, offset)
812	Tcl_Interp interp; / interpreter handling this request */
813	ClientData cdata; /* get from this data structure */
814	int offset; /* get from this offset in cdata */
815	{
816	int ptr = (int)(cdata+offset);
817	switch (*ptr) {
818	case PGA_POPREPL_BEST:
819	Tcl_SetResult(interp, "best", TCL_STATIC);
820	break;
821	case PGA_POPREPL_RANDOM_REP:
822	Tcl_SetResult(interp, "random-repl", TCL_STATIC);
823	break;
824	case PGA_POPREPL_RANDOM_NOREP:
825	Tcl_SetResult(interp, "random-norepl", TCL_STATIC);
826	break;
827	default:
828	Tcl_SetResult(interp, "???", TCL_STATIC);
829	break;
830	}
831	return TCL_OK;
832	}
833
834	/*
835	* ======================================================================
836	* OPTION: -stpcriteria <=> PGA_STOP_MAXITER / PGA_STOP_NOCHANGE / PGA_STOP_TOOSIMILAR
837	* ======================================================================
838	*/
839	int
840	RpOption_ParseStpCriteria(interp, valObj, cdata, offset)
841	Tcl_Interp interp; / interpreter handling this request */
842	Tcl_Obj valObj; / set option to this new value */
843	ClientData cdata; /* save in this data structure */
844	int offset; /* save at this offset in cdata */
845	{
846	int ptr = (int)(cdata+offset);
847	char val = Tcl_GetStringFromObj(valObj, (int)NULL);
848	if (strcmp(val,"maxiter") == 0) {
849	*ptr = PGA_STOP_MAXITER;
850	}
851	else if (strcmp(val,"nochange") == 0) {
852	*ptr = PGA_STOP_NOCHANGE;
853	}
854	else if (strcmp(val,"toosimilar") == 0){
855	*ptr = PGA_STOP_TOOSIMILAR;
856	}
857	else {
858	Tcl_AppendStringsToObj(Tcl_GetObjResult(interp),
859	"bad value \"", val, "\": should be maxiter, nochange or toosimilar",
860	(char*)NULL);
861	return TCL_ERROR;
862	}
863	return TCL_OK;
864	}
865
866	int
867	RpOption_GetStpCriteria(interp, cdata, offset)
868	Tcl_Interp interp; / interpreter handling this request */
869	ClientData cdata; /* get from this data structure */
870	int offset; /* get from this offset in cdata */
871	{
872	int ptr = (int)(cdata+offset);
873	switch (*ptr) {
874	case PGA_STOP_MAXITER:
875	Tcl_SetResult(interp, "maxiter", TCL_STATIC);
876	break;
877	case PGA_STOP_NOCHANGE:
878	Tcl_SetResult(interp, "nochange", TCL_STATIC);
879	break;
880	case PGA_STOP_TOOSIMILAR:
881	Tcl_SetResult(interp, "toosimilar", TCL_STATIC);
882	break;
883	default:
884	Tcl_SetResult(interp, "???", TCL_STATIC);
885	break;
886	}
887	return TCL_OK;
888	}
889
890	/*
891	* ======================================================================
892	* ROUTINES FOR CONNECTING PGACONTEXT <=> RPOPTIMENV
893	* ======================================================================
894	* PgapLinkContext2Env()
895	* This routine is used internally to establish a relationship between
896	* a PGAContext token and its corresponding RpOptimEnv data. The
897	* PGA routines don't provide a way to pass the RpOptimEnv data along,
898	* so we use these routines to find the correspondence.
899	*
900	* PgapGetEnvForContext()
901	* Returns the RpOptimEnv associated with a given PGAContext. If the
902	* link has not been established via PgapLinkContext2Env(), then this
903	* routine returns NULL.
904	*
905	* PgapUnlinkContext2Env()
906	* Breaks the link between a PGAContext and its RpOptimEnv. Should
907	* be called when the PGAContext is destroyed and is no longer valid.
908	* ----------------------------------------------------------------------
909	*/
910	static Tcl_HashTable *Pgacontext2Rpenv = NULL;
911
912	void
913	PgapLinkContext2Env(ctx, envPtr)
914	PGAContext ctx; / pgapack context for this optimization */
915	RpOptimEnv envPtr; / corresponding Rappture optimization data */
916	{
917	Tcl_HashEntry *ctxEntry;
918	int newEntry;
919
920	if (Pgacontext2Rpenv == NULL) {
921	Pgacontext2Rpenv = (Tcl_HashTable*)malloc(sizeof(Tcl_HashTable));
922	Tcl_InitHashTable(Pgacontext2Rpenv, TCL_ONE_WORD_KEYS);
923	}
924	ctxEntry = Tcl_CreateHashEntry(Pgacontext2Rpenv, (char*)ctx, &newEntry);
925	Tcl_SetHashValue(ctxEntry, (ClientData)envPtr);
926	}
927
928	RpOptimEnv*
929	PgapGetEnvForContext(ctx)
930	PGAContext *ctx;
931	{
932	Tcl_HashEntry *entryPtr;
933
934	if (Pgacontext2Rpenv) {
935	entryPtr = Tcl_FindHashEntry(Pgacontext2Rpenv, (char*)ctx);
936	if (entryPtr) {
937	return (RpOptimEnv*)Tcl_GetHashValue(entryPtr);
938	}
939	}
940	return NULL;
941	}
942
943	void
944	PgapUnlinkContext2Env(ctx)
945	PGAContext *ctx;
946	{
947	Tcl_HashEntry *entryPtr;
948
949	if (Pgacontext2Rpenv) {
950	entryPtr = Tcl_FindHashEntry(Pgacontext2Rpenv, (char*)ctx);
951	if (entryPtr) {
952	Tcl_DeleteHashEntry(entryPtr);
953	}
954	}
955	}
956	/*---------------------------------------------------------------------------------
957	* PGARuntimeDTInit(): It initializes the runtime data table.
958	* The table is organized slightly counter-intuitively
959	* Instead of a
960	* param1\|param2\|param3 \|param4...
961	* val11 \|val12 \|val13 \|val14...
962	* val12 \|val22 \|val23 \|val24....
963	* orientation, it is organized as
964	* param1\|val11\|val12
965	* param2\|val21\|val22
966	* param3\|val31\|val32
967	* param4\|val41\|val42
968	* Reallocating for additional columns is easier than reallocating additional rows and then
969	* reallocating for columns
970	* --------------------------------------------------------------------------------
971	*/
972
973	void PGARuntimeDataTableInit(envPtr)
974	RpOptimEnv *envPtr;
975	{
976	int i;
977	if(envPtr != NULL){
978	table.num_of_rows = (envPtr->numParams)+1;
979	table.data = malloc((table.num_of_rows)sizeof(double));
980	if(table.data == NULL){
981	panic("\nAllocation for Runtime Data Table failed\n");
982	}
983	for(i=0;i<table.num_of_rows;i++){
984	table.data[i] = malloc(PGAPACK_RUNTIME_TABLE_DEFAULT_SIZE*sizeof(double));
985	if(table.data[i] == NULL){
986	panic("\nAllocation for Runtime Data Table failed\n");
987	}
988	}
989	table.no_of_samples_evaled = 0;
990	table.no_of_columns = PGAPACK_RUNTIME_TABLE_DEFAULT_SIZE;
991
992	}else{
993	panic("\nError: NULL Environment variable OR Table pointer passed to Data Table Init\n");
994	}
995	}
996
997	void PGARuntimeDataTableDeInit()
998	{
999	int i;
1000	if((&table) == NULL){
1001	panic("Error: Table not present, therefore cannot free memory..");
1002	}
1003	for(i=0;i<table.num_of_rows;i++){
1004	free(table.data[i]);
1005	}
1006	free(table.data);
1007	}
1008
1009	void PGARuntimeDataTableSetSampleValue(chrom,fitness)
1010	RpOptimParam *chrom;
1011	double fitness;
1012	{
1013	int i;
1014	//printf("\nSetting sample value.......................\n");
1015	if(chrom!=NULL && (&table)!=NULL){
1016	(table.no_of_samples_evaled)+=1;
1017	if((table.no_of_samples_evaled) > table.no_of_columns){
1018	/* then Reallocate space for more columns)*/
1019	(table.no_of_columns)+=(table.no_of_columns);
1020	//TODO GTG: Delete printing stuff
1021	for(i=0;i<(table.num_of_rows);i++){
1022	table.data[i] = realloc(table.data[i],table.no_of_columns);
1023	if(table.data[i]==NULL){
1024	panic("\nError: Could not Reallocate more space for the table");
1025	}
1026	}
1027	}else{
1028	if(chrom->type == RP_OPTIMPARAM_NUMBER){
1029	for(i=0;i<(table.num_of_rows);i++){
1030	if(i==0){
1031	table.data[i][(table.no_of_samples_evaled)-1] = fitness;
1032	//printf("\nSample Number %d:- Fitness: %lf\t",table.no_of_samples_evaled,fitness);
1033	}else{
1034	table.data[i][(table.no_of_samples_evaled)-1] = chrom[i-1].value.dval;
1035	//printf("Param %d %lf\t",i,table.data[i][(table.no_of_samples_evaled)-1]);
1036	}
1037	}
1038	}else{
1039	panic("\n Chromosome value is RP_OPTIMPARAM_STRING\n");
1040	//GTG TODO: find out what happens in this case. Will we be better off handling Tcl_objects?
1041	}
1042	}
1043	}else{
1044	panic("\nError:Either Chromosome, or table passed to PGARuntimeDataTableSetSampleValue() is NULL\n");
1045	}
1046
1047	}
1048
1049	void GetSampleInformation(buffer,sampleNumber)
1050	char *buffer;
1051	int sampleNumber;
1052	{
1053	int i;
1054	char tempBuff[50];
1055	printf("\nFetching sample information.........................\n");
1056	if((&table) == NULL){
1057	panic("Table uninitialized");
1058	}
1059	if(sampleNumber<=0){
1060	sprintf(buffer,"\nNumber of Samples Evaluated so far: %d\n",(table.no_of_samples_evaled)+1);
1061	return;
1062	}
1063	if(((table.num_of_rows)-1)*10>SINGLE_SAMPLE_DATA_BUFFER_DEFAULT_SIZE){
1064	buffer = realloc(buffer,50+25*(table.num_of_rows));
1065	//resizing the buffer, keeping 50 for display related jazz, around 12-15 characs for param names
1066	//and 10 characs for Fl.pt. display of the value
1067	if(buffer == NULL){
1068	panic("\nError: Could not reallocate space for sample data buffer");
1069	}
1070	}
1071	for(i=0;i<(table.num_of_rows);i++){
1072	if(i==0){
1073	sprintf(buffer,"\nSample Number %d ----> Fitness: %lf ",sampleNumber,table.data[i][sampleNumber-1]);
1074	}else{
1075	sprintf(tempBuff,"Param %d: %lf ",i,table.data[i][sampleNumber-1]);
1076	strcat(buffer,tempBuff);
1077	}
1078	}
1079	strcat(buffer,"\n");
1080	}

Note: See TracBrowser for help on using the repository browser.

Download in other formats: