source: trunk/packages/optimizer/src/rp_optimizer.c @ 1070

Last change on this file since 1070 was 1070, checked in by liveletlive, 14 years ago

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.

File size: 8.5 KB
Line 
1/*
2 * ----------------------------------------------------------------------
3 *  rp_optimizer
4 *
5 *  This is the C language API for the optimization package in
6 *  Rappture.  It lets you set up an optimization of some fitness
7 *  function with respect to a set of inputs.
8 *
9 * ======================================================================
10 *  AUTHOR:  Michael McLennan, Purdue University
11 *  Copyright (c) 2008  Purdue Research Foundation
12 *
13 *  See the file "license.terms" for information on usage and
14 *  redistribution of this file, and for a DISCLAIMER OF ALL WARRANTIES.
15 * ======================================================================
16 */
17#include <math.h>
18#include <stdlib.h>
19#include <string.h>
20#include "rp_optimizer.h"
21
22static void RpOptimCleanupParam _ANSI_ARGS_((RpOptimParam *paramPtr));
23
24/*
25 * ----------------------------------------------------------------------
26 * RpOptimCreate()
27 *
28 * Used to create the context for an optimization.  Creates an empty
29 * context and returns a pointer to it.  The context can be updated
30 * by calling functions like RpOptimAddParamNumber to define various
31 * input parameters.
32 * ----------------------------------------------------------------------
33 */
34RpOptimEnv*
35RpOptimCreate(pluginDefn)
36    RpOptimPlugin *pluginDefn;    /* plug-in handling this optimization */
37{
38    RpOptimEnv *envPtr;
39    envPtr = (RpOptimEnv*)malloc(sizeof(RpOptimEnv));
40
41    envPtr->pluginDefn = pluginDefn;
42    envPtr->pluginData = NULL;
43    envPtr->toolData   = NULL;
44
45    if (pluginDefn->initProc) {
46        envPtr->pluginData = (*pluginDefn->initProc)();
47    }
48
49    envPtr->numParams = 0;
50    envPtr->maxParams = 5;
51    envPtr->paramList = (RpOptimParam**)malloc(
52        (size_t)(envPtr->maxParams*sizeof(RpOptimParam*))
53    );
54
55    return envPtr;
56}
57
58/*
59 * ----------------------------------------------------------------------
60 * RpOptimAddParam()
61 *
62 * Used internally to add a new parameter into the given optimization
63 * context.  The internal list of parameters is resized, if necessary,
64 * to accommodate the new parameter.
65 * ----------------------------------------------------------------------
66 */
67void
68RpOptimAddParam(envPtr, paramPtr)
69    RpOptimEnv *envPtr;      /* context for this optimization */
70    RpOptimParam *paramPtr;  /* parameter being added */
71{
72    RpOptimParam **newParamList;
73
74    /*
75     * Add the new parameter at the end of the list.
76     */
77    envPtr->paramList[envPtr->numParams++] = paramPtr;
78
79    /*
80     * Out of space?  Then double the space available for params.
81     */
82    if (envPtr->numParams >= envPtr->maxParams) {
83        envPtr->maxParams *= 2;
84        newParamList = (RpOptimParam**)malloc(
85            (size_t)(envPtr->maxParams*sizeof(RpOptimParam*))
86        );
87        memcpy(newParamList, envPtr->paramList,
88            (size_t)(envPtr->numParams*sizeof(RpOptimParam*)));
89        free(envPtr->paramList);
90        envPtr->paramList = newParamList;
91    }
92}
93
94/*
95 * ----------------------------------------------------------------------
96 * RpOptimAddParamNumber()
97 *
98 * Used to add a number parameter as an input to an optimization.
99 * Each number has a name and a double precision value that can be
100 * constrained between min/max values.  Adds this number to the end
101 * of the parameter list in the given optimization context.
102 * ----------------------------------------------------------------------
103 */
104RpOptimParam*
105RpOptimAddParamNumber(envPtr, name)
106    RpOptimEnv *envPtr;   /* context for this optimization */
107    char *name;           /* name of this parameter */
108{
109    RpOptimParamNumber *numPtr;
110    numPtr = (RpOptimParamNumber*)malloc(sizeof(RpOptimParamNumber));
111    numPtr->base.name = strdup(name);
112    numPtr->base.type = RP_OPTIMPARAM_NUMBER;
113    numPtr->base.value.dval = 0.0;
114    numPtr->min = -DBL_MAX;
115    numPtr->max = DBL_MAX;
116    numPtr->mutnrate = PARAM_NUM_UNSPEC_MUTN_RATE; /*Unspecified by default, should result in global mutn rate being applied*/
117    numPtr->randdist = RAND_NUMBER_DIST_GAUSSIAN ;/*Gaussian by default*/
118    numPtr->stddev = 1;
119    numPtr->mean = 0;
120    numPtr->strictmax = 0; /*no strict truncation by default*/
121    numPtr->strictmax = 0; /*no strict maximum truncation by default*/
122
123    RpOptimAddParam(envPtr, (RpOptimParam*)numPtr);
124
125    return (RpOptimParam*)numPtr;
126}
127
128/*
129 * ----------------------------------------------------------------------
130 * RpOptimAddParamString()
131 *
132 * Used to add a string parameter as an input to an optimization.
133 * Each string has a name and a list of allowed values terminated
134 * by a NULL.  Adds this string to the end of the parameter list
135 * in the given optimization context.
136 * ----------------------------------------------------------------------
137 */
138RpOptimParam*
139RpOptimAddParamString(envPtr, name)
140    RpOptimEnv *envPtr;   /* context for this optimization */
141    char *name;           /* name of this parameter */
142{
143    RpOptimParamString *strPtr;
144    strPtr = (RpOptimParamString*)malloc(sizeof(RpOptimParamString));
145    strPtr->base.name = strdup(name);
146    strPtr->base.type = RP_OPTIMPARAM_STRING;
147    strPtr->base.value.sval.num = -1;
148    strPtr->base.value.sval.str = NULL;
149    strPtr->values = NULL;
150    strPtr->numValues = 0;
151
152    RpOptimAddParam(envPtr, (RpOptimParam*)strPtr);
153
154    return (RpOptimParam*)strPtr;
155}
156
157/*
158 * ----------------------------------------------------------------------
159 * RpOptimFindParam()
160 *
161 * Used to look for an existing parameter with the specified name.
162 * Returns a pointer to the parameter, or NULL if not found.
163 * ----------------------------------------------------------------------
164 */
165RpOptimParam*
166RpOptimFindParam(envPtr, name)
167    RpOptimEnv *envPtr;   /* context for this optimization */
168    char *name;           /* name of this parameter */
169{
170    int n;
171    for (n=0; envPtr->numParams; n++) {
172        if (strcmp(name, envPtr->paramList[n]->name) == 0) {
173            return envPtr->paramList[n];
174        }
175    }
176    return NULL;
177}
178
179/*
180 * ----------------------------------------------------------------------
181 * RpOptimDeleteParam()
182 *
183 * Used to delete a parameter from the environment.  This is especially
184 * useful when an error is found while configuring the parameter, just
185 * after it was created.  If the name is not recognized, this function
186 * does nothing.
187 * ----------------------------------------------------------------------
188 */
189void
190RpOptimDeleteParam(envPtr, name)
191    RpOptimEnv *envPtr;   /* context for this optimization */
192    char *name;           /* name of this parameter */
193{
194    int n, j;
195    for (n=0; envPtr->numParams; n++) {
196        if (strcmp(name, envPtr->paramList[n]->name) == 0) {
197            RpOptimCleanupParam(envPtr->paramList[n]);
198            for (j=n+1; j < envPtr->numParams; j++) {
199                envPtr->paramList[j-1] = envPtr->paramList[j];
200            }
201            envPtr->numParams--;
202            break;
203        }
204    }
205}
206
207/*
208 * ----------------------------------------------------------------------
209 * RpOptimDelete()
210 *
211 * Used to delete the context for an optimization once it is finished
212 * or no longer needed.  Frees up the memory needed to store the
213 * context and all input parameters.  After this call, the context
214 * should not be used again.
215 * ----------------------------------------------------------------------
216 */
217void
218RpOptimDelete(envPtr)
219    RpOptimEnv *envPtr;   /* context for this optimization */
220{
221    int n;
222
223    if (envPtr->pluginDefn && envPtr->pluginDefn->cleanupProc) {
224        (*envPtr->pluginDefn->cleanupProc)(envPtr->pluginData);
225    }
226    for (n=0; n < envPtr->numParams; n++) {
227        RpOptimCleanupParam(envPtr->paramList[n]);
228    }
229    free(envPtr->paramList);
230    free(envPtr);
231}
232
233/*
234 * ----------------------------------------------------------------------
235 * RpOptimCleanupParam()
236 *
237 * Used internally to free up the data associated with an optimization
238 * parameter.  Looks at the parameter type and frees up the appropriate
239 * data.
240 * ----------------------------------------------------------------------
241 */
242static void
243RpOptimCleanupParam(paramPtr)
244    RpOptimParam *paramPtr;  /* data to be freed */
245{
246    int n;
247    RpOptimParamNumber *numPtr;
248    RpOptimParamString *strPtr;
249
250    free(paramPtr->name);
251    switch (paramPtr->type) {
252        case RP_OPTIMPARAM_NUMBER:
253            numPtr = (RpOptimParamNumber*)paramPtr;
254            /* nothing special to free here */
255            break;
256        case RP_OPTIMPARAM_STRING:
257            strPtr = (RpOptimParamString*)paramPtr;
258            if (strPtr->values) {
259                for (n=0; strPtr->values[n]; n++) {
260                    free(strPtr->values[n]);
261                }
262            }
263            break;
264    }
265    free(paramPtr);
266}
Note: See TracBrowser for help on using the repository browser.