Function Groups Standard API

Allele Access

group allele

Functions for getting and setting allele values.

Functions

void PGAEncodeIntegerAsBinary(PGAContext *ctx, int p, int pop, int start, int end, unsigned int val)

Encode an integer value as a binary string.

Example

Encode an integer 7 in 20 bits in bit positions 0–19 in string p in population PGA_NEWPOP.

PGAContext *ctx;
int p;

...
PGAEncodeIntegerAsBinary (ctx, p, PGA_NEWPOP, 0, 19, 7);

Parameters:

ctx – context variable
p – string index
pop – symbolic constant of the population the string is in
start – starting bit position in p to encode val in
end – ending bit position in p to encode val in
val – the integer value to be represented as a binary string

Returns:

The string is modified by side-effect

void PGAEncodeIntegerAsGrayCode(PGAContext *ctx, int p, int pop, int start, int end, unsigned int val)

Encode a real value as a binary reflected Gray code sequence.

Example

Encode an integer 7 in 20 bits in bit positions 0–19 in string p in population PGA_NEWPOP using Gray code.

PGAContext *ctx;
int p;

...
PGAEncodeIntegerAsGrayCode (ctx, p, PGA_NEWPOP, 0, 19, 7);

Parameters:

ctx – context variable
p – string index
pop – symbolic constant of the population the string is in
start – starting bit position in p to encode val in
end – ending bit position in p to encode val in
val – the integer value to be represented as a binary reflected Gray code sequence

Returns:

The string is modified by side-effect

void PGAEncodeRealAsBinary(PGAContext *ctx, int p, int pop, int start, int end, double low, double high, double val)

Encode a real value as a binary string.

Example

Encode 3.14 from the interval \([0,10]\) in 30 bits in bit positions 0–29 in string p in population PGA_NEWPOP.

PGAContext *ctx;
int p;

...
PGAEncodeRealAsBinary (ctx, p, PGA_NEWPOP, 0, 29, 0.0, 10.0, 3.14);

Parameters:

ctx – context variable
p – string index
pop – symbolic constant of the population the string is in
start – starting bit position in p to encode val in
end – ending bit position in p to encode val in
low – lower bound of the interval the val is defined on
high – upper bound of the interval the val is defined on
val – the real number to be represented as a binary string

Returns:

The string is modified by side-effect

void PGAEncodeRealAsGrayCode(PGAContext *ctx, int p, int pop, int start, int end, double low, double high, double val)

Encode a real value as a binary reflected Gray code sequence.

Example

Encode 3.14 from the interval \([0,10]\) in 30 bits in bit positions 0–29 in string p in population PGA_NEWPOP as a binary reflected Gray code sequence.

PGAContext *ctx;
int p;

...
PGAEncodeRealAsGrayCode (ctx, p, PGA_NEWPOP, 0, 29, 0.0, 10.0, 3.14);

Parameters:

ctx – context variable
p – string index
pop – symbolic constant of the population the string is in
start – starting bit position in p to encode val in
end – ending bit position in p to encode val in
low – lower bound of the interval the val is defined on
high – upper bound of the interval the val is defined on
val – the real number to be represented as a binary string

Returns:

The string is modified by side-effect

int PGAGetBinaryAllele(PGAContext *ctx, int p, int pop, int i)

Return the value of a (binary) allele.

Description

Applies to the binary data type, set with parameter PGA_DATATYPE_BINARY of PGACreate().

Example

Copies the alleles from member p in PGA_OLDPOP to member q PGA_NEWPOP. Assumes the strings are of the same length.

PGAContext *ctx;
int p, q, i;

...
for (i=PGAGetStringLength (ctx)-1; i>=0; i--) {
    int a = PGAGetBinaryAllele (ctx, p, PGA_OLDPOP, i);
    PGASetBinaryAllele (ctx, q, PGA_NEWPOP, i, a);
}

Parameters:

ctx – context variable
p – string index
pop – symbolic constant of the population the string is in
i – allele index

Returns:

The value of the ith allele of string p in population pop

char PGAGetCharacterAllele(PGAContext *ctx, int p, int pop, int i)

Return the value of character allele in a string of the character data type.

Example

Copies the alleles from member p in PGA_OLDPOP to member q in PGA_NEWPOP. Assumes the strings are of the same length.

PGAContext *ctx;
int p, q, i;
int l;

...
l = PGAGetStringLength (ctx);
for (i=0; i<l; i++) {
    char a = PGAGetCharacterAllele (ctx, p, PGA_OLDPOP, i);
    PGASetCharacterAllele (ctx, q, PGA_NEWPOP, i, a);
}

Parameters:

ctx – context variable
p – string index
pop – symbolic constant of the population the string is in
i – allele index

Returns:

The value of allele i in string p

PGAIndividual *PGAGetIndividual(PGAContext *ctx, int p, int pop)

Return individual defined by population symbolic constant and population index.

Example

PGAIndividual *source;
PGAContext *ctx;
int p;

...
source = PGAGetIndividual (ctx, p, PGA_NEWPOP);

Parameters:

ctx – context variable
p – string index
pop – symbolic constant of the population the string is in

Returns:

Address of the PGAIndividual structure for string p in population pop

int PGAGetIntegerAllele(PGAContext *ctx, int p, int pop, int i)

Return the value of allele i of member p in population pop.

Description

Assumes the data type is PGA_DATATYPE_INTEGER.

Example

Returns the value of integer allele i of string p in population PGA_NEWPOP.

PGAContext *ctx;
int p, i, k;

...
k =  PGAGetIntegerAllele (ctx, p, PGA_NEWPOP, i)

Parameters:

ctx – context variable
p – string index
pop – symbolic constant of the population the string is in
i – allele index

Returns:

The value of allele i in string p

unsigned int PGAGetIntegerFromBinary(PGAContext *ctx, int p, int pop, int start, int end)

Interpret a binary string as encoding an integer value and return the integer value it represents.

Example

Get an integer j from bits 10–29 of string p in population PGA_NEWPOP.

PGAContext *ctx;
int j, p;

...
j = PGAGetIntegerFromBinary (ctx, p, PGA_NEWPOP, 10, 29);

Parameters:

ctx – context variable
p – string index
pop – symbolic constant of the population the string is in
start – starting bit position in the binary representation
end – ending bit position in the binary representation

Returns:

The integer value encoded by the binary string

unsigned int PGAGetIntegerFromGrayCode(PGAContext *ctx, int p, int pop, int start, int end)

Interpret a binary reflected Gray code sequence as encoding an integer value and return the integer value it represents.

Example

Get an integer j from bits 10–29 of string p in population PGA_NEWPOP. The string is encoded in Gray code.

PGAContext *ctx;
int j, p;

...
j = PGAGetIntegerFromGrayCode (ctx, p, PGA_NEWPOP, 10, 29);

Parameters:

ctx – context variable
p – string index
pop – symbolic constant of the population the string is in
start – starting bit position in the binary representation
end – ending bit position in the binary representation

Returns:

The integer value encoded by the binary reflected Gray code sequence

double PGAGetRealAllele(PGAContext *ctx, int p, int pop, int i)

Return the value of real-valued allele i in string p in population pop.

Example

Returns the value of real-valued allele i of string p in population PGA_NEWPOP

PGAContext *ctx;
int p, i
double d;

...
d = PGAGetRealAllele (ctx, p, PGA_NEWPOP, i);

Parameters:

ctx – context variable
p – string index
pop – symbolic constant of the population the string is in
i – allele index

Returns:

The value of allele i

double PGAGetRealFromBinary(PGAContext *ctx, int p, int pop, int start, int end, double lower, double upper)

Interpret a binary string as encoding a real value and return the real value it represents.

Example

Decode a real value from the string p in population PGA_NEWPOP. The value to decode lies on the interval \([-10,20]\) and is represented using the 20 bits in bit positions 10–29.

double x;

...
x = PGAGetRealFromBinary (ctx, p, PGA_NEWPOP, 10, 29, -10.0, 20.0);

Parameters:

ctx – context variable
p – string index
pop – symbolic constant of the population the string is in
start – starting bit position in the binary representation
end – ending bit position in the binary representation
lower – lower bound of the interval the real number is defined on
upper – upper bound of the interval the real number is defined on

Returns:

The real value encoded by the binary string

double PGAGetRealFromGrayCode(PGAContext *ctx, int p, int pop, int start, int end, double lower, double upper)

Interpret a binary reflected Gray code sequence in a binary string as encoding a real value and return the real value it represents.

Example

Decode a real value from the string p in population PGA_NEWPOP. The value to decode lies on the interval \([-10,20]\) and is represented using the 20 bits in bit positions 10–29.

double x;

...
x = PGAGetRealFromGrayCode (ctx, p, PGA_NEWPOP, 10, 29, -10.0, 20.0);

Parameters:

ctx – context variable
p – string index
pop – symbolic constant of the population the string is in
start – starting bit position in the binary representation
end – ending bit position in the binary representation
lower – lower bound of the interval the real number is defined on
upper – upper bound of the interval the real number is defined on

Returns:

The real value encoded by the binary reflected Gray code sequence

void PGASetBinaryAllele(PGAContext *ctx, int p, int pop, int i, int val)

Sets a binary allele to the specified value.

Example

Copies the alleles from member p in PGA_OLDPOP to member q in PGA_NEWPOP.

PGAContext *ctx;
int p, q, i;
int l;

...
l = PGAGetStringLength (ctx);
for (i=0 i<l; i++) {
    int a = PGAGetBinaryAllele (ctx, p, PGA_OLDPOP, i);
    PGASetBinaryAllele (ctx, q, PGA_NEWPOP, i, a);
}

Parameters:

ctx – context variable
p – string index
pop – symbolic constant of the population the string is in
i – allele index
val – binary value (either 1 or 0) to set the allele to

Returns:

The allele is changed by side-effect

void PGASetCharacterAllele(PGAContext *ctx, int p, int pop, int i, char val)

Sets the value of an allele in a string of the character data type.

Example

Copies the alleles from member p in PGA_OLDPOP to member q in PGA_NEWPOP. Assumes the strings are of the same length.

PGAContext *ctx;
int p, q, i;
int l;

...
l = PGAGetStringLength (ctx);
for (i=0; i<l; i++) {
    char a = PGAGetCharacterAllele (ctx, p, PGA_OLDPOP, i);
    PGASetCharacterAllele (ctx, q, PGA_NEWPOP, i, a);
}

Parameters:

ctx – context variable
p – string index
pop – symbolic constant of the population the string is in
i – allele index
val – character value to set the allele to

Returns:

The allele is changed by side-effect.

void PGASetIntegerAllele(PGAContext *ctx, int p, int pop, int i, int val)

Set the value of a (integer) allele.

Example

Set the value of allele i of string p in population PGA_NEWPOP to 64.

PGAContext *ctx;
int p, i;

...
PGASetIntegerAllele (ctx, p, PGA_NEWPOP, i, 64)

Parameters:

ctx – context variable
p – string index
pop – symbolic constant of the population the string is in
i – allele index
val – integer value to set the allele to

Returns:

None

void PGASetRealAllele(PGAContext *ctx, int p, int pop, int i, double val)

Set the value of real-valued allele i in string p in population pop.

Example

Sets the value of allele i of string p in population PGA_NEWPOP to 1.57

PGAContext *ctx;
int i, p;

...
PGASetRealAllele (ctx, p, PGA_NEWPOP, i, 1.57);

Parameters:

ctx – context variable
p – string index
pop – symbolic constant of the population the string is in
i – allele index
val – real value to set the allele to

Returns:

The specified allele in p is modified by side-effect.

Evaluation

group evaluation

Functions used during evaluation and fitness computation.

Functions

void PGAFitness(PGAContext *ctx, int popindex)

Map the user’s evaluation function value to a fitness value.

Description

First, the user’s evaluation function value is translated to all positive values if any are negative. Next, this positive sequence is translated to a maximization problem if the user’s optimization direction was minimization. This positive sequence is then mapped to a fitness value using linear ranking, linear normalization fitness, or the identity (i.e., the evaluation function value). See Constants for Fitness Types in the user guide for allowed values. This routine is usually used after PGAEvaluate() is called.

Example

Calculate the fitness of all strings in population PGA_NEWPOP after calling PGAEvaluate() to calculate the strings evaluation value.

double energy (PGAContext *ctx, int p, int pop, double *aux);
PGAContext *ctx;
MPI_Comm comm;

...
PGAEvaluate (ctx, PGA_NEWPOP, energy, comm);
PGAFitness  (ctx, PGA_NEWPOP);

Parameters:

ctx – context variable
popindex – symbolic constant of the population to calculate fitness for

Returns:

Calculate the fitness for each string in the population via side effect

double *PGAGetAuxEvaluation(PGAContext *ctx, int p, int pop)

Return the auxiliary evaluation for string p in population pop.

Description

This is mostly used internally: the evaluation function will get a pointer to this anyway, this is the only point where the aux evaluations should be modified.

Example

PGAContext *ctx;
int p;
double *aux;

...
aux = PGAGetAuxEvaluation (ctx, p, PGA_NEWPOP);

Parameters:

ctx – context variable
p – string index
pop – symbolic constant of the population the string is in

Returns:

The evaluation function value for string p in population pop

int PGAGetEvaluationUpToDateFlag(PGAContext *ctx, int p, int pop)

Return boolean to indicate whether the evaluate function value is up to date.

Example

PGAContext *ctx;

...
if (PGAGetEvaluationUpToDateFlag (ctx)) {
    printf ("Evaluation function value current\n");
} else {
    printf ("Evaluation function value out-of-date\n");
}

Parameters:

ctx – context variable
p – string index
pop – symbolic constant of the population the string is in

Returns:

Return true if the evaluate function value is up to date

double PGAGetFitness(PGAContext *ctx, int p, int pop)

Return the fitness value for a string.

Example

PGAContext *ctx;
int p;
double fit;

...
fit = PGAGetFitness (ctx, p, PGA_NEWPOP);

Parameters:

ctx – context variable
p – string index
pop – symbolic constant of the population the string is in

Returns:

The fitness value for string p in population pop

int PGARank(PGAContext *ctx, int p, int *order, int n)

Return the rank of a string in a population.

Description

This is a value between 1,…,N (the population size). The most fit string has rank 1, the least fit string has rank N.

Example

Determine the rank of string p.

PGAContext *ctx;
int i, popsize, rank;
int popsize = PGAGetPopsize (ctx)
int order [popsize];

...
PGAEvalSort (ctx, pop, order);
rank = PGARank (ctx, p, order, popsize)

Parameters:

ctx – context variable
p – the index of the string whose rank is desired
order – an array containing a unique rank for each string
n – the size of the array order

Returns:

The rank of string p

void PGASetEvaluationUpToDateFlag(PGAContext *ctx, int p, int pop, int status)

Set the flag to indicate whether the evaluate function value is up-to-date or not.

Description

Note that this flag is always set to PGA_TRUE when _PGASetEvaluation() is called.

Example

Set the evaluation function flag for string p in population PGA_NEWPOP to PGA_FALSE (as might happen after, for example, calling a hill-climbing routine that modified this string).

PGAContext *ctx;
int p;

...
PGASetEvaluationUpToDateFlag (ctx, p, PGA_NEWPOP, PGA_FALSE);

Parameters:

ctx – context variable
p – string index
pop – symbolic constant of the population string p is in
status – boolean for whether up-to-date

Returns:

Sets the flag associated with the evaluation function value of string p via side effect

double _PGAGetEvaluation(PGAContext *ctx, int p, int pop, const double **aux)

Return the evaluation function value for string p in population pop and optionally a pointer to the auxiliary evaluations.

Description

This uses a trick for implementing optional arguments in C. The real function to use is without leading underscore. There is a macro that makes the last argument optional.

Example

PGAContext *ctx;
int p;
double eval;

...
eval = PGAGetEvaluation (ctx, p, PGA_NEWPOP);

or

const double *p;
...
eval = PGAGetEvaluation (ctx, p, PGA_NEWPOP, &p);

Parameters:

ctx – context variable
p – string index
pop – symbolic constant of the population the string is in
aux – Pointer to Auxiliary evaluations

Returns:

The evaluation function value for string p in population pop

void _PGASetEvaluation(PGAContext *ctx, int p, int pop, double val, const double *aux)

Set the evaluation function value for a string to a specified value.

Description

This uses a trick for implementing optional arguments in C. The real function to use is without leading underscore. There is a macro that makes the last argument optional. Also sets the evaluation up to date flag to PGA_TRUE.

Example

Set the evaluation function value of string p in population PGA_NEWPOP to 123.456.

PGAContext *ctx;
int p;
double aux [...];

...
PGASetEvaluation (ctx, p, PGA_NEWPOP, 123.456);

or

PGASetEvaluation (ctx, p, PGA_NEWPOP, 123.456, aux);

Parameters:

ctx – context variable
p – string index
pop – symbolic constant of the population string p is in
val – the (user) evaluation value to assign to string p
aux – Auxiliary evaluations

Returns:

Sets the evaluation function value of string p and the EvalUpToDate flag via side effect

Initialization

group init

Functions used to change initialization.

Functions

void PGASetBinaryInitProb(PGAContext *ctx, double p)

Specify the probability of initializing an allele to “1” for the binary data type.

Description

The default value is 0.5. This is used during string creation of a PGA_DATATYPE_BINARY string.

Example

Set approximately 1 percent of all binary alleles to “1” when randomly initializing the population.

PGAContext *ctx;

...
PGASetBinaryInitProb (ctx, 0.01);

Parameters:

ctx – context variable
p – the binary initialization probability

Returns:

None

void PGASetCharacterInitType(PGAContext *ctx, int value)

Sets a flag to specify whether the character strings will be exclusively lowercase, exclusively uppercase, or a mixure of both cases.

Description

Legal flags are PGA_CINIT_UPPER, PGA_CINIT_LOWER, and PGA_CINIT_MIXED. Default is PGA_CINIT_LOWER. See Constants for Random Initialization of Genes for the constants and section Initialization of the user guide for details.

Example

Set program to generate exclusively uppercase letters.

PGAContext *ctx;

...
PGASetCharacterInitType (ctx, PGA_CINIT_UPPER);

Parameters:

ctx – context variable
value – symbolic constant specifying which case

Returns:

None

void PGASetCommunicator(PGAContext *ctx, MPI_Comm comm)

Set the default communicator to use when PGARun is called.

Description

Does not necessarily need to be MPI_COMM_WORLD (which is the default).

Example

MPI_Comm mycomm;
PGAContext *ctx,
double f (PGAContext *ctx, int p, int pop, double *aux);

ctx = PGACreate (&argc, argv, PGA_DATATYPE_BINARY, 100, PGA_MAXIMIZE);
PGASetCommunicator (ctx, mycomm);
PGASetUp (ctx);
PGARun (ctx, f);
PGADestroy (ctx);

Parameters:

ctx – context variable
comm – communicator to use

Returns:

None

void PGASetCrossoverBounceBackFlag(PGAContext *ctx, int flag)

If this flag is set to true, then for Integer and Real strings with simulated binary crossover (SBX) crossed over values that exceed the bounds are confined to the bounds by bouncing them back to a random value between the boundary and the neares parent.

Example

PGAContext *ctx;

...
PGASetCrossoverBounceBackFlag (ctx, PGA_TRUE);

Parameters:

ctx – context variable
flag – to indicate whether out-of-range values should be bounced

Returns:

None

void PGASetCrossoverBoundedFlag(PGAContext *ctx, int flag)

If this flag is set to true, then for Integer and Real strings with simulated binary crossover (SBX) crossed over values that exceed the bounds are confined to the bounds by setting them to the boundary.

Example

PGAContext *ctx;

...
PGASetCrossoverBoundedFlag (ctx, PGA_TRUE);

Parameters:

ctx – context variable
flag – to indicate if strings should be constrained to boundary

Returns:

None

void PGASetCrossoverProb(PGAContext *ctx, double p)

Set Probability that a selected string will undergo crossover.

Description

The default is 0.85.

Example

Make crossover happen infrequently.

PGAContext *ctx;

...
PGASetCrossoverProb (ctx, 0.001);

Parameters:

ctx – context variable
p – the crossover probability

Returns:

None

void PGASetCrossoverSBXEta(PGAContext *ctx, double eta)

Set the eta parameter for simulated binary crossover (SBX).

Example

PGAContext *ctx;

...
PGASetCrossoverSBXEta (ctx, 10);

Parameters:

ctx – context variable
eta – eta >= 0

Returns:

None

void PGASetCrossoverSBXOncePerString(PGAContext *ctx, int val)

Compute random number for simulated binary crossover (SBX) polynomial distribution only once per string/individual.

Description

If set to PGA_TRUE all alleles will use the same value which means that the resulting string will point into the same direction as the vector between both parents. The default is PGA_FALSE indicating that a new random number is used for each string.

Example

PGAContext *ctx;

...
PGASetCrossoverSBXOncePerString (ctx, PGA_TRUE);

Parameters:

ctx – context variable
val – flag indicating if random number is computed once per string

Returns:

None

void PGASetCrossoverType(PGAContext *ctx, int crossover_type)

Specify the type of crossover to use.

Description

Valid choices are PGA_CROSSOVER_ONEPT, PGA_CROSSOVER_TWOPT, or PGA_CROSSOVER_UNIFORM, PGA_CROSSOVER_SBX, and PGA_CROSSOVER_EDGE for one-point, two-point, uniform, simulated binary (SBX), and edge crossover, respectively. The default is PGA_CROSSOVER_TWOPT. Edge crossover is only defined for integer genes and SBX is only defined for integer and real genes. See Crossover Constants for the constants and section Crossover in the user guide for details.

Example

Use uniform crossover when crossingover strings.

PGAContext *ctx;

...
PGASetCrossoverType (ctx, PGA_CROSSOVER_UNIFORM);

Parameters:

ctx – context variable
crossover_type – symbolic constant to specify crossover type

Returns:

None

void PGASetDEAuxFactor(PGAContext *ctx, double val)

Set the auxiliary factor K for Differential Evolution.

Description

The default for the aux factor \(K\) of Differential Evolution is \(0.5 * (F + 1)\) where \(F\) is the Differential Evolution scale factor, see PGASetDEScaleFactor().

Example

PGAContext *ctx;

...
PGASetDEAuxFactor (ctx, 0.75);

Parameters:

ctx – context variable
val – the auxiliary factor

Returns:

None

void PGASetDECrossoverProb(PGAContext *ctx, double val)

Set the crossover probability for Differential Evolution.

Description

The default for the Differential Evolution crossover probability is 0.9.

Example

PGAContext *ctx;

...
PGASetDECrossoverProb (ctx, 0.75);

Parameters:

ctx – context variable
val – the crossover probability

Returns:

None

void PGASetDECrossoverType(PGAContext *ctx, int val)

Set the crossover type for Differential Evolution.

Description

Differential Evolution supports the crossover types PGA_DE_CROSSOVER_BIN and PGA_DE_CROSSOVER_EXP, the default is PGA_DE_CROSSOVER_BIN. See Differential Evolution Crossover Constants for the constants and section Mutation of the user guide for details.

Example

PGAContext *ctx;

...
PGASetDECrossoverType (ctx, PGA_DE_CROSSOVER_EXP);

Parameters:

ctx – context variable
val – the crossover type

Returns:

None

void PGASetDEDither(PGAContext *ctx, double val)

Set the Differential Evolution dither range (+/-).

Description

By default dither is turned off (the value is 0 by default). Quite large amounts (on the order of 0.5) are recommended for some problems like digital filter design. See section Mutation in the user guide for details.

Example

PGAContext *ctx;

...
PGASetDEDither (ctx, 0.5);

Parameters:

ctx – context variable
val – the dither range

Returns:

None

void PGASetDEDitherPerIndividual(PGAContext *ctx, int val)

Set if Differential Evolution dither is per individual.

Description

If this is set to PGA_TRUE, then for Differential Evolution if the dither value is non-zero we produce a new random value to add to the scale factor \(F\) for each individual. Otherwise if the flag is not set (PGA_FALSE), then we produce a new value in each generation, the same value for all individuals.

Example

PGAContext *ctx;

...
PGASetDEDitherPerIndividual (ctx, PGA_TRUE);

Parameters:

ctx – context variable
val – boolean flag

Returns:

None

void PGASetDEJitter(PGAContext *ctx, double val)

Set the jitter for Differential Evolution.

Description

By default jitter is turned off (the value is 0 by default). Very small amounts (on the order of 0.001) have been recommended for some problems like digital filter design. See section Mutation in the user guide for details.

Example

PGAContext *ctx;

...
PGASetDEJitter (ctx, 0.001);

Parameters:

ctx – context variable
val – the jitter for Differential Evolution

Returns:

None

void PGASetDENumDiffs(PGAContext *ctx, int val)

Set the number of differences for Differential Evolution.

Description

Some variants of Differential Evolution can specify the number of differences that go into the new value of an allele. By default this number is 1.

Example

PGAContext *ctx;

...
PGASetDENumDiffs (ctx, 2);

Parameters:

ctx – context variable
val – the number of differences

Returns:

None

void PGASetDEProbabilityEO(PGAContext *ctx, double val)

Set the either-or probability of Differential Evolution.

Description

The default for this probability is 0.5, it is only used when the either-or variant of Differential Evolution has been selected by calling PGASetDEVariant() with parameter PGA_DE_VARIANT_EITHER_OR.

Example

PGAContext *ctx;

...
PGASetDEProbabilityEO (ctx, 0.75);

Parameters:

ctx – context variable
val – the either-or probability

Returns:

None

void PGASetDEScaleFactor(PGAContext *ctx, double val)

Set the scale factor F for Differential Evolution.

Description

The default for the scale factor \(F\) is 0.9. For details see section Mutation in the user guide.

Example

PGAContext *ctx;

...
PGASetDEScaleFactor (ctx, 0.75);

Parameters:

ctx – context variable
val – the scale factor

Returns:

None

void PGASetDEVariant(PGAContext *ctx, int variant)

Set the variant used for Differential Evolution.

Description

Only used if the mutation type is Differential Evolution PGA_MUTATION_DE. The possible variants are PGA_DE_VARIANT_RAND, PGA_DE_VARIANT_BEST, and PGA_DE_VARIANT_EITHER_OR. See Constants for Differential Evolution Variants for the constants and section Mutation in the user guide for details.

Example

PGAContext *ctx;

...
PGASetDEVariant (ctx, PGA_DE_VARIANT_BEST);

Parameters:

ctx – context variable
variant – symbolic constant for variant

Returns:

None

void PGASetEpsilonExponent(PGAContext *ctx, double e)

Configure the exponent of the term computing the epsilon value in each generation.

Example

PGAContext *ctx;

...
PGASetEpsilonExponent (ctx, 5);

Parameters:

ctx – context variable
e – Exponent

Returns:

None

void PGASetEpsilonGeneration(PGAContext *ctx, int gen)

Configure the generation until which constraints are relaxed via the Epsilon Contraint method.

Description

The default is 0 (no Epsilon Contraint method is used). The parameter gen must be below the value set with PGASetMaxGAIterValue().

Example

PGAContext *ctx;

...
PGASetEpsilonGeneration (ctx, 50);

Parameters:

ctx – context variable
gen – Epsilon contraint generation

Returns:

None

void PGASetEpsilonTheta(PGAContext *ctx, int theta)

Set the theta generation value that is used for initializing the epsilon constraint.

Description

The initial population is sorted by constraint violation and the individual with index theta is used for initializing the initial epsilon for the epsilon constraint method.

Example

PGAContext *ctx;

...
PGASetEpsilonTheta (ctx, n);

Parameters:

ctx – context variable
theta – population index

Returns:

None

void PGASetFitnessCmaxValue(PGAContext *ctx, double val)

Set value of the multiplier used by MinCmax fitness algorithm so that the worst string has a nonzero fitness.

Description

The default value is 1.01.

Example

PGAContext *ctx;

...
PGASetFitnessCmaxValue (ctx, 1.2);

Parameters:

ctx – context variable
val – the value of the multiplier

Returns:

None

void PGASetFitnessMinType(PGAContext *ctx, int fitness_type)

Set the type of algorithm used if a minimization problem is specified to determine how values are remapped for maximization.

Description

Valid choices are PGA_FITNESSMIN_RECIPROCAL and PGA_FITNESSMIN_CMAX to do the mapping using the reciprocal of the evaluation function, or by subtracting the worst evaluation function value from each evaluation function value, respectively. The default is PGA_FITNESSMIN_CMAX. See Constants for Fitness Minimization Strategies for the constants and section String Evaluation and Fitness in the user guide for details.

Example

PGAContext *ctx;

...
PGASetFitnessMinType (ctx, PGA_FITNESSMIN_CMAX);

Parameters:

ctx – context variable
fitness_type – symbolic constant to specify fitness minimization type

Returns:

None

void PGASetFitnessType(PGAContext *ctx, int fitness_type)

Set the type of fitness algorithm to use.

Description

Valid choices are PGA_FITNESS_RAW, PGA_FITNESS_NORMAL, or PGA_FITNESS_RANKING for raw fitness (the evaluation function value), linear normalization, or linear ranking, respectively. The default is PGA_FITNESS_RAW. See Constants for Fitness Types for the constants and section String Evaluation and Fitness in the user guide for details.

Example

PGAContext *ctx;

...
PGASetFitnessType (ctx, PGA_FITNESS_RANKING);

Parameters:

ctx – context variable
fitness_type – symbolic constant to specify fitness type

Returns:

None

void PGASetIntegerInitPermute(PGAContext *ctx, int min, int max)

Set a flag to tell the initialization routines to set each integer-valued gene to a random permutation of the values given by an upper and lower bound.

Description

The length of the interval must be the same as the string length. This is the default strategy for initializing integer-valued strings. The default interval is \([0,L-1]\) where \(L\) is the string length. No string initialization is done by this call.

Example

Set the initialization routines to set each gene to a random and unique value from the interval [500,599].

PGAContext *ctx;

...
PGASetIntegerInitPermute (ctx, 500, 599)}

Parameters:

ctx – context variable
min – the lower bound of numbers used in the permutation
max – the upper bound of numbers used in the permutation

Returns:

None

void PGASetIntegerInitRange(PGAContext *ctx, const int *min, const int *max)

Set a flag to tell the initialization routines to set each integer-valued gene to a value chosen randomly from the interval given by an upper and lower bound.

Example

Set the initialization routines to select a value for gene i uniformly randomly from the interval \([0,i]\). Assumes all strings are of the same length.

PGAContext *ctx;
int *low, *high, stringlen, i;

...
stringlen = PGAGetStringLength (ctx);
low  = malloc (stringlen * sizeof (int));
high = malloc (stringlen * sizeof (int));
for (i=0; i<stringlen; i++) {
    low  [i] = 0;
    high [i] = i;
}
PGASetIntegerInitRange (ctx, low, high);

Parameters:

ctx – context variable
min – array of lower bounds that define the interval the gene is initialized from
max – array of upper bounds that define the interval the gene is initialized from

Returns:

None

void PGASetMaxFitnessRank(PGAContext *ctx, double max)

The value of the parameter Max when using linear ranking for fitness determination.

Description

The default value is 1.2. The value must be from the interval \([1.0, 2.0]\). The fitness type must have been set to PGA_FITNESS_RANKING with PGASetFitnessType() for this function call to have any effect.

Example

PGAContext *ctx;

...
PGASetMaxFitnessRank (ctx, 1.1);

Parameters:

ctx – context variable
max – the value of the parameter Max when using linear ranking

Returns:

None

void PGASetMaxGAIterValue(PGAContext *ctx, int maxiter)

Specify the maximum number of iterations.

Description

The stopping rule PGA_STOP_MAXITER is the default stopping rule and is always in effect. The default value is 1000 iterations.

Example

PGAContext *ctx;

...
PGASetMaxGAIterValue (ctx, 5000);

Parameters:

ctx – context variable
maxiter – the maximum number of GA iterations to run before stopping

Returns:

None

void PGASetMaxNoChangeValue(PGAContext *ctx, int max_no_change)

Specify maximum number of iterations of no change in the evaluation function value of the best string before stopping.

Description

The default value is 100. The stopping rule PGA_STOP_NOCHANGE must have been set by PGASetStoppingRuleType() for this function call to have any effect.

Example

PGAContext *ctx;

...
PGASetMaxNoChangeValue (ctx, 100);

Parameters:

ctx – context variable
max_no_change – the maximum number of GA iterations allowed with no change in the best evaluation function value

Returns:

None

void PGASetMaxSimilarityValue(PGAContext *ctx, int max_similarity)

Specify the maximum percent of homogeneity of the population before stopping.

Description

The similarity measure is the same evaluation function value. The default value is that 95 percent of the population have the same evaluation function value. The stopping rule PGA_STOP_TOOSIMILAR must have been set by PGASetStoppingRuleType() for this function call to have any effect.

Example

PGAContext *ctx;

...
PGASetMaxSimilarityValue (ctx, 99);

Parameters:

ctx – context variable
max_similarity – the maximum percent of the population that can share the same evaluation function value

Returns:

None

void PGASetMixingType(PGAContext *ctx, int type)

Set strategy for combining mutation and crossover.

Example

Set the genetic algorithm to use mutation only.

PGAContext *ctx;

...
PGASetMixingType (ctx, PGA_MIX_MUTATE_ONLY);

Parameters:

ctx – context variable
type – Type of Mutation/Crossover combination

Returns:

None

void PGASetMultiObjPrecision(PGAContext *ctx, int prec)

Specify the precision in decimal places for printing evaluations of multi objective optimization.

Example

PGAContext *ctx;

...
PGASetMultiObjPrecision (ctx, 12);

Parameters:

ctx – context variable
prec – the precision

Returns:

None

void PGASetMutationBounceBackFlag(PGAContext *ctx, int val)

If this flag is set to true, then for Integer and Real strings whenever a gene is mutated, if it underflows (overflows) the lower (upper) bound it is reset to a random value between the old value and the violated bound.

Description

When this flag is set, all allele values remain within the range the strings were initialized on by bouncing values that violate the bound back from the boundary. If this flag is PGA_FALSE (the default), the alleles may take any values. See also PGASetMutationBoundedFlag().

Example

PGAContext *ctx;

...
PGASetMutationBounceBackFlag (ctx, PGA_TRUE);

Parameters:

ctx – context variable
val – either PGA_TRUE or PGA_FALSE

Returns:

None

void PGASetMutationBoundedFlag(PGAContext *ctx, int val)

If this flag is set to true, then for Integer and Real strings whenever a gene is mutated, if it underflows (overflows) the lower (upper) bound it is reset to the lower (upper) bound.

Description

When this is enabled, all allele values remain within the range the integer strings were initialized on. If this flag is PGA_FALSE (the default), the alleles may take any values.

Example

PGAContext *ctx;

...
PGASetMutationBoundedFlag (ctx, PGA_TRUE);

Parameters:

ctx – context variable
val – flag to indicate if mutation is bounded

Returns:

None

void PGASetMutationIntegerValue(PGAContext *ctx, int val)

Set multiplier to mutate data type integer strings with.

Description

The use of this value depends on the type of mutation being used. The default value is 1. See section Mutation of the user guide for more details.

Example

PGAContext *ctx;

...
PGASetMutationIntegerValue (ctx, 5);

Parameters:

ctx – context variable
val – the mutation value to use for Integer mutation

Returns:

None

void PGASetMutationPolyEta(PGAContext *ctx, double eta)

Set Eta for polynomial mutation.

Example

PGAContext *ctx;

...
PGASetMutationPolyEta (ctx, 200);

Parameters:

ctx – context variable
eta – the polynomial mutation eta

Returns:

None

void PGASetMutationPolyValue(PGAContext *ctx, double v)

Specify the constant for polynomial mutation.

Example

PGAContext *ctx;

...
PGASetMutationPolyValue (ctx, 2.5);

Parameters:

ctx – context variable
v – the polynomial mutation constant

Returns:

None

void PGASetMutationProb(PGAContext *ctx, double mutation_prob)

Specify the probability that a given allele will be mutated.

Description

If this is called without calling PGASetMutationType(), the default mutation type is PGA_MUTATION_CONSTANT. The default probability is the reciprocal of the string length.

Example

PGAContext *ctx;

...
PGASetMutationProb (ctx, 0.001);

Parameters:

ctx – context variable
mutation_prob – the mutation probability

Returns:

None

void PGASetMutationRealValue(PGAContext *ctx, double val)

Set multiplier to mutate strings of data type real with.

Description

The use of this value depends on the type of mutation being used. The default value is 0.1 unless the mutation type is PGA_MUTATION_CONSTANT in which case the default is 0.01. See section Mutation in the user guide for more details.

Example

PGAContext *ctx;

...
PGASetMutationRealValue (ctx, 50.0);

Parameters:

ctx – context variable
val – the mutation value to use for Real mutation

Returns:

None

void PGASetMutationType(PGAContext *ctx, int mutation_type)

Set type of mutation to use.

Description

Only effects integer- and real-valued strings. Binary-valued strings are always complemented. In character-valued strings, one alphabetic character is replaced with another chosen uniformly randomly. The alphabetic characters will be lower, upper, or mixed case depending on how the strings were initialized.

Valid choices are PGA_MUTATION_CONSTANT (Real/Integer), PGA_MUTATION_RANGE (Real/Integer), PGA_MUTATION_UNIFORM (Real), PGA_MUTATION_GAUSSIAN (Real), PGA_MUTATION_PERMUTE (Integer), PGA_MUTATION_DE (Real), and PGA_MUTATION_POLY (Real/Integer). The default for integer-valued strings conforms to how the strings were initialized. The default for real-valued strings is PGA_MUTATION_GAUSSIAN. See Constants for Mutation Types for the constants and section Mutation in the user guide for more details.

Example

PGAContext *ctx;

...
PGASetMutationType (ctx, PGA_MUTATION_UNIFORM);

Parameters:

ctx – context variable
mutation_type – symbolic constant to specify the mutation type

Returns:

None

void PGASetNAMWindowSize(PGAContext *ctx, int wsize)

Set window size for negative assortative mating (NAM).

Description

On selection select first individual as configured, for the second individual draw wsize individuals and select the one that has the largest genetic difference to the first individual. The default window size 1 doesn’t use NAM. See description [FR01].

Example

PGAContext *ctx,

...
PGASetNAMWindowSize (ctx, 3);

Parameters:

ctx – context variable
wsize – window size

Returns:

None

void PGASetNoDuplicatesFlag(PGAContext *ctx, int no_dup)

A boolean flag to indicate if duplicate strings are allowed in the population.

Description

Valid choices are PGA_TRUE and PGA_FALSE. The default is PGA_FALSE allow duplicates.

Example

Set the NoDuplicates flag to require that all strings are unique.

PGAContext *ctx;

...
PGASetNoDuplicatesFlag (ctx, PGA_TRUE);

Parameters:

ctx – context variable
no_dup – PGA_TRUE or PGA_FALSE

Returns:

None

void PGASetNumAuxEval(PGAContext *ctx, int n)

Initialize the number of auxiliary evaluations.

Example

PGAContext *ctx;

...
PGASetNumAuxEval (ctx, 5);

Parameters:

ctx – context variable
n – Number of auxiliary evaluations

Returns:

None

void PGASetNumConstraint(PGAContext *ctx, int n)

Initialize the number of constraints.

Description

The maximum number of constraints (and the default) is the number of Auxiliary evaluations, see PGASetNumAuxEval().

Example

PGAContext *ctx;

...
PGASetNumConstraint (ctx, 5);

Parameters:

ctx – context variable
n – Number of constraints

Returns:

None

void PGASetNumReplaceValue(PGAContext *ctx, int pop_replace)

Specify the number of new strings to create each generation.

Description

The default is ten percent of the population size.

Example

PGAContext *ctx;

...
PGASetNumReplaceValue (ctx, 35);

Parameters:

ctx – context variable
pop_replace – the number of population members to create each generation

Returns:

None

void PGASetOutputFile(PGAContext *ctx, const char *name)

Set output file name for printing statistics etc.

Description

Note that the file is not immediately opened, instead it is later opened in the rank 0 individual.

Example

PGAContext *ctx;
char *name = "output.file";

...
PGASetOutputFile (ctx, name);

Parameters:

ctx – context variable
name – output filename

Returns:

None

void PGASetPTournamentProb(PGAContext *ctx, double ptournament_prob)

Specify the probability that the string that wins a binary tournament will be selected.

Description

This function will have no effect unless PGA_SELECT_PTOURNAMENT was specified as the type of selection to use with PGASetSelectType(). The default value is 0.6.

Example

PGAContext *ctx;

...
PGASetPTournamentProb (ctx, 0.8);

Parameters:

ctx – context variable
ptournament_prob – the probability of selecting the better string

Returns:

None

void PGASetPopReplaceType(PGAContext *ctx, int pop_replace)

Choose method of replacing strings in the new population.

Description

Valid choices are PGA_POPREPL_BEST, PGA_POPREPL_RANDOM_NOREP, or PGA_POPREPL_RANDOM_REP for copying the best strings, or random string, with or without replacement, respectively, from the old population into the new population. Additional replacement types are PGA_POPREPL_RTR for restricted tournament replacement, PGA_POPREPL_PAIRWISE_BEST for pairwise comparison of each individual in the old/new population, and PGA_POPREPL_NSGA_II and PGA_POPREPL_NSGA_III for multiobjective optimization using the Nondominated Sorting Genetic Algorithm (NSGA-II or NSGA-III). The default is PGA_POPREPL_BEST. See Constants for Population Replacement Strategies for the constants and section Population Replacement in the user guide for details.

Example

PGAContext *ctx;

...
PGASetPopReplaceType (ctx, PGA_POPREPL_RANDOM_NOREP);

Parameters:

ctx – context variable
pop_replace – symbolic constant to specify the population replacement strategy

Returns:

None

void PGASetPopSize(PGAContext *ctx, int popsize)

Specify the size of the genetic algorithm population.

Description

The default population size is 100, unless reference directions or reference points have been specified for NSGA-III replacement in which case the default is the number of reference points plus the number of reference directions.

Example

PGAContext *ctx;

...
PGASetPopSize (ctx, 200);

Parameters:

ctx – context variable
popsize – the genetic algorithm population size to use

Returns:

None

void PGASetPrintFrequencyValue(PGAContext *ctx, int print_freq)

Specify the frequency with which genetic algorithm statistics are reported.

Description

The default is every 10 GA iterations. Used only if PGARun() is used to run the GA.

Example

PGAContext *ctx;

...
PGASetPrintFrequencyValue (ctx, 1);

Parameters:

ctx – context variable
print_freq – print frequency (in generations)

Returns:

None

void PGASetPrintOptions(PGAContext *ctx, int option)

Set flags to indicate what GA statistics should be printed whenever output is printed.

Description

May be called more than once to specify different report options. Valid choices are PGA_REPORT_AVERAGE, PGA_REPORT_OFFLINE, PGA_REPORT_ONLINE, PGA_REPORT_WORST, PGA_REPORT_GENE_DISTANCE, and PGA_REPORT_STRING to specify offline analysis, online analysis, the worst string in the population, the mean genetic distance of the population, and the actual allele values of the best string. The best string is always printed. Note that reporting of mean genetic distance is quadratic in the population size and probably should be used only when trying to diagnose premature convergence problems. See Constants for Reporting for the constants and section Report Options in the user guide for details.

Example

PGAContext *ctx;

...
PGASetPrintOptions (ctx, PGA_REPORT_WORST);

Parameters:

ctx – context variable
option – symbolic constant to specify a print option

Returns:

None

void PGASetRTRWindowSize(PGAContext *ctx, int windowsize)

Set window size used for restricted tournament replacement.

Description

This function will have no effect unless PGA_POPREPL_RTR was specified as the population replacement strategy with PGASetPopReplaceType(). The window size must be smaller than the population size. The default is \(\min (n, N/20)\) where \(n\) is the string length and \(N\) is the population size.

Example

PGAContext *ctx;

...
PGASetRTRWindowSize (ctx, windowsize);

Parameters:

ctx – context variable
windowsize – size of the window for restricted tournament replacement

Returns:

None

void PGASetRandomInitFlag(PGAContext *ctx, int flag)

A boolean flag to indicate whether to randomly initialize alleles.

Description

Legal values are PGA_TRUE and PGA_FALSE. Default is PGA_TRUE: randomly initialize alleles.

Example

Set the initialization routine to initialize all alleles to zero:

PGAContext *ctx;

...
PGASetRandomInitFlag (ctx,PGA_FALSE);

Parameters:

ctx – context variable
flag – indicates whether random initialization should be performed

Returns:

None

void PGASetRandomSeed(PGAContext *ctx, int seed)

Set a seed for the random number generator.

Description

The default is to initialize the seed randomly (from the time). Specifying a seed explicitly allows for reproducibility of runs.

Example

PGAContext *ctx;

...
PGASetRandomSeed (ctx, 1);

Parameters:

ctx – context variable
seed – seed for the random number generator

Returns:

None

void PGASetRandomizeSelect(PGAContext *ctx, int v)

Specify if during PGASelect the chosen individuals should be randomized again.

Description

All selection schemes except PGA_SELECT_SUS already return the individuals in randomized order, previously this was randomized again. With this method you can re-enable the randomization for selection schemes other than PGA_SELECT_SUS (for which a randomization step is always performed).

Example

PGAContext *ctx;

...
PGASetRandomizeSelect (ctx, PGA_TRUE);

Parameters:

ctx – context variable
v – flag, true if randomized again

Returns:

None

void PGASetRealInitFraction(PGAContext *ctx, double *median, double *frac)

Set the upper and lower bounds for randomly initializing real-valued genes.

Description

For each gene these bounds define an interval from which the initial allele value is selected uniformly randomly. With this routine the user specifies a median value and a fraction of the median for each allele.

Example

Set the initialization routines to select a value for each real-valued gene i uniformly randomly from the interval \([i-v,i+v]\), where \(v = i/2\). Assumes all strings are the same length.

PGAContext *ctx;
double *median, *frac;
int i, stringlen;

...
stringlen = PGAGetStringLength (ctx);
median = malloc (stringlen * sizeof(double));
frac   = malloc (stringlen * sizeof(double));
for (i=0; i<stringlen; i++) {
   median [i] = (double) i;
   frac   [i] = 0.5;
}
PGASetRealInitPercent (ctx, median, frac);

Parameters:

ctx – context variable
median – an array containing the mean value of the interval
frac – an array containing the fraction of median to add and subtract to/from the median to define the interval

Returns:

None

void PGASetRealInitRange(PGAContext *ctx, const double *min, const double *max)

Set the upper and lower bounds for randomly initializing real-valued genes.

Description

For each gene these bounds define an interval from which the initial allele value is selected uniformly randomly. The user specifies two arrays containing lower and upper bound for each gene to define the interval. This is the default strategy for initializing real-valued strings. The default interval is \([0,1.0]\) for each gene.

Example

Set the initialization routines to select a value for each real-valued gene \(i\) uniformly randomly from the interval \([-10.,i]\) Assumes all strings are of the same length.

PGAContext *ctx;
double *low, *high;
int i, stringlen;

...
stringlen = PGAGetStringLength (ctx);
low  = malloc (stringlen * sizeof(double));
high = malloc (stringlen * sizeof(double));
for (i=0; i<stringlen; i++) {
   low  [i] = -10.0;
   high [i] = i;
}
PGASetRealInitRange (ctx, low, high);

Parameters:

ctx – context variable
min – array containing the lower bound of the interval for each gene
max – array containing the upper bound of the interval for each gene

Returns:

None

void PGASetReferenceDirections(PGAContext *ctx, size_t ndirs, void *dirs, int npart, double scale)

Set reference directions for NSGA-III.

Description

A direction is a point in objective space and can be seen as a vector from the origin to that point. During optimization the reference directions are mapped to the reference hyperplane and a scaled Das/Dennis hyperplane is constructed around that point. Each direction consists of dimension double variables.

Example

Asume 3 dimensions, i.e. 3 evaluation functions

PGAContext *ctx;
double dirs [][3] = {{1, 2, 3}, {4, 5, 6}};
...
int dim = PGAGetNumAuxEval (ctx) - PGAGetNumConstraint (ctx) + 1;

...
PGASetReferenceDirections (ctx, 2, dirs, 5, 0.1);

Parameters:

ctx – context variable
ndirs – Number of directions
dirs – Pointer to directions
npart – Number of Das / Dennis partitions
scale – Scale factor for constructed Das / Dennis points, must be 0 < scale <= 1 but will typically be < 0.5

Returns:

None

void PGASetReferencePoints(PGAContext *ctx, size_t npoints, void *points)

Set reference points on reference hyperplane for NSGA-III.

Example

PGAContext *ctx;
...
int dim = PGAGetNumAuxEval (ctx) - PGAGetNumConstraint (ctx) + 1;
void *p = NULL;
int np  = 0;

...
np = LIN_dasdennis (dim, 3, &p, 0, 1, NULL);
PGASetReferencePoints (ctx, np, p);

Parameters:

ctx – context variable
npoints – Number of points
points – Pointer to points

Returns:

None

void PGASetRestartAlleleChangeProb(PGAContext *ctx, double prob)

Specify the probability with which an allele will be mutated during a restart.

Description

By default the change probability for allele mutations during restart is 0.5.

Example

PGAContext *ctx;

...
PGASetRestartAlleleChangeProb (ctx, 0.7);

Parameters:

ctx – context variable
prob – probability of mutation

Returns:

None

void PGASetRestartFlag(PGAContext *ctx, int val)

Specify whether the algorithm should employ the restart operator.

Description

By default no restart is performed.

Example

PGAContext *ctx;

...
PGASetRestartFlag (ctx, PGA_TRUE);

Parameters:

ctx – context variable
val – boolean variable

Returns:

None

void PGASetRestartFrequencyValue(PGAContext *ctx, int numiter)

Specify the number of iterations of no change in the best string after which the algorithm should restart.

Description

By default no restarts are performed, see PGASetRestartFlag(). If restarts are performed, the default is after 50 iterations of no change.

Example

PGAContext *ctx;

...
PGASetRestartFrequencyValue (ctx, 100);

Parameters:

ctx – context variable
numiter – number of changeless iterations

Returns:

None

void PGASetSelectType(PGAContext *ctx, int select_type)

Specify the type of selection to use.

Description

Valid choices are PGA_SELECT_PROPORTIONAL, PGA_SELECT_SUS, PGA_SELECT_TOURNAMENT, PGA_SELECT_PTOURNAMENT, PGA_SELECT_TRUNCATION, and PGA_SELECT_LINEAR for proportional, stochastic universal selection, tournament, probabilistic tournament selection, truncation selection and linear selection, respectively. The default is PGA_SELECT_TOURNAMENT. See Constants for Selection Types for the constants and section Selection in the user guide for details.

Example

PGAContext *ctx;

...
PGASetSelectType (ctx, PGA_SELECT_SUS);

Parameters:

ctx – context variable
select_type – symbolic constant to specify selection type

Returns:

None

void PGASetStoppingRuleType(PGAContext *ctx, int stoprule)

Specify a stopping criterion.

Description

If called more than once the different stopping criterion are ORed together. Valid choices are PGA_STOP_MAXITER, PGA_STOP_TOOSIMILAR, or PGA_STOP_NOCHANGE to specify iteration limit reached, population too similar, or no change in the best solution found in a given number of iterations, respectively. The default is to stop when a maximum iteration limit is reached (by default, 1000 iterations). The constants can be found in Constants for Stopping Conditions and more details are in section Stopping Criteria of the user guide.

Example

PGAContext *ctx;

...
PGASetStoppingRuleType (ctx, PGA_STOP_TOOSIMILAR);

Parameters:

ctx – context variable
stoprule – symbolic constant to specify stopping rule

Returns:

None

void PGASetSumConstraintsFlag(PGAContext *ctx, int n)

Configure if constraints are summed for minimization or use nondominated sorting for optimization.

Description

This only has an effect if the NSGA-II or NSGA-III replacement scheme is configured. In that case, using nondominated sorting for constraint optimization can be turned on by this option. By default constraints are summed and the sum in minimized. This is also done if no NSGA replacement scheme is in use. If summing is disabled by setting this configuration to PGA_FALSE, constraints are minimized using nondominated sorting. Note that nondominated sorting for constrains may not work very well on many problems.

Example

PGAContext *ctx;

...
PGASetSumConstraintsFlag (ctx, PGA_FALSE);

Parameters:

ctx – context variable
n – PGA_TRUE or PGA_FALSE

Returns:

None

void PGASetTournamentSize(PGAContext *ctx, double tournament_size)

Specify the number of participants in a non-probabilistic Tournament.

Description

This function will have no effect unless PGA_SELECT_TOURNAMENT was specified as the type of selection to use with PGASetSelectType(). The default value is 2.

Example

PGAContext *ctx;

...
PGASetTournamentSize (ctx, 3);

Parameters:

ctx – context variable
tournament_size – the size of the tournament

Returns:

None

void PGASetTournamentWithReplacement(PGAContext *ctx, int v)

Specify if tournament is with or without replacement.

Description

This function will have no effect unless PGA_SELECT_TOURNAMENT was specified as the type of selection to use with PGASetSelectType(). The default value is PGA_TRUE indicating tournament with replacement.

Example

PGAContext *ctx;

...
PGASetTournamentWithReplacement (ctx, PGA_FALSE);

Parameters:

ctx – context variable
v – flag indicating if replacement is used

Returns:

None

void PGASetTruncationProportion(PGAContext *ctx, double proportion)

Specify the proportion of selected individuals for truncation selection.

Description

This function will have no effect unless PGA_SELECT_TRUNCATION was specified as the type of selection to use with PGASetSelectType(). The default value is 0.5.

Example

PGAContext *ctx;

...
PGASetTruncationProportion (ctx, 0.7);

Parameters:

ctx – context variable
proportion – The value, 0 < proportion <= 1

Returns:

None

void PGASetUniformCrossoverProb(PGAContext *ctx, double p)

Set probability used in uniform crossover to specify that an allele value value be selected from a particular parent.

Description

The default is 0.6. The crossover type must have been set to PGA_CROSSOVER_UNIFORM with PGASetCrossoverType() for this function call to have any effect.

Example

PGAContext *ctx;

...
PGASetUniformCrossoverProb (ctx, 0.9);

Parameters:

ctx – context variable
p – the crossover probability

Returns:

None

void PGASetUserFunction(PGAContext *ctx, int constant, void *f)

Specify the name of a user-written function to provide a specific GA capability (e.g., crossover, mutation, etc.).

Description

This function must be used when using a non-native datatype and must be called once for each of:

PGA_USERFUNCTION_CREATESTRING – String creation
PGA_USERFUNCTION_MUTATION – Mutation
PGA_USERFUNCTION_CROSSOVER – Crossover
PGA_USERFUNCTION_PRINTSTRING – String Output
PGA_USERFUNCTION_COPYSTRING – Duplication
PGA_USERFUNCTION_DUPLICATE – Duplicate Checking
PGA_USERFUNCTION_GEN_DISTANCE – Genetic Distance
PGA_USERFUNCTION_INITSTRING – Initialization
PGA_USERFUNCTION_BUILDDATATYPE – MPI Datatype creation
PGA_USERFUNCTION_STOPCOND – Stopping conditions
PGA_USERFUNCTION_ENDOFGEN – Auxiliary functions at the end of each generation
PGA_USERFUNCTION_PRE_EVAL – Auxiliary functions before evaluation but after crossover and mutation
PGA_USERFUNCTION_HASH – Hashing of genes
PGA_USERFUNCTION_SERIALIZE – Serialize userdefined gene
PGA_USERFUNCTION_DESERIALIZE – Deserialize userdefined gene
PGA_USERFUNCTION_SERIALIZE_FREE – Free serialized version
PGA_USERFUNCTION_CHROM_FREE – Free chromosome

It may be called when using a native datatype to replace the built-in functions PGAPack has for that datatype (For example, if the Integer data type is used for a traveling salesperson problem, the user may want to provide their own custom crossover operator). See Constants for User Functions for the constants and chapters Custom Usage: Native Data Types and Custom Usage: New Data Types in the user guide and the examples in the examples directory for more details.

Example

void MyStringInit (PGAContext *, void *);
PGAContext *ctx;

...
PGASetUserFunction (ctx, PGA_USERFUNCTION_INITSTRING, MyStringInit);

Parameters:

ctx – context variable
constant – symbolic constant of the user function to set
f – name of the function to use

Returns:

None

Standard API

group standard-api

The standard API.

Functions

double INDGetAuxTotal(PGAIndividual *ind)

Compute total value over all constraint violations.

Description

This returns the sum of all positive individual aux evaluations that are used for constraints. The semantics is a total value of all constraint violations.

Example

PGAIndividual *ind = PGAGetIndividual (ctx, p, PGA_OLDPOP);
double result;

...
result = INDGetAuxTotal (ind);

Parameters:

ind – Pointer to Individual

Returns:

Computed or cached total value over all constraint violations

int LIN_dasdennis(int dim, int npart, void *result, int nexist, double scale, double *dir)

Allocate memory and compute Das & Dennis points.

Description

It will re-alloc the exiting array pointer pointed to by result (this must be a NULL pointer if no pre-existing points are given) and return the new number of points. Note that if there are no pre-existing points, the pointer pointed to by result must be NULL and nexist must be 0. Optionally the points can be scaled (with 0 < scale <= 1) and shifted in the direction of a given point back onto the reference hyperplane. This is not done if dir == NULL or scale == 1. A previously allocated result will be de-allocated in case of error.

Parameters:

dim – dimension
npart – Number of partitions
result – List of existing points to extend
nexist – Number of existing points
scale – Scaling factor
dir – Direction vector

Returns:

Number of points allocated, -1 on error

int PGACheckStoppingConditions(PGAContext *ctx)

Return boolean to indicate if the configured PGAPack termination conditions have been met.

Description

The default termination conditions are given in Constants for Stopping Conditions and more details are found in section Stopping Criteria of the user guide.

Example

Useful in a user-defined function that is registered as a stopping condition function. We can use this to keep the builtin stopping conditions in addition to a user-defined condition.

int StopCond (PGAContext *ctx)
{
    if (my_stop_check (ctx)) {
        return PGA_TRUE;
    }
    return PGACheckStoppingConditions (ctx);
}

Parameters:

ctx – context variable

Returns:

return true if at least one of the termination conditions has been met

PGAContext *PGACreate(int *argc, char **argv, int datatype, int len, int maxormin)

Create an uninitialized context variable.

Description

The Fortran version of this function call contains only the last three arguments.

The datatype must be one of PGA_DATATYPE_BINARY, PGA_DATATYPE_CHARACTER, PGA_DATATYPE_INTEGER, PGA_DATATYPE_REAL, or PGA_DATATYPE_USER to specify binary-valued, character-valued, integer-valued, real-valued, or a user-defined datatype, respectively. See Constants for Datatypes for the constants and types.

The maxormin parameter must be one of PGA_MAXIMIZE or PGA_MINIMIZE for maximization or minimization, respectively. See Constants for Optimization Direction for the constants.

Example

In C:

void main (int argc, char **argv) {
    PGAContext *ctx;

    ctx = PGACreate (&argc, argv, PGA_DATATYPE_BINARY, 100, PGA_MAXIMIZE);
    //  Set options here
    PGASetUp (ctx);
    //  Run the GA here
    PGADestroy (ctx);
}

In Fortran:

        integer ctx

        ctx = PGACreate(PGA_DATATYPE_BINARY, 100, PGA_MAXIMIZE)
c       Set options here
        call PGASetUp(ctx)
c       Run the GA here
        call PGADestroy(ctx)
        stop
        end

Parameters:

argc – Address of the count of the number of command line arguments
argv – Array of command line arguments
datatype – The data type used for the strings
len – The string length (number of genes)
maxormin – The direction of optimization.

Returns:

A pointer to the context variable

void PGADestroy(PGAContext *ctx)

Deallocate memory for this instance of PGAPack, if this context initialized MPI, finalize MPI as well.

Example

PGAContext *ctx;

...
PGADestroy (ctx);

Parameters:

ctx – context variable

Returns:

None

double PGAIntegerEuclidianDistance(PGAContext *ctx, int p1, int pop1, int p2, int pop2)

Compute genetic distance of two strings.

Description

This uses the Euclidian distance metric, the square-root of the sum of all squared differences of each allele. It can be used to override the default integer genetic distance function (which uses a manhattan distance metric) using PGASetUserFunction() with the PGA_USERFUNCTION_GEN_DISTANCE setting.

Example

Override genetic distance function:

PGAContext *ctx;

...
assert (PGAGetDataType (ctx) == PGA_DATATYPE_INTEGER);
PGASetUserFunction
 (ctx, PGA_USERFUNCTION_GEN_DISTANCE, PGAIntegerEuclidianDistance);

Parameters:

ctx – context variable
p1 – first string index
pop1 – symbolic constant of the population the first string is in
p2 – second string index
pop2 – symbolic constant of the population the second string is in

Returns:

genetic euclidian distance of the two strings

void PGAIntegerSetFixedEdges(PGAContext *ctx, size_t n, PGAInteger (*edge)[2], int symmetric)

Set edges that have to be present.

Description

This is used only in Edge Crossover. Note: The edges data structure is copied and must be freed by the caller. It is admissible that the edges data is in automatic variables allocated on the stack.

Example

Set edges (0, 213) and (7, 11) as fixed edges.

PGAContext *ctx;
PGAInteger edge[][2] = {(PGAInteger []){0, 213}, (PGAInteger []){7, 11}};
int  n = sizeof (edge) / (2 * sizeof (PGAInteger));

...
PGAIntegerSetFixedEdges (ctx, n, edge, PGA_TRUE);

Parameters:

ctx – context variable
n – Number of edges
edge – Pointer to edges, each edge consists of two indices
symmetric – Flag that indicates if edges are allowed in reverse direction

Returns:

None

double PGARealEuclidianDistance(PGAContext *ctx, int p1, int pop1, int p2, int pop2)

Compute genetic difference of two strings.

Description

This uses the Euclidian distance metric, the square-root of the sum of all squared differences of each allele. It can be used to override the default real genetic distance function (which uses a manhattan distance metric) using PGASetUserFunction() with the PGA_USERFUNCTION_GEN_DISTANCE setting.

Example

Override genetic distance function:

PGAContext *ctx;

...
assert (PGAGetDataType (ctx) == PGA_DATATYPE_REAL);
PGASetUserFunction
 (ctx, PGA_USERFUNCTION_GEN_DISTANCE, PGARealEuclidianDistance);

Parameters:

ctx – context variable
p1 – first string index
pop1 – symbolic constant of the population the first string is in
p2 – second string index
pop2 – symbolic constant of the population the second string is in

Returns:

Genetic euclidian distance of the two strings

void PGARun(PGAContext *ctx, double (*evaluate)(PGAContext *c, int p, int pop, double*))

Highest level routine to execute the genetic algorithm.

Description

It is called after PGACreate() and PGASetup() have been called.

Example

PGAContext *ctx;
double f (PGAContext *ctx, int p, int pop, double *aux);

ctx = PGACreate (&argc, argv, PGA_DATATYPE_BINARY, 100, PGA_MAXIMIZE);
PGASetUp (ctx);
PGARun (ctx, f);
PGADestroy (ctx);

Parameters:

ctx – context variable
evaluate – a pointer to the user’s evaluation function, which must have the calling sequence shown in the example

Returns:

None

void PGASetUp(PGAContext *ctx)

Set all uninitialized variables to default values and initialize some internal arrays.

Description

Must be called after PGACreate() and before the GA is started.

Example

PGAContext *ctx;

PGACreate (ctx, ...);
//  Set options here
PGASetUp (ctx);

Parameters:

ctx – context variable

Returns:

Uninitialized values in the context variable are set to defaults, and set values are checked for legality

PGAHash PGAUtilHash(const void *data, size_t len, PGAHash hashv)

Hashing utility function.

Description

This is Bob Jenkins’ hash function as implemented in the uthash project. The last parameter is the previous hash (if hashing different pieces), use PGA_INITIAL_HASH for the first hash.

Parameters:

data – pointer to data to hash
len – length of data
hashv – previous hash, use PGA_INITIAL_HASH if first

Returns:

hash over data

Querying Parameters

group query

Functions to query PGA parameters.

Functions

double PGAGetAuxTotal(PGAContext *ctx, int p, int pop)

Compute total value over all constraint violations.

Description

This returns the sum of all positive individual aux evaluations that are used for constraints. The semantics is a total value of all constraint violations.

Example

PGAContext *ctx;
double result;

...
result = PGAGetAuxTotal (ctx, p, PGA_OLDPOP);

Parameters:

ctx – context variable
p – index of individual
pop – population

Returns:

Computed or cached total value over all constraint violations

int PGAGetBestIndex(PGAContext *ctx, int popidx)

Return the index of the string with the best evaluation function value in population pop.

Description

Note that in the presence of multiple evaluations, this will return

If all strings violate constraints the one with the least constraint violation
In case there exist strings without constraint violations one randomly chosen from rank 0.

Example

PGAContext *ctx;
int best;

...
best = PGAGetBestIndex (ctx, PGA_OLDPOP);

Parameters:

ctx – context variable
popidx – symbolic constant of the population to find the best string in

Returns:

Index of the string with the best evaluation function value

double PGAGetBestReport(PGAContext *ctx, int pop, int idx)

Return the best evaluation value in population pop for the given evaluation index.

Description

The evaluation function index must be 0 < idx <= NumAuxEval. So for single evaluation only the index 0 is allowed and the return is the evaluation as from PGAGetBestIndex(). Note that this accesses the pre-computed statistics and therefore only PGA_OLDPOP is allowed for the population constant.

Example

PGAContext *ctx;
double best;

...
best = PGAGetBestReport (ctx, PGA_OLDPOP, 1);

Parameters:

ctx – context variable
pop – symbolic constant of the population to find the best eval, only PGA_OLDPOP is allowed
idx – Index of the evaluation function, 0 for the one return by your evaluation function 1 .. NumAuxEval for the auxiliary evaluations

Returns:

Index of the string with the best evaluation function value

int PGAGetBestReportIndex(PGAContext *ctx, int pop, int idx)

Return the index of the string with the best evaluation function value in population pop for the given evaluation index.

Description

The evaluation function index must be 0 < idx <= NumAuxEval. So for single evaluation only the index 0 is allowed and the return is the same as from PGAGetBestIndex(). Note that this accesses the pre-computed statistics and therefore only PGA_OLDPOP is allowed for the population constant.

Example

PGAContext *ctx;
int best;

...
best = PGAGetBestReportIndex (ctx, PGA_OLDPOP, 1);

Parameters:

ctx – context variable
pop – symbolic constant of the population to find the best string in
idx – Index of the evaluation function, 0 for the one return by your evaluation function 1 .. NumAuxEval for the auxiliary evaluations

Returns:

Index of the string with the best evaluation function value

double PGAGetBinaryInitProb(PGAContext *ctx)

Return the probability that an allele will be randomly initialized to “1” for data type binary.

Description

This is used during string creation of a PGA_DATATYPE_BINARY string.

Example

PGAContext *ctx;
double prob;

...
prob = PGAGetBinaryInitProb (ctx);

Parameters:

ctx – context variable

Returns:

The probability that a bit will be randomly initialized to one

MPI_Comm PGAGetCommunicator(PGAContext *ctx)

Returns the default communicator used when PGARun is called.

Example

MPI_Comm comm;
PGAContext *ctx,
double f (PGAContext *ctx, int p, int pop, double *aux);

ctx = PGACreate (&argc, argv, PGA_DATATYPE_BINARY, 100, PGA_MAXIMIZE);
PGASetUp (ctx);
comm = PGAGetCommunicator (ctx);

Parameters:

ctx – context variable

Returns:

The default communicator

int PGAGetCrossoverBounceBackFlag(PGAContext *ctx)

Return boolean to indicate whether crossed over strings are bounced back when exceeding the bounds.

Description

Return PGA_TRUE if restricted to the given range by bouncing out-of-range values back from the boundary, otherwise PGA_FALSE.

Example

PGAContext *ctx;
int val;

...
val = PGAGetCrossoverBounceBackFlag (ctx);

Parameters:

ctx – context variable

Returns:

flag indicating whether out-of-range values are bounced back

int PGAGetCrossoverBoundedFlag(PGAContext *ctx)

Return boolean value to indicate whether crossed over strings remain in the range specified.

Description

Return PGA_TRUE if restricted to the given range, otherwise PGA_FALSE.

Example

PGAContext *ctx;
int val;

...
val = PGAGetCrossoverBoundedFlag (ctx);

Parameters:

ctx – context variable

Returns:

boolean value indicating if strings remain in range

double PGAGetCrossoverProb(PGAContext *ctx)

Return the crossover probability.

Example

PGAContext *ctx;
double pc;

...
pc = PGAGetCrossoverProb (ctx);

Parameters:

ctx – context variable

Returns:

The crossover probability

double PGAGetCrossoverSBXEta(PGAContext *ctx)

Return simulated binary crossover (SBX) eta value.

Example

PGAContext *ctx;
double eta;

...
eta = PGAGetCrossoverSBXEta (ctx);

Parameters:

ctx – context variable

Returns:

The SBX eta value

int PGAGetCrossoverSBXOncePerString(PGAContext *ctx)

Return simulated binary crossover (SBX) setting if random number for SBX polynomial distribution is computed once per string.

Example

PGAContext *ctx;
int r;

...
r = PGAGetCrossoverSBXOncePerString (ctx);

Parameters:

ctx – context variable

Returns:

The SBX once-per-string value

int PGAGetCrossoverType(PGAContext *ctx)

Return the type of crossover selected.

Example

PGAContext *ctx;
int crosstype;

...
crosstype = PGAGetCrossoverType (ctx);
switch (crosstype) {
case PGA_CROSSOVER_ONEPT:
    printf ("Crossover Type = PGA_CROSSOVER_ONEPT\n");
    break;
case PGA_CROSSOVER_TWOPT:
    printf ("Crossover Type = PGA_CROSSOVER_TWOPT\n");
    break;
case PGA_CROSSOVER_UNIFORM:
    printf ("Crossover Type = PGA_CROSSOVER_UNIFORM\n");
    break;
case PGA_CROSSOVER_SBX:
    printf ("Crossover Type = PGA_CROSSOVER_SBX\n");
    break;
case PGA_CROSSOVER_EDGE:
    printf ("Crossover Type = PGA_CROSSOVER_EDGE\n");
    break;
}

Parameters:

ctx – context variable

Returns:

Return the integer corresponding to the symbolic constant used to specify the crossover type.

double PGAGetDEAuxFactor(PGAContext *ctx)

Return the value of the auxiliary factor K for Differential Evolution.

Example

PGAContext *ctx;
double val;

...
val = PGAGetDEAuxFactor (ctx);

Parameters:

ctx – context variable

Returns:

The value of the auxiliary factor

double PGAGetDECrossoverProb(PGAContext *ctx)

Return the crossover probability for Differential Evolution.

Example

PGAContext *ctx;
double val;

...
val = PGAGetDECrossoverProb (ctx);

Parameters:

ctx – context variable

Returns:

The value of the Differential Evolution crossover probability

int PGAGetDECrossoverType(PGAContext *ctx)

Return the Differential Evolution crossover type.

Example

PGAContext *ctx;
int val;

...
val = PGAGetDECrossoverType (ctx);

Parameters:

ctx – context variable

Returns:

The value of the Differential Evolution crossover type

double PGAGetDEDither(PGAContext *ctx)

Return the Differential Evolution dither value.

Example

PGAContext *ctx;
double val;

...
val = PGAGetDEDither (ctx);

Parameters:

ctx – context variable

Returns:

The value of the Differential Evolution dither

int PGAGetDEDitherPerIndividual(PGAContext *ctx)

Return boolean flag to indicate whether the dither is applied anew for each individual or if the value is re-used for all individuals in one generation.

Example

PGAContext *ctx;
int val;

...
val = PGAGetDEDitherPerIndividual (ctx);

Parameters:

ctx – context variable

Returns:

flag to indicate if dither is applied for each individual

double PGAGetDEJitter(PGAContext *ctx)

Return the jitter for Differential Evolution.

Example

PGAContext *ctx;
double val;

...
val = PGAGetDEJitter (ctx);

Parameters:

ctx – context variable

Returns:

The value of the Differential Evolution jitter

int PGAGetDENumDiffs(PGAContext *ctx)

Return the number of differences for Differential Evolution.

Example

PGAContext *ctx;
int val;

...
val = PGAGetDENumDiffs (ctx);

Parameters:

ctx – context variable

Returns:

The value of the Differential Evolution number of differences

double PGAGetDEProbabilityEO(PGAContext *ctx)

Return the probability of the either-or variant of Differential Evolution.

Example

PGAContext *ctx;
double val;

...
val = PGAGetDEProbabilityEO (ctx);

Parameters:

ctx – context variable

Returns:

The value of the Differential Evolution EO-Probability

double PGAGetDEScaleFactor(PGAContext *ctx)

Return the value of the scale factor F for Differential Evolution.

Example

PGAContext *ctx;
double val;

...
val = PGAGetDEScaleFactor (ctx);

Parameters:

ctx – context variable

Returns:

The value of the scale factor

int PGAGetDEVariant(PGAContext *ctx)

Return the variant of Differential Evolution.

Example

PGAContext *ctx;
int variant;

...
variant = PGAGetDEVariant (ctx);
switch (variant) {
case PGA_DE_VARIANT_RAND:
    printf ("DE Variant = PGA_DE_VARIANT_RAND\n");
    break;
case PGA_DE_VARIANT_BEST:
    printf ("DE Variant = PGA_DE_VARIANT_BEST\n");
    break;
case PGA_DE_VARIANT_EITHER_OR:
    printf ("DE Variant = PGA_DE_VARIANT_EITHER_OR\n");
    break;
}

Parameters:

ctx – context variable

Returns:

Returns the integer corresponding to the symbolic constant used to specify the variant of differential evolution

int PGAGetDataType(PGAContext *ctx)

Return the data type used by the given context.

Example

PGAContext *ctx;
int datatype;

...
datatype = PGAGetDataType (ctx);
switch (datatype) {
case PGA_DATATYPE_BINARY:
    printf ("Data Type = PGA_DATATYPE_BINARY\n");
    break;
case PGA_DATATYPE_CHARACTER:
    printf ("Data Type = PGA_DATATYPE_CHARACTER\n");
    break;
case PGA_DATATYPE_INTEGER:
    printf ("Data Type = PGA_DATATYPE_INTEGER\n");
    break;
case PGA_DATATYPE_REAL:
    printf ("Data Type = PGA_DATATYPE_REAL\n");
    break;
case PGA_DATATYPE_USER:
    printf ("Data Type = PGA_DATATYPE_USER\n");
    break;
}

Parameters:

ctx – context variable

Returns:

The integer corresponding to the symbolic constant used to specify the data type

double PGAGetEpsilonExponent(PGAContext *ctx)

Get the exponent used for epsilon constraints.

Example

PGAContext *ctx;
double e;

...
e = PGAGetEpsilonExponent (ctx);

Parameters:

ctx – context variable

Returns:

The epsilon exponent

int PGAGetEpsilonGeneration(PGAContext *ctx)

Get value of the generation until which constraints are relaxed via the Epsilon Contraint method.

Example

PGAContext *ctx;
int n;

...
n = PGAGetEpsilonGeneration (ctx);

Parameters:

ctx – context variable

Returns:

The epsilon generation

int PGAGetEpsilonTheta(PGAContext *ctx)

Query the population index for initializing epsilon for the epsilon constraint method.

Example

PGAContext *ctx;
int n;

...
n = PGAGetEpsilonTheta (ctx);

Parameters:

ctx – context variable

Returns:

The epsilon theta

int PGAGetEvalCount(PGAContext *ctx)

Return the number of function evaluations so far.

Example

PGAContext *ctx;
int g;

...
g = PGAGetEvalCount (ctx);

Parameters:

ctx – context variable

Returns:

The number of function evaluations

double PGAGetFitnessCmaxValue(PGAContext *ctx)

Return the value of the multiplier used in the MinCmax fitness algorithm.

Example

PGAContext *ctx;
double cmax;

...
cmax = PGAGetFitnessCmaxValue (ctx);

Parameters:

ctx – context variable

Returns:

The value of Cmax used

int PGAGetFitnessMinType(PGAContext *ctx)

Return the type of fitness transformation used for minimization problems.

Example

PGAContext *ctx;
int fitmintype;

...
fitmintype = PGAGetFitnessMinType (ctx);
switch (fitmintype) {
case PGA_FITNESSMIN_RECIPROCAL:
    printf ("Fitness Minimization Type = PGA_FITNESSMIN_RECIPROCAL\n");
    break;
case PGA_FITNESSMIN_CMAX:
    printf ("Fitness Minimization Type = PGA_FITNESSMIN_CMAX\n");
    break;
}

Parameters:

ctx – context variable

Returns:

Returns the integer corresponding to the symbolic constant used to specify the type of fitness transformation used for minimization problems

int PGAGetFitnessType(PGAContext *ctx)

Return the type of fitness transformation used.

Example

PGAContext *ctx;
int fittype;

...
fittype = PGAGetFitnessType (ctx);
switch (fittype) {
case PGA_FITNESS_RAW:
    printf ("Fitness Type = PGA_FITNESS_RAW\n");
    break;
case PGA_FITNESS_NORMAL:
    printf ("Fitness Type = PGA_FITNESS_NORMAL\n");
    break;
case PGA_FITNESS_RANKING:
    printf ("Fitness Type = PGA_FITNESS_RANKING\n");
    break;
}

Parameters:

ctx – context variable

Returns:

Returns the integer corresponding to the symbolic constant to specify the type of fitness transformation used

int PGAGetGAIterValue(PGAContext *ctx)

Return the number of the current genetic algorithm generation.

Example

PGAContext *ctx;
int g;

...
g = PGAGetGAIterValue (ctx);

Parameters:

ctx – context variable

Returns:

The genetic algorithm generation number

int PGAGetIntegerInitType(PGAContext *ctx)

Return the type of scheme used to randomly initialize strings of data type integer.

Example

PGAContext *ctx;
int inittype;

...
inittype = PGAGetIntegerInitType (ctx);
switch (inittype) {
case PGA_IINIT_PERMUTE:
    printf ("Data Type = PGA_IINIT_PERMUTE\n");
    break;
case PGA_IINIT_RANGE:
    printf ("Data Type = PGA_IINIT_RANGE\n");
    break;
}

Parameters:

ctx – context variable

Returns:

Returns the integer corresponding to the symbolic constant used to specify the scheme used to initialize integer strings.

double PGAGetMaxFitnessRank(PGAContext *ctx)

Return the maximum value used in rank-based fitness.

Example

PGAContext *ctx;
double max;

...
max = PGAGetMaxFitnessRank (ctx);

Parameters:

ctx – context variable

Returns:

The value of MAX used in rank-based fitness

int PGAGetMaxGAIterValue(PGAContext *ctx)

Return the maximum number of iterations to run.

Example

PGAContext *ctx;
int maxiter;

...
maxiter = PGAGetMaxGAIterValue (ctx);

Parameters:

ctx – context variable

Returns:

The maximum number of iterations to run

int PGAGetMaxIntegerInitValue(PGAContext *ctx, int i)

Return the maximum of the range of integers used to randomly initialize integer strings.

Example

PGAContext *ctx;
int idx;
int max;

...
max = PGAGetMaxIntegerInitValue (ctx, idx);

Parameters:

ctx – context variable
i – Index of the initialization range

Returns:

The maximum of the range of integers used to randomly initialize integer strings

double PGAGetMaxMachineDoubleValue(PGAContext *ctx)

Return the largest double of the current machine.

Example

PGAContext *ctx;
double big;

...
big = PGAGetMaxMachineDoubleValue (ctx);

Parameters:

ctx – context variable

Returns:

The largest double of the given machine

int PGAGetMaxMachineIntValue(PGAContext *ctx)

Return the largest integer of the current machine.

Example

PGAContext *ctx;
int intmax;

...
intmax = PGAGetMaxMachineIntValue (ctx);

Parameters:

ctx – context variable

Returns:

The largest integer of the given machine

double PGAGetMaxRealInitValue(PGAContext *ctx, int i)

Return the maximum value used to randomly initialize allele i in a real string.

Example

PGAContext *ctx;
int max;

...
max = PGAGetMaxRealInitValue (ctx, 0);

Parameters:

ctx – context variable
i – an allele position

Returns:

The maximum value used to randomly initialize allele i

int PGAGetMaxSimilarityValue(PGAContext *ctx)

Get the maximum percent of homogeneity of the population before stopping.

Example

PGAContext *ctx;
int max_similarity;

...
max_similarity = PGAGetMaxSimilarityValue (ctx);

Parameters:

ctx – context variable

Returns:

the maximum percent of the population that can share the same evaluation function value

int PGAGetMinIntegerInitValue(PGAContext *ctx, int i)

Return the minimum of the range of integers used to randomly initialize integer strings.

Example

PGAContext *ctx;
int min;
int idx;

...
min = PGAGetMinIntegerInitValue (ctx, idx);

Parameters:

ctx – context variable
i – Index of the initialization range

Returns:

The minimum of the range of integers used to randomly initialize integer strings

double PGAGetMinMachineDoubleValue(PGAContext *ctx)

Return the smallest double of the current machine.

Example

PGAContext *ctx;
double small;

...
small = PGAGetMinMachineDoubleValue (ctx);

Parameters:

ctx – context variable

Returns:

The smallest double of the given machine

int PGAGetMinMachineIntValue(PGAContext *ctx)

Return the smallest integer of the current machine.

Example

PGAContext *ctx;
int intmin;

...
intmin = PGAGetMinMachineIntValue (ctx);

Parameters:

ctx – context variable

Returns:

The smallest integer of the given machine

double PGAGetMinRealInitValue(PGAContext *ctx, int i)

Returns the minimum value used to randomly initialize allele i in a real string.

Example

PGAContext *ctx;
int min;

...
min = PGAGetMinRealInitValue (ctx, 0);

Parameters:

ctx – context variable
i – an allele position

Returns:

The minimum value used to randomly initialize allele i

int PGAGetMixingType(PGAContext *ctx)

Return the strategy setting for combination of mutation and crossover.

Example

PGAContext *ctx;
int mixtype;

...
mixtype = PGAGetMixingType (ctx);

Parameters:

ctx – context variable

Returns:

Return the mixing type

int PGAGetMultiObjPrecision(PGAContext *ctx)

Return the precision for printing multi objective optimization evaluations.

Example

PGAContext *ctx;
int prec;

...
prec = PGAGetMultiObjPrecision (ctx);

Parameters:

ctx – context variable

Returns:

The precision of printing multi objective evaluations

int PGAGetMutationBounceBackFlag(PGAContext *ctx)

Return flag to indicate whether mutated strings remain within the initialization range by bouncing them from the boundary.

Example

PGAContext *ctx;
int val;

...
val = PGAGetMutationBounceBackFlag (ctx);

Parameters:

ctx – context variable

Returns:

true if restricted to the given range

int PGAGetMutationBoundedFlag(PGAContext *ctx)

Return flag to indicate whether mutated integer strings remain in the initialization range.

Description

The initialization range is specified when initialized with PGASetIntegerInitRange().

Example

PGAContext *ctx;
int val;

...
val = PGAGetMutationBoundedFlag (ctx);

Parameters:

ctx – context variable

Returns:

true if restricted to the given range

int PGAGetMutationIntegerValue(PGAContext *ctx)

Return the value of the multiplier used to mutate data type integer strings with.

Example

PGAContext *ctx;
int ival;

...
ival = PGAGetMutationIntegerValue (ctx);

Parameters:

ctx – context variable

Returns:

The value of the multiplier

double PGAGetMutationPolyEta(PGAContext *ctx)

Return the Eta for polynomial mutation.

Example

PGAContext *ctx;
double eta;

...
eta = PGAGetMutationPolyEta (ctx);

Parameters:

ctx – context variable

Returns:

The eta for polynomial mutation

double PGAGetMutationPolyValue(PGAContext *ctx)

Return the value for polynomial mutation.

Example

PGAContext *ctx;
double v;

...
v = PGAGetMutationPolyValue (ctx);

Parameters:

ctx – context variable

Returns:

The value for polynomial mutation

double PGAGetMutationProb(PGAContext *ctx)

Return the probability of mutation.

Example

PGAContext *ctx;
double pm;

...
pm = PGAGetMutationProb (ctx);

Parameters:

ctx – context variable

Returns:

The mutation probability

double PGAGetMutationRealValue(PGAContext *ctx)

Return the value of the multiplier used to mutate strings of data type real with.

Example

PGAContext *ctx;
double val;

...
val = PGAGetMutationRealValue (ctx);

Parameters:

ctx – context variable

Returns:

The value of the multiplier

int PGAGetMutationType(PGAContext *ctx)

Return the type of mutation used.

Example

PGAContext *ctx;
int mutatetype;

...
mutatetype = PGAGetMutationType (ctx);
switch (mutatetype) {
case PGA_MUTATION_CONSTANT:
    printf ("Mutation Type = PGA_MUTATION_CONSTANT\n");
    break;
case PGA_MUTATION_RANGE:
    printf ("Mutation Type = PGA_MUTATION_RANGE\n");
    break;
case PGA_MUTATION_UNIFORM:
    printf ("Mutation Type = PGA_MUTATION_UNIFORM\n");
    break;
case PGA_MUTATION_GAUSSIAN:
    printf ("Mutation Type = PGA_MUTATION_GAUSSIAN\n");
    break;
case PGA_MUTATION_PERMUTE:
    printf ("Mutation Type = PGA_MUTATION_PERMUTE\n");
    break;
case PGA_MUTATION_DE:
    printf ("Mutation Type = PGA_MUTATION_DE\n");
    break;
case PGA_MUTATION_POLY:
    printf ("Mutation Type = PGA_MUTATION_POLY\n");
    break;
}

Parameters:

ctx – context variable

Returns:

Returns the integer corresponding to the symbolic constant used to specify the type of mutation specified

int PGAGetNAMWindowSize(PGAContext *ctx)

Get window size for negative assortative mating (NAM).

Description

On selection select first individual as configured, for the second individual draw wsize individuals and select the one that has the largest genetic difference to the first individual. The default window size 1 doesn’t use NAM. See description [FR01]. This gets the currently configured NAM window size.

Example

PGAContext *ctx,
int wsize;

...
wsize = PGAGetNAMWindowSize (ctx);

Parameters:

ctx – context variable

Returns:

Window size for NAM

int PGAGetNoDuplicatesFlag(PGAContext *ctx)

Return PGA_TRUE if duplicates are not allowed, else return PGA_FALSE.

Example

PGAContext *ctx;

...
if (PGAGetNoDuplicatesFlag (ctx)) {
    printf ("Duplicate strings not allowed in population\n");
} else {
    printf ("Duplicate strings allowed in population\n");
}

Parameters:

ctx – context variable

Returns:

The value of the NoDuplicates flag

int PGAGetNumAuxEval(PGAContext *ctx)

Get the number of auxiliary evaluations.

Example

PGAContext *ctx;
int num;

...
num = PGAGetNumAuxEval (ctx);

Parameters:

ctx – context variable

Returns:

Number of auxiliary evaluations

int PGAGetNumConstraint(PGAContext *ctx)

Get the number of constraints.

Example

PGAContext *ctx;
int num;

...
num = PGAGetNumConstraint (ctx);

Parameters:

ctx – context variable

Returns:

Number of constraints

int PGAGetNumReplaceValue(PGAContext *ctx)

Return the maximum number of strings to replace in each generation.

Example

PGAContext *ctx;
int numreplace;

...
numreplace = PGAGetNumReplaceValue (ctx);

Parameters:

ctx – context variable

Returns:

The maximum number number of strings to replace each generation

int PGAGetOptDirFlag(PGAContext *ctx)

Return a symbolic constant that represents the direction of optimization.

Example

PGAContext *ctx;
int optdir;

...
optdir = PGAGetOptDirFlag (ctx);
switch (optdir) {
case PGA_MAXIMIZE:
    printf ("Optimization direction = PGA_MAXIMIZE\n");
    break;
case PGA_MINIMIZE:
    printf ("Optimization direction = PGA_MINIMIZE\n");
    break;
}

Parameters:

ctx – context variable

Returns:

The integer corresponding to the symbolic constant used to specify the direction of optimization

double PGAGetPTournamentProb(PGAContext *ctx)

Return the probability of selecting the best string in a probabilistic binary tournament.

Example

PGAContext *ctx;
double pt;

...
pt = PGAGetPTournamentProb (ctx);

Parameters:

ctx – context variable

Returns:

The probabilistic binary tournament selection probability

int PGAGetPopReplaceType(PGAContext *ctx)

Return the symbolic constant used to determine which strings to copy from the old population to the new population.

Example

PGAContext *ctx;
int popreplace;

...
popreplace = PGAGetPopReplaceType (ctx);
switch (popreplace) {
case PGA_POPREPL_BEST:
    printf ("Replacement Strategy = PGA_POPREPL_BEST\n");
    break;
case PGA_POPREPL_RANDOM_REP:
    printf ("Replacement Strategy = PGA_POPREPL_RANDOM_REP\n");
    break;
case PGA_POPREPL_RANDOM_NOREP:
    printf ("Replacement Strategy = PGA_POPREPL_RANDOM_NOREP\n");
    break;
default:
    printf ("Another Replacement Strategy\n");
    break;
}

Parameters:

ctx – context variable

Returns:

The symbolic constant of the replacement strategy

int PGAGetPopSize(PGAContext *ctx)

Return the population size.

Example

PGAContext *ctx;
int popsize;

...
popsize = PGAGetPopSize (ctx);

Parameters:

ctx – context variable

Returns:

The population size

int PGAGetPrintFrequencyValue(PGAContext *ctx)

Return how often to print statistics reports.

Example

PGAContext *ctx;
int freq;

...
freq = PGAGetPrintFrequencyValue (ctx);

Parameters:

ctx – context variable

Returns:

The frequency of printing output

int PGAGetRTRWindowSize(PGAContext *ctx)

Return the window size for restricted tournament replacement.

Example

PGAContext *ctx;
int windowsize;

...
windowsize = PGAGetRTRWindowSize (ctx);

Parameters:

ctx – context variable

Returns:

The size of the window for restricted tournament selection

int PGAGetRandomInitFlag(PGAContext *ctx)

Return true/false to indicate whether or not alleles are randomly initialized.

Example

PGAContext *ctx;

...
if (PGAGetRandomInitFlag (ctx)) {
    printf ("Population is randomly initialized\n");
} else {
    printf ("Population initialized to zero\n");
}

Parameters:

ctx – context variable

Returns:

Return true if alleles are randomly initialized

int PGAGetRandomSeed(PGAContext *ctx)

Return the integer the random number generator was seeded with.

Example

PGAContext *ctx;
int seed;

...
seed = PGAGetRandomSeed (ctx);

Parameters:

ctx – context variable

Returns:

The seed for the random number generator

int PGAGetRandomizeSelect(PGAContext *ctx)

Return the setting for additional select randomization.

Description

This function will return PGA_TRUE if a second randomization step after selection is performed. All selection schemes except PGA_SELECT_SUS already return the individuals in randomized order, previously this was randomized again. With this method you can find out if the randomization for selection schemes other than PGA_SELECT_SUS (for which a randomization step is always performed)

Example

PGAContext *ctx;
int v;

...
v = PGAGetRandomizeSelect (ctx);

Parameters:

ctx – context variable

Returns:

The setting of select randomization, true if on

int PGAGetRealInitType(PGAContext *ctx)

Return the type of scheme used to randomly initialize strings of data type real.

Example

PGAContext *ctx;
int inittype;

...
inittype = PGAGetRealInitType (ctx);
switch (inittype) {
case PGA_RINIT_PERCENT:
    printf ("Data Type = PGA_RINIT_PERCENT\n");
    break;
case PGA_RINIT_RANGE:
    printf ("Data Type = PGA_RINIT_RANGE\n");
    break;
}

Parameters:

ctx – context variable

Returns:

Returns the integer corresponding to the symbolic constant used to specify the scheme used to initialize real strings

double PGAGetRestartAlleleChangeProb(PGAContext *ctx)

Return the probability with which an allele will be mutated during a restart.

Example

PGAContext *ctx;
double prob;

...
prob = PGAGetRestartAlleleChangeProb (ctx);

Parameters:

ctx – context variable

Returns:

The probability of mutating an allele during a restart

int PGAGetRestartFlag(PGAContext *ctx)

Return whether the algorithm should employ the restart operator.

Example

PGAContext *ctx;
int val;

...
val = PGAGetRestartFlag (ctx);

Parameters:

ctx – context variable

Returns:

true if restarting is enabled

int PGAGetRestartFrequencyValue(PGAContext *ctx)

Return the number of iterations of no change in the best string after which the algorithm should restart.

Example

PGAContext *ctx;
int frq;

...
frq = PGAGetRestartFrequencyValue (ctx);

Parameters:

ctx – context variable

Returns:

The number of iteration of no change required for a restart

int PGAGetSelectType(PGAContext *ctx)

Return the type of selection selected.

Example

PGAContext *ctx;
int selecttype;

...
selecttype = PGAGetSelectType (ctx);
switch (selecttype) {
case PGA_SELECT_PROPORTIONAL:
    printf ("Selection Type = PGA_SELECT_PROPORTIONAL\n");
    break;
case PGA_SELECT_SUS:
    printf ("Selection Type = PGA_SELECT_SUS\n");
    break;
case PGA_SELECT_TOURNAMENT:
    printf ("Selection Type = PGA_SELECT_TOURNAMENT\n");
    break;
case PGA_SELECT_PTOURNAMENT:
    printf ("Selection Type = PGA_SELECT_PTOURNAMENT\n");
    break;
case PGA_SELECT_TRUNCATION:
    printf ("Selection Type = PGA_SELECT_TRUNCATION\n");
    break;
}

Parameters:

ctx – context variable

Returns:

Return the integer corresponding to the symbolic constant used to specify the type of selection specified

int PGAGetSortedPopIndex(PGAContext *ctx, int n)

Return a population string index from the array created by sorting of the population.

Example

Copy the five best strings from the old population into the new population. The rest of the new population will be created by recombination, and is not shown.

PGAContext *ctx;
int i, j;

...
PGASetPopReplaceType (ctx,PGA_POPREPL_BEST)
PGASortPop (ctx, PGA_OLDPOP);
for (i=0; i<5; i++) {
    j = PGAGetSortedPopIndex (ctx, i);
    PGACopyIndividual (ctx, j, PGA_OLDPOP, i, PGA_NEWPOP);
}

Parameters:

ctx – context variable
n – specified which index element is to be returned.

Returns:

A population string index from the array created by PGASortPop

int PGAGetStoppingRuleType(PGAContext *ctx)

Return a symbolic constant that defines the termination criteria.

Example

PGAContext *ctx;
int stop;

...
stop = PGAGetStoppingRuleType (ctx);
if (stop & PGA_STOP_MAXITER) {
    printf ("Stopping Rule = PGA_STOP_MAXITER\n");
}
if (stop & PGA_STOP_NOCHANGE) {
    printf ("Stopping Rule = PGA_STOP_NOCHANGE\n");
}
if (stop & PGA_STOP_TOOSIMILAR) {
    printf ("Stopping Rule = PGA_STOP_TOOSIMILAR\n");
}

Parameters:

ctx – context variable

Returns:

Return an integer which is an ORed mask of the symbolic constants used to specify the stopping rule(s).

int PGAGetStringLength(PGAContext *ctx)

Return the string length.

Example

PGAContext *ctx;
int stringlen;

...
stringlen = PGAGetStringLength (ctx);

Parameters:

ctx – context variable

Returns:

The string length

int PGAGetSumConstraintsFlag(PGAContext *ctx)

Query if constraints are summed or optimized by NSGA-II nondominated sorting.

Example

PGAContext *ctx;
int n;

...
n = PGAGetSumConstraintsFlag (ctx);

Parameters:

ctx – context variable

Returns:

sum constraints flag

double PGAGetTournamentSize(PGAContext *ctx)

Return the number of participants in a tournament.

Example

PGAContext *ctx;
double sz;

...
sz = PGAGetTournamentSize (ctx);

Parameters:

ctx – context variable

Returns:

The number of participants in a non probabilistic tournament

int PGAGetTournamentWithReplacement(PGAContext *ctx)

Return the setting for tournament sampling, true if with replacement.

Example

PGAContext *ctx;
int v;

...
v = PGAGetTournamentWithReplacement (ctx);

Parameters:

ctx – context variable

Returns:

The setting of tournament with/without replacement, true if with replacement

double PGAGetTruncationProportion(PGAContext *ctx)

Return the proportion of best individuals selected in truncation selection.

Example

PGAContext *ctx;
double v;

...
v = PGAGetTruncationProportion (ctx);

Parameters:

ctx – context variable

Returns:

Proportion of best individuals selected in truncation selection

double PGAGetUniformCrossoverProb(PGAContext *ctx)

Return the probability of an allele being selected from the first child string in uniform crossover.

Example

PGAContext *ctx;
double pu;

...
pu = PGAGetUniformCrossoverProb (ctx);

Parameters:

ctx – context variable

Returns:

The uniform crossover probability

int PGAGetWorstIndex(PGAContext *ctx, int pop)

Return the index of the string with the worst evaluation function value in population pop.

Example

PGAContext *ctx;
int worst;

...
worst = PGAGetWorstIndex (ctx, PGA_OLDPOP);

Parameters:

ctx – context variable
pop – symbolic constant of the population to find the worst string in

Returns:

Index of the string with the worst evaluation function value

Deprecated

group deprecated

Deprecated functions, see doc for replacement.

Functions

int PGAGetMutationAndCrossoverFlag(PGAContext *ctx)

Return true if mutation occurs only when crossover does.

Description

Note: This is a legacy interface. If mixing types other than PGA_MIX_MUTATE_OR_CROSS and PGA_MIX_MUTATE_AND_CROSS have been set this might return wrong values, use PGAGetMixingType() instead. Do not use this for new code.

Parameters:

ctx – context variable

Returns:

Return true if mutation is applied to crossed-over strings

int PGAGetMutationOnlyFlag(PGAContext *ctx)

Return true if only mutation is used.

Description

Note: This is a legacy interface, use PGAGetMixingType() instead. Do not use this for new code.

Parameters:

ctx – context variable

Returns:

flag to indicate if only mutation is applied

int PGAGetMutationOrCrossoverFlag(PGAContext *ctx)

Return true if mutation only occurs when crossover does not.

Description

Note: This is a legacy interface. If mixing types other than PGA_MIX_MUTATE_OR_CROSS and PGA_MIX_MUTATE_AND_CROSS have been set this might return wrong values, use PGAGetMixingType() instead. Do not use this for new code.

Parameters:

ctx – context variable

Returns:

Return true if mutation only occurs when crossover does not

void PGASetMutationAndCrossoverFlag(PGAContext *ctx, int flag)

Set a boolean flag to indicate if recombination uses both crossover and mutation on selected strings.

Description

Note: This is a legacy interface, use PGASetMixingType() instead. Do not use this for new code.

Parameters:

ctx – context variable
flag – PGA_TRUE (default) or PGA_FALSE

Returns:

None

void PGASetMutationOnlyFlag(PGAContext *ctx, int flag)

Set a boolean flag to indicate that recombination uses mutation only.

Description

Note: This is a legacy interface, use PGASetMixingType() instead. Note: This will override settings of PGASetMutationOrCrossoverFlag() and PGASetMutationAndCrossoverFlag() and will set the default (PGASetMutationOrCrossoverFlag()) when using PGA_FALSE as the flag. Do not use this for new code.

Parameters:

ctx – context variable
flag – to indicate if only mutation is used

Returns:

None

void PGASetMutationOrCrossoverFlag(PGAContext *ctx, int flag)

Set a boolean flag to indicate if recombination uses exactly one of crossover or mutation on selected strings.

Description

Note: This is a legacy interface, use PGASetMixingType() instead. Do not use this for new code.

Parameters:

ctx – context variable
flag – to indicate if mutation uses exactly one of crossover or mutation

Returns:

None

static inline void PGASetRealInitPercent(PGAContext *ctx, double *median, double *frac)

Set the upper and lower bounds for randomly initializing real-valued genes.

Description

This function is deprecated due to wrong naming: The last parameter was always a fraction, not a percentage. It is kept for backwards compatibility, do not use for new code. Use PGASetRealInitFraction() instead.

Parameters:

ctx – context variable
median – an array containing the mean value of the interval
frac – an array containing the fraction of median to add and subtract to/from the median to define the interval

Returns:

None

Function Groups Explicit Usage

Command Line

group cmdline

Functions

void PGAReadCmdLine(PGAContext *ctx, int *argc, char **argv)

Code that looks at the arguments, recognizes any that are for PGAPack, uses the arguments, and removes them from the command line args.

Example

int main (int argc, char **argv)
{
    PGAContext *ctx;

    PGAReadCmdLine (ctx, &argc, argv);
}

Parameters:

ctx – context variable
argc – address of the count of the number of command line arguments
argv – array of command line arguments

Returns:

None

Debugging

group debug

Functions for debugging function calls.

Functions

void PGAClearDebugLevel(PGAContext *ctx, int level)

Turn off a debug level.

Description

Only does anything if PGAPack was compiled to include debugging calls. See chapter Debugging Tools in the user guide for details.

Example

PGAContext *ctx;

...
PGAClearDebugLevel (ctx, 70);

Parameters:

ctx – context variable
level – the debug level to turn off

Returns:

None

void PGAClearDebugLevelByName(PGAContext *ctx, char *funcname)

Turn off debugging of the named function.

Example

PGAContext *ctx;

...
PGAClearDebugLevelByName (ctx, "PGAGetBinaryAllele");

Parameters:

ctx – context variable
funcname – name of the function to turn off debugging output

Returns:

None

void PGADebugPrint(PGAContext *ctx, int level, char *funcname, char *msg, int datatype, void *data)

Write debugging information.

Description

Valid values for level are PGA_DEBUG_ENTERED, PGA_DEBUG_EXIT, PGA_DEBUG_MALLOC, PGA_DEBUG_PRINTVAR, PGA_DEBUG_SEND, and PGA_DEBUG_RECV. See Debugging Constants for the constants and chapter Debugging Tools in the user guide for details.

Valid values for the datatype argument are PGA_INT, PGA_DOUBLE, PGA_CHAR and PGA_VOID (no data). The parameter data should be NULL, for PGA_VOID. See Constants for Error Printing for the constants in the user guide for details.

Example

If the debugging level includes printing variables (level 82), print the value of the integer variable num as a debugging tool in the routine Add2Nums.

PGAContext *ctx;
int num;

...
PGADebugPrint
   ( ctx, PGA_DEBUG_PRINTVAR
   , "Add2Nums", "num = ", PGA_INT, (void *) &num
   );

Parameters:

ctx – context variable
level – a symbolic constant that maps to the type of print requested (e.g., an entry or exit print).
funcname – the name of the function that called this routine
msg – message to print
datatype – a symbolic constant that maps to the data type of the parameter data
data – a pointer, whose contents will be interpreted based upon the datatype parameter

Returns:

The debugging information is printed to stdout

void PGASetDebugLevel(PGAContext *ctx, int level)

Turn on a debug level.

Description

Only does anything if PGAPack was compiled to include debugging calls. See chapter Debugging Tools in the user guide for details.

Example

PGAContext *ctx;

...
PGASetDebugLevel (ctx, 70);

Parameters:

ctx – context variable
level – the debug level to set

Returns:

None

void PGASetDebugLevelByName(PGAContext *ctx, char *funcname)

Turn on debugging of the named function.

Example

PGAContext *ctx;

...
PGASetDebugLevelByName (ctx, "PGAGetBinaryAllele");

Parameters:

ctx – context variable
funcname – name of the function to turn on debugging output

Returns:

None

Explicit Usage

group explicit

These functions are needed when explicitly programming the GA.

See chapter Explicit Usage for more details.

Functions

void INDCopyIndividual(PGAIndividual *src, PGAIndividual *dst)

Copy individual source to individual dest.

Example

PGAContext *ctx;
PGAIndividual *source, *dest;

...
INDCopyIndividual (ctx, source, dest);

Parameters:

src – Individual to copy
dst – Individual to copy ind1 to

Returns:

Individual dest is a copy of Individual source

MPI_Datatype PGABuildDatatype(PGAContext *ctx, int p, int pop)

Build an MPI datatype for string p in population pop.

Example

PGAContext *ctx;
int p;
MPI_Datatype dt;

...
dt = PGABuildDatatype (ctx, p, PGA_NEWPOP);

Parameters:

ctx – context variable
p – index of an individual
pop – symbolic constant of the population

Returns:

An MPI datatype for member p of population pop

int PGABuildDatatypeHeader(PGAContext *ctx, int p, int pop, int *counts, MPI_Aint *displs, MPI_Datatype *types)

Common part for building an MPI datatype for an individual.

Description

Returns by side effect a partially filled array of counts, displs, types. The returned index will be max PGA_MPI_HEADER_ELEMENTS. This means callers may use a statically allocated buffer.

Example

PGAContext *ctx;
int idx = 0;
int counts [PGA_MPI_HEADER_ELEMENTS + ...];
int displs [PGA_MPI_HEADER_ELEMENTS + ...];
MPI_Datatype types [PGA_MPI_HEADER_ELEMENTS + ...];

...
idx = PGABuildDatatypeHeader (ctx, counts, displs, types);
// Fill rest of counts, displs, types here and build datatype
counts [idx] =
displs [idx] =
types  [idx] =
idx++;
...

Parameters:

ctx – context variable
p – index of string
pop – symbolic constant of the population string p is in
counts – Number of elements in each block
displs – byte displacement array pointer
types – type elements

Returns:

The index of the next-to-be-filled counts, displs, types

void PGAChange(PGAContext *ctx, int p, int pop)

Repeatedly apply mutation to a string (with an increasing mutation rate) until one or more mutations have occurred.

Description

This routine is usually used with PGADuplicate() to modify a duplicate string. It is not intended to replace PGAMutate().

Example

Check the current to-be-inserted string if it is a copy of any of the strings in PGA_NEWPOP. Note that the check relies on all individuals in PGA_NEWPOP to also be inserted into the duplicate hash, see PGAHashIndividual().

PGAContext *ctx;
int p;

...
while (PGADuplicate (ctx, p, PGA_NEWNEW, PGA_NEWPOP)) {
    PGAChange (ctx, p, PGA_NEWPOP);
}

Parameters:

ctx – context variable
p – string index
pop – symbolic constant of the population containing string p

Returns:

Mutates string p in population pop via side effect

void PGACopyIndividual(PGAContext *ctx, int p1, int pop1, int p2, int pop2)

Copy string p1 in population pop1 to position p2 in population pop2.

Example

PGAContext *ctx;
int i, j;

...
PGACopyIndividual (ctx, i, PGA_OLDPOP, j, PGA_NEWPOP);

Parameters:

ctx – context variable
p1 – string to copy
pop1 – symbolic constant of population containing string p1
p2 – string to copy p1 to
pop2 – symbolic constant of population containing string p2

Returns:

String p2 is an exact copy of string p1

void PGACrossover(PGAContext *ctx, int p1, int p2, int pop1, int c1, int c2, int pop2)

Perform crossover on two parent strings to create two child strings (via side-effect).

Description

The type of crossover performed is either the default or that specified by PGASetCrossoverType().

Example

Perform crossover on the two parent strings mom and dad in population PGA_OLDPOP, and insert the child strings, child1 and child1, in population PGA_NEWPOP.

PGAContext *ctx;
int mom, dad, child1, child2;

...
PGACrossover (ctx, mom, dad, PGA_OLDPOP, child1, child2, PGA_NEWPOP);

Parameters:

ctx – the context variable
p1 – the first parent string
p2 – the second parent string
pop1 – symbolic constant of the population containing string p1 and p2
c1 – the first child string
c2 – the second child string
pop2 – symbolic constant of the population to contain string c1 and c2

Returns:

c1 and c2 in pop2 are children of p1 and p2 in pop1. p1 and p2 are not modified.

int PGADone(PGAContext *ctx, MPI_Comm comm)

Return true if the stopping conditions have been met.

Description

Calls exactly one of the user defined C or Fortran or system PGACheckStoppingConditions() stopping condition functions.

Example

PGAContext *ctx;

...
PGADone (ctx, comm);

Parameters:

ctx – context variable
comm – an MPI communicator

Returns:

return true if at least one of the termination conditions has been met

int PGADuplicate(PGAContext *ctx, int p, int pop1, int pop2)

Determine if a specified string is a duplicate of one already in an existing population.

Description

Return PGA_TRUE if PGAGetNoDuplicatesFlag() returns PGA_TRUE and string p in population pop1 is a duplicate of at least one strings already inserted into population pop2, otherwise return PGA_FALSE.

Example

Check the current to-be-inserted string if it is a copy of any of the strings in PGA_NEWPOP. Note that the check relies on all individuals in PGA_NEWPOP to also be inserted into the duplicate hash, see PGAHashIndividual().

PGAContext *ctx;
int p;

...
while (PGADuplicate (ctx, p, PGA_NEWNEW, PGA_NEWPOP)) {
    PGAChange (ctx, p, PGA_NEWPOP);
}

Parameters:

ctx – context variable
p – string index
pop1 – symbolic constant of the population containing string p
pop2 – symbolic constant of the (possibly partial) population containing strings to compare string p against

Returns:

Return true if duplicate

void PGAEvaluate(PGAContext *ctx, int pop, double (*evaluate)(PGAContext*, int, int, double*), MPI_Comm comm)

Call a user-specified function to return an evaluation of each string in the population.

Description

The user-specified function is only called if the string has been changed (e.g., by crossover or mutation) or the user has explicitly signaled the string’s evaluation is out-of-date by a call to PGASetEvaluationUpToDateFlag().

The user-specified function will be called once for each string in population pop that requires evaluation. This function must return a double (the evaluation function value) and must fit the prototype:

double evaluate (PGAContext *c, int p, int pop, double *aux);

Example

Evaluate all strings in population PGA_NEWPOP using the user-defined evaluation function Energy.

double Energy (PGAContext *ctx, int p, int pop, double *aux) {
    ...
};

PGAContext *ctx;

...
PGAEvaluate (ctx, PGA_NEWPOP, Energy, MPI_COMM_WORLD);

Parameters:

ctx – context variable
pop – symbolic constant of the population to be evaluated
evaluate – a pointer to a function to evaluate a string.
comm – an MPI communicator

Returns:

Evaluates the population via side effect

double PGAGeneDistance(PGAContext *ctx, int pop)

Calculate the mean genetic distance for a population.

Description

This function has effort \(O(n^2)\) in the population size \(n\). It is very useful for detecting premature convergence and is used when genetic distance reporting has been turned on with PGA_REPORT_GENE_DISTANCE.

Example

PGAContext *ctx;
double gd;

...
gd = PGAGeneDistance (ctx, PGA_NEWPOP);

Parameters:

ctx – context variable
pop – symbolic constant of the population for which the genetic distance is to be calculated

Returns:

The mean genetic distance in the population

void PGAHashIndividual(PGAContext *ctx, int p, int pop)

Compute Hash for this individual and insert into hash-table.

Description

Calls PGAIndividualHashIndex() for the hash value and puts it into the correct hash bucket.

Parameters:

ctx – context variable
p – string index
pop – symbolic constant of the population containing string p

Returns:

Computes hash of given individual and inserts it into hash table

int PGAMutate(PGAContext *ctx, int p, int pop)

Perform mutation on a string.

Description

The type of mutation depends on the data type. Refer to section Mutation in the user guide for data-specific examples.

Example

Mutate the best string in the population, until 10 or more mutations have occured.

PGAContext *ctx;
int p, count = 0;

...
p = PGAGetBestIndex (ctx, PGA_NEWPOP);
while (count < 10) {
    count += PGAMutate (ctx, p, PGA_NEWPOP);
}

Parameters:

ctx – context variable
p – index of string to mutate
pop – symbolic constant of the population containing p

Returns:

The number of mutations performed. Member p in population pop is mutated by side-effect

void PGAPairwiseBestReplacement(PGAContext *ctx)

Perform pairwise best replacement.

Description

Compare individuals with same index in PGA_OLDPOP and PGA_NEWPOP and select the one with better evalutation. Note that we may not use the fitness here: Fitness from two different populations are uncompareable! This replacement strategy is used in evolutionary algorithms that modify a single individual and replace the parent if the offspring is better. A popular example is Differential Evolution (DE). After this populations are swapped (exchange of PGA_NEWPOP and PGA_OLDPOP) for further processing.

Example

PGAContext *ctx;

...
PGAPairwiseBestReplacement (ctx);

Parameters:

ctx – context variable

Returns:

None

void PGAReceiveIndividual(PGAContext *ctx, int p, int pop, int source, int tag, MPI_Comm comm, MPI_Status *status)

Receive an individual from another process.

Description

This is usually called by one of the functions called via PGAEvaluate().

Example

Receive a string from the rank-0 process with tag PGA_SR_STRINGTOEVAL, and place it into the first temporary location in PGA_NEWPOP.

PGAContext *ctx;
MPI_Comm    comm;
MPI_Status  status;

...
PGAReceiveIndividual
  (ctx, PGA_TEMP1, PGA_NEWPOP, 0, PGA_SR_STRINGTOEVAL, comm, &status);

Parameters:

ctx – contex variable
p – index of an individual
pop – symbolic constant of the population
source – ID of the process from which to receive
tag – MPI tag to look for
comm – MPI communicator
status – pointer to an MPI status structure

Returns:

Status and string p in population pop are changed by side-effect

void PGARestart(PGAContext *ctx, int source_pop, int dest_pop)

Reseed a population from the best string.

Description

Perform mutation on the best string. For integers and reals, the amount by which to change is set with PGASetMutationIntegerValue() and PGASetMutationRealValue(), respectively. For binary strings, the bits are complemented.

Example

Perform an unspecified test to determine if the current evolution is not evolving fast enough, and if so, restart the evolution.

PGAContext *ctx;
...
PGAEvaluate (ctx, PGA_OLDPOP, f, comm);
PGAFitness  (ctx, PGA_OLDPOP);

...
if (StagnantEvolution ()) {
    PGARestart  (ctx, PGA_OLDPOP, PGA_NEWPOP);
    PGAEvaluate (ctx, PGA_NEWPOP, EvalFunc);
    PGAUpdateGeneration (ctx);
}

Parameters:

ctx – context variable
source_pop – symbolic constant of the source population
dest_pop – symbolic constant of the destination population

Returns:

dest_pop is modified by side-effect

void PGARestrictedTournamentReplacement(PGAContext *ctx)

Perform restricted tournament replacement.

Description

For each individual in PGA_NEWPOP we select a window of individuals from PGA_OLDPOP, find the one genetically most like the new candidate and replace the individual if the new candidate has better evalutation. Note that we may not use the fitness here: Fitness from two different populations are uncompareable! After this populations are swapped (exchange of PGA_NEWPOP and PGA_OLDPOP) for further processing.

Example

PGAContext *ctx;

...
PGARestrictedTournamentReplacement (ctx);

Parameters:

ctx – context variable

Returns:

None

void PGARunGM(PGAContext *ctx, double (*evaluate)(PGAContext*, int, int, double*), MPI_Comm comm)

High-level routine to execute the genetic algorithm using the global model.

Description

It is called after PGACreate() and PGASetUp() have been called. If a NULL communicator is given, a sequential execution method is used, otherwise, work is divided among the processors in the communicator.

Example

PGAContext *ctx;
double f (PGAContext *ctx, int p, int pop, double *aux);

...
PGARunGM (ctx, f, MPI_COMM_WORLD);

Parameters:

ctx – context variable
evaluate – a pointer to the user’s evaluation function, which must have the calling sequence shown in the example
comm – an MPI communicator

Returns:

None

void PGARunMutationAndCrossover(PGAContext *ctx, int oldpop, int newpop)

Perform crossover and mutation from one population to create the next.

Description

Assumes PGASelect() has been called.

Example

PGAContext *ctx;

...
PGARunMutationAndCrossover (ctx, PGA_OLDPOP, PGA_NEWPOP);

Parameters:

ctx – context variable
oldpop – symbolic constant of old population
newpop – symbolic constant of new population

Returns:

newpop is modified by side-effect

void PGARunMutationOnly(PGAContext *ctx, int oldpop, int newpop)

Perform only mutation.

Description

Assumes PGASelect() has been called.

Example

PGAContext *ctx;

...
PGARunMutationOnly (ctx, PGA_OLDPOP, PGA_NEWPOP);

Parameters:

ctx – context variable
oldpop – symbolic constant of old population
newpop – symbolic constant of new population

Returns:

newpop is modified by side-effect

void PGARunMutationOrCrossover(PGAContext *ctx, int oldpop, int newpop)

Perform crossover or mutation (but not both) from one population to create the next.

Description

Assumes PGASelect() has been called.

Example

PGAContext *ctx;

...
PGARunMutationOrCrossover (ctx, PGA_OLDPOP, PGA_NEWPOP);

Parameters:

ctx – context variable
oldpop – symbolic constant of old population
newpop – symbolic constant of new population

Returns:

newpop is modified by side-effect

void PGASelect(PGAContext *ctx, int popix)

Perform genetic algorithm selection using the defined selection scheme.

Description

The selection scheme used is either the default selection scheme or that specified with PGASetSelectType().

Valid selection methods are proportional, stochastic universal, tournament, probabilistic tournament selection, truncation selection, or linear selection with macros PGA_SELECT_PROPORTIONAL, PGA_SELECT_SUS, PGA_SELECT_TOURNAMENT, PGA_SELECT_PTOURNAMENT, PGA_SELECT_TRUNCATION, PGA_SELECT_LINEAR respectively. This function updates an internal array with the indices of members of popix selected for recombination. These indices may be accessed with PGASelectNextIndex(). See Constants for Selection Types for the constants and section Selection in the user guide for details.

Example

PGAContext *ctx,

...
PGASelect (ctx, PGA_OLDPOP);

Parameters:

ctx – context variable
popix – symbolic constant of population to select from

Returns:

An array used by PGASelectNextIndex is created which contains the population indices of the selected individuals

int PGASelectNextIndex(PGAContext *ctx, int popix)

Return the index of next individual in internal array.

Description

The internal array used contains the indices determined by PGASelect().

Example

PGAContext *ctx;
int l;

...
l = PGASelectNextIndex (ctx, PGA_OLDPOP);

Parameters:

ctx – context variable
popix – the population index, typically PGA_OLDPOP

Returns:

A population index for the next selected creature

int PGASelectNextNAMIndex(PGAContext *ctx, int p1, int popix)

Return the index of next individual in internal array taking into account the genetic distance if negative assortative mating (NAM) is configured.

Description

Select the next index out of NAMWindow items that is genetically most distant from the first selected individual given in p1. Ties are broken by considering better evaluation.

Example

PGAContext *ctx;
int l;

...
l = PGASelectNextNAMIndex (ctx, PGA_OLDPOP);

Parameters:

ctx – context variable
p1 – Index of first individual selected
popix – the population index, typically PGA_OLDPOP

Returns:

A population index for the next selected creature taking NAM into account

void PGASendIndividual(PGAContext *ctx, int p, int pop, int dest, int tag, MPI_Comm comm)

Transmit an individual to another process.

Description

This is usually called by one of the functions called via PGAEvaluate().

Example

PGAContext *ctx;
int p, dest;

...
dest = SelectAFreeProcessor ();
PGASendIndividual (ctx, p, PGA_NEWPOP, dest, PGA_SR_STRINGTOEVAL, comm);

Parameters:

ctx – context variable
p – index of an individual
pop – symbolic constant of the population
dest – ID of the process where this is going
tag – MPI tag to send with the individual
comm – MPI communicator

Returns:

None

void PGASendReceiveIndividual(PGAContext *ctx, int send_p, int send_pop, int dest, int send_tag, int recv_p, int recv_pop, int source, int recv_tag, MPI_Comm comm, MPI_Status *status)

Send an individual to a process, while receiving a different individual from a different process.

Example

A dedicated process is being used to perform an optimization algorithm on the strings. Send a new string, s, to the process, while receiving an optimized string, r, from it.

PGAContext *ctx;
MPI_Comm    comm;
MPI_Status  status;
int  s, r;

...
PGASendReceiveIndividual
  ( ctx
  , s, PGA_NEWPOP, 1, PGA_SR_STRINGTOMODIFY
  , r, PGA_NEWPOP, 1, PGA_SR_MODIFIEDSTRING
  , comm, &status
  );

Parameters:

ctx – context variable
send_p – index of string to send
send_pop – symbolic constant of population to send from
dest – destination process
send_tag – tag to send with
recv_p – index of string to receive
recv_pop – symbolic constant of population to receive from
source – process to receive from
recv_tag – tag to receive with
comm – an MPI communicator
status – pointer to the MPI status structure

Returns:

status and string recv_p in population recv_pop are modified by side-effect

void PGASortPop(PGAContext *ctx, int pop)

Creates an (internal) array of indices according to one of three criteria.

Description

If PGA_POPREPL_BEST is used (the default) the array is sorted from most fit to least fit. If PGA_POPREPL_RANDOM_REP is used the indices in the array are selected randomly with replacement. If PGA_POPREPL_RANDOM_NOREP is used the indices in the array are selected randomly without replacement. The function PGASetPopReplaceType() is used to specify which strategy is used. The indices of the sorted population members may then be accessed from the internal array via PGAGetSortedPopIndex(). This routine is typically used during population replacement.

Example

Copy the five best strings from the old population into the new population. The rest of the new population will be created by recombination, and is not shown.

PGAContext *ctx;
int i, j;

...
PGASetPopReplaceType (ctx, PGA_POPREPL_BEST)
...
PGASortPop (ctx, PGA_OLDPOP);
for (i=0; i<5; i++) {
    j = PGAGetSortedPopIndex (ctx, i);
    PGACopyIndividual (ctx, j, PGA_OLDPOP, i, PGA_NEWPOP);
}

Parameters:

ctx – context variable
pop – symbolic constant of the population from which to create the sorted array

Returns:

An inteneral array of indices sorted according to one of three criteria is created

void PGAUnHashIndividual(PGAContext *ctx, int p, int pop)

Compute Hash for this individual and remove from hash-table.

Description

Calls PGAIndividualHashIndex() for the hash value and removes it from the correct hash bucket.

Parameters:

ctx – context variable
p – string index
pop – symbolic constant of the population containing string p

Returns:

Computes hash of given individual and removes it from hash table

void PGAUpdateGeneration(PGAContext *ctx, MPI_Comm comm)

Update internal data structures for the next genetic algorithm iteration, and check if the termination conditions, both user and PGAPack, have been met.

Description

This routine must be called by both rank-0 and worker processes at the end of each GA generation.

Example

PGAContext *ctx;

...
PGAUpdateGeneration (ctx, MPI_COMM_WORLD);

Parameters:

ctx – context variable
comm – an MPI communicator

Returns:

PGA_TRUE if the genetic algorithm has terminated, otherwise PGA_FALSE

static inline double PGAUserFunctionGeneDistance(PGAContext *ctx, int p1, int pop1, int p2, int pop2)

Call the genetic distance user function.

Description

Call the genetic distance user function. This calls the data-type specific user function for computing the genetic distance. For user-defined data types you need to register a genetic distance user function with PGASetUserFunction() with the constant PGA_USERFUNCTION_GEN_DISTANCE.

Parameters:

ctx – context variable
p1 – first string index
pop1 – symbolic constant of the population the first string is in
p2 – second string index
pop2 – symbolic constant of the population the second string is in

Returns:

Genetic distance of the two strings

void PGA_NSGA_III_Replacement(PGAContext *ctx)

Perform NSGA-III Replacement.

Description

Perform dominance computation (ranking)
Perform crowding computation specific to NSGA-III
Sort individuals and replace into next generation

Example

PGAContext *ctx;

...
PGA_NSGA_II_Replacement (ctx);

Parameters:

ctx – context variable

Returns:

None

void PGA_NSGA_II_Replacement(PGAContext *ctx)

Perform NSGA-II Replacement.

Description

Perform dominance computation (ranking)
Perform crowding computation specific to NSGA-II
Sort individuals and replace into next generation

Example

PGAContext *ctx;

...
PGA_NSGA_II_Replacement (ctx);

Parameters:

ctx – context variable

Returns:

None

Parallel Execution

group parallel

Parallel implementation of GA.

Functions

int PGAGetNumProcs(PGAContext *ctx, MPI_Comm comm)

Return the size of communicator comm in processes.

Description

If comm is NULL or a sequential version of PGAPack is used, 1 is returned.

Example

PGAContext  *ctx;

...
if (PGAGetNumProcs (ctx, MPI_COMM_WORLD) < 4) {
    printf ("Too few processors for decent performance!\n");
    exit (-1);
}

Parameters:

ctx – context variable structure pointer
comm – an MPI communicator

Returns:

The numbers of processors in communicator comm

int PGAGetRank(PGAContext *ctx, MPI_Comm comm)

Return the rank of the processor in communicator comm.

Description

If comm is NULL or a sequential version of PGAPack is used, 0 is returned.

Example

PGAContext  *ctx;
int          rank;

...
rank = PGAGetRank (ctx, MPI_COMM_WORLD);
if (rank == 0) {
    LetRank0DoSomething ();
}

Parameters:

ctx – context variable structure pointer
comm – an MPI communicator

Returns:

The rank of this processor

Randomness

group random

Functions

double PGARandom01(PGAContext *ctx, int newseed)

Generate a uniform random number on the interval [0,1).

Description

If the second argument is 0 it returns the next random number in the sequence. Otherwise, the second argument is used as a new seed for the population.

This is a C language implementation of the universal random number generator proposed by George Marsaglia, Arif Zaman, and Wai Wan Tsang [MZT90] and translated from F. James’ version [Jam90].

This algorithm is a combination of a lagged Fibonacci and arithmetic sequence (F. James) generator with period of \(2^{144}\). It provides 32-bit floating point numbers in the range from zero to one. It is claimed to be portable and provides bit-identical results on all machines with at least 24-bit mantissas.

PGARandom01() should be initialized with a 32-bit integer seed such that \(0 \le seed \le 900,000,000\). Each of these 900,000,000 values gives rise to an independent sequence of \(\approx 10^{30}\).

Warning on use of static storage class on thread shared memory machines.

Example

To get the next random number use

PGAContext *ctx;
double r;

...
r = PGARandom01 (ctx, 0);

Parameters:

ctx – context variable
newseed – either 0 to get the next random number, or nonzero to reseed

Returns:

A random number on the interval [0,1)

int PGARandomFlip(PGAContext *ctx, double p)

Flip a biased coin and return true if the coin is a “winner”.

Example

To return PGA_TRUE approximately seventy percent of the time, use

PGAContext *ctx;
int bit;

...
bit = PGARandomFlip (ctx, 0.7)

Parameters:

ctx – context variable
p – biased probability (.5 is a fair coin)

Returns:

true if coin flip is a winner

double PGARandomGaussian(PGAContext *ctx, double mean, double sigma)

Return an approximation to a Gaussian random number.

Example

To generate a Gaussian random number with mean 0.0 and standard deviation 1.0 use

PGAContext *ctx;
double r;

...
r = PGARandomGaussian (ctx, 0.0, 1.0);

Parameters:

ctx – context variable
mean – the mean of the Gaussian distribution
sigma – the standard deviation of the Gaussian distribution

Returns:

A random number selected from a Gaussian distribution with given mean and standard deviation

int PGARandomInterval(PGAContext *ctx, int start, int end)

Return a uniform random number on the specified interval.

Example

Generate a value uniformly random from the interval \([0,99]\)

PGAContext *ctx;
int r;

...
r = PGARandomInterval (ctx, 0, 99);

Parameters:

ctx – context variable
start – starting (integer) value of the interval
end – ending (integer) value of the interval

Returns:

A uniformly distributed random number in the interval [start, end]

int PGARandomNextSample(PGASampleState *state)

Get next sample index for k out of n.

Description

See PGARandomSampleInit() for documentation and example.

Parameters:

state – pointer to PGASampleState, needs to be allocated by caller and initialized by PGARandomSampleInit

Returns:

next sample

void PGARandomSampleInit(PGAContext *ctx, PGASampleState *state, int k, int n)

Init random sampling of k out of n without replacement.

Description

Algorithm from [Vit87]. This is implemented as an iterator, i.e., this init method that initializes n and k and a function PGARandomNextSample() that returns the next sample index. The algorithm guarantees that sample indexes are returned sorted in index order. Note that the internal implementation variable CUTOFF is arbitrary and no measurements were performed – modern CPUs can probably iterate a lot when not accessing memory, so this can probably be set a lot higher.

Example

PGAContext *ctx;
PGASampleState state;
int s;

...
PGARandomSampleInit (ctx, &state, 3, 6);
s = PGARandomNextSample (&state);

Parameters:

ctx – context variable
state – pointer to PGASampleState, needs to be allocated by caller
k – k of the k out of n
n – n of the k out of n

Returns:

None

double PGARandomUniform(PGAContext *ctx, double start, double end)

Return a uniform random number on the interval [start,end].

Example

Generate a uniform random number on the interval \([-0.5, 1.5]\)

PGAContext *ctx;
double r;

...
r = PGARandomUniform (ctx, -0.5, 1.5);

Parameters:

ctx – context variable
start – starting (double) value of the interval
end – ending (double) value of the interval

Returns:

A random number on the interval [start,end]

Reporting and Errors

group reporting

Reporting, output printing.

Functions

void PGAError(PGAContext *ctx, char *msg, int level, int datatype, void *data)

Report error messages.

Description

Prints out the message supplied, and the value of a piece of data. Terminates if PGA_FATAL. See Constants for Error Printing Flags for the level constants and Miscellaneous in the user guide for more information.

Example

PGAContext *ctx;
int         val;

...
PGAError
 ( ctx, "Some Non Fatal Error: val = "
 , PGA_WARNING, PGA_INT, (void *) &val
 );

PGAError (ctx, "A Fatal Error!", PGA_FATAL, PGA_VOID, NULL);

Parameters:

ctx – context variable
msg – the error message to print
level – indicate the error’s severity
datatype – the data type of the following argument
data – the address of the data to be written out, cast as a void pointer

Returns:

None

void PGAErrorPrintf(PGAContext *ctx, int level, char *fmt, ...)

Report error messages using printf-like interface.

Description

Prints out the message supplied, and optional parameters. Uses a printf-style interface. Terminates if PGA_FATAL. Note that compared to PGAError() msg and level are exchanged, seems more natural. See Constants for Error Printing Flags for the level constants and Miscellaneous in the user guide for more information.

Example

PGAContext *ctx;
int         val;

...
PGAErrorPrintf (ctx, PGA_WARNING, "Some Non Fatal Error: val = %d", val);
PGAErrorPrintf (ctx, PGA_FATAL, "A Fatal Error!");

Parameters:

ctx – context variable
level – indicate the error’s severity
fmt – the printf-style format to print
... – additional parameters depending on format string in msg

Returns:

None

void PGAPrintContextVariable(PGAContext *ctx, FILE *fp)

Print the value of all the fields in the context variable.

Example

PGAContext *ctx;

...
PGAPrintContextVariable (ctx, stdout);

Parameters:

ctx – context variable
fp – file pointer to print the output to

Returns:

The value of all the fields in the context variable are printed to fp

void PGAPrintIndividual(PGAContext *ctx, FILE *fp, int p, int pop)

Print the allele values of a string and associated fields (evaluation, fitness, etc.) of a string.

Example

PGAContext *ctx;
int p;

...
PGAPrintIndividual (ctx, stdout, p, PGA_NEWPOP);

Parameters:

ctx – context variable
fp – file pointer to print the output to
p – string index
pop – symbolic constant of the population string p is in

Returns:

The allele values of string p and associated fields are printed to fp

void PGAPrintPopulation(PGAContext *ctx, FILE *fp, int pop)

Print each member of a population.

Description

Call PGAPrintIndividual() to print each member of a population.

Example

PGAContext *ctx;

...
PGAPrintPopulation (ctx, stdout, PGA_NEWPOP);

Parameters:

ctx – context variable
fp – file pointer to print the output to
pop – symbolic constant of the population to be printed

Returns:

The strings and associated fields that make up a population member are printed to fp

void PGAPrintReport(PGAContext *ctx, FILE *fp, int pop)

Print genetic algorithm statistics.

Description

The statistics that are printed are determined by PGASetPrintOptions().

Example

PGAContext *ctx;
int p;

...
PGAPrintReport (ctx, stdout, PGA_NEWPOP);

Parameters:

ctx – context variable
fp – file pointer to print the output to
pop – symbolic constant of the population whose statistics are printed

Returns:

genetic algorithm statistics are printed to fp

void PGAPrintString(PGAContext *ctx, FILE *fp, int p, int pop)

Write the allele values in a string to a file.

Example

PGAContext *ctx;
int p;

...
PGAPrintString (ctx, stdout, p, PGA_OLDPOP);

Parameters:

ctx – context variable
fp – pointer to file to write the string to
p – index of the string to write out
pop – symbolic constant of the population string p is in

Returns:

None

void PGAUsage(PGAContext *ctx)

Print list of available parameters and quit.

Description

Print the usage info out if MPI isn’t running (thus, only one process is probably running), or if we actually are the rank-0 process.

Example

PGAContext ctx;

...
PGAUsage (ctx);

Parameters:

ctx – context variable

Returns:

print list of available parameters

Utilities

group utility

Utility functions for internal and explicit use.

Functions

int INDEvalCompare(PGAIndividual *ind1, PGAIndividual *ind2)

Compare two individuals by evaluation.

Description

This typically simply compares evaluation taking into account the evaluation direction (minimize/maximize). We sort “better” individuals first. For more details see PGAEvalCompare().

Thinks of this as sorting individuals by decreasing fitness or increasing constraint violations. See also PGAEvalCompare().

Example

PGAIndividual *ind1, *ind2;
int result;
ind1 = PGAGetIndividual (...
ind2 = PGAGetIndividual (...

result = INDEvalCompare (ind1, ind2);

Parameters:

ind1 – Pointer to first individual
ind2 – Pointer to second individual

Returns:

>0 if p2 is “better” than p1
<0 if p1 is “better” than p2
0 if both compare equal

int PGACheckSum(PGAContext *ctx, int p, int pop)

Map a string to a number to be used as verification check.

Description

The data type PGA_DATATYPE_USER is not supported. See also the USER function PGAHash PGA_USERFUNCTION_HASH and the hash implementations for individual data types.

Example

PGAContext *ctx;
int p, sum;

...
sum = PGACheckSum (ctx, p, PGA_NEWPOP);

Parameters:

ctx – context variable
p – string index
pop – symbolic constant for the population

Returns:

An integer representing the “value” of the string

int PGAEvalCompare(PGAContext *ctx, int p1, int pop1, int p2, int pop2)

Compare two strings for selection.

Description

Thinks of this as sorting individuals by decreasing fitness or increasing constraint violations.

This typically simply compares evaluation taking into account the evaluation direction (minimize/maximize). But if auxiliary evaluations are defined, the auxiliary evaluations are treated as constraints or for multi-objective optimization. The default handling of auxiliary evaluations is incompatible with certain selection schemes, see checks in create.c We handle constraints to compare first: If two constrained individuals are compared, the one with less constraint violations wins. If a constrained individual is compared to an unconstrained one, the latter wins. If two unconstrained individuals are compared, the (single) evaluation is compared depending on the direction of optimization (minimization or maximization).

For multi-objective optimization we do not compare the evaluations but only the rank (as computed by the NSGA-II algorithm). Note that many individuals may have the same rank.

Note that PGAEvalCompare() is now used in several contexts, including finding the best evaluation. For very badly scaled problems, the default fitness computation will degenerate if there are very large evaluation values and very small ones. In that case the fitness will not reflect the evaluation. Therefore PGAEvalCompare() will now always sort on evaluation values ignoring the fitness. This improves Tournament selection for very badly scaled problems.

Example

PGAContext *ctx;
int result;

...
result = PGAEvalCompare (ctx, p1, PGA_OLDPOP, p2, PGA_OLDPOP);

Parameters:

ctx – context variable
p1 – first string to compare
pop1 – symbolic constant of population of first string
p2 – second string to compare
pop2 – symbolic constant of population of second string

Returns:

>0 if p2 is “better” than p1
<0 if p1 is “better” than p2
0 if both compare equal

void PGAEvalSort(PGAContext *ctx, int pop, int *idx)

Sort list of population indeces by evaluation.

Description

Note that the given list idx of indeces need not be initialized. It just has to have the correct size of course. Think of this as sorting individuals by “better” evaluation or increasing constraint violations. The best individals are sorted first.

Example

PGAContext *ctx;
int indexes [ctx->ga.PopSize];

...
PGAEvalSort (ctx, PGA_OLDPOP, indexes);

Parameters:

ctx – context variable
pop – symbolic constant of population to sort
idx – Array of integer indeces into population pop

Returns:

Array idx sorted by evalation

double PGAMean(PGAContext *ctx, double *a, int n)

Calculates the mean value of an array of elements.

Example

PGAContext *ctx;
double a [100], mean;

...
mean = PGAMean (ctx, a, 100);

Parameters:

ctx – context variable
a – array to take the mean of
n – number of elements in array a

Returns:

The mean of the n elements in array a

int PGARound(PGAContext *ctx, double x)

Mathematically round a double to an integer, using 0.5 as the cutoff value.

Example

PGAContext *ctx;
int y;

...
y = PGARound (ctx, -78.6);

Parameters:

ctx – context variable
x – the number to be rounded

Returns:

The rounded number

void PGAShuffle(PGAContext *ctx, int *list, int n)

Shuffle a list.

Description

We’re using Durstenfeld’s version of the Fisher-Yates shuffle.

Example

PGAContext *ctx;
int list [ctx->ga.PopSize];
...
for (i=0; i<ctx->ga.PopSize; i++) {
    list [i] = i;
}
PGAShuffle (ctx, list, ctx->ga.PopSize);

Parameters:

ctx – Context pointer
list – array of integers to shuffle
n – number of elements in array

Returns:

Shuffled array

double PGAStddev(PGAContext *ctx, double *a, int n, double mean)

Calculate the standard deviation of an array of elements.

Example

PGAContext *ctx;
double a [100], mean, sigma;

...
mean  = PGAMean (ctx, a, 100);
sigma = PGAStddev (ctx, a, 100, mean);

Parameters:

ctx – context variable
a – array to take the standard deviation of
n – number of elements in array a
mean – the mean of the elements in array a

Returns:

The standard deviation of the n elements in array a

Function Groups Internal Implementation

Bit Manipulation

group fun-bit

Some functions for manipulating bit arrays.

Functions

static inline void SET_BIT(PGABinary *bitptr, int idx): Bit array: Set a bit.

static inline int GET_BIT(PGABinary *bitptr, int idx): Bit array: Get a bit.

static inline void CLEAR_BIT(PGABinary *bitptr, int idx): Bit array: Clear a bit.

Internal Implementation

group internal

These functions are only used internally.

Functions

static inline int CMP(const double a, const double b): Used in PGAEvalCompare and others.

MPI_Datatype PGABinaryBuildDatatype(PGAContext *ctx, int p, int pop)

Build an MPI datatype for a binary string datatype.

Description

Called only by MPI routines. Not for user consumption.

Parameters:

ctx – context variable
p – index of the string to build a datatype from
pop – symbolic constant of the population string p is in

Returns:

MPI_Datatype.

void PGABinaryCopyString(PGAContext *ctx, int p1, int pop1, int p2, int pop2)

Copy one bit string to another.

Description

Note that this function is set in PGASetUp() as the copy string user function for the binary datatype by default.

Example

Copy bit string x to y (both are implicitly assumed to have the same length).

PGAContext *ctx;
int x, y

...
PGABinaryCopyString (ctx, x, PGA_OLDPOP, y, PGA_NEWPOP);

Parameters:

ctx – context variable
p1 – string to copy
pop1 – symbolic constant of population containing string p1
p2 – string to copy p1 to
pop2 – symbolic constant of population containing string p2

Returns:

None

void PGABinaryCreateString(PGAContext *ctx, int p, int pop, int initflag)

Allocate a binary string for member p of population pop.

Description

If initflag is PGA_TRUE, randomly initialize all alleles, otherwise clear all alleles. Applies to PGA_DATATYPE_BINARY strings.

Note that this function is set in PGASetUp() as the create string user function for the binary datatype by default.

Example

Allocates and clears alleles for all strings in PGA_NEWPOP.

PGAContext *ctx;
int p;

...
for (p=PGAGetPopSize(ctx)-1; p>=0; p--) {
    PGABinaryCreateString (ctx, p, PGA_NEWPOP, PGA_FALSE);
}

Parameters:

ctx – context variable
p – string index
pop – symbolic constant of the population string p is in
initflag – a flag, if set, randomly initialize, else clear alleles

Returns:

Member p in population pop is allocated and initialized.

int PGABinaryDuplicate(PGAContext *ctx, int p1, int pop1, int p2, int pop2)

Return true if bit string a is a duplicate of bit string b, else returns false.

Description

Note that this function is set in PGASetUp() as the duplicate checking user function for the binary datatype by default.

Example

Compare bit string x with y and print a message if they are the same.

PGAContext *ctx;
int x, y;

...
if (PGABinaryDuplicate (ctx, x, PGA_NEWPOP, y, PGA_NEWPOP)) {
    printf ("strings are duplicates\n");
}

Parameters:

ctx – context variable
p1 – string index of the first string to compare
pop1 – symbolic constant of the population string p1 is in
p2 – string index of the second string to compare
pop2 – symbolic constant of the population string p2 is in

Returns:

Return true/false if strings are duplicates

double PGABinaryGeneDistance(PGAContext *ctx, int p1, int pop1, int p2, int pop2)

Compute genetic difference of two strings.

Description

For binary genes this is the Hamming distance. It is used in the default setting of the PGA_USERFUNCTION_GEN_DISTANCE user function for the binary data type. Internal function. Use the gene distance user function PGAUserFunctionGeneDistance().

Parameters:

ctx – context variable
p1 – first string index
pop1 – symbolic constant of the population the first string is in
p2 – second string index
pop2 – symbolic constant of the population the second string is in

Returns:

genetic distance of the two strings

int PGABinaryHammingDistance(PGAContext *ctx, PGABinary *s1, PGABinary *s2)

Return the Hamming distance between two strings.

Description

Note that this function is used in PGABinaryGeneDistance() for implementing a generic genetic distance function. It is used in the default setting of the PGA_USERFUNCTION_GEN_DISTANCE user function for the binary data type.

Example

Return the Hamming distance between bit strings x and y.

PGAContext *ctx;
PGABinary *x, *y;
int d;

...
d = PGABinaryHammingDistance (ctx, x, y);

Parameters:

ctx – context variable
s1 – the first string to compare
s2 – the second string to compare

Returns:

The Hamming distance between two strings

PGAHash PGABinaryHash(PGAContext *ctx, int p, int pop)

Return hash value of given gene.

Description

Note that this function is set in PGASetUp() as the hash user function for the binary datatype by default.

Parameters:

ctx – context variable
p – string index of the string to hash
pop – symbolic constant of the population string p is in

Returns:

Hash value for string

void PGABinaryInitString(PGAContext *ctx, int p, int pop)

Randomly initialize a string of the binary data type.

Description

Note that this function is set in PGASetUp() as the init string user function for the binary datatype by default.

Example

PGAContext *ctx;
int p;

...
PGABinaryInitString (ctx, p, PGA_NEWPOP);

Parameters:

ctx – context variable
p – index of string to randomly initialize
pop – symbolic constant of the population string p is in

Returns:

None

int PGABinaryMutation(PGAContext *ctx, int p, int pop, double mr)

Randomly mutates a bit with a specified probability.

Description

This routine is called from PGAMutate().

Note that this function is set in PGASetUp() as the mutation user function for the binary datatype by default.

Example

Mutates string p in population PGA_NEWPOP with a probability of 0.001 for each bit.

PGAContext *ctx;
int p;

...
PGABinaryMutation (ctx, p, PGA_NEWPOP, .001);

Parameters:

ctx – context variable
p – string index
pop – symbolic constant for the population string p is in
mr – probability of mutating (toggling) a bit

Returns:

Return the number of mutations

void PGABinaryOneptCrossover(PGAContext *ctx, int p1, int p2, int pop1, int c1, int c2, int pop2)

Performs one-point crossover on two parent strings to create two children via side-effect.

Description

Note that this function is set in PGASetUp() as the crossover user function for the binary datatype when selecting one-point crossover.

Example

Performs crossover on the two parent strings m and d, producing children s and b.

PGAContext *ctx;
int m, d, s, b;

...
PGABinaryOneptCrossover (ctx, m, d, PGA_OLDPOP, s, b, PGA_NEWPOP);

Parameters:

ctx – context variable
p1 – the first parent string
p2 – the second parent string
pop1 – symbolic constant of the population containing p1 and p2
c1 – the first child string
c2 – the second child string
pop2 – symbolic constant of the population containing c1 and c2

Returns:

None

static void PGABinaryPrint(PGAContext *ctx, FILE *fp, PGABinary *chrom, int nb)

Write a bit string to a file.

Description

Puts the binary representation of the bit string pointed to by chrom into a character string and writes that out. Assumes the maximum length of string to print is WL, and that all bits are in the same word.

Internal function. Use PGABinaryPrintString() to print a binary string.

Parameters:

ctx – context variable
fp – file to write the bit string to
chrom – pointer to the bit string to write
nb – number of bits to write out

Returns:

None

void PGABinaryPrintString(PGAContext *ctx, FILE *fp, int p, int pop)

Write a bit string to a file.

Example

Write string s to stdout.

PGAContext *ctx;
int s;

...
PGABinaryPrintString (ctx, stdout, s, PGA_NEWPOP);

Parameters:

ctx – context variable
fp – file pointer to file to write bit string to
p – index of the string to write out
pop – symbolic constant of the population string p is in

Returns:

None

void PGABinaryTwoptCrossover(PGAContext *ctx, int p1, int p2, int pop1, int c1, int c2, int pop2)

Perform two-point crossover on two parent strings producing two children via side-effect.

Description

Note that this function is set in PGASetUp() as the crossover user function for the binary datatype when selecting two-point crossover.

Example

Performs crossover on the two parent strings m and d, producing children s and b.

PGAContext *ctx;
int m, d, s, b;

...
PGABinaryTwoptCrossover (ctx, m, d, PGA_OLDPOP, s, b, PGA_NEWPOP);

Parameters:

ctx – context variable
p1 – the first parent string
p2 – the second parent string
pop1 – symbolic constant of the population containing string p1 and p2
c1 – the first child string
c2 – the second child string
pop2 – symbolic constant of the population to contain string c1 and c2

Returns:

None

void PGABinaryUniformCrossover(PGAContext *ctx, int p1, int p2, int pop1, int c1, int c2, int pop2)

Perform uniform crossover on two parent strings producing two children via side-effect.

Description

Note that this function is set in PGASetUp() as the crossover user function for the binary datatype when selecting uniform crossover.

Example

Performs crossover on the two parent strings m and d, producing children s and b.

PGAContext *ctx;
int m, d, s, b;

...
PGABinaryUniformCrossover (ctx, m, d, PGA_OLDPOP, s, b, PGA_NEWPOP);

Parameters:

ctx – context variable
p1 – the first parent string
p2 – the second parent string
pop1 – symbolic constant of the population containing string p1 and p2
c1 – the first child string
c2 – the second child string
pop2 – symbolic constant of the population to contain string c1 and c2

Returns:

None

static MPI_Datatype PGABuildEvaluation(PGAContext *ctx, int p, int pop)

Build an MPI datatype for eval and auxeval.

Example

PGAContext   *ctx;
int           p;
MPI_Datatype  dt;

...
dt = PGABuildEvaluation (ctx, p, pop);

Parameters:

ctx – context variable
p – index of string
pop – symbolic constant of population string p is in

Returns:

An MPI_Datatype

MPI_Datatype PGACharacterBuildDatatype(PGAContext *ctx, int p, int pop)

Build an MPI datatype for a character string.

Description

Called only by MPI routines. Not for user consumption.

Parameters:

ctx – context variable
p – index of the string to build a datatype from
pop – symbolic constant of the population string p is in

Returns:

MPI_Datatype

void PGACharacterCopyString(PGAContext *ctx, int p1, int pop1, int p2, int pop2)

Copy one character-valued string to another, assumes the strings are of the same length.

Description

Note that this function is set in PGASetUp() as the copy string user function for the char datatype by default.

Example

Copy character string x to y (both are implicitly assumed to be the same length)

PGAContext *ctx;
int x, y;

...
PGACharacterCopyString (ctx, x, PGA_OLDPOP, y, PGA_NEWPOP);

Parameters:

ctx – context variable
p1 – string to copy
pop1 – symbolic constant of population containing string p1
p2 – string to copy p1 to
pop2 – symbolic constant of population containing string p2

Returns:

None

void PGACharacterCreateString(PGAContext *ctx, int p, int pop, int initflag)

Allocate memory for a string of type character.

Description

Note that this function is set in PGASetUp() as the create string user function for the char datatype by default.

Example

Allocates memory and assigns the address of the allocated memory to the string field ind->chrom of the individual. Additionally, the string is initialized to zero.

PGAContext *ctx;
int p;

...
PGACharacterCreateString (ctx, p, PGA_NEWPOP, PGA_FALSE);

Parameters:

ctx – context variable
p – string index
pop – symbolic constant of the population string p is in
initflag – A true/false flag used in conjunction with ctx->ga.RandomInit to initialize the string either randomly or set to zero

Returns:

Member p in population pop is allocated and initialized.

int PGACharacterDuplicate(PGAContext *ctx, int p1, int pop1, int p2, int pop2)

Return true if string p1 in pop1 is a duplicate of string p2 in pop2, else returns false, assumes the strings are the same length.

Description

Note that this function is set in PGASetUp() as the duplicate checking user function for the char datatype by default.

Example

Compare string x with y to see if they are duplicates

PGAContext *ctx;
int x, y;

...
if (PGACharacterDuplicate (ctx, x, PGA_NEWPOP, y, PGA_NEWPOP)) {
    printf ("strings are duplicates\n");
}

Parameters:

ctx – context variable
p1 – string index of the first string to compare
pop1 – symbolic constant of the population string p1 is in
p2 – string index of the second string to compare
pop2 – symbolic constant of the population string p2 is in

Returns:

Returns true if strings are duplicates

double PGACharacterGeneDistance(PGAContext *ctx, int p1, int pop1, int p2, int pop2)

Compute genetic difference of two strings.

Description

Return sum of the absolute values of the differences of each allele. Internal function. Use PGAUserFunctionGeneDistance().

Parameters:

ctx – context variable
p1 – first string index
pop1 – symbolic constant of the population the first string is in
p2 – second string index
pop2 – symbolic constant of the population the second string is in

Returns:

genetic distance of the two strings

PGAHash PGACharacterHash(PGAContext *ctx, int p, int pop)

Return hash value of given gene.

Description

Note that this function is set in PGASetUp() as the hash user function for the char datatype by default.

Parameters:

ctx – context variable
p – string index of the string to hash
pop – symbolic constant of the population string p is in

Returns:

Hash value for string

void PGACharacterInitString(PGAContext *ctx, int p, int pop)

Randomly initialize a string of type character.

Description

Note that this function is set in PGASetUp() as the init string user function for the char datatype by default.

Example

PGAContext *ctx;
int p;

...
PGACharacterInitString (ctx, p, PGA_NEWPOP);

Parameters:

ctx – context variable
p – index of string to randomly initialize
pop – symbolic constant of the population string p is in

Returns:

None

int PGACharacterMutation(PGAContext *ctx, int p, int pop, double mr)

Randomly mutates a character-valued gene with a specified probability.

Description

This routine is called from PGAMutate().

Note that this function is set in PGASetUp() as the mutation user function for the char datatype by default.

Example

PGAContext *ctx;
int p;
int NumMutations;

...
NumMutations = PGACharacterMutation (ctx, p, PGA_NEWPOP, 0.01);

Parameters:

ctx – context variable
p – string index
pop – symbolic constant of the population string p is in
mr – probability of mutating an character-valued gene

Returns:

Returns the number of mutations

void PGACharacterOneptCrossover(PGAContext *ctx, int p1, int p2, int pop1, int c1, int c2, int pop2)

Perform one-point crossover on two parent strings producing two children via side-effect.

Description

Note that this function is set in PGASetUp() as the crossover user function for the char datatype when selecting one-point crossover.

Example

Performs crossover on the two parent strings m and d, producing children s and b.

PGAContext *ctx;
int m, d, s, b;

...
PGACharacterOneptCrossover (ctx, m, d, PGA_OLDPOP, s, b, PGA_NEWPOP);

Parameters:

ctx – context variable
p1 – the first parent string
p2 – the second parent string
pop1 – symbolic constant of the population containing string p1 and p2
c1 – the first child string
c2 – the second child string
pop2 – symbolic constant of the population to contain string c1 and c2

Returns:

None

void PGACharacterPrintString(PGAContext *ctx, FILE *fp, int p, int pop)

Write a character-valued string to a file.

Example

Write string s to stdout.

PGAContext *ctx;
int p;

...
PGACharacterPrintString (ctx, stdout, p, PGA_NEWPOP);

Parameters:

ctx – context variable
fp – file pointer to file to write the string to
p – index of the string to write out
pop – symbolic constant of the population string p is in

Returns:

None

void PGACharacterTwoptCrossover(PGAContext *ctx, int p1, int p2, int pop1, int c1, int c2, int pop2)

Perform two-point crossover on two parent strings producing two children via side-effect.

Description

Note that this function is set in PGASetUp() as the crossover user function for the char datatype when selecting two-point crossover.

Example

Performs crossover on the two parent strings m and d, producing children s and b.

PGAContext *ctx;
int m, d, s, b;

...
PGACharacterTwoptCrossover (ctx, m, d, PGA_OLDPOP, s, b, PGA_NEWPOP);

Parameters:

ctx – context variable
p1 – the first parent string
p2 – the second parent string
pop1 – symbolic constant of the population containing string p1 and p2
c1 – the first child string
c2 – the second child string
pop2 – symbolic constant of the population to contain string c1 and c2

Returns:

None

void PGACharacterUniformCrossover(PGAContext *ctx, int p1, int p2, int pop1, int c1, int c2, int pop2)

Perform uniform crossover on two parent strings producing two children via side-effect.

Description

Note that this function is set in PGASetUp() as the crossover user function for the char datatype when selecting uniform crossover.

Example

Performs crossover on the two parent strings m and d, producing children s and b.

PGAContext *ctx;
int m, d, s, b;

...
PGACharacterUniformCrossover (ctx, m, d, PGA_OLDPOP, s, b, PGA_NEWPOP);

Parameters:

ctx – context variable
p1 – the first parent string
p2 – the second parent string
pop1 – symbolic constant of the population containing string p1 and p2
c1 – the first child string
c2 – the second child string
pop2 – symbolic constant of the population to contain string c1 and c2

Returns:

None

int PGAComputeSimilarity(PGAContext *ctx, int popindex)

Compute the percentage of the population that have the same evaluation function.

Example

PGAContext *ctx;

...
PGAComputeSimilarity (ctx, PGA_NEWPOP);

Parameters:

ctx – context variable
popindex – symbolic constant of the population whose statistics to use

Returns:

returns a count of the number of population members that have the same evaluation function value

static void PGACreateIndividual(PGAContext *ctx, int p, int pop, int initflag)

Initialize to zero various data structures of an individual and call the appropriate function to create and initialize the string for the specific data type.

Example

PGAContext *ctx;
int p;

...
PGACreateIndividual (ctx, p, PGA_NEWPOP, PGA_TRUE);

Parameters:

ctx – Context variable
p – String index
pop – Symbolic constant of the population string p is in
initflag – If the value is PGA_TRUE, the string is randomly initialized, otherwise it is set to zero

Returns:

None

static void PGACreatePop(PGAContext *ctx, int pop)

Allocate a population of individuals and calls PGACreateIndividual to set up each one.

Example

PGAContext *ctx;

...
PGACreatePop (ctx, PGA_NEWPOP);

Parameters:

ctx – context variable
pop – symbolic constant of the population to create

Returns:

None

void PGACrossoverSBX(PGAContext *ctx, double p1, double p2, double u, double *c1, double *c2)

Cross over two parent alleles with simulated binary crossover (SBX).

Description

This uses double for both parent alleles but is re-used in both, integer and real SBX crossover in PGAIntegerSBXCrossover() and PGARealSBXCrossover(), respectively. The probability is used to compute the new alleles from the polynomial distribution.

Example

PGAContext *ctx;
double p1, p2, u;
double c1, c2;
double result;

...
u = PGARandom01 (ctx, 0);
result = PGACrossoverSBX (ctx, p1, p2, u, &c1, &c2);

Parameters:

ctx – context variable
p1 – (double) Allele of first string
p2 – (double) Allele of second string
u – Random value between 0 and 1
c1 – pointer to new first child allele
c2 – pointer to new second child allele

Returns:

None

int PGAEvalSortHelper(const void *a1, const void *a2)

Compare two PGAIndividual pointers for qsort.

Description

Used as the comparison function in qsort.

Parameters:

a1 – void pointer to first individual
a2 – void pointer to second individual

Returns:

-1 if less, 0 if equal, 1 if greater

static void PGAEvaluateCoop(PGAContext *ctx, int pop, double (*evaluate)(PGAContext*, int, int, double*), MPI_Comm comm)

Cooperative internal evaluation function.

Description

Evaluates all strings that need to be evaluated using two processors cooperatively. The first being the rank-0 process will send a string to the second for evaluation. While the second is evaluating, the rank-0 process will also evaluate a string.

Parameters:

ctx – context variable
pop – symbolic constant of the population to be evaluated
evaluate – a pointer to a function to evaluate a string.
comm – an MPI communicator

Returns:

None

static void PGAEvaluateMP(PGAContext *ctx, int pop, MPI_Comm comm)

Internal evaluation function, multiprocessing version.

Description

Evaluates all strings that need evaluating using three or more processors. The rank-0 process sends individuals to evaluate to all other processes and collects the results. The rank-0 process performs no evaluations itself.

Parameters:

ctx – context variable
pop – symbolic constant of the population to be evaluated
comm – an MPI communicator

Returns:

None

static void PGAEvaluateSeq(PGAContext *ctx, int pop, double (*evaluate)(PGAContext*, int, int, double*))

Sequential internal evalution function.

Description

Evaluates all strings that need to be evaluated using one processor.

Parameters:

ctx – context variable
pop – symbolic constant of the population to be evaluated
evaluate – a pointer to a function to evaluate a string.

static void PGAEvaluateWorker(PGAContext *ctx, int pop, double (*evaluate)(PGAContext*, int, int, double*), MPI_Comm comm)

Evaluation worker routine.

Description

Sit around and wait for a string to eval to show up, then evaluate it and return the evaluation. Terminates when it receives PGA_COMM_DONEWITHEVALS.

Parameters:

ctx – context variable
pop – symbolic constant of the population to be evaluated
evaluate – a pointer to a function to evaluate a string.
comm – an MPI communicator

Returns:

None

static void PGAFitnessLinearNormal(PGAContext *ctx, int popindex)

Calculates fitness using a ranking method and linear ordering.

Description

The fitness function is of the form \(u(x) = K - (\text{rank} \cdot \sigma)\) with the constant \(K\) equal to the mean of the evaluation functions, and the decrement \(\sigma\) equal to the standard deviation of the same as defined by Davis [Dav91], p.33.

Parameters:

ctx – context variable
popindex – population index to calculate fitness for

Returns:

Calculates the fitness for each string in the population via side effect

static void PGAFitnessLinearRank(PGAContext *ctx, int popindex)

Calculate fitness using linear ranking.

Description

The fitness function is of the form

\[\frac{1}{N} \cdot \left(\max - (\max-\min) * \frac{i-1}{N-1}\right)\]

where \(\min = 2-\max\) and \(1 \le \max \le 2\). See Baker [Bak87], Bäck and Hoffmeister [BH91], Grefenstette and Baker [GB89] and Whitley’s linear function on p. 121 in [Whi89].

Parameters:

ctx – context variable
popindex – population index to calculate fitness for

Returns:

Calculates the fitness for each string in the population via side effect

static void PGAFitnessMinCmax(PGAContext *ctx, PGAIndividual *pop)

Calculate fitness in the case of a minimization problem by subtracting the worst evaluation function value from each evaluation function.

Description

This is a dynamic linear fitness function \(u(x) = a f(x) + b(t)\) with \(a=-1, b(t) = 1.1 * \max f(x)\)

Parameters:

ctx – context variable
pop – population pointer to calculate fitness for

Returns:

Calculates the fitness for each string in the population via side effect

static void PGAFitnessMinReciprocal(PGAContext *ctx, PGAIndividual *pop)

Calculate fitness in the case of a minimization problem using the reciprocal of the evaluation function.

Description

This is a power law \(u(x) = (a f(x) + b)^k\) with \(a=1, b=0, k=-1\).

Parameters:

ctx – context variable
pop – population pointer to calculate fitness for

Returns:

Calculates the fitness for each string in the population via side effect

static void PGAFreeIndividual(PGAContext *ctx, PGAIndividual *ind)

Deallocate memory for given PGAIndividual.

Example

PGAContext *ctx;
PGAIndividual *ind;

...
PGAFreeIndividual (ctx, ind);

Parameters:

ctx – context variable
ind – individual

Returns:

None

size_t PGAIndividualHashIndex(PGAContext *ctx, int p, int pop)

Compute Hash for individual in given population.

Description

Call the hash user function, by default PGACreate() makes sure the correct one is set for the data type.

Parameters:

ctx – context variable
p – string index
pop – symbolic constant of the population containing string p

Returns:

Hash of given individual

MPI_Datatype PGAIntegerBuildDatatype(PGAContext *ctx, int p, int pop)

Build an MPI datatype for a string of data type integer.

Description

Called only by MPI routines. Not for user consumption.

Parameters:

ctx – context variable
p – index of string
pop – symbolic constant of the population string p is in

Returns:

MPI_Datatype

void PGAIntegerCopyString(PGAContext *ctx, int p1, int pop1, int p2, int pop2)

Copy one integer-valued string to another.

Description

Note that this function is set in PGASetUp() as the copy string user function for the integer datatype by default.

Parameters:

ctx – context variable
p1 – string to copy
pop1 – symbolic constant of population containing string p1
p2 – string to copy p1 to
pop2 – symbolic constant of population containing string p2

Returns:

None

void PGAIntegerCreateString(PGAContext *ctx, int p, int pop, int initflag)

Allocate memory for a string of type PGAInteger, and initializes or clears the string according to initflag.

Description

Note that this function is set in PGASetUp() as the create string user function for the integer datatype.

Example

Allocates and clears memory and assigns the address of the allocated memory to the string field ind->chrom of the individual.

PGAContext *ctx;
PGAIndividual *ind;

...
PGAIntegerCreateString (ctx, ind, PGA_FALSE);

Parameters:

ctx – context variable
p – string index
pop – symbolic constant of the population string p is in
initflag – A true/false flag used in conjunction with ctx->ga.RandomInit to initialize the string either randomly or set to zero

Returns:

None

int PGAIntegerDuplicate(PGAContext *ctx, int p1, int pop1, int p2, int pop2)

Return true if string a is a duplicate of string b, else returns false.

Description

Note that this function is set in PGASetUp() as the duplicate checking user function for the integer datatype by default.

Parameters:

ctx – context variable
p1 – string index of the first string to compare
pop1 – symbolic constant of the population string p1 is in
p2 – string index of the second string to compare
pop2 – symbolic constant of the population string p2 is in

Returns:

Returns true/false if strings are duplicates

void PGAIntegerEdgeCrossover(PGAContext *ctx, int p1, int p2, int pop1, int c1, int c2, int pop2)

Perform Edge Recombination on two parent strings producing two children via side-effect.

Description

Note that this function is set in PGASetUp() as the crossover user function for the integer datatype when selecting edge crossover.

Example

Performs crossover on the two parent strings m and d, producing children s and b.

PGAContext *ctx;
int m, d, s, b;

...
PGAIntegerEdgeCrossover (ctx, m, d, PGA_OLDPOP, s, b, PGA_NEWPOP);

Parameters:

ctx – context variable
p1 – the first parent string
p2 – the second parent string
pop1 – symbolic constant of the population containing string p1 and p2
c1 – the first child string
c2 – the second child string
pop2 – symbolic constant of the population to contain string c1 and c2

Returns:

c1 and c2 in population pop2 are modified by side-effect.

double PGAIntegerGeneDistance(PGAContext *ctx, int p1, int pop1, int p2, int pop2)

Compute genetic distance of two strings.

Description

Sum of the absolute values of the differences of each allele. Internal function. Use PGAUserFunctionGeneDistance().

Parameters:

ctx – context variable
p1 – first string index
pop1 – symbolic constant of the population the first string is in
p2 – second string index
pop2 – symbolic constant of the population the second string is in

Returns:

genetic distance of the two strings

PGAHash PGAIntegerHash(PGAContext *ctx, int p, int pop)

Return hash value of given gene.

Description

Note that this function is set in PGASetUp() as the hash user function for the integer datatype by default.

Parameters:

ctx – context variable
p – string index of the string to hash
pop – symbolic constant of the population string p is in

Returns:

Hash value for string

void PGAIntegerInitString(PGAContext *ctx, int p, int pop)

Randomly initialize a string of data type integer.

Description

Note that this function is set in PGASetUp() as the init string user function for the integer datatype by default.

Parameters:

ctx – context variable
p – index of string to randomly initialize
pop – symbolic constant of the population string p is in

Returns:

None

int PGAIntegerMutation(PGAContext *ctx, int p, int pop, double mr)

Randomly mutates an integer-valued gene with a specified probability.

Description

This routine is called from PGAMutate().

Note that this function is set in PGASetUp() as the mutation user function for the integer datatype by default.

Parameters:

ctx – context variable
p – string index
pop – symbolic constant of the population string p is in
mr – probability of mutating an integer-valued gene

Returns:

Returns the number of mutations

void PGAIntegerOneptCrossover(PGAContext *ctx, int p1, int p2, int pop1, int c1, int c2, int pop2)

Perform one-point crossover on two parent strings producing two children via side-effect.

Description

Note that this function is set in PGASetUp() as the crossover user function for the integer datatype when selecting one-point crossover.

Example

Performs crossover on the two parent strings m and d, producing children s and b.

PGAContext *ctx;
int m, d, s, b;

...
PGAIntegerOneptCrossover (ctx, m, d, PGA_OLDPOP, s, b, PGA_NEWPOP);

Parameters:

ctx – context variable
p1 – the first parent string
p2 – the second parent string
pop1 – symbolic constant of the population containing string p1 and p2
c1 – the first child string
c2 – the second child string
pop2 – symbolic constant of the population to contain string c1 and c2

Returns:

c1 and c2 in population pop2 are modified by side-effect

void PGAIntegerPrintString(PGAContext *ctx, FILE *fp, int p, int pop)

Write an integer-valued string to a file.

Example

Write member p in population PGA_NEWPOP to stdout.

PGAContext *ctx;
int  p;

...
PGAIntegerPrintString (ctx, stdout, p, PGA_NEWPOP);

Parameters:

ctx – context variable
fp – file pointer to file to write the string to
p – index of the string to write out
pop – symbolic constant of the population string p is in

Returns:

None

void PGAIntegerSBXCrossover(PGAContext *ctx, int p1, int p2, int pop1, int c1, int c2, int pop2)

Performs simulated binary crossover (SBX) on two parent strings producing two children via side-effect.

Description

Note that this function is set in PGASetUp() as the crossover user function for the integer datatype when selecting simulated binary crossover.

Example

Performs crossover on the two parent strings m and d, producing children s and b.

PGAContext *ctx;
int m, d, s, b;

...
PGAIntegerSBXCrossover (ctx, m, d, PGA_OLDPOP, s, b, PGA_NEWPOP);

Parameters:

ctx – context variable
p1 – the first parent string
p2 – the second parent string
pop1 – symbolic constant of the population containing string p1 and p2
c1 – the first child string
c2 – the second child string
pop2 – symbolic constant of the population to contain string c1 and c2

Returns:

c1 and c2 in population pop2 are modified by side-effect.

void PGAIntegerTwoptCrossover(PGAContext *ctx, int p1, int p2, int pop1, int c1, int c2, int pop2)

Perform two-point crossover on two parent strings producing two children via side-effect.

Description

Note that this function is set in PGASetUp() as the crossover user function for the integer datatype when selecting two-point crossover.

Example

Performs crossover on the two parent strings m and d, producing children s and b.

PGAContext *ctx;
int m, d, s, b;

...
PGAIntegerTwoptCrossover (ctx, m, d, PGA_OLDPOP, s, b, PGA_NEWPOP);

Parameters:

ctx – context variable
p1 – the first parent string
p2 – the second parent string
pop1 – symbolic constant of the population containing string p1 and p2
c1 – the first child string
c2 – the second child string
pop2 – symbolic constant of the population to contain string c1 and c2

Returns:

c1 and c2 in population pop2 are modified by side-effect

void PGAIntegerUniformCrossover(PGAContext *ctx, int p1, int p2, int pop1, int c1, int c2, int pop2)

Perform uniform crossover on two parent strings producing two children via side-effect.

Description

Note that this function is set in PGASetUp() as the crossover user function for the integer datatype when selecting uniform crossover.

Example

Performs crossover on the two parent strings m and d, producing children s and b.

PGAContext *ctx;
int m, d, s, b;

...
PGAIntegerUniformCrossover (ctx, m, d, PGA_OLDPOP, s, b, PGA_NEWPOP);

Parameters:

ctx – context variable
p1 – the first parent string
p2 – the second parent string
pop1 – symbolic constant of the population containing string p1 and p2
c1 – the first child string
c2 – the second child string
pop2 – symbolic constant of the population to contain string c1 and c2

Returns:

c1 and c2 in population pop2 are modified by side-effect

static double PGAMapIntegerToReal(PGAContext *ctx, int v, int a, int b, double l, double u)

Maps the value v defined on [a,b] to r defined on [l,u].

Description

In the context of PGAPack \([a,b]\) is the discrete interval \([0,2^{nbits}-1]\) (i.e., the number of bits in a binary string) and \([l,u]\) represent the range of possible values of the real number \(r\).

Example

Map a five bit (that is, an integer with a range of [0, 31]) integer 5 to a real in the range [0, 3.14].

PGAContext *ctx;
double x;

...
x = PGAMapIntegerToReal (ctx, 5, 0, 31, 0.0, 3.14);

Parameters:

ctx – context variable
v – value from original interval (usually the decoded bit string)
a – lower bound of integer interval
b – upper bound of integer interval
l – lower bound of real interval
u – upper bound of real interval

Returns:

Scaled value of v defined on [l,u]

static int PGAMapRealToInteger(PGAContext *ctx, double r, double l, double u, int a, int b)

Map the value r defined on [l,u] to v defined on [a,b].

Description

In the context of PGAPack \([a,b]\) is the discrete interval \([0,2^{nbits}-1]\) (i.e., the number of bits in a binary string) and \([l,u]\) represent the range of possible values of the real number \(r\).

Example

Map the value r on the interval [0, 3.14] to a five bit integer v.

PGAContext *ctx;
double r;
int v;

...
v = PGAMapRealToInteger (ctx, r, 0.0, 3.14, 0, 31);

Parameters:

ctx – context variable
r – real value defined on [l,u]
l – lower bound of real interval
u – upper bound of real interval
a – lower bound of integer interval
b – upper bound of integer interval

Returns:

Scaled value of r defined on [a,b]

static void PGAParseDebugArg(PGAContext *ctx, char *st)

Routine to parse debug command line options, and set the appropriate debug level.

Description

Internal function. Called only by PGAReadCmdLine(). Uses PGASetDebugLevel() for setting the debug level.

Parameters:

ctx – context variable
st – debug command line options

Returns:

None

MPI_Datatype PGARealBuildDatatype(PGAContext *ctx, int p, int pop)

Build an MPI datatype for a string.

Example

PGAContext   *ctx;
int           p;
MPI_Datatype  dt;

...
dt = PGARealBuildDatatype(ctx, p, pop);

Parameters:

ctx – context variable
p – index of string
pop – symbolic constant of population string p is in

Returns:

An MPI_Datatype

void PGARealCopyString(PGAContext *ctx, int p1, int pop1, int p2, int pop2)

Copy one real-valued string string to another.

Description

Note that this function is set in PGASetUp() as the copy string user function for the real datatype by default.

Example

Copy string x in old population to y in new population.

PGAContext *ctx;
int x, y;

...
PGARealCopyString (ctx, x, PGA_OLDPOP, y, PGA_NEWPOP);

Parameters:

ctx – context variable
p1 – string to copy
pop1 – symbolic constant of population containing string p1
p2 – string to copy p1 to
pop2 – symbolic constant of population containing string p2

Returns:

String p2 in population pop2 is modified to be a copy of string p1 in population pop1.

void PGARealCreateString(PGAContext *ctx, int p, int pop, int initflag)

Allocate memory for a string of type real.

Description

Note that this function is set in PGASetUp() as the create string user function for the real datatype by default. Parameter initflag is used in conjunction with ctx->ga.RandomInit to initialize the string either randomly or set to zero.

Example

Allocates memory and assigns the address of the allocated memory to the real string field ind->chrom of the individual. Also, clears the string.

PGAContext *ctx;
int p;

...
PGARealCreateString (ctx, p, PGA_NEWPOP, PGA_FALSE);

Parameters:

ctx – context variable
p – string index
pop – symbolic constant of the population string p is in
initflag – A boolean flag to indicate random initialization

Returns:

None

int PGARealDuplicate(PGAContext *ctx, int p1, int pop1, int p2, int pop2)

Returns true if real-valued string a is a duplicate of real-valued string b, else returns false.

Description

Note that this function is set in PGASetUp() as the duplicate checking user function for the real datatype by default.

Example

Compare strings x with y to see if they are duplicates.

PGAContext *ctx;
int x, y;

...
if (PGARealDuplicate (ctx, x, PGA_OLDPOP, y, PGA_OLDPOP)) {
    printf ("strings are duplicates\n");
}

Parameters:

ctx – context variable
p1 – string index of the first string to compare
pop1 – symbolic constant of the population string p1 is in
p2 – string index of the second string to compare
pop2 – symbolic constant of the population string p2 is in

Returns:

Returns true/false if strings are duplicates

double PGARealGeneDistance(PGAContext *ctx, int p1, int pop1, int p2, int pop2)

Compute genetic difference of two strings.

Description

Sum of the absolute values of the differences of each allele. So this is a Manhattan distance (mainly for performance reasons). Internal function. Use PGAUserFunctionGeneDistance().

Parameters:

ctx – context variable
p1 – first string index
pop1 – symbolic constant of the population the first string is in
p2 – second string index
pop2 – symbolic constant of the population the second string is in

Returns:

genetic distance of the two strings

PGAHash PGARealHash(PGAContext *ctx, int p, int pop)

Return hash value of given gene.

Description

Note that this function is set in PGASetUp() as the hash user function for the real datatype by default.

Parameters:

ctx – context variable
p – string index of the string to hash
pop – symbolic constant of the population string p is in

Returns:

Hash value for string

void PGARealInitString(PGAContext *ctx, int p, int pop)

Randomly initialize a string of type real.

Description

Note that this function is set in PGASetUp() as the init string user function for the real datatype by default.

Example

PGAContext *ctx;
int p;

...
PGARealInitString (ctx, p, PGA_NEWPOP);

Parameters:

ctx – context variable
p – index of string to randomly initialize
pop – symbolic constant of the population string p is in

Returns:

String p in population pop is randomly initialized by side-effect

int PGARealMutation(PGAContext *ctx, int p, int pop, double mr)

Randomly mutates a floating point string with probability mr.

Description

Three of the four mutation operators are of the form \(v = v +- p \cdot v\). That is, the new value of \(v\) (allele \(i\)) is the old value + or - a percentage, \(p\), of the old value. There are three possibilities for choosing \(p\): (1) constant value (0.01 by default), (2) selected uniformly on \((0,\text{UB})\) (UB is .1 by default), and (3) selected from a Gaussian distribution (with mean 0 and standard deviation .1 be default). The change to an allele, \(p \cdot v\), is added or subtracted to the old value with a probability of .5. The fourth option is to replace \(v\) with a value selected uniformly random from the initialization range of that gene. Alleles to mutate are randomly selected. The value set by the routine PGASetMutationRealValue() is used as \(p\), UB, and sigma in cases 1, 2, and 3, respectively.

Note that this function is set in PGASetUp() as the mutation user function for the real datatype by default.

Example

Mutate string p in population PGA_NEWPOP with probability 0.001.

PGAContext *ctx;
int NumMutations, p;

...
NumMutations = PGARealMutation (ctx, p, PGA_NEWPOP, .001);

Parameters:

ctx – context variable
p – string index
pop – symbolic constant of the population string p is in
mr – probability of mutating a real-valued gene

Returns:

The number of mutations performed

void PGARealOneptCrossover(PGAContext *ctx, int p1, int p2, int pop1, int c1, int c2, int pop2)

This routine performs one point crossover on two parent strings, producing (via side effect) the crossed children child1 and child2.

Description

Note that this function is set in PGASetUp() as the crossover user function for the real datatype when selecting one-point crossover.

Example

Performs crossover on the two parent strings m and d, producing children s and b.

PGAContext *ctx;
int m, d, s, b;

...
PGARealOneptCrossover (ctx, m, d, PGA_OLDPOP, s, b, PGA_NEWPOP);

Parameters:

ctx – context variable
p1 – the first parent string
p2 – the second parent string
pop1 – symbolic constant of the population containing string p1 and p2
c1 – the first child string
c2 – the second child string
pop2 – symbolic constant of the population to contain string c1 and c2

Returns:

c1 and c2 in population pop2 are modified by side-effect

void PGARealPrintString(PGAContext *ctx, FILE *fp, int p, int pop)

Write a real-valued string to a file.

Example

Write string s to stdout.

PGAContext *ctx;
int s;

...
PGARealPrintString (ctx, stdout, s, PGA_NEWPOP);

Parameters:

ctx – context variable
fp – file pointer to file to write the string to
p – index of the string to write out
pop – symbolic constant of the population string p is in

Returns:

None

void PGARealSBXCrossover(PGAContext *ctx, int p1, int p2, int pop1, int c1, int c2, int pop2)

Perform simulated binary crossover (SBX) on two parent strings producing two children via side-effect.

Description

Note that this function is set in PGASetUp() as the crossover user function for the real datatype when selecting simulated binary crossover.

Example

Performs crossover on the two parent strings m and d, producing children s and b.

PGAContext *ctx;
int m, d, s, b;

...
PGARealSBXCrossover (ctx, m, d, PGA_OLDPOP, s, b, PGA_NEWPOP);

Parameters:

ctx – context variable
p1 – the first parent string
p2 – the second parent string
pop1 – symbolic constant of the population containing string p1 and p2
c1 – the first child string
c2 – the second child string
pop2 – symbolic constant of the population to contain string c1 and c2

Returns:

c1 and c2 in population pop2 are modified by side-effect

void PGARealTwoptCrossover(PGAContext *ctx, int p1, int p2, int pop1, int c1, int c2, int pop2)

Perform two-point crossover on two parent strings producing two children via side-effect.

Description

Note that this function is set in PGASetUp() as the crossover user function for the real datatype when selecting two-point crossover.

Example

Performs crossover on the two parent strings m and d, producing children s and b.

PGAContext *ctx;
int m, d, s, b;

...
PGARealTwoptCrossover (ctx, m, d, PGA_OLDPOP, s, b, PGA_NEWPOP);

Parameters:

ctx – context variable
p1 – the first parent string
p2 – the second parent string
pop1 – symbolic constant of the population containing string p1 and p2
c1 – the first child string
c2 – the second child string
pop2 – symbolic constant of the population to contain string c1 and c2

Returns:

c1 and c2 in population pop2 are modified by side-effect

void PGARealUniformCrossover(PGAContext *ctx, int p1, int p2, int pop1, int c1, int c2, int pop2)

Perform uniform crossover on two parent strings producing two children via side-effect.

Description

Note that this function is set in PGASetUp() as the crossover user function for the real datatype when selecting uniform crossover.

Example

Performs crossover on the two parent strings m and d, producing children s and b.

PGAContext *ctx;
int m, d, s, b;

...
PGARealUniformCrossover (ctx, m, d, PGA_OLDPOP, s, b, PGA_NEWPOP);

Parameters:

ctx – context variable
p1 – the first parent string
p2 – the second parent string
pop1 – symbolic constant of the population containing string p1 and p2
c1 – the first child string
c2 – the second child string
pop2 – symbolic constant of the population to contain string c1 and c2

Returns:

c1 and c2 in population pop2 are modified by side-effect

static void PGAReceiveEvaluation(PGAContext *ctx, int p, int pop, int source, int tag, MPI_Comm comm, MPI_Status *status)

Receive evaluation and aux eval from another process.

Example

Receive evaluation from sub-process and place it into the first temporary location in PGA_NEWPOP.

PGAContext *ctx;
MPI_Comm    comm;
MPI_Status  status;

...
PGAReceiveEvaluation
  (ctx, PGA_TEMP1, PGA_NEWPOP, 0, PGA_COMM_EVALOFSTRING, comm, &status);

Parameters:

ctx – contex variable
p – index of an individual
pop – symbolic constant of the population
source – ID of the process from which to receive
tag – MPI tag to look for
comm – an MPI communicator
status – pointer to an MPI status structure

Returns:

string p in population pop is changed by side-effect

static int PGASelectLinear(PGAContext *ctx, PGAIndividual *pop)

Choose all strings that are not already copied to the next generation due to elitist strategies.

Description

Note that this ‘selection’ scheme isn’t a selection scheme in the genetic sense, it has no selection pressure. Note that the indeces are not randomized.

Example

PGAContext *ctx,
int l;

...
l = PGASelectLinear (ctx, PGA_OLDPOP);

Parameters:

ctx – context variable
pop – pointer to first individual of population

Returns:

index of the selected string

int PGASelectPTournament(PGAContext *ctx, int pop)

Choose two strings randomly and return the one with better evaluation with a specified probability.

Description

See description in Goldbergs classic book [Gol89], p. 121.

Example

PGAContext *ctx,
int l;

...
l = PGASelectPTournament (ctx, PGA_OLDPOP);

Parameters:

ctx – context variable
pop – symbolic constant of population to select from

Returns:

index of the selected string

static int PGASelectProportional(PGAContext *ctx, PGAIndividual *pop)

Select a parent for the next generation using a linear search through a (fitness) weighted ‘roulette wheel’.

Description

The probability of selection of individual \(i\) with fitness \(f_i\) is given by Goldberg [Gol89], p. 11 as \(p_i = \frac{f_i}{\sum_{i} f_i}\)

Example

PGAContext *ctx,
int l;

...
l = PGASelectProportional (ctx, PGA_OLDPOP);

Parameters:

ctx – context variable
pop – pointer to first individual of population

Returns:

index of the selected string

static void PGASelectSUS(PGAContext *ctx, PGAIndividual *pop)

A select routine using stochastic universal sampling.

Description

Perform stochastic universal sampling selection [Bak87], p. 16. This routine creates the entire selected population with one call.

Example

PGAContext *ctx,

...
PGASelectSUS (ctx, PGA_OLDPOP);

Parameters:

ctx – context variable
pop – pointer to first individual of population

Returns:

the array ga.selected [] created via side effect.

static int PGASelectTournament(PGAContext *ctx, int pop)

Choose N strings randomly and return the one with best evaluation.

Description

The configuration parameter N is the value set with PGASetTournamentSize(), the default is 2. Depending on the setting of PGASetTournamentWithReplacement() calls one of two local functions to use the right sampling.

Example

PGAContext *ctx,
int l;

...
l = PGASelectTournament (ctx, PGA_OLDPOP);

Parameters:

ctx – context variable
pop – symbolic constant of population to select from

Returns:

index of the selected string

static int PGASelectTournamentWithReplacement(PGAContext *ctx, int pop)

Choose N strings randomly and return the one with best evaluation.

Description

The configuration parameter N is the value set with PGASetTournamentSize(), the default is 2. The selection happens with replacement. This is a generalization of Goldbergs description [Gol89], for the generalization see, e.g. in Goldberg and Deb [GD91].

Example

PGAContext *ctx,
int l;

...
l = PGASelectTournamentWithReplacement (ctx, PGA_OLDPOP);

Parameters:

ctx – context variable
pop – symbolic constant of population to select from

Returns:

index of the selected string

static int PGASelectTournamentWithoutReplacement(PGAContext *ctx, int pop)

Choose N strings randomly and return the one with best evaluation.

Description

The configuration parameter N is the value set with PGASetTournamentSize(), the default is 2. The selection happens without replacement. This means if we select N individuals with a tournament size of 2, each individual is participating in exactly two tournaments. This does not mean that a single individual cannot be returned more than once. For implementation notes on the algorithm see [GKD89], p. 504.

Example

PGAContext *ctx,
int l;

...
l = PGASelectTournamentWithoutReplacement (ctx, PGA_OLDPOP);

Parameters:

ctx – context variable
pop – symbolic constant of population to select from

Returns:

index of the selected string

int PGASelectTruncation(PGAContext *ctx, int pop)

Choose the best k strings and return them in random order.

Description

The value k is (N * TruncationProportion) rounded to the next integer.

Example

PGAContext *ctx,
int l;

...
l = PGASelectTruncation (ctx, PGA_OLDPOP);

Parameters:

ctx – context variable
pop – symbolic constant of population to select from

Returns:

index of the selected string

static void PGASendEvaluation(PGAContext *ctx, int p, int pop, int dest, int tag, MPI_Comm comm)

Transmit evaluation and aux eval to another process.

Example

PGAContext *ctx;
int p, dest;

...
dest = SelectAFreeProcessor ();
PGASendEvaluation (ctx, p, PGA_NEWPOP, dest, PGA_COMM_EVALOFSTRING, comm);

Parameters:

ctx – context variable
p – index of an individual
pop – symbolic constant of the population
dest – ID of the process where this is going
tag – MPI tag to send with the individual
comm – MPI communicator

MPI_Datatype PGASerializedBuildDatatype(PGAContext *ctx, int p, int pop)

Build datatype from serialized data.

Description

This is the default function for the BuildDatatype user function if serialization is in use.

Parameters:

ctx – context variable
p – index of string
pop – symbolic constant of the population string p is in

Returns:

An MPI_Datatype

double PGASetupDE(PGAContext *ctx, int p, int pop, int maxidx, int *idx)

Helper function for differential evolution, used by both, the integer and the real implementations.

Parameters:

ctx – context variable
p – string index
pop – symbolic constant of the population the string is in
maxidx – maximum index of DE vectors needed
idx – indeces of population members

Returns:

dither value

void PGASortFuncNameIndex(PGAContext *ctx)

Sort the index of function names alphabetically.

Description

Only used internally by PGACreate().

Parameters:

ctx – context variable

Returns:

None

static void PGAStripArgs(char **argv, int *argc, int *c, int num)

Code to strip arguments out of command list.

Description

Internal function. Called only by PGAReadCmdLine().

Parameters:

argc – address of the count of the number of command line arguments
argv – array of command line arguments
c – current command-line index
num – number of args to strip

Returns:

None

void PGAUpdateAverage(PGAContext *ctx, int pop)

Update the average fitness statistic for reporting.

Description

Note that in the presence of constraints only the unconstrained function evaluations are averaged, except for the constraint-functions, these are averaged unconditionally.

Parameters:

ctx – context variable
pop – symbolic constant of the population

Returns:

None

void PGAUpdateBest(PGAContext *ctx, int popix)

Updates the best fitness statistic for reporting.

Description

Note that in the presence of constraints if no individual without constraints is found, the best value (for all functions except constraint functions) is NAN.

Parameters:

ctx – context variable
popix – symbolic constant of the population

Returns:

None

void PGAUpdateOffline(PGAContext *ctx, int pop)

Update the offline value based on the results in the new generation.

Description

Note that in the presence of constraints only the unconstrained best function evaluations are averaged, except for the constraint-functions, these are averaged unconditionally.

Example

PGAContext *ctx;

...
PGAUpdateOffline (ctx, PGA_NEWPOP);

Parameters:

ctx – context variable
pop – symbolic constant of the population whose statistics to use

Returns:

Updates an internal field in the context variable

void PGAUpdateOnline(PGAContext *ctx, int pop)

Update the online value based on the results in the new generation.

Description

Note that in the presence of constraints only the unconstrained function evaluations are averaged, except for the constraint-functions, these are averaged unconditionally.

Example

PGAContext *ctx;

...
PGAUpdateOnline (ctx, PGA_NEWPOP);

Parameters:

ctx – context variable
pop – symbolic constant of the population whose statistics to use

Returns:

Updates an internal field in the context variable

static void PGA_NSGA_Replacement(PGAContext *ctx, crowding_t crowding_method)

Perform NSGA Replacement.

Description

Perform dominance computation (ranking)
Perform crowding computation specific to the NSGA-Variant given as the parameter crowding_method
Sort individuals and replace into next generation

Note that the crowding_method makes the difference between NSGA-II and NSGA-III.

Parameters:

ctx – context variable
crowding_method – Method used for crowding sort

Returns:

None

static int dasdennis(int dim, int npart, int depth, int sum, void *p)

Static recursive function for LIN_dasdennis.

Parameters:

dim – dimension
npart – Number of partitions
depth – Recursion depth
sum – Number of points so far
p – Pointer to created points, memory must be already allocated

Returns:

The number of points allocated

static void dasdennisscale(int dim, int npoints, double scale, double *dir, void *v)

Static function for LIN_dasdennis scaling of points.

Description

When scaling we translate the scaled-down points from the centroid of the shifted points to the reference direction on the reference plane.

Parameters:

dim – dimension
npoints – Number of points
scale – Scaling factor
dir – Direction vector
v – Pointer to points, points must have been created

Returns:

None

Linear Algebra

group linalg

Functions

double LIN_2norm(int dim, double *v)

Euclidian norm (2-norm) of a vector.

Parameters:

dim – size of the vectors
v – vector of length n

Returns:

The euclidian norm of v

size_t LIN_binom(int a, int b)

Compute binomial coefficient of two integers.

Description

Computes \(\binom{a}{b}\)

Parameters:

a – first integer
b – second integer

Returns:

Binomial coefficient

void LIN_dasdennis_allocated(int dim, int npart, double scale, double *dir, int npoints, void *mem)

Compute Das & Dennis points to allocated memory.

Description

This is the case where the memory is already allocated. For more details see LIN_dasdennis().

Parameters:

dim – dimension
npart – Number of partitions
scale – Scaling factor
dir – Direction vector
npoints – Number of points
mem – Memory for points, memory must have been allocated

Returns:

None

double LIN_dot(int dim, double *v1, double *v2)

Dot product of two vectors.

Parameters:

dim – size of the vectors
v1 – first vector of length n
v2 – second vector of length n

Returns:

The dot product of v1 and v2

double LIN_euclidian_distance(int dim, double *v1, double *v2)

Euclidian distance of two vectors.

Parameters:

dim – size of the vectors
v1 – first vector of length n
v2 – second vector of length n

Returns:

The euclidian distance of v1 and v2

int LIN_gcd(int a, int b)

Greatest common divisor of two integers.

Parameters:

a – first integer
b – second integer

Returns:

The greatest common divisor (gcd) of a and b

void LIN_normalize_to_refplane(int dim, double *v)

Normalize a vector with dimension dim to the n-dimensional reference hyperplane.

Description

Hyperplane is probably a misnomer, it’s a 3-dimensional tetraeder for dimension 4. It is a plane for the 3-dimensional case going through the point 1 on each axis.

Parameters:

dim – dimension
v – vector of dimension dim

Returns:

The vector v is modified in-place

void LIN_print_matrix(int n, void *a)

Print matrix.

Description

Print matrix \(a\). Mainly used for testing.

Parameters:

n – size of the matrix
a – n * n matrix

Returns:

None

void LIN_print_vector(int n, double *v)

Print vector.

Description

Print vector \(v\). Mainly used for testing.

Parameters:

n – size of the vector
v – vector of length n

Returns:

None

int LIN_solve(int n, void *a, double *b)

Solve a linear matrix equation, or system of linear scalar equations.

Description

Linear matrix equation \(ax = b\)

Parameters:

n – size of the matrix
a – n * n matrix
b – vector of lenth n

Returns:

0 if no error, a positive error-code otherwise, returns the solution in b, a and b are modified in-place

Not Yet Implemented

group notimplemented

Not yet implemented, mainly used for island/multiple demes.

Functions

int PGAGetNumDemes(PGAContext *ctx)

Returns the number of demes to use in a neighborhood model.

Example

PGAContext *ctx;
int npop;

...
npop = PGAGetNumDemes (ctx);

Parameters:

ctx – context variable

Returns:

The number of demes to use in a neighborhood model

int PGAGetNumIslands(PGAContext *ctx)

Returns the number of islands to use in an island model.

Example

PGAContext *ctx;
int npop;

...
npop = PGAGetNumIslands (ctx);

Parameters:

ctx – context variable

Returns:

The number of islands to use in an island model

void PGAPrintVersionNumber(PGAContext *ctx)

Print PGAPack version number.

Description

This currently prints a meaningless hard-coded string.

Example

PGAContext ctx;

...
PGAPrintVersionNumber (ctx);

Parameters:

ctx – context variable

Returns:

print PGAPack version number

void PGARunIM(PGAContext *ctx, double (*evaluate)(PGAContext *c, int p, int pop, double *aux), MPI_Comm comm)

Execute the island model genetic algorithm.

Description

Not yet implemented. Based on ctx->par.topology this routine will need to create the appropriate communicator out of comm.

Example

PGAContext *ctx,
double f (PGAContext *ctx, int p, int pop, double *aux);
MPI_Comm comm;

...
PGARunIM (ctx, f, comm);

Parameters:

ctx – context variable
evaluate – a pointer to the user’s evaluation function, which must have the calling sequence shown in the example.
comm – the MPI communicator to use

Returns:

None

void PGARunNM(PGAContext *ctx, double (*evaluate)(PGAContext *c, int p, int pop, double *aux), MPI_Comm comm)

Execute a neighborhood model genetic algorithm.

Description

Not yet implemented. Based on ctx->par.topology this routine will need to create the appropriate communicator out of comm.

Example

PGAContext *ctx,
MPI_Comm comm;
double f (PGAContext *ctx, int p, int pop);

...
PGARunNM (ctx, f, comm);

Parameters:

ctx – context variable
evaluate – a pointer to the user’s evaluation function, which must have the calling sequence shown in the example.
comm – the MPI communicator to use

Returns:

None

void PGASetNumDemes(PGAContext *ctx, int numdemes)

Set the number of demes to use in a neighborhood model GA.

Description

Currently must be the same as the number of processes in the default communicator. The default is one.

Example

PGAContext *ctx,
double f (PGAContext *ctx, int p, int pop, double *aux);

ctx = PGACreate (&argc, argv, PGA_DATATYPE_BINARY, 100, PGA_MAXIMIZE);
PGASetNumDemes (ctx, 4);
PGASetUp (ctx);
PGARun (ctx, f);
PGADestroy (ctx);

Parameters:

ctx – context variable
numdemes – number of demes

Returns:

None

void PGASetNumIslands(PGAContext *ctx, int n)

Set the number of islands to use in an island model GA.

Description

The default is one. Currently must be the same as the number of processes in the default communicator.

Example

PGAContext *ctx,
double f (PGAContext *ctx, int p, int pop, double *aux);

ctx = PGACreate (&argc, argv, PGA_DATATYPE_BINARY, 100, PGA_MAXIMIZE);
PGASetNumIslands (ctx, 10);
PGASetUp (ctx);
PGARun (ctx, f);
PGADestroy (ctx);

Parameters:

ctx – context variable
n – number of islands

Returns:

None

Constant Definitions

Boolean Constants

group const-bool

Constants for booleans.

Defines

PGA_TRUE: True value

PGA_FALSE: False value.

Crossover Constants

group const-crossover

Constants for crossover variants.

Defines

PGA_CROSSOVER_ONEPT: One point crossover

PGA_CROSSOVER_TWOPT: Two point crossover (default)

PGA_CROSSOVER_UNIFORM: Uniform crossover

PGA_CROSSOVER_SBX: Simulated binary crossover (SBX)

PGA_CROSSOVER_EDGE: Edge Recombination

Constants for Datatypes

group const-datatype

Abstract Data Types.

Defines

PGA_DATATYPE_BINARY: Array of unsigned ints parsed into bits.

PGA_DATATYPE_INTEGER: Array of ints.

PGA_DATATYPE_REAL: Array of doubles.

PGA_DATATYPE_CHARACTER: Array of characters.

PGA_DATATYPE_USER: user defined data type

Typedefs

typedef unsigned long PGABinary: Allele data type binary (bit)

typedef signed long int PGAInteger: Allele data type int.

typedef double PGAReal: Allele data type real.

typedef signed char PGACharacter: Allele data type char.

typedef unsigned int PGAHash: Result of hashing.

Debugging Constants

group const-debug

Debug Levels.

Defines

PGA_DEBUG_ENTERED: Entering a function.

PGA_DEBUG_EXIT: Exiting a function

PGA_DEBUG_MALLOC: Memory management

PGA_DEBUG_PRINTVAR: Variables

PGA_DEBUG_SEND: Sending

PGA_DEBUG_RECV: Receiving

PGA_DEBUG_MAXFLAGS: All debug flags

Differential Evolution Crossover Constants

group const-de-cross

Constants for Differential Evolution Crossover Variants.

Defines

PGA_DE_CROSSOVER_BIN: Standard DE binomial crossover.

PGA_DE_CROSSOVER_EXP: Exponential crossover

Constants for Differential Evolution Variants

group const-de-variant

Constants for Differential Evolution Variants.

Defines

PGA_DE_VARIANT_RAND: Standard DE from random string (default)

PGA_DE_VARIANT_BEST: Derive from best string.

PGA_DE_VARIANT_EITHER_OR: Either-or variant.

Constants for Epsilon Constraints

group const-eps

Constants for epsilon constraints algorithm.

Defines

PGA_EPSILON_EXPONENT_MIN: minimum exponent cp from paper

PGA_EPSILON_EXPONENT_MAX: maximum exponent cp from paper

Constants for Error Printing

group const-err-print

Constants for error printing.

Use these with PGAError or better use PGAErrorPrintf.

Defines

PGA_INT: integer value for printing

PGA_DOUBLE: double value for printing

PGA_CHAR: char value for printing

PGA_VOID: void (no) value for printing

Constants for Fitness Types

group const-fitness

Constants for fitness variants.

Defines

PGA_FITNESS_RAW: use raw fitness (evaluation) (default)

PGA_FITNESS_NORMAL: linear normalization fitness

PGA_FITNESS_RANKING: linear ranking fitness

Constants for Fitness Minimization Strategies

group const-fitness-min

Constants for fitness minimization variants.

Defines

PGA_FITNESSMIN_RECIPROCAL: reciprocal fitness

PGA_FITNESSMIN_CMAX: cmax fitness (default)

Miscellaneous Constants

group const-misc

Misc Constants.

Defines

PGA_TEMP1: temporary individual 1

PGA_TEMP2: temporary individual 2

PGA_OLDPOP: Old population.

PGA_NEWPOP: New population.

PGA_UNINITIALIZED_INT: Un-initialized integer.

PGA_UNINITIALIZED_DOUBLE: Un-initialized double

Constants for Mixing Variants

group const-mixing

Constants for defining mixing variants.

This defines how mutation/crossover are combined (or not) The MUTATE_AND_CROSS variant performs mutation only if crossover was also performed. The TRADITIONAL variant performs mutation with the configured probability and then mutates with the given probability regardless if crossover was performed or not (this is the way all traditional implementations of GA are handling it). Note: This replaces the previous flags (PGASetMutationOrCrossoverFlag and friends) which are still supported for legacy reasons. The default is PGA_MIX_MUTATE_OR_CROSS also for legacy reasons.

Defines

PGA_MIX_MUTATE_OR_CROSS: Either mutation or crossover (default)

PGA_MIX_MUTATE_AND_CROSS: Mutation only if crossover.

PGA_MIX_MUTATE_ONLY: Only mutation.

PGA_MIX_TRADITIONAL: Mutation after crossover (also when no mutation occurs due to randomness)

Constants for MPI Send/Receive Tags

group const-mpitag

MPI Send/Recv Tags.

Defines

PGA_COMM_STRINGTOEVAL: MPI tag for sending string

PGA_COMM_EVALOFSTRING: MPI tag for returning evaluation.

PGA_COMM_DONEWITHEVALS: MPI tag for ending parallel eval.

PGA_COMM_SERIALIZE_SIZE: MPI tag for serialized data size.

Constants for Mutation Types

group const-mutation

Constants for mutation variants.

The defaults for Integer and Real data types are noted in the docs of the individual constants. For the Binary data type mutation is a random flip. For the Character data type, mutation selects a random character from the init range, see PGASetCharacterInitType().

Defines

PGA_MUTATION_CONSTANT: Real/Integer: Fixed value.

PGA_MUTATION_RANGE: Real/Integer: Uniform range.

PGA_MUTATION_UNIFORM: Real: +- Uniform random no.

PGA_MUTATION_GAUSSIAN: Real: +- Gaussian random number (default for Real data type)

PGA_MUTATION_PERMUTE: Integer: Permutation (swap) (default for Integer data type)

PGA_MUTATION_DE: Differential Evolution (only real)

PGA_MUTATION_POLY: Polynomial mutation.

Constants for Optimization Direction

group const-opt-dir

Optimization Direction (Maximize/Minimize).

Defines

PGA_MAXIMIZE: specify direction for fitness calc

PGA_MINIMIZE: specify direction for fitness calc

Constants for Population Replacement Strategies

group const-poprep

Constants for population replacement variants.

Defines

PGA_POPREPL_BEST: Select best string (default)

PGA_POPREPL_RANDOM_NOREP: Select random string w/o replacement.

PGA_POPREPL_RANDOM_REP: Select random string w/ replacement.

PGA_POPREPL_RTR: Restricted tournament replacement

PGA_POPREPL_PAIRWISE_BEST: Pairwise compare old/newpop

PGA_POPREPL_NSGA_II: NSGA-II non-dominated sorting

PGA_POPREPL_NSGA_III: NSGA-III non-dominated sorting

Constants for Error Printing Flags

group const-printflags

Printing flags.

Defines

PGA_FATAL: Fatal error.

PGA_WARNING: Warning

Constants for Random Initialization of Genes

group const-randinit

Variants for random initialization of genes.

Defines

PGA_RINIT_PERCENT: real percent offset

PGA_RINIT_RANGE: real range (default)

PGA_IINIT_PERMUTE: integer permutation (default)

PGA_IINIT_RANGE: integer range (nonunique)

PGA_CINIT_LOWER: all lowercase letters (default)

PGA_CINIT_UPPER: all uppercase letters

PGA_CINIT_MIXED: both upper and lower case letters

Constants for Reporting

group const-rep

Reporting Options, multiple options can be defined.

Defines

PGA_REPORT_ONLINE: Print the online analysis

PGA_REPORT_OFFLINE: Print the offline analysis

PGA_REPORT_GENE_DISTANCE: Print the genetic distance

PGA_REPORT_HAMMING: For backwards compatibility, this used to be defined only for binary strings.

PGA_REPORT_STRING: Print the string

PGA_REPORT_WORST: Print the worst individual

PGA_REPORT_AVERAGE: Print average of the population.

Constants for Selection Types

group const-selection

Constants for selection variants.

Defines

PGA_SELECT_PROPORTIONAL: proportional selection

PGA_SELECT_SUS: stochastic universal selection

PGA_SELECT_TOURNAMENT: tournament selection (default)

PGA_SELECT_PTOURNAMENT: probabilistic tournament selection

PGA_SELECT_TRUNCATION: truncation selection

PGA_SELECT_LINEAR: linear selection

Constants for Stopping Conditions

group const-stop

Define when to stop, multiple conditions selectable.

Defines

PGA_STOP_MAXITER: Stop: for maximum iterations (default)

PGA_STOP_NOCHANGE: Stop: no change in best string

PGA_STOP_TOOSIMILAR: Stop: homogeneous population

Constants for User Functions

group const-ufun

Constants used for registering user functions.

Defines

PGA_USERFUNCTION_CREATESTRING: String create

PGA_USERFUNCTION_MUTATION: Custom Mutation

PGA_USERFUNCTION_CROSSOVER: Custom Crossover

PGA_USERFUNCTION_PRINTSTRING: Gene printing

PGA_USERFUNCTION_COPYSTRING: Gene copy

PGA_USERFUNCTION_DUPLICATE: Dupe checking

PGA_USERFUNCTION_INITSTRING: Gene init

PGA_USERFUNCTION_BUILDDATATYPE: Build MPI datatype

PGA_USERFUNCTION_STOPCOND: Stopping check

PGA_USERFUNCTION_ENDOFGEN: End of generation

PGA_USERFUNCTION_GEN_DISTANCE: Distance of genes

PGA_USERFUNCTION_GEN_DIFFERENCE: Only used for backward compatibility.

PGA_USERFUNCTION_PRE_EVAL: Start of generation.

PGA_USERFUNCTION_HASH: Gene hashing

PGA_USERFUNCTION_SERIALIZE: Serialization

PGA_USERFUNCTION_DESERIALIZE: De-serialization

PGA_USERFUNCTION_SERIALIZE_FREE: Free serialization

PGA_USERFUNCTION_CHROM_FREE: Free chromosome

PGA_NUM_USERFUNCTIONS: Count