Changeset 1070 for trunk

Timestamp:

Jun 26, 2008, 7:46:14 PM (16 years ago)

Author:

liveletlive

Message:

Added changes to accomodate gaussian profiles and random number distribution selection on a per gene basis.
also changed the mutation to a per gene based mutation if specified.

Location:

trunk/packages/optimizer/src

Files:

• plugin_pgapack.c (modified) (3 diffs)
• rp_optimizer.c (modified) (1 diff)
• rp_optimizer.h (modified) (3 diffs)
• rp_optimizer_tcl.c (modified) (2 diffs)

trunk/packages/optimizer/src/plugin_pgapack.c

@@ -291 +291 @@
             case RP_OPTIMPARAM_NUMBER:
                 numPtr = (RpOptimParamNumber*)envPtr->paramList[n];
-                dval = PGARandom01(ctx,0);
-                newParamPtr[n].value.dval =
+                if(numPtr->randdist == RAND_NUMBER_DIST_UNIFORM){
+                        dval = PGARandom01(ctx,0);
+                        newParamPtr[n].value.dval =
                     (numPtr->max - numPtr->min)*dval + numPtr->min;
+                }else if(numPtr->randdist == RAND_NUMBER_DIST_GAUSSIAN){
+                                dval = PGARandomGaussian(ctx,numPtr->mean,numPtr->stddev);
+                                if(numPtr->strictmax){
+                                        if(dval>numPtr->max){
+                                                dval = numPtr->max;
+                                        }
+                                }
+                                if(numPtr->strictmin){
+                                        if(dval<numPtr->min){
+                                                dval = numPtr->min;
+                                        }
+                                }
+                                newParamPtr[n].value.dval = dval;
+                }else{
+                        panic("Incorrect Random Number distribution option in PgapcreateString()");
+                }
                 break;
             case RP_OPTIMPARAM_STRING:
@@ -325 +342 @@
     int count = 0;    /* number of mutations */
 
-    int n, ival;
+    int n, ival,tempmr;
     RpOptimEnv *envPtr;
     RpOptimParam *paramPtr;
@@ -335 +352 @@
 
     for (n=0; n < envPtr->numParams; n++) {
-        if (PGARandomFlip(ctx, mr)) {
-            /* won the coin toss -- change this parameter */
-            count++;
+
 
             switch (paramPtr[n].type) {
             case RP_OPTIMPARAM_NUMBER:
-                /* bump the value up/down a little, randomly */
-                if (PGARandomFlip(ctx, 0.5)) {
-                    paramPtr[n].value.dval += 0.1*paramPtr[n].value.dval;
-                } else {
-                    paramPtr[n].value.dval -= 0.1*paramPtr[n].value.dval;
+                numPtr = (RpOptimParamNumber*)envPtr->paramList[n];
+                if(numPtr->mutnrate!=PARAM_NUM_UNSPEC_MUTN_RATE){
+                        tempmr = numPtr->mutnrate;
+                }else{
+                        tempmr = mr;
                 }
-                /* make sure the resulting value is still in bounds */
-                numPtr = (RpOptimParamNumber*)envPtr->paramList[n];
-                if (paramPtr[n].value.dval > numPtr->max) {
-                    paramPtr[n].value.dval = numPtr->max;
-                }
-                if (paramPtr[n].value.dval < numPtr->min) {
-                    paramPtr[n].value.dval = numPtr->min;
+                if (PGARandomFlip(ctx, tempmr)) {
+                            /* won the coin toss -- change this parameter */
+                                count++;
+                                
+                        /* bump the value up/down a little, randomly */
+                        if (PGARandomFlip(ctx, 0.5)) {
+                            paramPtr[n].value.dval += 0.1*paramPtr[n].value.dval;
+                        } else {
+                            paramPtr[n].value.dval -= 0.1*paramPtr[n].value.dval;
+                        }
+                        /* make sure the resulting value is still in bounds */
+                        if(numPtr->randdist == RAND_NUMBER_DIST_UNIFORM ||
+                         (numPtr->randdist == RAND_NUMBER_DIST_GAUSSIAN && numPtr->strictmax)){
+                                if (paramPtr[n].value.dval > numPtr->max) {
+                                    paramPtr[n].value.dval = numPtr->max;
+                                }
+                         }
+                         /*also make sure it obeys configured parameters when gaussian*/
+                         if(numPtr->randdist == RAND_NUMBER_DIST_UNIFORM ||
+                         (numPtr->randdist == RAND_NUMBER_DIST_GAUSSIAN && numPtr->strictmin)){
+                                if (paramPtr[n].value.dval < numPtr->min) {
+                                    paramPtr[n].value.dval = numPtr->min;
+                                }
+                         }
+                        
                 }
                 break;
+                
 
             case RP_OPTIMPARAM_STRING:
-                ival = paramPtr[n].value.sval.num;
-                if (PGARandomFlip(ctx, 0.5)) {
-                    ival += 1;
-                } else {
-                    ival -= 1;
-                }
-                strPtr = (RpOptimParamString*)envPtr->paramList[n];
-                if (ival < 0) ival = 0;
-                if (ival >= strPtr->numValues) ival = strPtr->numValues-1;
-                paramPtr[n].value.sval.num = ival;
-                paramPtr[n].value.sval.str = strPtr->values[ival];
-                break;
-
+                    if (PGARandomFlip(ctx, mr)) {
+                    /* won the coin toss -- change this parameter */
+                        count++;
+                
+                        ival = paramPtr[n].value.sval.num;
+                        if (PGARandomFlip(ctx, 0.5)) {
+                            ival += 1;
+                        } else {
+                            ival -= 1;
+                        }
+                        strPtr = (RpOptimParamString*)envPtr->paramList[n];
+                        if (ival < 0) ival = 0;
+                        if (ival >= strPtr->numValues) ival = strPtr->numValues-1;
+                        paramPtr[n].value.sval.num = ival;
+                        paramPtr[n].value.sval.str = strPtr->values[ival];
+                    }
+                    
+                    break;
+                    
             default:
                 panic("bad parameter type in PgapMutation()");
             }
-        }
+        
     }
     return count;

trunk/packages/optimizer/src/rp_optimizer.c

@@ -114 +114 @@
     numPtr->min = -DBL_MAX;
     numPtr->max = DBL_MAX;
+    numPtr->mutnrate = PARAM_NUM_UNSPEC_MUTN_RATE; /*Unspecified by default, should result in global mutn rate being applied*/
+    numPtr->randdist = RAND_NUMBER_DIST_GAUSSIAN ;/*Gaussian by default*/
+    numPtr->stddev = 1; 
+    numPtr->mean = 0;
+    numPtr->strictmax = 0; /*no strict truncation by default*/
+    numPtr->strictmax = 0; /*no strict maximum truncation by default*/
 
     RpOptimAddParam(envPtr, (RpOptimParam*)numPtr);

trunk/packages/optimizer/src/rp_optimizer.h

@@ -27 +27 @@
 #define PGAPACK_RUNTIME_TABLE_DEFAULT_SIZE 5000 /*Approx Number of Samples in a run*/
 #define SINGLE_SAMPLE_DATA_BUFFER_DEFAULT_SIZE 5000
+
+/*User defined Random Number Distributions*/
+#define RAND_NUMBER_DIST_GAUSSIAN 1
+#define RAND_NUMBER_DIST_UNIFORM 2
+
+/* Used to indicate unspecified mutation rate for a param, will result in global mutn rate being applied*/
+#define PARAM_NUM_UNSPEC_MUTN_RATE -1.0
 
 /*
@@ -93 +100 @@
 
 /*
- * NUMBER PARAMETERS have additional min/max values as constraints.
+ * NUMBER PARAMETERS have additional constraints.
  */
 typedef struct RpOptimParamNumber {
@@ -99 +106 @@
     double min;                     /* optimization constraint: min value */
     double max;                     /* optimization constraint: max value */
+    double mutnrate;                    /* independently sets mutation rate for each parameter*/
+    int randdist;                       /* gaussian or uniform distribution*/
+    int strictmin;                                      /* whether a strict min is to be applied for gauss. rand. numbers*/
+    int strictmax;                                      /* whether a strict max is to be applied for gauss. rand. numbers*/
+    double stddev;                                      /* std deviaton for gaussian profile*/
+    double mean;                                        /* mean for gaussian profile*/
 } RpOptimParamNumber;
 

trunk/packages/optimizer/src/rp_optimizer_tcl.c

@@ -47 +47 @@
  * ----------------------------------------------------------------------
  */
+ 
+RpCustomTclOptionGet RpOption_GetRandDist;
+RpCustomTclOptionParse RpOption_ParseRandDist;
+RpTclOptionType RpOption_RandDist = {
+        "pga_randdist", RpOption_ParseRandDist,RpOption_GetRandDist,NULL
+}; 
 RpTclOption rpOptimNumberOpts[] = {
   {"-min", RP_OPTION_DOUBLE, Rp_Offset(RpOptimParamNumber,min)},
   {"-max", RP_OPTION_DOUBLE, Rp_Offset(RpOptimParamNumber,max)},
+  {"-mutnrate",RP_OPTION_DOUBLE, Rp_Offset(RpOptimParamNumber,mutnrate)},
+  {"-randdist",&RpOption_RandDist,Rp_Offset(RpOptimParamNumber,randdist)},
+  {"-strictmin",RP_OPTION_BOOLEAN,Rp_Offset(RpOptimParamNumber,strictmin)},
+  {"-strictmax",RP_OPTION_BOOLEAN,Rp_Offset(RpOptimParamNumber,strictmax)},
+  {"-stddev",RP_OPTION_DOUBLE,Rp_Offset(RpOptimParamNumber,stddev)},
+  {"-mean",RP_OPTION_DOUBLE,Rp_Offset(RpOptimParamNumber,mean)},
   {NULL, NULL, 0}
 };
@@ -884 +896 @@
     return result;
 }
+
+/*
+ * ======================================================================
+ *  OPTION:  -randdist <=> RAND_NUMBER_DIST_GAUSSIAN / RAND_NUMBER_DIST_UNIFORM 
+ * ======================================================================
+ */
+int
+RpOption_ParseRandDist(interp, valObj, cdata, offset)
+    Tcl_Interp *interp;  /* interpreter handling this request */
+    Tcl_Obj *valObj;     /* set option to this new value */
+    ClientData cdata;    /* save in this data structure */
+    int offset;          /* save at this offset in cdata */
+{
+    int *ptr = (int*)(cdata+offset);
+    char *val = Tcl_GetStringFromObj(valObj, (int*)NULL);
+    if (strcmp(val,"gaussian") == 0) {
+        *ptr = RAND_NUMBER_DIST_GAUSSIAN;
+    }
+    else if (strcmp(val,"uniform") == 0) {
+        *ptr = RAND_NUMBER_DIST_UNIFORM;
+    }
+    else {
+        Tcl_AppendStringsToObj(Tcl_GetObjResult(interp),
+            "bad value \"", val, "\": should be gaussian or uniform",
+            (char*)NULL);
+        return TCL_ERROR;
+    }
+    return TCL_OK;
+}
+
+int
+RpOption_GetRandDist(interp, cdata, offset)
+    Tcl_Interp *interp;  /* interpreter handling this request */
+    ClientData cdata;    /* get from this data structure */
+    int offset;          /* get from this offset in cdata */
+{
+    int *ptr = (int*)(cdata+offset);
+    switch (*ptr) {
+    case RAND_NUMBER_DIST_GAUSSIAN:
+        Tcl_SetResult(interp, "gaussian", TCL_STATIC);
+        break;
+    case RAND_NUMBER_DIST_UNIFORM:
+        Tcl_SetResult(interp, "uniform", TCL_STATIC);
+        break;
+    default:
+        Tcl_SetResult(interp, "???", TCL_STATIC);
+        break;
+    }
+    return TCL_OK;
+}