[815] | 1 | /* |
---|
| 2 | * |
---|
| 3 | * ********************************************************************* |
---|
| 4 | * (C) COPYRIGHT 1995 UNIVERSITY OF CHICAGO |
---|
| 5 | * ********************************************************************* |
---|
| 6 | * |
---|
| 7 | * This software was authored by |
---|
| 8 | * |
---|
| 9 | * D. Levine |
---|
| 10 | * Mathematics and Computer Science Division Argonne National Laboratory |
---|
| 11 | * Argonne IL 60439 |
---|
| 12 | * levine@mcs.anl.gov |
---|
| 13 | * (708) 252-6735 |
---|
| 14 | * (708) 252-5986 (FAX) |
---|
| 15 | * |
---|
| 16 | * with programming assistance of participants in Argonne National |
---|
| 17 | * Laboratory's SERS program. |
---|
| 18 | * |
---|
| 19 | * This program contains material protectable under copyright laws of the |
---|
| 20 | * United States. Permission is hereby granted to use it, reproduce it, |
---|
| 21 | * to translate it into another language, and to redistribute it to |
---|
| 22 | * others at no charge except a fee for transferring a copy, provided |
---|
| 23 | * that you conspicuously and appropriately publish on each copy the |
---|
| 24 | * University of Chicago's copyright notice, and the disclaimer of |
---|
| 25 | * warranty and Government license included below. Further, permission |
---|
| 26 | * is hereby granted, subject to the same provisions, to modify a copy or |
---|
| 27 | * copies or any portion of it, and to distribute to others at no charge |
---|
| 28 | * materials containing or derived from the material. |
---|
| 29 | * |
---|
| 30 | * The developers of the software ask that you acknowledge its use in any |
---|
| 31 | * document referencing work based on the program, such as published |
---|
| 32 | * research. Also, they ask that you supply to Argonne National |
---|
| 33 | * Laboratory a copy of any published research referencing work based on |
---|
| 34 | * the software. |
---|
| 35 | * |
---|
| 36 | * Any entity desiring permission for further use must contact: |
---|
| 37 | * |
---|
| 38 | * J. Gleeson |
---|
| 39 | * Industrial Technology Development Center Argonne National Laboratory |
---|
| 40 | * Argonne IL 60439 |
---|
| 41 | * gleesonj@smtplink.eid.anl.gov |
---|
| 42 | * (708) 252-6055 |
---|
| 43 | * |
---|
| 44 | * ******************************************************************** |
---|
| 45 | * DISCLAIMER |
---|
| 46 | * |
---|
| 47 | * THIS PROGRAM WAS PREPARED AS AN ACCOUNT OF WORK SPONSORED BY AN AGENCY |
---|
| 48 | * OF THE UNITED STATES GOVERNMENT. NEITHER THE UNIVERSITY OF CHICAGO, |
---|
| 49 | * THE UNITED STATES GOVERNMENT NOR ANY OF THEIR EMPLOYEES MAKE ANY |
---|
| 50 | * WARRANTY, EXPRESS OR IMPLIED, OR ASSUMES ANY LEGAL LIABILITY OR |
---|
| 51 | * RESPONSIBILITY FOR THE ACCURACY, COMPLETENESS, OR USEFULNESS OF ANY |
---|
| 52 | * INFORMATION OR PROCESS DISCLOSED, OR REPRESENTS THAT ITS USE WOULD NOT |
---|
| 53 | * INFRINGE PRIVATELY OWNED RIGHTS. |
---|
| 54 | * |
---|
| 55 | * ********************************************************************** |
---|
| 56 | * GOVERNMENT LICENSE |
---|
| 57 | * |
---|
| 58 | * The Government is granted for itself and others acting on its behalf a |
---|
| 59 | * paid-up, non-exclusive, irrevocable worldwide license in this computer |
---|
| 60 | * software to reproduce, prepare derivative works, and perform publicly |
---|
| 61 | * and display publicly. |
---|
| 62 | */ |
---|
| 63 | |
---|
| 64 | /***************************************************************************** |
---|
| 65 | * FILE: create.c: This file contains functions to create and initialize |
---|
| 66 | * data structures and populations. |
---|
| 67 | * |
---|
| 68 | * Authors: David M. Levine, Philip L. Hallstrom, David M. Noelle, |
---|
| 69 | * Brian P. Walenz |
---|
| 70 | *****************************************************************************/ |
---|
| 71 | |
---|
| 72 | #include "pgapack.h" |
---|
| 73 | |
---|
| 74 | /*U**************************************************************************** |
---|
| 75 | PGACreate - creates an uninitialized context variable. The Fortran version |
---|
| 76 | of this function call contains only the last three arguments |
---|
| 77 | |
---|
| 78 | Category: Generation |
---|
| 79 | |
---|
| 80 | Inputs: |
---|
| 81 | argc - address of the count of the number of command line arguments. |
---|
| 82 | argv - array of command line arguments. |
---|
| 83 | datatype - the data type used for the strings. Must be one of |
---|
| 84 | PGA_DATATYPE_BINARY, PGA_DATATYPE_CHARACTER, |
---|
| 85 | PGA_DATATYPE_INTEGER, PGA_DATATYPE_REAL, or PGA_DATATYPE_USER |
---|
| 86 | to specify binary-valued, character-valued, integer-valued, |
---|
| 87 | real-valued, or a user-defined datatype, respectively. |
---|
| 88 | len - the string length (number of genes). |
---|
| 89 | maxormin - the direction of optimization. Must be one of PGA_MAXIMIZE or |
---|
| 90 | PGA_MINIMIZE for maximization or minimization, respectively. |
---|
| 91 | |
---|
| 92 | Outputs: |
---|
| 93 | A pointer to the context variable. |
---|
| 94 | |
---|
| 95 | Example: |
---|
| 96 | |
---|
| 97 | In C: |
---|
| 98 | void main(int argc, char **argv) { |
---|
| 99 | PGAContext *ctx; |
---|
| 100 | : |
---|
| 101 | ctx = PGACreate(&argc, argv, PGA_DATATYPE_BINARY, 100, PGA_MAXIMIZE); |
---|
| 102 | : |
---|
| 103 | // Set options here |
---|
| 104 | : |
---|
| 105 | PGASetUp(ctx); |
---|
| 106 | : |
---|
| 107 | // Run the GA here |
---|
| 108 | : |
---|
| 109 | PGADestroy(ctx); |
---|
| 110 | } |
---|
| 111 | |
---|
| 112 | In FORTRAN: |
---|
| 113 | integer ctx |
---|
| 114 | : |
---|
| 115 | ctx = PGACreate(PGA_DATATYPE_BINARY, 100, PGA_MAXIMIZE) |
---|
| 116 | : |
---|
| 117 | c Set options here |
---|
| 118 | : |
---|
| 119 | call PGASetUp(ctx) |
---|
| 120 | : |
---|
| 121 | c Run the GA here |
---|
| 122 | : |
---|
| 123 | call PGADestroy(ctx) |
---|
| 124 | stop |
---|
| 125 | end |
---|
| 126 | |
---|
| 127 | ****************************************************************************U*/ |
---|
| 128 | PGAContext *PGACreate ( int *argc, char **argv, |
---|
| 129 | int datatype, int len, int maxormin ) |
---|
| 130 | { |
---|
| 131 | int i; |
---|
| 132 | PGAContext *ctx; |
---|
| 133 | |
---|
| 134 | /* gekco purify ctx = (PGAContext *) malloc ( sizeof(PGAContext) ); */ |
---|
| 135 | ctx = (PGAContext *) calloc ( 1, sizeof(PGAContext) ); |
---|
| 136 | |
---|
| 137 | /* We cannot make PGA calls until we sort the FuncNameIndex below, |
---|
| 138 | * so we just manually print the (rather severe) error message. |
---|
| 139 | */ |
---|
| 140 | if( ctx == NULL ) { |
---|
| 141 | fprintf(stderr, "PGACreate: No room to allocate ctx\n"); |
---|
| 142 | exit(-1); |
---|
| 143 | } |
---|
| 144 | |
---|
| 145 | |
---|
| 146 | /* We use this (indirectly) in PGAReadCmdLine -- in processing |
---|
| 147 | * -pgahelp and -pgahelp debug. |
---|
| 148 | */ |
---|
| 149 | MPI_Initialized (&ctx->par.MPIAlreadyInit); |
---|
| 150 | |
---|
| 151 | /* Initialize MPI, only if it isn't already running (fortran) */ |
---|
| 152 | if (!ctx->par.MPIAlreadyInit) |
---|
| 153 | MPI_Init (argc, &argv); |
---|
| 154 | |
---|
| 155 | |
---|
| 156 | #if OPTIMIZE==0 |
---|
| 157 | /* Sort the FuncNameIndex. This allows us to use a binary search |
---|
| 158 | * for finding the function names. |
---|
| 159 | */ |
---|
| 160 | PGASortFuncNameIndex(ctx); |
---|
| 161 | #endif |
---|
| 162 | |
---|
| 163 | /* Initialize debug flags, then parse command line arguments. */ |
---|
| 164 | for (i=0; i<PGA_DEBUG_MAXFLAGS; i++) |
---|
| 165 | ctx->debug.PGADebugFlags[i] = PGA_FALSE; |
---|
| 166 | PGAReadCmdLine( ctx, argc, argv ); |
---|
| 167 | |
---|
| 168 | |
---|
| 169 | /* The context variable is now initialized enough to allow this |
---|
| 170 | * call to complete successfully. |
---|
| 171 | */ |
---|
| 172 | PGADebugEntered("PGACreate"); |
---|
| 173 | |
---|
| 174 | /* required parameter 1: abstract data type */ |
---|
| 175 | switch (datatype) |
---|
| 176 | { |
---|
| 177 | case PGA_DATATYPE_BINARY: |
---|
| 178 | case PGA_DATATYPE_INTEGER: |
---|
| 179 | case PGA_DATATYPE_REAL: |
---|
| 180 | case PGA_DATATYPE_CHARACTER: |
---|
| 181 | case PGA_DATATYPE_USER: |
---|
| 182 | ctx->ga.datatype = datatype; |
---|
| 183 | break; |
---|
| 184 | default: |
---|
| 185 | PGAError( ctx, "PGACreate: Invalid value of datatype:", |
---|
| 186 | PGA_FATAL, PGA_INT, (void *) &datatype ); |
---|
| 187 | }; |
---|
| 188 | |
---|
| 189 | /* required parameter 2: string string length */ |
---|
| 190 | if (len <= 1) |
---|
| 191 | PGAError( ctx, "PGACreate: Invalid value of len:", |
---|
| 192 | PGA_FATAL, PGA_INT, (void *) &len ); |
---|
| 193 | else |
---|
| 194 | ctx->ga.StringLen = len; |
---|
| 195 | |
---|
| 196 | |
---|
| 197 | /* required parameter 3: optimization direction */ |
---|
| 198 | switch (maxormin) { |
---|
| 199 | case PGA_MAXIMIZE: |
---|
| 200 | case PGA_MINIMIZE: |
---|
| 201 | ctx->ga.optdir = maxormin; |
---|
| 202 | break; |
---|
| 203 | default: |
---|
| 204 | PGAError( ctx, "PGACreate: Invalid value of optdir:", |
---|
| 205 | PGA_FATAL, PGA_INT, (void *) &maxormin ); |
---|
| 206 | }; |
---|
| 207 | |
---|
| 208 | |
---|
| 209 | /* For datatype == PGA_DATATYPE_BINARY, set how many full words |
---|
| 210 | * are used in the packed representation, and how many extra bits |
---|
| 211 | * this leaves us with. Finally, set how many total words are used; |
---|
| 212 | * if there are no extra bits, this is just the number of full words, |
---|
| 213 | * else, there is one more word used than the number of full words. |
---|
| 214 | */ |
---|
| 215 | switch (datatype) { |
---|
| 216 | case PGA_DATATYPE_BINARY: |
---|
| 217 | ctx->ga.fw = ctx->ga.StringLen/WL; |
---|
| 218 | ctx->ga.eb = ctx->ga.StringLen%WL; |
---|
| 219 | if ( ctx->ga.eb == 0 ) |
---|
| 220 | ctx->ga.tw = ctx->ga.fw; |
---|
| 221 | else |
---|
| 222 | ctx->ga.tw = ctx->ga.fw+1; |
---|
| 223 | break; |
---|
| 224 | default: |
---|
| 225 | ctx->ga.fw = PGA_UNINITIALIZED_INT; |
---|
| 226 | ctx->ga.eb = PGA_UNINITIALIZED_INT; |
---|
| 227 | ctx->ga.tw = PGA_UNINITIALIZED_INT; |
---|
| 228 | break; |
---|
| 229 | } |
---|
| 230 | |
---|
| 231 | /* Clear all the setting. Later on, PGASetUp() will be called, and then |
---|
| 232 | * it will notice which setting are uninitialized, and set them to the |
---|
| 233 | * default value. |
---|
| 234 | */ |
---|
| 235 | ctx->ga.PopSize = PGA_UNINITIALIZED_INT; |
---|
| 236 | ctx->ga.StoppingRule = PGA_STOP_MAXITER; |
---|
| 237 | ctx->ga.MaxIter = PGA_UNINITIALIZED_INT; |
---|
| 238 | ctx->ga.MaxNoChange = PGA_UNINITIALIZED_INT; |
---|
| 239 | ctx->ga.MaxSimilarity = PGA_UNINITIALIZED_INT; |
---|
| 240 | ctx->ga.NumReplace = PGA_UNINITIALIZED_INT; |
---|
| 241 | ctx->ga.CrossoverType = PGA_UNINITIALIZED_INT; |
---|
| 242 | ctx->ga.SelectType = PGA_UNINITIALIZED_INT; |
---|
| 243 | ctx->ga.FitnessType = PGA_UNINITIALIZED_INT; |
---|
| 244 | ctx->ga.FitnessMinType = PGA_UNINITIALIZED_INT; |
---|
| 245 | ctx->ga.MutationType = PGA_UNINITIALIZED_INT; |
---|
| 246 | ctx->ga.MutateOnlyNoCross = PGA_UNINITIALIZED_INT; |
---|
| 247 | ctx->ga.MutateRealValue = PGA_UNINITIALIZED_DOUBLE; |
---|
| 248 | ctx->ga.MutateIntegerValue = PGA_UNINITIALIZED_INT; |
---|
| 249 | ctx->ga.MutateBoundedFlag = PGA_UNINITIALIZED_INT; |
---|
| 250 | ctx->ga.NoDuplicates = PGA_UNINITIALIZED_INT; |
---|
| 251 | ctx->ga.MutationProb = PGA_UNINITIALIZED_DOUBLE; |
---|
| 252 | ctx->ga.CrossoverProb = PGA_UNINITIALIZED_DOUBLE; |
---|
| 253 | ctx->ga.UniformCrossProb = PGA_UNINITIALIZED_DOUBLE; |
---|
| 254 | ctx->ga.PTournamentProb = PGA_UNINITIALIZED_DOUBLE; |
---|
| 255 | ctx->ga.FitnessRankMax = PGA_UNINITIALIZED_DOUBLE; |
---|
| 256 | ctx->ga.FitnessCmaxValue = PGA_UNINITIALIZED_DOUBLE; |
---|
| 257 | ctx->ga.PopReplace = PGA_UNINITIALIZED_INT; |
---|
| 258 | ctx->ga.iter = 0; |
---|
| 259 | ctx->ga.ItersOfSame = 0; |
---|
| 260 | ctx->ga.PercentSame = 0; |
---|
| 261 | ctx->ga.selected = NULL; |
---|
| 262 | ctx->ga.SelectIndex = 0; |
---|
| 263 | ctx->ga.restart = PGA_UNINITIALIZED_INT; |
---|
| 264 | ctx->ga.restartFreq = PGA_UNINITIALIZED_INT; |
---|
| 265 | ctx->ga.restartAlleleProb = PGA_UNINITIALIZED_DOUBLE; |
---|
| 266 | |
---|
| 267 | |
---|
| 268 | /***************************** |
---|
| 269 | * EHW Addition * |
---|
| 270 | *****************************/ |
---|
| 271 | ctx->inputex = NULL; |
---|
| 272 | |
---|
| 273 | |
---|
| 274 | |
---|
| 275 | /* Operations */ |
---|
| 276 | ctx->cops.CreateString = NULL; |
---|
| 277 | ctx->cops.Mutation = NULL; |
---|
| 278 | ctx->cops.Crossover = NULL; |
---|
| 279 | ctx->cops.PrintString = NULL; |
---|
| 280 | ctx->cops.CopyString = NULL; |
---|
| 281 | ctx->cops.Duplicate = NULL; |
---|
| 282 | ctx->cops.InitString = NULL; |
---|
| 283 | ctx->cops.BuildDatatype = NULL; |
---|
| 284 | ctx->cops.StopCond = NULL; |
---|
| 285 | ctx->cops.EndOfGen = NULL; |
---|
| 286 | |
---|
| 287 | /***************************** |
---|
| 288 | * EHW Addition * |
---|
| 289 | *****************************/ |
---|
| 290 | ctx->cops.SetTemp = NULL; |
---|
| 291 | ctx->cops.EndOfRepFcn = NULL; |
---|
| 292 | ctx->cops.DestroyUD = NULL; |
---|
| 293 | ctx->cops.InitUserCtx = NULL; |
---|
| 294 | ctx->cops.KillUserCtx = NULL; |
---|
| 295 | |
---|
| 296 | |
---|
| 297 | |
---|
| 298 | ctx->fops.Mutation = NULL; |
---|
| 299 | ctx->fops.Crossover = NULL; |
---|
| 300 | ctx->fops.PrintString = NULL; |
---|
| 301 | ctx->fops.CopyString = NULL; |
---|
| 302 | ctx->fops.Duplicate = NULL; |
---|
| 303 | ctx->fops.InitString = NULL; |
---|
| 304 | ctx->fops.StopCond = NULL; |
---|
| 305 | ctx->fops.EndOfGen = NULL; |
---|
| 306 | |
---|
| 307 | /***************************** |
---|
| 308 | * EHW Addition * |
---|
| 309 | *****************************/ |
---|
| 310 | ctx->fops.SetTemp = NULL; |
---|
| 311 | ctx->fops.EndOfRepFcn = NULL; |
---|
| 312 | ctx->fops.DestroyUD = NULL; |
---|
| 313 | ctx->fops.InitUserCtx = NULL; |
---|
| 314 | ctx->fops.KillUserCtx = NULL; |
---|
| 315 | |
---|
| 316 | |
---|
| 317 | /* Parallel */ |
---|
| 318 | ctx->par.NumIslands = PGA_UNINITIALIZED_INT; |
---|
| 319 | ctx->par.NumDemes = PGA_UNINITIALIZED_INT; |
---|
| 320 | ctx->par.DefaultComm = (MPI_Comm) NULL; |
---|
| 321 | #ifdef FAKE_MPI |
---|
| 322 | ctx->par.MPIStubLibrary = PGA_TRUE; |
---|
| 323 | #else |
---|
| 324 | ctx->par.MPIStubLibrary = PGA_FALSE; |
---|
| 325 | #endif |
---|
| 326 | |
---|
| 327 | /* Reporting */ |
---|
| 328 | ctx->rep.PrintFreq = PGA_UNINITIALIZED_INT; |
---|
| 329 | ctx->rep.PrintOptions = 0; |
---|
| 330 | ctx->rep.Online = 0; |
---|
| 331 | ctx->rep.Offline = 0; |
---|
| 332 | ctx->rep.Best = PGA_UNINITIALIZED_DOUBLE; |
---|
| 333 | ctx->rep.starttime = PGA_UNINITIALIZED_INT; |
---|
| 334 | |
---|
| 335 | /* System |
---|
| 336 | * |
---|
| 337 | * If ctx->sys.UserFortran is not set to PGA_TRUE in pgacreate_ (the |
---|
| 338 | * fortran stub to PGACreate), the user program is in C. |
---|
| 339 | */ |
---|
| 340 | if (ctx->sys.UserFortran != PGA_TRUE) |
---|
| 341 | ctx->sys.UserFortran = PGA_FALSE; |
---|
| 342 | ctx->sys.SetUpCalled = PGA_FALSE; |
---|
| 343 | ctx->sys.PGAMaxInt = INT_MAX; |
---|
| 344 | ctx->sys.PGAMinInt = INT_MIN; |
---|
| 345 | ctx->sys.PGAMaxDouble = DBL_MAX; |
---|
| 346 | ctx->sys.PGAMinDouble = DBL_MIN; |
---|
| 347 | |
---|
| 348 | /* Debug */ |
---|
| 349 | /* Set above before parsing command line arguments */ |
---|
| 350 | |
---|
| 351 | /* Initialization */ |
---|
| 352 | ctx->init.RandomInit = PGA_UNINITIALIZED_INT; |
---|
| 353 | ctx->init.BinaryProbability = PGA_UNINITIALIZED_DOUBLE; |
---|
| 354 | ctx->init.RealType = PGA_UNINITIALIZED_INT; |
---|
| 355 | ctx->init.IntegerType = PGA_UNINITIALIZED_INT; |
---|
| 356 | ctx->init.CharacterType = PGA_UNINITIALIZED_INT; |
---|
| 357 | ctx->init.RandomSeed = PGA_UNINITIALIZED_INT; |
---|
| 358 | |
---|
| 359 | /* Allocate and clear arrays to define the minimum and maximum values |
---|
| 360 | * allowed by integer and real datatypes. |
---|
| 361 | */ |
---|
| 362 | switch (datatype) |
---|
| 363 | { |
---|
| 364 | case PGA_DATATYPE_INTEGER: |
---|
| 365 | ctx->init.IntegerMax = (int *) malloc(len * sizeof(PGAInteger)); |
---|
| 366 | if (!ctx->init.IntegerMax) |
---|
| 367 | PGAError(ctx, "PGACreate: No room to allocate:", PGA_FATAL, |
---|
| 368 | PGA_CHAR, (void *) "ctx->init.IntegerMax"); |
---|
| 369 | ctx->init.IntegerMin = (int *) malloc(len * sizeof(PGAInteger)); |
---|
| 370 | if (!ctx->init.IntegerMin) |
---|
| 371 | PGAError(ctx, "PGACreate: No room to allocate:", PGA_FATAL, |
---|
| 372 | PGA_CHAR, (void *) "ctx->init.IntegerMin"); |
---|
| 373 | ctx->init.RealMax = NULL; |
---|
| 374 | ctx->init.RealMin = NULL; |
---|
| 375 | for (i = 0; i < len; i++) |
---|
| 376 | { |
---|
| 377 | ctx->init.IntegerMin[i] = PGA_UNINITIALIZED_INT; |
---|
| 378 | ctx->init.IntegerMax[i] = PGA_UNINITIALIZED_INT; |
---|
| 379 | } |
---|
| 380 | break; |
---|
| 381 | case PGA_DATATYPE_REAL: |
---|
| 382 | ctx->init.RealMax = (PGAReal *) malloc(len * sizeof(PGAReal)); |
---|
| 383 | if (!ctx->init.RealMax) |
---|
| 384 | PGAError(ctx, "PGACreate: No room to allocate:", PGA_FATAL, |
---|
| 385 | PGA_CHAR, (void *) "ctx->init.RealMax"); |
---|
| 386 | ctx->init.RealMin = (PGAReal *) malloc(len * sizeof(PGAReal)); |
---|
| 387 | if (!ctx->init.RealMin) |
---|
| 388 | PGAError(ctx, "PGACreate: No room to allocate:", PGA_FATAL, |
---|
| 389 | PGA_CHAR, (void *) "ctx->init.RealMin"); |
---|
| 390 | ctx->init.IntegerMax = NULL; |
---|
| 391 | ctx->init.IntegerMin = NULL; |
---|
| 392 | for (i = 0; i < len; i++) |
---|
| 393 | { |
---|
| 394 | ctx->init.RealMin[i] = PGA_UNINITIALIZED_DOUBLE; |
---|
| 395 | ctx->init.RealMax[i] = PGA_UNINITIALIZED_DOUBLE; |
---|
| 396 | } |
---|
| 397 | break; |
---|
| 398 | default: |
---|
| 399 | ctx->init.RealMax = NULL; |
---|
| 400 | ctx->init.RealMin = NULL; |
---|
| 401 | ctx->init.IntegerMax = NULL; |
---|
| 402 | ctx->init.IntegerMin = NULL; |
---|
| 403 | break; |
---|
| 404 | } |
---|
| 405 | |
---|
| 406 | PGADebugExited("PGACreate"); |
---|
| 407 | |
---|
| 408 | return(ctx); |
---|
| 409 | } |
---|
| 410 | |
---|
| 411 | |
---|
| 412 | /*U**************************************************************************** |
---|
| 413 | PGASetUp - set all uninitialized variables to default values and initialize |
---|
| 414 | some internal arrays. Must be called after PGACreate() and before the GA |
---|
| 415 | is started. |
---|
| 416 | |
---|
| 417 | Category: Generation |
---|
| 418 | |
---|
| 419 | Inputs: |
---|
| 420 | ctx - context variable |
---|
| 421 | |
---|
| 422 | Outputs: |
---|
| 423 | Uninitialized values in the context variable are set to defaults, and |
---|
| 424 | set values are checked for legality. |
---|
| 425 | |
---|
| 426 | Example: |
---|
| 427 | PGAContext *ctx; |
---|
| 428 | : |
---|
| 429 | PGACreate(ctx, ...); |
---|
| 430 | : |
---|
| 431 | // Set options here |
---|
| 432 | : |
---|
| 433 | PGASetUp(ctx); |
---|
| 434 | |
---|
| 435 | ****************************************************************************U*/ |
---|
| 436 | void PGASetUp ( PGAContext *ctx ) |
---|
| 437 | { |
---|
| 438 | /* These are for temporary storage of datatype specific functions. |
---|
| 439 | * They allow some (understatement of the yesr!!) cleaning of the |
---|
| 440 | * code below. |
---|
| 441 | */ |
---|
| 442 | void (*CreateString)(PGAContext *, int, int, int); |
---|
| 443 | int (*Mutation)(PGAContext *, int, int, double); |
---|
| 444 | void (*Crossover)(PGAContext *, int, int, int, int, int, int); |
---|
| 445 | void (*PrintString)(PGAContext *, FILE *, int, int); |
---|
| 446 | void (*CopyString)(PGAContext *, int, int, int, int); |
---|
| 447 | int (*Duplicate)(PGAContext *, int, int, int, int); |
---|
| 448 | void (*InitString)(PGAContext *, int, int); |
---|
| 449 | MPI_Datatype (*BuildDatatype)(PGAContext *, int, int); |
---|
| 450 | int err=0, i; |
---|
| 451 | |
---|
| 452 | PGADebugEntered("PGASetUp"); |
---|
| 453 | PGAFailIfSetUp("PGASetUp"); |
---|
| 454 | |
---|
| 455 | ctx->sys.SetUpCalled = PGA_TRUE; |
---|
| 456 | |
---|
| 457 | if ( ctx->ga.datatype == PGA_DATATYPE_BINARY && |
---|
| 458 | ctx->ga.tw == PGA_UNINITIALIZED_INT ) |
---|
| 459 | PGAError( ctx, |
---|
| 460 | "PGASetUp: Binary: Total Words (ctx->ga.tw) == UNINITIALIZED?", |
---|
| 461 | PGA_FATAL, PGA_INT, (void *) &ctx->ga.tw ); |
---|
| 462 | |
---|
| 463 | if ( ctx->ga.datatype == PGA_DATATYPE_BINARY && |
---|
| 464 | ctx->ga.fw == PGA_UNINITIALIZED_INT ) |
---|
| 465 | PGAError( ctx, |
---|
| 466 | "PGASetUp: Binary: Full Words (ctx->ga.fw) == UNINITIALIZED?", |
---|
| 467 | PGA_FATAL, PGA_INT, (void *) &ctx->ga.fw ); |
---|
| 468 | |
---|
| 469 | if ( ctx->ga.datatype == PGA_DATATYPE_BINARY && |
---|
| 470 | ctx->ga.eb == PGA_UNINITIALIZED_INT ) |
---|
| 471 | PGAError( ctx, |
---|
| 472 | "PGASetUp: Binary: Empty Bits (ctx->ga.eb) == UNINITIALIZED?", |
---|
| 473 | PGA_FATAL, PGA_INT, (void *) &ctx->ga.eb ); |
---|
| 474 | |
---|
| 475 | if ( ctx->ga.PopSize == PGA_UNINITIALIZED_INT) |
---|
| 476 | ctx->ga.PopSize = 100; |
---|
| 477 | |
---|
| 478 | if ( ctx->ga.MaxIter == PGA_UNINITIALIZED_INT) |
---|
| 479 | ctx->ga.MaxIter = 1000; |
---|
| 480 | |
---|
| 481 | if ( ctx->ga.MaxNoChange == PGA_UNINITIALIZED_INT) |
---|
| 482 | ctx->ga.MaxNoChange = 100; |
---|
| 483 | |
---|
| 484 | if ( ctx->ga.MaxSimilarity == PGA_UNINITIALIZED_INT) |
---|
| 485 | ctx->ga.MaxSimilarity = 95; |
---|
| 486 | |
---|
| 487 | if ( ctx->ga.NumReplace == PGA_UNINITIALIZED_INT) |
---|
| 488 | ctx->ga.NumReplace = (int) ceil(ctx->ga.PopSize * 0.1); |
---|
| 489 | |
---|
| 490 | if ( ctx->ga.NumReplace > ctx->ga.PopSize) |
---|
| 491 | PGAError(ctx, "PGASetUp: NumReplace > PopSize", |
---|
| 492 | PGA_FATAL, PGA_VOID, NULL); |
---|
| 493 | |
---|
| 494 | if ( ctx->ga.CrossoverType == PGA_UNINITIALIZED_INT) |
---|
| 495 | ctx->ga.CrossoverType = PGA_CROSSOVER_TWOPT; |
---|
| 496 | |
---|
| 497 | if (ctx->ga.CrossoverType == PGA_CROSSOVER_TWOPT && |
---|
| 498 | ctx->ga.StringLen == 2) |
---|
| 499 | PGAError(ctx, "PGASetUp: Invalid Crossover type for string of length " |
---|
| 500 | "2", PGA_FATAL, PGA_INT, (void *) &ctx->ga.CrossoverType); |
---|
| 501 | |
---|
| 502 | if ( ctx->ga.SelectType == PGA_UNINITIALIZED_INT) |
---|
| 503 | ctx->ga.SelectType = PGA_SELECT_TOURNAMENT; |
---|
| 504 | |
---|
| 505 | if ( ctx->ga.FitnessType == PGA_UNINITIALIZED_INT) |
---|
| 506 | ctx->ga.FitnessType = PGA_FITNESS_RAW; |
---|
| 507 | |
---|
| 508 | if ( ctx->ga.FitnessMinType == PGA_UNINITIALIZED_INT) |
---|
| 509 | ctx->ga.FitnessMinType = PGA_FITNESSMIN_CMAX; |
---|
| 510 | |
---|
| 511 | if ( ctx->ga.MutateOnlyNoCross == PGA_UNINITIALIZED_INT) |
---|
| 512 | ctx->ga.MutateOnlyNoCross = PGA_TRUE; |
---|
| 513 | |
---|
| 514 | if ( ctx->ga.MutationProb == PGA_UNINITIALIZED_DOUBLE) |
---|
| 515 | ctx->ga.MutationProb = 1. / ctx->ga.StringLen; |
---|
| 516 | |
---|
| 517 | if ( ctx->ga.MutationType == PGA_UNINITIALIZED_INT) { |
---|
| 518 | switch (ctx->ga.datatype) { |
---|
| 519 | case PGA_DATATYPE_BINARY: |
---|
| 520 | case PGA_DATATYPE_CHARACTER: |
---|
| 521 | case PGA_DATATYPE_USER: |
---|
| 522 | /* leave PGA_UNINITIALIZED_INT for these data types */ |
---|
| 523 | break; |
---|
| 524 | case PGA_DATATYPE_REAL: |
---|
| 525 | ctx->ga.MutationType = PGA_MUTATION_GAUSSIAN; |
---|
| 526 | break; |
---|
| 527 | case PGA_DATATYPE_INTEGER: |
---|
| 528 | switch (ctx->init.IntegerType) { |
---|
| 529 | case PGA_UNINITIALIZED_INT: |
---|
| 530 | case PGA_IINIT_PERMUTE: |
---|
| 531 | ctx->ga.MutationType = PGA_MUTATION_PERMUTE; |
---|
| 532 | break; |
---|
| 533 | case PGA_IINIT_RANGE: |
---|
| 534 | ctx->ga.MutationType = PGA_MUTATION_RANGE; |
---|
| 535 | break; |
---|
| 536 | } |
---|
| 537 | break; |
---|
| 538 | default: |
---|
| 539 | PGAError( ctx, "PGASetup: Invalid value of ctx->ga.datatype:", |
---|
| 540 | PGA_FATAL, PGA_INT, (void *) &(ctx->ga.datatype) ); |
---|
| 541 | } |
---|
| 542 | } |
---|
| 543 | |
---|
| 544 | if (ctx->ga.MutateRealValue == PGA_UNINITIALIZED_DOUBLE) { |
---|
| 545 | switch (ctx->ga.MutationType) { |
---|
| 546 | case PGA_MUTATION_GAUSSIAN: |
---|
| 547 | ctx->ga.MutateRealValue = 0.1; |
---|
| 548 | break; |
---|
| 549 | case PGA_MUTATION_UNIFORM: |
---|
| 550 | ctx->ga.MutateRealValue = 0.1; |
---|
| 551 | break; |
---|
| 552 | case PGA_MUTATION_CONSTANT: |
---|
| 553 | ctx->ga.MutateRealValue = 0.01; |
---|
| 554 | break; |
---|
| 555 | case PGA_MUTATION_RANGE: |
---|
| 556 | default: |
---|
| 557 | ctx->ga.MutateRealValue = 0.0; |
---|
| 558 | } |
---|
| 559 | } |
---|
| 560 | |
---|
| 561 | if ( ctx->ga.MutateIntegerValue == PGA_UNINITIALIZED_INT) |
---|
| 562 | ctx->ga.MutateIntegerValue = 1; |
---|
| 563 | |
---|
| 564 | if ( ctx->ga.MutateBoundedFlag == PGA_UNINITIALIZED_INT) |
---|
| 565 | ctx->ga.MutateBoundedFlag = PGA_FALSE; |
---|
| 566 | |
---|
| 567 | if ( ctx->ga.NoDuplicates == PGA_UNINITIALIZED_INT) |
---|
| 568 | ctx->ga.NoDuplicates = PGA_FALSE; |
---|
| 569 | |
---|
| 570 | if ( ctx->ga.NoDuplicates && ((ctx->ga.StoppingRule & PGA_STOP_TOOSIMILAR) |
---|
| 571 | == PGA_STOP_TOOSIMILAR)) |
---|
| 572 | PGAError(ctx, "PGASetUp: No Duplicates inconsistent with Stopping " |
---|
| 573 | "Rule:", PGA_FATAL, PGA_INT, (void *) &ctx->ga.StoppingRule); |
---|
| 574 | |
---|
| 575 | if ( ctx->ga.CrossoverProb == PGA_UNINITIALIZED_DOUBLE) |
---|
| 576 | ctx->ga.CrossoverProb = 0.85; |
---|
| 577 | |
---|
| 578 | if ( ctx->ga.UniformCrossProb == PGA_UNINITIALIZED_DOUBLE) |
---|
| 579 | ctx->ga.UniformCrossProb = 0.6; |
---|
| 580 | |
---|
| 581 | if ( ctx->ga.PTournamentProb == PGA_UNINITIALIZED_DOUBLE) |
---|
| 582 | ctx->ga.PTournamentProb = 0.6; |
---|
| 583 | |
---|
| 584 | if ( ctx->ga.FitnessRankMax == PGA_UNINITIALIZED_DOUBLE) |
---|
| 585 | ctx->ga.FitnessRankMax = 1.2; |
---|
| 586 | |
---|
| 587 | if ( ctx->ga.FitnessCmaxValue == PGA_UNINITIALIZED_DOUBLE) |
---|
| 588 | ctx->ga.FitnessCmaxValue = 1.01; |
---|
| 589 | |
---|
| 590 | if ( ctx->ga.PopReplace == PGA_UNINITIALIZED_INT) |
---|
| 591 | ctx->ga.PopReplace = PGA_POPREPL_BEST; |
---|
| 592 | |
---|
| 593 | if ( ctx->ga.restart == PGA_UNINITIALIZED_INT) |
---|
| 594 | ctx->ga.restart = PGA_FALSE; |
---|
| 595 | |
---|
| 596 | if ( ctx->ga.restartFreq == PGA_UNINITIALIZED_INT) |
---|
| 597 | ctx->ga.restartFreq = 50; |
---|
| 598 | |
---|
| 599 | if ( ctx->ga.restartAlleleProb == PGA_UNINITIALIZED_DOUBLE) |
---|
| 600 | ctx->ga.restartAlleleProb = 0.5; |
---|
| 601 | |
---|
| 602 | |
---|
| 603 | /* ops */ |
---|
| 604 | /* If no user supplied "done" function, use the built in one. |
---|
| 605 | * No need to check EndOfGen; they only get called if they |
---|
| 606 | * are defined. |
---|
| 607 | */ |
---|
| 608 | if (((void *)ctx->cops.StopCond == (void *)PGADone) || |
---|
| 609 | ((void *)ctx->fops.StopCond == (void *)PGADone)) |
---|
| 610 | PGAError( ctx, |
---|
| 611 | "PGASetUp: Using PGADone as the user stopping condition will" |
---|
| 612 | " result in an infinite loop!", PGA_FATAL, PGA_VOID, NULL); |
---|
| 613 | |
---|
| 614 | switch (ctx->ga.datatype) { |
---|
| 615 | case PGA_DATATYPE_BINARY: |
---|
| 616 | CreateString = PGABinaryCreateString; |
---|
| 617 | BuildDatatype = PGABinaryBuildDatatype; |
---|
| 618 | Mutation = PGABinaryMutation; |
---|
| 619 | |
---|
| 620 | switch (ctx->ga.CrossoverType) { |
---|
| 621 | case PGA_CROSSOVER_ONEPT: |
---|
| 622 | Crossover = PGABinaryOneptCrossover; |
---|
| 623 | break; |
---|
| 624 | case PGA_CROSSOVER_TWOPT: |
---|
| 625 | Crossover = PGABinaryTwoptCrossover; |
---|
| 626 | break; |
---|
| 627 | case PGA_CROSSOVER_UNIFORM: |
---|
| 628 | Crossover = PGABinaryUniformCrossover; |
---|
| 629 | break; |
---|
| 630 | } |
---|
| 631 | PrintString = PGABinaryPrintString; |
---|
| 632 | CopyString = PGABinaryCopyString; |
---|
| 633 | Duplicate = PGABinaryDuplicate; |
---|
| 634 | InitString = PGABinaryInitString; |
---|
| 635 | break; |
---|
| 636 | case PGA_DATATYPE_INTEGER: |
---|
| 637 | CreateString = PGAIntegerCreateString; |
---|
| 638 | BuildDatatype = PGAIntegerBuildDatatype; |
---|
| 639 | Mutation = PGAIntegerMutation; |
---|
| 640 | switch (ctx->ga.CrossoverType) { |
---|
| 641 | case PGA_CROSSOVER_ONEPT: |
---|
| 642 | Crossover = PGAIntegerOneptCrossover; |
---|
| 643 | break; |
---|
| 644 | case PGA_CROSSOVER_TWOPT: |
---|
| 645 | Crossover = PGAIntegerTwoptCrossover; |
---|
| 646 | break; |
---|
| 647 | case PGA_CROSSOVER_UNIFORM: |
---|
| 648 | Crossover = PGAIntegerUniformCrossover; |
---|
| 649 | break; |
---|
| 650 | } |
---|
| 651 | PrintString = PGAIntegerPrintString; |
---|
| 652 | CopyString = PGAIntegerCopyString; |
---|
| 653 | Duplicate = PGAIntegerDuplicate; |
---|
| 654 | InitString = PGAIntegerInitString; |
---|
| 655 | break; |
---|
| 656 | case PGA_DATATYPE_REAL: |
---|
| 657 | CreateString = PGARealCreateString; |
---|
| 658 | BuildDatatype = PGARealBuildDatatype; |
---|
| 659 | Mutation = PGARealMutation; |
---|
| 660 | switch (ctx->ga.CrossoverType) { |
---|
| 661 | case PGA_CROSSOVER_ONEPT: |
---|
| 662 | Crossover = PGARealOneptCrossover; |
---|
| 663 | break; |
---|
| 664 | case PGA_CROSSOVER_TWOPT: |
---|
| 665 | Crossover = PGARealTwoptCrossover; |
---|
| 666 | break; |
---|
| 667 | case PGA_CROSSOVER_UNIFORM: |
---|
| 668 | Crossover = PGARealUniformCrossover; |
---|
| 669 | break; |
---|
| 670 | } |
---|
| 671 | PrintString = PGARealPrintString; |
---|
| 672 | CopyString = PGARealCopyString; |
---|
| 673 | Duplicate = PGARealDuplicate; |
---|
| 674 | InitString = PGARealInitString; |
---|
| 675 | break; |
---|
| 676 | case PGA_DATATYPE_CHARACTER: |
---|
| 677 | CreateString = PGACharacterCreateString; |
---|
| 678 | BuildDatatype = PGACharacterBuildDatatype; |
---|
| 679 | Mutation = PGACharacterMutation; |
---|
| 680 | switch (ctx->ga.CrossoverType) { |
---|
| 681 | case PGA_CROSSOVER_ONEPT: |
---|
| 682 | Crossover = PGACharacterOneptCrossover; |
---|
| 683 | break; |
---|
| 684 | case PGA_CROSSOVER_TWOPT: |
---|
| 685 | Crossover = PGACharacterTwoptCrossover; |
---|
| 686 | break; |
---|
| 687 | case PGA_CROSSOVER_UNIFORM: |
---|
| 688 | Crossover = PGACharacterUniformCrossover; |
---|
| 689 | break; |
---|
| 690 | } |
---|
| 691 | PrintString = PGACharacterPrintString; |
---|
| 692 | CopyString = PGACharacterCopyString; |
---|
| 693 | Duplicate = PGACharacterDuplicate; |
---|
| 694 | InitString = PGACharacterInitString; |
---|
| 695 | break; |
---|
| 696 | case PGA_DATATYPE_USER: |
---|
| 697 | if (ctx->cops.CreateString == NULL) |
---|
| 698 | PGAError( ctx, |
---|
| 699 | "PGASetUp: User datatype needs CreateString function:", |
---|
| 700 | PGA_WARNING, PGA_INT, (void *) &err ); |
---|
| 701 | if (ctx->cops.Mutation == NULL) |
---|
| 702 | PGAError( ctx, |
---|
| 703 | "PGASetUp: User datatype needs Mutation function:", |
---|
| 704 | PGA_WARNING, PGA_INT, (void *) &err ); |
---|
| 705 | if (ctx->cops.Crossover == NULL) |
---|
| 706 | PGAError( ctx, |
---|
| 707 | "PGASetUp: User datatype needs Crossover function:", |
---|
| 708 | PGA_WARNING, PGA_INT, (void *) &err ); |
---|
| 709 | if (ctx->cops.PrintString == NULL) |
---|
| 710 | PGAError( ctx, |
---|
| 711 | "PGASetUp: User datatype needs PrintString function:", |
---|
| 712 | PGA_WARNING, PGA_INT, (void *) &err ); |
---|
| 713 | if (ctx->cops.Duplicate == NULL) |
---|
| 714 | PGAError( ctx, |
---|
| 715 | "PGASetUp: User datatype needs Duplicate function:", |
---|
| 716 | PGA_WARNING, PGA_INT, (void *) &err ); |
---|
| 717 | if (ctx->cops.CopyString == NULL) |
---|
| 718 | PGAError( ctx, |
---|
| 719 | "PGASetUp: User datatype needs CopyString function:", |
---|
| 720 | PGA_WARNING, PGA_INT, (void *) &err ); |
---|
| 721 | if (ctx->cops.BuildDatatype == NULL) |
---|
| 722 | PGAError(ctx, |
---|
| 723 | "PGASetUp: User datatype needs BuildDatatype " |
---|
| 724 | "function:", PGA_FATAL, PGA_INT, (void *) &err ); |
---|
| 725 | break; |
---|
| 726 | } |
---|
| 727 | if ((ctx->cops.Mutation == NULL) && (ctx->fops.Mutation == NULL)) |
---|
| 728 | ctx->cops.Mutation = Mutation; |
---|
| 729 | if ((ctx->cops.Crossover == NULL) && (ctx->fops.Crossover == NULL)) |
---|
| 730 | ctx->cops.Crossover = Crossover; |
---|
| 731 | if ((ctx->cops.PrintString == NULL) && (ctx->fops.PrintString == NULL)) |
---|
| 732 | ctx->cops.PrintString = PrintString; |
---|
| 733 | if ((ctx->cops.Duplicate == NULL) && (ctx->fops.Duplicate == NULL)) |
---|
| 734 | ctx->cops.Duplicate = Duplicate; |
---|
| 735 | if ((ctx->cops.InitString == NULL) && (ctx->fops.InitString == NULL)) |
---|
| 736 | ctx->cops.InitString = InitString; |
---|
| 737 | if (ctx->cops.CreateString == NULL) |
---|
| 738 | ctx->cops.CreateString = CreateString; |
---|
| 739 | if (ctx->cops.CopyString == NULL) |
---|
| 740 | ctx->cops.CopyString = CopyString; |
---|
| 741 | if (ctx->cops.BuildDatatype == NULL) |
---|
| 742 | ctx->cops.BuildDatatype = BuildDatatype; |
---|
| 743 | |
---|
| 744 | /* par */ |
---|
| 745 | if ( ctx->par.NumIslands == PGA_UNINITIALIZED_INT) |
---|
| 746 | ctx->par.NumIslands = 1; |
---|
| 747 | if ( ctx->par.NumDemes == PGA_UNINITIALIZED_INT) |
---|
| 748 | ctx->par.NumDemes = 1; |
---|
| 749 | if ( ctx->par.DefaultComm == (MPI_Comm) NULL ) |
---|
| 750 | ctx->par.DefaultComm = MPI_COMM_WORLD; |
---|
| 751 | |
---|
| 752 | |
---|
| 753 | |
---|
| 754 | /* rep */ |
---|
| 755 | if ( ctx->rep.PrintFreq == PGA_UNINITIALIZED_INT) |
---|
| 756 | ctx->rep.PrintFreq = 10; |
---|
| 757 | |
---|
| 758 | /* sys */ |
---|
| 759 | /* no more sets necessary here. */ |
---|
| 760 | |
---|
| 761 | /* debug */ |
---|
| 762 | |
---|
| 763 | /* init */ |
---|
| 764 | if ( ctx->init.RandomInit == PGA_UNINITIALIZED_INT) |
---|
| 765 | ctx->init.RandomInit = PGA_TRUE; |
---|
| 766 | |
---|
| 767 | if ( ctx->init.BinaryProbability == PGA_UNINITIALIZED_DOUBLE) |
---|
| 768 | ctx->init.BinaryProbability = 0.5; |
---|
| 769 | |
---|
| 770 | if ( ctx->init.RealType == PGA_UNINITIALIZED_INT) |
---|
| 771 | ctx->init.RealType = PGA_RINIT_RANGE; |
---|
| 772 | if ( ctx->init.IntegerType == PGA_UNINITIALIZED_INT) |
---|
| 773 | ctx->init.IntegerType = PGA_IINIT_PERMUTE; |
---|
| 774 | if ( ctx->init.CharacterType == PGA_UNINITIALIZED_INT) |
---|
| 775 | ctx->init.CharacterType = PGA_CINIT_LOWER; |
---|
| 776 | |
---|
| 777 | switch (ctx->ga.datatype) |
---|
| 778 | { |
---|
| 779 | case PGA_DATATYPE_INTEGER: |
---|
| 780 | for (i = 0; i < ctx->ga.StringLen; i++) |
---|
| 781 | { |
---|
| 782 | if (ctx->init.IntegerMin[i] == PGA_UNINITIALIZED_INT) |
---|
| 783 | ctx->init.IntegerMin[i] = 0; |
---|
| 784 | if (ctx->init.IntegerMax[i] == PGA_UNINITIALIZED_INT) |
---|
| 785 | ctx->init.IntegerMax[i] = ctx->ga.StringLen - 1; |
---|
| 786 | } |
---|
| 787 | break; |
---|
| 788 | case PGA_DATATYPE_REAL: |
---|
| 789 | for (i = 0; i < ctx->ga.StringLen; i++) |
---|
| 790 | { |
---|
| 791 | if (ctx->init.RealMin[i] == PGA_UNINITIALIZED_DOUBLE) |
---|
| 792 | ctx->init.RealMin[i] = 0.; |
---|
| 793 | if (ctx->init.RealMax[i] == PGA_UNINITIALIZED_DOUBLE) |
---|
| 794 | ctx->init.RealMax[i] = 1.; |
---|
| 795 | } |
---|
| 796 | break; |
---|
| 797 | } |
---|
| 798 | |
---|
| 799 | /* If a seed was not specified, get one from a time of day call */ |
---|
| 800 | if ( ctx->init.RandomSeed == PGA_UNINITIALIZED_INT) |
---|
| 801 | ctx->init.RandomSeed = (int)time(NULL); |
---|
| 802 | |
---|
| 803 | /* seed random number generator with this process' unique seed */ |
---|
| 804 | ctx->init.RandomSeed += PGAGetRank(ctx, MPI_COMM_WORLD); |
---|
| 805 | PGARandom01( ctx, ctx->init.RandomSeed ); |
---|
| 806 | |
---|
| 807 | ctx->ga.selected = (int *)malloc( sizeof(int) * ctx->ga.PopSize ); |
---|
| 808 | if (ctx->ga.selected == NULL) |
---|
| 809 | PGAError(ctx, "PGASetUp: No room to allocate ctx->ga.selected", |
---|
| 810 | PGA_FATAL, PGA_VOID, NULL); |
---|
| 811 | |
---|
| 812 | ctx->ga.sorted = (int *)malloc( sizeof(int) * ctx->ga.PopSize ); |
---|
| 813 | if (ctx->ga.sorted == NULL) |
---|
| 814 | PGAError(ctx, "PGASetUp: No room to allocate ctx->ga.sorted", |
---|
| 815 | PGA_FATAL, PGA_VOID, NULL); |
---|
| 816 | |
---|
| 817 | ctx->scratch.intscratch = (int *)malloc( sizeof(int) * ctx->ga.PopSize ); |
---|
| 818 | if (ctx->scratch.intscratch == NULL) |
---|
| 819 | PGAError(ctx, "PGASetUp: No room to allocate ctx->scratch.intscratch", |
---|
| 820 | PGA_FATAL, PGA_VOID, NULL); |
---|
| 821 | |
---|
| 822 | ctx->scratch.dblscratch = (double *)malloc(sizeof(double) * ctx->ga.PopSize); |
---|
| 823 | if (ctx->scratch.dblscratch == NULL) |
---|
| 824 | PGAError(ctx, "PGASetUp: No room to allocate ctx->scratch.dblscratch", |
---|
| 825 | PGA_FATAL, PGA_VOID, NULL); |
---|
| 826 | |
---|
| 827 | PGACreatePop ( ctx , PGA_OLDPOP ); |
---|
| 828 | PGACreatePop ( ctx , PGA_NEWPOP ); |
---|
| 829 | |
---|
| 830 | ctx->rep.starttime = time(NULL); |
---|
| 831 | |
---|
| 832 | PGADebugExited("PGASetUp"); |
---|
| 833 | } |
---|
| 834 | |
---|
| 835 | /*U**************************************************************************** |
---|
| 836 | PGASetRandomInitFlag - A boolean flag to indicate whether to randomly |
---|
| 837 | initialize alleles. Legal values are PGA_TRUE and PGA_FALSE. Default |
---|
| 838 | is PGA_TRUE -- randomly initialize alleles. |
---|
| 839 | |
---|
| 840 | Category: Initialization |
---|
| 841 | |
---|
| 842 | Inputs: |
---|
| 843 | ctx - context variable |
---|
| 844 | flag - either PGA_TRUE or PGA_FALSE |
---|
| 845 | |
---|
| 846 | Outputs: |
---|
| 847 | None |
---|
| 848 | |
---|
| 849 | Example: |
---|
| 850 | Set the initialization routine to initialize all alleles to zero |
---|
| 851 | |
---|
| 852 | PGAContext *ctx; |
---|
| 853 | : |
---|
| 854 | PGASetRandomInitFlag(ctx,PGA_FALSE); |
---|
| 855 | |
---|
| 856 | ****************************************************************************U*/ |
---|
| 857 | void PGASetRandomInitFlag(PGAContext *ctx, int RandomBoolean) |
---|
| 858 | { |
---|
| 859 | PGADebugEntered("PGASetRandomInitFlag"); |
---|
| 860 | PGAFailIfSetUp("PGASetRandomInitFlag"); |
---|
| 861 | |
---|
| 862 | switch (RandomBoolean) { |
---|
| 863 | case PGA_TRUE: |
---|
| 864 | case PGA_FALSE: |
---|
| 865 | ctx->init.RandomInit = RandomBoolean; |
---|
| 866 | break; |
---|
| 867 | default: |
---|
| 868 | PGAError(ctx, "PGASetRandomInitFlag: Invalid value of RandomBoolean:", |
---|
| 869 | PGA_FATAL, PGA_INT, (void *) &RandomBoolean); |
---|
| 870 | break; |
---|
| 871 | } |
---|
| 872 | PGADebugExited("PGASetRandomInitFlag"); |
---|
| 873 | } |
---|
| 874 | |
---|
| 875 | /*U*************************************************************************** |
---|
| 876 | PGAGetRandomInitFlag - returns true/false to indicate whether or not |
---|
| 877 | alleles are randomly initialized. |
---|
| 878 | |
---|
| 879 | Category: Initialization |
---|
| 880 | |
---|
| 881 | Inputs: |
---|
| 882 | ctx - context variable |
---|
| 883 | |
---|
| 884 | Outputs: |
---|
| 885 | Returns PGA_TRUE if alleles are randomly initialized. |
---|
| 886 | Otherwise, returns PGA_FALSE |
---|
| 887 | |
---|
| 888 | Example: |
---|
| 889 | PGAContext *ctx; |
---|
| 890 | int raninit; |
---|
| 891 | : |
---|
| 892 | raninit = PGAGetRandomInitFlag(ctx); |
---|
| 893 | switch (raninit) { |
---|
| 894 | case PGA_TRUE: |
---|
| 895 | printf("Population is randomly initialized\n"); |
---|
| 896 | break; |
---|
| 897 | case PGA_FALSE: |
---|
| 898 | printf("Population initialized to zero\n"); |
---|
| 899 | break; |
---|
| 900 | } |
---|
| 901 | |
---|
| 902 | ***************************************************************************U*/ |
---|
| 903 | int PGAGetRandomInitFlag (PGAContext *ctx) |
---|
| 904 | { |
---|
| 905 | PGADebugEntered("PGAGetRandomInitFlag"); |
---|
| 906 | |
---|
| 907 | PGAFailIfNotSetUp("PGAGetRandomInitFlag"); |
---|
| 908 | |
---|
| 909 | PGADebugExited("PGAGetRandomInitFlag"); |
---|
| 910 | |
---|
| 911 | return(ctx->init.RandomInit); |
---|
| 912 | } |
---|
| 913 | |
---|
| 914 | |
---|
| 915 | /*I**************************************************************************** |
---|
| 916 | PGACreatePop - allocates a population of individuals and calls |
---|
| 917 | PGACreateIndividual to set up each one |
---|
| 918 | |
---|
| 919 | Inputs: |
---|
| 920 | ctx - context variable |
---|
| 921 | pop - symbolic constant of the population to create |
---|
| 922 | |
---|
| 923 | Outputs: |
---|
| 924 | None |
---|
| 925 | |
---|
| 926 | Example: |
---|
| 927 | PGAContext *ctx; |
---|
| 928 | : |
---|
| 929 | PGACreatePop(ctx, PGA_NEWPOP); |
---|
| 930 | |
---|
| 931 | ****************************************************************************I*/ |
---|
| 932 | void PGACreatePop (PGAContext *ctx, int pop) |
---|
| 933 | { |
---|
| 934 | int p, flag=0; |
---|
| 935 | |
---|
| 936 | PGADebugEntered("PGACreatePop"); |
---|
| 937 | |
---|
| 938 | switch (pop) |
---|
| 939 | { |
---|
| 940 | case PGA_OLDPOP: |
---|
| 941 | ctx->ga.oldpop = (PGAIndividual *)malloc(sizeof(PGAIndividual) * |
---|
| 942 | (ctx->ga.PopSize + 3)); |
---|
| 943 | if (ctx->ga.oldpop == NULL) |
---|
| 944 | PGAError(ctx, "PGACreatePop: No room to allocate " |
---|
| 945 | "ctx->ga.oldpop", PGA_FATAL, PGA_VOID, NULL); |
---|
| 946 | flag = ctx->init.RandomInit; |
---|
| 947 | break; |
---|
| 948 | case PGA_NEWPOP: |
---|
| 949 | ctx->ga.newpop = (PGAIndividual *)malloc(sizeof(PGAIndividual) * |
---|
| 950 | (ctx->ga.PopSize + 3)); |
---|
| 951 | if (ctx->ga.newpop == NULL) |
---|
| 952 | PGAError(ctx, "PGACreatePop: No room to allocate " |
---|
| 953 | "ctx->ga.newpop", PGA_FATAL, PGA_VOID, NULL); |
---|
| 954 | flag = PGA_FALSE; |
---|
| 955 | break; |
---|
| 956 | default: |
---|
| 957 | PGAError(ctx, "PGACreatePop: Invalid value of pop:", PGA_FATAL, |
---|
| 958 | PGA_INT, (void *) &pop ); |
---|
| 959 | break; |
---|
| 960 | }; |
---|
| 961 | for (p = 0; p < ctx->ga.PopSize; p++) |
---|
| 962 | PGACreateIndividual (ctx, p, pop, flag); |
---|
| 963 | PGACreateIndividual (ctx, PGA_TEMP1, pop, PGA_FALSE); |
---|
| 964 | PGACreateIndividual (ctx, PGA_TEMP2, pop, PGA_FALSE); |
---|
| 965 | PGACreateIndividual (ctx, PGA_TEMP3, pop, PGA_FALSE); |
---|
| 966 | |
---|
| 967 | |
---|
| 968 | PGADebugExited("PGACreatePop"); |
---|
| 969 | } |
---|
| 970 | |
---|
| 971 | |
---|
| 972 | /*I**************************************************************************** |
---|
| 973 | PGACreateIndividual - initialize to zero various data structures of an |
---|
| 974 | individual and call the appropriate function to create and initialize the |
---|
| 975 | string for the specific data type |
---|
| 976 | |
---|
| 977 | Inputs: |
---|
| 978 | ctx - context variable |
---|
| 979 | p - string index |
---|
| 980 | pop - symbolic constant of the population string p is in |
---|
| 981 | initflag - if the value is PGA_TRUE, the string is randomly initialized. |
---|
| 982 | Otherwise it is set to zero. |
---|
| 983 | |
---|
| 984 | Outputs: |
---|
| 985 | None |
---|
| 986 | |
---|
| 987 | Example: |
---|
| 988 | PGAContext *ctx; |
---|
| 989 | int p; |
---|
| 990 | : |
---|
| 991 | PGACreateIndividual(ctx, p, PGA_NEWPOP, PGA_TRUE); |
---|
| 992 | |
---|
| 993 | ****************************************************************************I*/ |
---|
| 994 | void PGACreateIndividual (PGAContext *ctx, int p, int pop, int initflag) |
---|
| 995 | { |
---|
| 996 | PGAIndividual *ind = PGAGetIndividual(ctx, p, pop); |
---|
| 997 | |
---|
| 998 | PGADebugEntered("PGACreateIndividual"); |
---|
| 999 | |
---|
| 1000 | ind->evalfunc = 0.0; |
---|
| 1001 | ind->fitness = 0.0; |
---|
| 1002 | ind->evaluptodate = PGA_FALSE; |
---|
| 1003 | ind->UserData = NULL; |
---|
| 1004 | |
---|
| 1005 | (*ctx->cops.CreateString)(ctx, p, pop, initflag); |
---|
| 1006 | |
---|
| 1007 | PGADebugExited("PGACreateIndividual"); |
---|
| 1008 | } |
---|
| 1009 | |
---|