Context Navigation

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

Last change on this file since 1062 was 1062, checked in by liveletlive, 16 years ago
Committing changes related to command <name> samples ?number?
File size: 28.4 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	} PgapackData;
25
26
27	RpCustomTclOptionParse RpOption_ParseOper;
28	RpCustomTclOptionGet RpOption_GetOper;
29	RpTclOptionType RpOption_Oper = {
30	"pga_operation", RpOption_ParseOper, RpOption_GetOper, NULL
31	};
32
33	RpCustomTclOptionParse RpOption_ParsePopRepl;
34	RpCustomTclOptionGet RpOption_GetPopRepl;
35	RpTclOptionType RpOption_PopRepl = {
36	"pga_poprepl", RpOption_ParsePopRepl, RpOption_GetPopRepl, NULL
37	};
38
39	typedef struct PgapackRuntimeDataTable{
40	double *data; /Actual data per sample, like values of the genes, fitness of a sample, etc*/
41	int num_of_rows; /Number of rows alloced..should be constant for a run/
42	int no_of_samples_evaled; /Number of samples evaluated so far/
43	int no_of_columns; /Number of columns allocated to the data table so far/
44	}PgapackRuntimeDataTable;
45
46	RpTclOption PgapackOptions[] = {
47	{"-maxruns", RP_OPTION_INT, Rp_Offset(PgapackData,maxRuns)},
48	{"-operation", &RpOption_Oper, Rp_Offset(PgapackData,operation)},
49	{"-poprepl", &RpOption_PopRepl, Rp_Offset(PgapackData,popRepl)},
50	{"-popsize", RP_OPTION_INT, Rp_Offset(PgapackData,popSize)},
51	{NULL, NULL, 0}
52	};
53
54	static double PgapEvaluate _ANSI_ARGS_((PGAContext *ctx, int p, int pop));
55	static void PgapCreateString _ANSI_ARGS_((PGAContext *ctx, int, int, int));
56	static int PgapMutation _ANSI_ARGS_((PGAContext *ctx, int, int, double));
57	static void PgapCrossover _ANSI_ARGS_((PGAContext *ctx, int, int, int,
58	int, int, int));
59	static void PgapPrintString _ANSI_ARGS_((PGAContext ctx, FILE, int, int));
60	static void PgapCopyString _ANSI_ARGS_((PGAContext *ctx, int, int, int, int));
61	static int PgapDuplicateString _ANSI_ARGS_((PGAContext *ctx, int, int, int, int));
62	static MPI_Datatype PgapBuildDT _ANSI_ARGS_((PGAContext *ctx, int, int));
63
64	static void PgapLinkContext2Env _ANSI_ARGS_((PGAContext *ctx,
65	RpOptimEnv *envPtr));
66	static RpOptimEnv* PgapGetEnvForContext _ANSI_ARGS_((PGAContext *ctx));
67	static void PgapUnlinkContext2Env _ANSI_ARGS_((PGAContext *ctx));
68	void PGARuntimeDataTableInit _ANSI_ARGS_((RpOptimEnv *envPtr));
69	void PGARuntimeDataTableDeInit();
70	void GetSampleInformation _ANSI_ARGS_((char *buffer, int sampleNumber));
71	void PGARuntimeDataTableSetSampleValue _ANSI_ARGS_((RpOptimParam *chrom, double fitness));
72	static PgapackRuntimeDataTable table;
73	/*
74	* ----------------------------------------------------------------------
75	* PgapackInit()
76	*
77	* This routine is called whenever a new optimization object is created
78	* to initialize Pgapack. Returns a pointer to PgapackData that is
79	* used in later routines.
80	* ----------------------------------------------------------------------
81	*/
82	ClientData
83	PgapackInit()
84	{
85	PgapackData *dataPtr;
86
87	dataPtr = (PgapackData*)malloc(sizeof(PgapackData));
88	dataPtr->operation = PGA_MINIMIZE;
89	dataPtr->maxRuns = 10000;
90	dataPtr->popRepl = PGA_POPREPL_BEST;
91	dataPtr->popSize = 200;
92	return (ClientData)dataPtr;
93	}
94
95	int pgapack_abort = 0;
96
97	/*
98	* ----------------------------------------------------------------------
99	* PgapackRun()
100	*
101	* This routine is called to kick off an optimization run. Sets up
102	* a PGApack context and starts invoking runs.
103	* ----------------------------------------------------------------------
104	*/
105	RpOptimStatus
106	PgapackRun(envPtr, evalProc, fitnessExpr)
107	RpOptimEnv envPtr; / optimization environment */
108	RpOptimEvaluator evalProc; / call this proc to run tool */
109	char fitnessExpr; / fitness function in string form */
110	{
111	PgapackData dataPtr =(PgapackData)envPtr->pluginData;
112	PGAContext *ctx;
113
114	/* pgapack requires at least one arg -- the executable name */
115	/* fake it here by just saying something like "rappture" */
116	int argc = 1; char *argv[] = {"rappture"};
117
118	pgapack_abort = 0; /* FALSE */
119	PGASetAbortVar(&pgapack_abort);
120
121	ctx = PGACreate(&argc, argv, PGA_DATATYPE_USER, envPtr->numParams,
122	dataPtr->operation);
123
124	PGASetMaxGAIterValue(ctx, dataPtr->maxRuns);
125	PGASetPopSize(ctx, dataPtr->popSize);
126	PGASetPopReplaceType(ctx, dataPtr->popRepl);
127	PGASetCrossoverType(ctx, PGA_CROSSOVER_UNIFORM);
128
129	/* stop if any of these are true */
130	PGASetStoppingRuleType(ctx, PGA_STOP_MAXITER);
131	PGASetStoppingRuleType(ctx, PGA_STOP_NOCHANGE);
132	PGASetStoppingRuleType(ctx, PGA_STOP_TOOSIMILAR);
133
134	PGASetUserFunction(ctx, PGA_USERFUNCTION_CREATESTRING, PgapCreateString);
135	PGASetUserFunction(ctx, PGA_USERFUNCTION_MUTATION, PgapMutation);
136	PGASetUserFunction(ctx, PGA_USERFUNCTION_CROSSOVER, PgapCrossover);
137	PGASetUserFunction(ctx, PGA_USERFUNCTION_PRINTSTRING, PgapPrintString);
138	PGASetUserFunction(ctx, PGA_USERFUNCTION_COPYSTRING, PgapCopyString);
139	PGASetUserFunction(ctx, PGA_USERFUNCTION_DUPLICATE, PgapDuplicateString);
140	PGASetUserFunction(ctx, PGA_USERFUNCTION_BUILDDATATYPE, PgapBuildDT);
141
142	envPtr->evalProc = evalProc; /* plug these in for later during eval */
143	envPtr->fitnessExpr = fitnessExpr;
144
145	/*
146	* We need a way to convert from a PGAContext to our RpOptimEnv
147	* data. This happens when Pgapack calls routines like
148	* PgapCreateString, passing in the PGAContext, but nothing else.
149	* Call PgapLinkContext2Env() here, so later on we can figure
150	* out how many parameters, names, types, etc.
151	*/
152	PgapLinkContext2Env(ctx, envPtr);
153
154	PGASetUp(ctx);
155	PGARun(ctx, PgapEvaluate);
156	PGADestroy(ctx);
157	PgapUnlinkContext2Env(ctx);
158
159	if (pgapack_abort) {
160	return RP_OPTIM_ABORTED;
161	}
162	return RP_OPTIM_SUCCESS;
163	}
164
165	/*
166	* ----------------------------------------------------------------------
167	* PgapackEvaluate()
168	*
169	* Called by PGApack whenever a set of input values needs to be
170	* evaluated. Passes the values on to the underlying Rappture tool,
171	* launches a run, and computes the value of the fitness function.
172	* Returns the value for the fitness function.
173	* ----------------------------------------------------------------------
174	*/
175	double
176	PgapEvaluate(ctx, p, pop)
177	PGAContext ctx; / pgapack context for this optimization */
178	int p; /* sample #p being run */
179	int pop; /* identifier for this population */
180
181	{
182	double fit = 0.0;
183	RpOptimEnv *envPtr;
184	RpOptimParam *paramPtr;
185	RpOptimStatus status;
186	envPtr = PgapGetEnvForContext(ctx);
187	paramPtr = (RpOptimParam*)PGAGetIndividual(ctx, p, pop)->chrom;
188	status = (*envPtr->evalProc)(envPtr, paramPtr, envPtr->numParams, &fit);
189
190	if (pgapack_abort) {
191	fprintf(stderr, "==WARNING: run aborted!");
192	return 0.0;
193	}
194
195	if (status != RP_OPTIM_SUCCESS) {
196	fprintf(stderr, "==WARNING: run failed!");
197	PgapPrintString(ctx, stderr, p, pop);
198	}
199
200	/populate the table with this sample/
201	PGARuntimeDataTableSetSampleValue(paramPtr,fit);
202	return fit;
203	}
204
205	/*
206	* ----------------------------------------------------------------------
207	* PgapackCleanup()
208	*
209	* This routine is called whenever an optimization object is deleted
210	* to clean up data associated with the object. Frees the data
211	* allocated in PgapackInit.
212	* ----------------------------------------------------------------------
213	*/
214	void
215	PgapackCleanup(cdata)
216	ClientData cdata; /* data from to be cleaned up */
217	{
218	PgapackData dataPtr = (PgapackData)cdata;
219	free(dataPtr);
220	}
221
222	/*
223	* ======================================================================
224	* ROUTINES FOR MANAGING DATA STRINGS
225	* ======================================================================
226	* PgapCreateString()
227	*
228	* Called by pgapack to create the so-called "string" of data used for
229	* an evaluation.
230	* ----------------------------------------------------------------------
231	*/
232	void
233	PgapCreateString(ctx, p, pop, initFlag)
234	PGAContext ctx; / pgapack context for this optimization */
235	int p; /* sample #p being run */
236	int pop; /* identifier for this population */
237	int initFlag; /* non-zero => fields should be initialized */
238	{
239	int n, ival;
240	double dval;
241	RpOptimEnv *envPtr;
242	RpOptimParam oldParamPtr, newParamPtr;
243	PGAIndividual *newData;
244	RpOptimParamNumber *numPtr;
245	RpOptimParamString *strPtr;
246
247	envPtr = PgapGetEnvForContext(ctx);
248
249	newData = PGAGetIndividual(ctx, p, pop);
250	newData->chrom = malloc(envPtr->numParams*sizeof(RpOptimParam));
251	newParamPtr = (RpOptimParam*)newData->chrom;
252
253	for (n=0; n < envPtr->numParams; n++) {
254	oldParamPtr = envPtr->paramList[n];
255	newParamPtr[n].name = oldParamPtr->name;
256	newParamPtr[n].type = oldParamPtr->type;
257	switch (oldParamPtr->type) {
258	case RP_OPTIMPARAM_NUMBER:
259	newParamPtr[n].value.dval = 0.0;
260	break;
261	case RP_OPTIMPARAM_STRING:
262	newParamPtr[n].value.sval.num = -1;
263	newParamPtr[n].value.sval.str = NULL;
264	break;
265	default:
266	panic("bad parameter type in PgapCreateString()");
267	}
268	}
269
270	if (initFlag) {
271	for (n=0; n < envPtr->numParams; n++) {
272	switch (newParamPtr[n].type) {
273	case RP_OPTIMPARAM_NUMBER:
274	numPtr = (RpOptimParamNumber*)envPtr->paramList[n];
275	dval = PGARandom01(ctx,0);
276	newParamPtr[n].value.dval =
277	(numPtr->max - numPtr->min)*dval + numPtr->min;
278	break;
279	case RP_OPTIMPARAM_STRING:
280	strPtr = (RpOptimParamString*)envPtr->paramList[n];
281	ival = (int)floor(PGARandom01(ctx,0) * strPtr->numValues);
282	envPtr->paramList[n]->value.sval.num = ival;
283	envPtr->paramList[n]->value.sval.str = strPtr->values[ival];
284	break;
285	default:
286	panic("bad parameter type in PgapCreateString()");
287	}
288	}
289	}
290	}
291
292	/*
293	* ----------------------------------------------------------------------
294	* PgapMutation()
295	*
296	* Called by pgapack to perform random mutations on the input data
297	* used for evaluation.
298	* ----------------------------------------------------------------------
299	*/
300	int
301	PgapMutation(ctx, p, pop, mr)
302	PGAContext ctx; / pgapack context for this optimization */
303	int p; /* sample #p being run */
304	int pop; /* identifier for this population */
305	double mr; /* probability of mutation for each gene */
306	{
307	int count = 0; /* number of mutations */
308
309	int n, ival;
310	RpOptimEnv *envPtr;
311	RpOptimParam *paramPtr;
312	RpOptimParamNumber *numPtr;
313	RpOptimParamString *strPtr;
314
315	envPtr = PgapGetEnvForContext(ctx);
316	paramPtr = (RpOptimParam*)PGAGetIndividual(ctx, p, pop)->chrom;
317
318	for (n=0; n < envPtr->numParams; n++) {
319	if (PGARandomFlip(ctx, mr)) {
320	/* won the coin toss -- change this parameter */
321	count++;
322
323	switch (paramPtr[n].type) {
324	case RP_OPTIMPARAM_NUMBER:
325	/* bump the value up/down a little, randomly */
326	if (PGARandomFlip(ctx, 0.5)) {
327	paramPtr[n].value.dval += 0.1*paramPtr[n].value.dval;
328	} else {
329	paramPtr[n].value.dval -= 0.1*paramPtr[n].value.dval;
330	}
331	/* make sure the resulting value is still in bounds */
332	numPtr = (RpOptimParamNumber*)envPtr->paramList[n];
333	if (paramPtr[n].value.dval > numPtr->max) {
334	paramPtr[n].value.dval = numPtr->max;
335	}
336	if (paramPtr[n].value.dval < numPtr->min) {
337	paramPtr[n].value.dval = numPtr->min;
338	}
339	break;
340
341	case RP_OPTIMPARAM_STRING:
342	ival = paramPtr[n].value.sval.num;
343	if (PGARandomFlip(ctx, 0.5)) {
344	ival += 1;
345	} else {
346	ival -= 1;
347	}
348	strPtr = (RpOptimParamString*)envPtr->paramList[n];
349	if (ival < 0) ival = 0;
350	if (ival >= strPtr->numValues) ival = strPtr->numValues-1;
351	paramPtr[n].value.sval.num = ival;
352	paramPtr[n].value.sval.str = strPtr->values[ival];
353	break;
354
355	default:
356	panic("bad parameter type in PgapMutation()");
357	}
358	}
359	}
360	return count;
361	}
362
363	/*
364	* ----------------------------------------------------------------------
365	* PgapCrossover()
366	*
367	* Called by pgapack to perform cross-over mutations on the input data
368	* used for evaluation.
369	* ----------------------------------------------------------------------
370	*/
371	void
372	PgapCrossover(ctx, p1, p2, pop1, c1, c2, pop2)
373	PGAContext ctx; / pgapack context for this optimization */
374	int p1; /* sample # for parent of input string1 */
375	int p2; /* sample # for parent of input string2 */
376	int pop1; /* population containing p1 and p2 */
377	int c1; /* sample # for child of input string1 */
378	int c2; /* sample # for child of input string2 */
379	int pop2; /* population containing c1 and c2 */
380	{
381	int n;
382	RpOptimEnv *envPtr;
383	RpOptimParam parent1, parent2, child1, child2;
384	double pu;
385
386	envPtr = PgapGetEnvForContext(ctx);
387	parent1 = (RpOptimParam*)PGAGetIndividual(ctx, p1, pop1)->chrom;
388	parent2 = (RpOptimParam*)PGAGetIndividual(ctx, p2, pop1)->chrom;
389	child1 = (RpOptimParam*)PGAGetIndividual(ctx, c1, pop2)->chrom;
390	child2 = (RpOptimParam*)PGAGetIndividual(ctx, c2, pop2)->chrom;
391
392	pu = PGAGetUniformCrossoverProb(ctx);
393
394	for (n=0; n < envPtr->numParams; n++) {
395	if (PGARandomFlip(ctx, pu)) {
396	/* child inherits from parent */
397	memcpy(&child1[n], &parent1[n], sizeof(RpOptimParam));
398	memcpy(&child2[n], &parent2[n], sizeof(RpOptimParam));
399	} else {
400	/* crossover */
401	memcpy(&child1[n], &parent2[n], sizeof(RpOptimParam));
402	memcpy(&child2[n], &parent1[n], sizeof(RpOptimParam));
403	}
404	}
405	}
406
407	/*
408	* ----------------------------------------------------------------------
409	* PgapPrintString()
410	*
411	* Called by pgapack to format the values for a particular string of
412	* input data.
413	* ----------------------------------------------------------------------
414	*/
415	void
416	PgapPrintString(ctx, fp, p, pop)
417	PGAContext ctx; / pgapack context for this optimization */
418	FILE fp; / write to this file pointer */
419	int p; /* sample #p being run */
420	int pop; /* identifier for this population */
421	{
422	int n;
423	RpOptimEnv *envPtr;
424	RpOptimParam *paramPtr;
425
426	envPtr = PgapGetEnvForContext(ctx);
427	paramPtr = (RpOptimParam*)PGAGetIndividual(ctx, p, pop)->chrom;
428
429	for (n=0; n < envPtr->numParams; n++) {
430	fprintf(fp, "#%4d: ", n);
431	switch (paramPtr[n].type) {
432	case RP_OPTIMPARAM_NUMBER:
433	fprintf(fp, "[%11.7g] (%s)\n", paramPtr[n].value.dval,
434	paramPtr[n].name);
435	break;
436	case RP_OPTIMPARAM_STRING:
437	fprintf(fp, "[%d]=\"%s\" (%s)\n", paramPtr[n].value.sval.num,
438	paramPtr[n].value.sval.str, paramPtr[n].name);
439	break;
440	default:
441	panic("bad parameter type in PgapPrintString()");
442	}
443	}
444	}
445
446	/*
447	* ----------------------------------------------------------------------
448	* PgapCopyString()
449	*
450	* Called by pgapack to copy one input string to another.
451	* ----------------------------------------------------------------------
452	*/
453	void
454	PgapCopyString(ctx, p1, pop1, p2, pop2)
455	PGAContext ctx; / pgapack context for this optimization */
456	int p1; /* source sample # being run */
457	int pop1; /* population containing p1 */
458	int p2; /* destination sample # being run */
459	int pop2; /* population containing p1 */
460	{
461	int n;
462	RpOptimEnv *envPtr;
463	RpOptimParam src, dst;
464
465	envPtr = PgapGetEnvForContext(ctx);
466	src = (RpOptimParam*)PGAGetIndividual(ctx, p1, pop1)->chrom;
467	dst = (RpOptimParam*)PGAGetIndividual(ctx, p2, pop2)->chrom;
468
469	for (n=0; n < envPtr->numParams; n++) {
470	dst[n].type = src[n].type;
471	switch (src[n].type) {
472	case RP_OPTIMPARAM_NUMBER:
473	dst[n].value.dval = src[n].value.dval;
474	break;
475	case RP_OPTIMPARAM_STRING:
476	dst[n].value.sval.num = src[n].value.sval.num;
477	dst[n].value.sval.str = src[n].value.sval.str;
478	break;
479	default:
480	panic("bad parameter type in PgapCopyString()");
481	}
482	}
483	}
484
485	/*
486	* ----------------------------------------------------------------------
487	* PgapDuplicateString()
488	*
489	* Called by pgapack to compare two input strings. Returns non-zero if
490	* the two are duplicates and 0 otherwise.
491	* ----------------------------------------------------------------------
492	*/
493	int
494	PgapDuplicateString(ctx, p1, pop1, p2, pop2)
495	PGAContext ctx; / pgapack context for this optimization */
496	int p1; /* sample #p being run */
497	int pop1; /* population containing p1 */
498	int p2; /* sample #p being run */
499	int pop2; /* population containing p1 */
500	{
501	int n;
502	RpOptimEnv *envPtr;
503	RpOptimParam param1, param2;
504
505	envPtr = PgapGetEnvForContext(ctx);
506	param1 = (RpOptimParam*)PGAGetIndividual(ctx, p1, pop1)->chrom;
507	param2 = (RpOptimParam*)PGAGetIndividual(ctx, p2, pop2)->chrom;
508
509	for (n=0; n < envPtr->numParams; n++) {
510	if (param1[n].type != param2[n].type) {
511	return 0; /* different! */
512	}
513	switch (param1[n].type) {
514	case RP_OPTIMPARAM_NUMBER:
515	if (param1[n].value.dval != param2[n].value.dval) {
516	return 0; /* different! */
517	}
518	break;
519	case RP_OPTIMPARAM_STRING:
520	if (param1[n].value.sval.num != param2[n].value.sval.num) {
521	return 0; /* different! */
522	}
523	break;
524	default:
525	panic("bad parameter type in PgapDuplicateString()");
526	}
527	}
528	return 1;
529	}
530
531
532
533	/*
534	* ----------------------------------------------------------------------
535	* PgapCopyString()
536	*
537	* Called by pgapack to copy one input string to another.
538	* ----------------------------------------------------------------------
539	*/
540	MPI_Datatype
541	PgapBuildDT(ctx, p, pop)
542	PGAContext ctx; / pgapack context for this optimization */
543	int p; /* sample # being run */
544	int pop; /* population containing sample */
545	{
546	panic("MPI support not implemented!");
547	return NULL;
548	}
549
550	/*
551	* ======================================================================
552	* OPTION: -operation <=> PGA_MINIMIZE / PGA_MAXIMIZE
553	* ======================================================================
554	*/
555	int
556	RpOption_ParseOper(interp, valObj, cdata, offset)
557	Tcl_Interp interp; / interpreter handling this request */
558	Tcl_Obj valObj; / set option to this new value */
559	ClientData cdata; /* save in this data structure */
560	int offset; /* save at this offset in cdata */
561	{
562	int ptr = (int)(cdata+offset);
563	char val = Tcl_GetStringFromObj(valObj, (int)NULL);
564	if (strcmp(val,"minimize") == 0) {
565	*ptr = PGA_MINIMIZE;
566	}
567	else if (strcmp(val,"maximize") == 0) {
568	*ptr = PGA_MAXIMIZE;
569	}
570	else {
571	Tcl_AppendStringsToObj(Tcl_GetObjResult(interp),
572	"bad value \"", val, "\": should be minimize, maximize",
573	(char*)NULL);
574	return TCL_ERROR;
575	}
576	return TCL_OK;
577	}
578
579	int
580	RpOption_GetOper(interp, cdata, offset)
581	Tcl_Interp interp; / interpreter handling this request */
582	ClientData cdata; /* get from this data structure */
583	int offset; /* get from this offset in cdata */
584	{
585	int ptr = (int)(cdata+offset);
586	switch (*ptr) {
587	case PGA_MINIMIZE:
588	Tcl_SetResult(interp, "minimize", TCL_STATIC);
589	break;
590	case PGA_MAXIMIZE:
591	Tcl_SetResult(interp, "maximize", TCL_STATIC);
592	break;
593	default:
594	Tcl_SetResult(interp, "???", TCL_STATIC);
595	break;
596	}
597	return TCL_OK;
598	}
599
600	/*
601	* ======================================================================
602	* OPTION: -poprepl <=> PGASetPopReplacementType()
603	* ======================================================================
604	*/
605	int
606	RpOption_ParsePopRepl(interp, valObj, cdata, offset)
607	Tcl_Interp interp; / interpreter handling this request */
608	Tcl_Obj valObj; / set option to this new value */
609	ClientData cdata; /* save in this data structure */
610	int offset; /* save at this offset in cdata */
611	{
612	int ptr = (int)(cdata+offset);
613	char val = Tcl_GetStringFromObj(valObj, (int)NULL);
614	if (*val == 'b' && strcmp(val,"best") == 0) {
615	*ptr = PGA_POPREPL_BEST;
616	}
617	else if (*val == 'r' && strcmp(val,"random-repl") == 0) {
618	*ptr = PGA_POPREPL_RANDOM_REP;
619	}
620	else if (*val == 'r' && strcmp(val,"random-norepl") == 0) {
621	*ptr = PGA_POPREPL_RANDOM_NOREP;
622	}
623	else {
624	Tcl_AppendStringsToObj(Tcl_GetObjResult(interp),
625	"bad value \"", val, "\": should be best, random-norepl,"
626	" or random-repl", (char*)NULL);
627	return TCL_ERROR;
628	}
629	return TCL_OK;
630	}
631
632	int
633	RpOption_GetPopRepl(interp, cdata, offset)
634	Tcl_Interp interp; / interpreter handling this request */
635	ClientData cdata; /* get from this data structure */
636	int offset; /* get from this offset in cdata */
637	{
638	int ptr = (int)(cdata+offset);
639	switch (*ptr) {
640	case PGA_POPREPL_BEST:
641	Tcl_SetResult(interp, "best", TCL_STATIC);
642	break;
643	case PGA_POPREPL_RANDOM_REP:
644	Tcl_SetResult(interp, "random-repl", TCL_STATIC);
645	break;
646	case PGA_POPREPL_RANDOM_NOREP:
647	Tcl_SetResult(interp, "random-norepl", TCL_STATIC);
648	break;
649	default:
650	Tcl_SetResult(interp, "???", TCL_STATIC);
651	break;
652	}
653	return TCL_OK;
654	}
655
656	/*
657	* ======================================================================
658	* ROUTINES FOR CONNECTING PGACONTEXT <=> RPOPTIMENV
659	* ======================================================================
660	* PgapLinkContext2Env()
661	* This routine is used internally to establish a relationship between
662	* a PGAContext token and its corresponding RpOptimEnv data. The
663	* PGA routines don't provide a way to pass the RpOptimEnv data along,
664	* so we use these routines to find the correspondence.
665	*
666	* PgapGetEnvForContext()
667	* Returns the RpOptimEnv associated with a given PGAContext. If the
668	* link has not been established via PgapLinkContext2Env(), then this
669	* routine returns NULL.
670	*
671	* PgapUnlinkContext2Env()
672	* Breaks the link between a PGAContext and its RpOptimEnv. Should
673	* be called when the PGAContext is destroyed and is no longer valid.
674	* ----------------------------------------------------------------------
675	*/
676	static Tcl_HashTable *Pgacontext2Rpenv = NULL;
677
678	void
679	PgapLinkContext2Env(ctx, envPtr)
680	PGAContext ctx; / pgapack context for this optimization */
681	RpOptimEnv envPtr; / corresponding Rappture optimization data */
682	{
683	Tcl_HashEntry *ctxEntry;
684	int newEntry;
685
686	if (Pgacontext2Rpenv == NULL) {
687	Pgacontext2Rpenv = (Tcl_HashTable*)malloc(sizeof(Tcl_HashTable));
688	Tcl_InitHashTable(Pgacontext2Rpenv, TCL_ONE_WORD_KEYS);
689	}
690	ctxEntry = Tcl_CreateHashEntry(Pgacontext2Rpenv, (char*)ctx, &newEntry);
691	Tcl_SetHashValue(ctxEntry, (ClientData)envPtr);
692	}
693
694	RpOptimEnv*
695	PgapGetEnvForContext(ctx)
696	PGAContext *ctx;
697	{
698	Tcl_HashEntry *entryPtr;
699
700	if (Pgacontext2Rpenv) {
701	entryPtr = Tcl_FindHashEntry(Pgacontext2Rpenv, (char*)ctx);
702	if (entryPtr) {
703	return (RpOptimEnv*)Tcl_GetHashValue(entryPtr);
704	}
705	}
706	return NULL;
707	}
708
709	void
710	PgapUnlinkContext2Env(ctx)
711	PGAContext *ctx;
712	{
713	Tcl_HashEntry *entryPtr;
714
715	if (Pgacontext2Rpenv) {
716	entryPtr = Tcl_FindHashEntry(Pgacontext2Rpenv, (char*)ctx);
717	if (entryPtr) {
718	Tcl_DeleteHashEntry(entryPtr);
719	}
720	}
721	}
722	/*---------------------------------------------------------------------------------
723	* PGARuntimeDTInit(): It initializes the runtime data table.
724	* The table is organized slightly counter-intuitively
725	* Instead of a
726	* param1\|param2\|param3 \|param4...
727	* val11 \|val12 \|val13 \|val14...
728	* val12 \|val22 \|val23 \|val24....
729	* orientation, it is organized as
730	* param1\|val11\|val12
731	* param2\|val21\|val22
732	* param3\|val31\|val32
733	* param4\|val41\|val42
734	* Reallocating for additional columns is easier than reallocating additional rows and then
735	* reallocating for columns
736	* --------------------------------------------------------------------------------
737	*/
738
739	void PGARuntimeDataTableInit(envPtr)
740	RpOptimEnv *envPtr;
741	{
742	int i;
743	if(envPtr != NULL){
744	table.num_of_rows = (envPtr->numParams)+1;
745	table.data = malloc((table.num_of_rows)sizeof(double));
746	if(table.data == NULL){
747	panic("\nAllocation for Runtime Data Table failed\n");
748	}
749	for(i=0;i<table.num_of_rows;i++){
750	table.data[i] = malloc(PGAPACK_RUNTIME_TABLE_DEFAULT_SIZE*sizeof(double));
751	if(table.data[i] == NULL){
752	panic("\nAllocation for Runtime Data Table failed\n");
753	}
754	}
755	table.no_of_samples_evaled = 0;
756	table.no_of_columns = PGAPACK_RUNTIME_TABLE_DEFAULT_SIZE;
757
758	}else{
759	panic("\nError: NULL Environment variable OR Table pointer passed to Data Table Init\n");
760	}
761	}
762
763	void PGARuntimeDataTableDeInit()
764	{
765	int i;
766	if((&table) == NULL){
767	panic("Error: Table not present, therefore cannot free memory..");
768	}
769	for(i=0;i<table.num_of_rows;i++){
770	free(table.data[i]);
771	}
772	free(table.data);
773	}
774
775	void PGARuntimeDataTableSetSampleValue(chrom,fitness)
776	RpOptimParam *chrom;
777	double fitness;
778	{
779	int i;
780	printf("\nSetting sample value.......................\n");
781	if(chrom!=NULL && (&table)!=NULL){
782	(table.no_of_samples_evaled)+=1;
783	if((table.no_of_samples_evaled) > table.no_of_columns){
784	/* then Reallocate space for more columns)*/
785	(table.no_of_columns)+=(table.no_of_columns);
786	//TODO GTG: Delete printing stuff
787	for(i=0;i<(table.num_of_rows);i++){
788	table.data[i] = realloc(table.data[i],table.no_of_columns);
789	if(table.data[i]==NULL){
790	panic("\nError: Could not Reallocate more space for the table");
791	}
792	}
793	}else{
794	if(chrom->type == RP_OPTIMPARAM_NUMBER){
795	for(i=0;i<(table.num_of_rows);i++){
796	if(i==0){
797	table.data[i][(table.no_of_samples_evaled)-1] = fitness;
798	printf("\nSample Number %d:- Fitness: %lf\t",table.no_of_samples_evaled,fitness);
799	}else{
800	table.data[i][(table.no_of_samples_evaled)-1] = chrom[i-1].value.dval;
801	printf("Param %d %lf\t",i,table.data[i][(table.no_of_samples_evaled)-1]);
802	}
803	}
804	}else{
805	panic("\n Chromosome value is RP_OPTIMPARAM_STRING\n");
806	//GTG TODO: find out what happens in this case. Will we be better off handling Tcl_objects?
807	}
808	}
809	}else{
810	panic("\nError:Either Chromosome, or table passed to PGARuntimeDataTableSetSampleValue() is NULL\n");
811	}
812
813	}
814
815	void GetSampleInformation(buffer,sampleNumber)
816	char *buffer;
817	int sampleNumber;
818	{
819	int i;
820	char tempBuff[50];
821	printf("\nFetching sample information.........................\n");
822	if((&table) == NULL){
823	panic("Table uninitialized");
824	}
825	if(sampleNumber<=0){
826	sprintf(buffer,"\nNumber of Samples Evaluated so far: %d\n",(table.no_of_samples_evaled)+1);
827	return;
828	}
829	if(((table.num_of_rows)-1)*10>SINGLE_SAMPLE_DATA_BUFFER_DEFAULT_SIZE){
830	buffer = realloc(buffer,50+25*(table.num_of_rows));
831	//resizing the buffer, keeping 50 for display related jazz, around 12-15 characs for param names
832	//and 10 characs for Fl.pt. display of the value
833	if(buffer == NULL){
834	panic("\nError: Could not reallocate space for sample data buffer");
835	}
836	}
837	for(i=0;i<(table.num_of_rows);i++){
838	if(i==0){
839	sprintf(buffer,"\nSample Number %d ----> Fitness: %lf ",sampleNumber,table.data[i][sampleNumber-1]);
840	}else{
841	sprintf(tempBuff,"Param %d: %lf ",i,table.data[i][sampleNumber-1]);
842	strcat(buffer,tempBuff);
843	}
844	}
845	strcat(buffer,"\n");
846	}

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

Download in other formats: