API

DLL_EXPORT struct parameters *initialiseParameters( const  int  numInputs, const  int  numNodes, const  int  numOutputs, const  int  arity )

Initialises a parameters structure used throughout the CGP-Library.  The arguments describe the structure of the chromosomes created when using initialiseChromosome, runCGP or repeatCGP.

Parameters

Returns

A pointer to an initialised parameters structure.

Example

Initialising parameters

struct parameters *params;

int numInputs = 3;
int numNodes = 10;
int numOutputs = 2;
int nodeArity = 2;

params = initialiseParameters(numInputs, numNodes, numOutputs, nodeArity);

See Also

freeParameters, printParameters

DLL_EXPORT void freeParameters( struct  parameters  * params )

Frees parameters structure instance.

Parameters

See Also

initialiseParameters

DLL_EXPORT void printParameters( struct  parameters  * params )

Prints the given parameters to the screen in a human readable format.

Parameters

Example

Typical parameters structure printed using printParameters.

---------------------------------------------------
       Parameters
---------------------------------------------------
Evolutionary Strategy:      (1+4)-ES
Inputs:                     1
Nodes:                      15
Outputs:                    1
Node Arity:                 2
Connection weights range:   +/- 1.000000
Mutation Type:              probabilistic
Mutation rate:              0.050000
Fitness Function:           supervisedLearning
Target Fitness:             0.100000
Selection scheme:           selectFittest
Reproduction scheme:        mutateRandomParent
Update frequency:           500
Function Set: add sub mul div sin (5)
---------------------------------------------------

DLL_EXPORT void addNodeFunction( struct  parameters  * params, char  const  * functionNames )

Adds pre-defined node function(s) to the set of functions stored by a parameters structure.  These are the node functions available when using runCGP, repeatCGP and mutateChromosome.

If one function name is given that function is added to the function set.  If multiple node function names are given then each must be separated by a ‘,’.

If a node function name is given which is not recognised, a warning is given and that function is not added to the function set.

Parameters

Node Functions

mathematical operations

• add - summation over all inputs.
• sub - subtracts all but the first input from the first input
• mul - multiplies all of the inputs
• div - divides the first input by the second and then the third etc
• abs - the absolute of the first input
• sqrt - the square root of the first input
• sq - the square of the first input
• cube - the cube of the first input
• pow - the first input raised to the power of the second input
• exp - the exponential of the first input
• sin - the sine of the first input
• cos - the cosine of the first input
• tan - the tangent of the first input

logic gates

• and - returns ‘1’ if all inputs are ‘1’, else ‘0’
• nand - returns ‘0’ if all inputs are ‘1’, else, ‘1’
• or - returns ‘0’ if all inputs are ‘0’, else, ‘1’
• nor - returns ‘1’ if all inputs are ‘0’, else, ‘0’
• xor - returns ‘1’ if only one of the inputs is ‘1’, else, ‘0’
• xnor - returns ‘0’ if only one of the inputs is ‘1’, else, ‘1’
• not - returns ‘1’ if first input is ‘0’, else ‘1’

neuron transfer/activation functions

• sig - the logistic sigmoid of the weighted sum of inputs.  Output range [0,1]
• gauss - the Gaussian of the weighted sum of inputs.  Output range [0,1]
• step - the heaviside step function of the weighted sum of inputs.  Output range [0,1]
• softsign - the softsign of the weighted sum of inputs.  Output range [-1,1]
• tanh - the hyperbolic tangent of the weighted sum of inputs.  Output range [-1,1]

Other

• rand - produces a different random number in the range [-1,1] each time it is called
• pi - produces the constant pi
• 1 - produces the constant one
• 0 - produces the constant zero
• wire - acts as a simple wire mapping the input to the output

Example

Add the node functions logical AND OR NAND NOR and XOR to the function set.

addNodeFunction(params, "and,or,nand,nor,xor");

See Also

clearFunctionSet, addCustomNodeFunction

DLL_EXPORT void addCustomNodeFunction(     struct  parameters  * params,     double  (*function)(const int numInputs, const double *inputs, const double *weights),     char  const  * functionName,     int  maxNumInputs )

Adds custom node function to the set of functions stored by a parameters structure.  See addNodeFunction.

The custom fitness function prototype must take the form

double nodeFunctionName(const int numInputs, const double *inputs, const double *weights);

where the user replaces ‘nodeFunctionName’ with their own function name.

Parameters

Example

Creating a custom node function ‘add’

double add(const int numInputs, const double *inputs, const double *connectionWeights){

    int i;
    double sum = 0;

    for(i=0; i<numInputs; i++){
        sum += inputs[i];
    }

    return sum;
}

Adding the new custom node function to the function set

addCustomNodeFunction(params, add, "add", -1);

Note

The connections weights are used for when creating custom node functions for Artificial Neural Networks.  If required they are accessed in the same way as the inputs.

See Also

clearFunctionSet, addNodeFunction

DLL_EXPORT void clearFunctionSet( struct  parameters  * params )

Resets the function set stored by a parameters structure to contain no functions.

Parameters

See Also

addNodeFunction, addCustomNodeFunction

DLL_EXPORT void setNumInputs( struct  parameters  * params, int  numInputs )

Sets the number of chromosome inputs in the given parameters.

The given number of chromosome inputs is also parsed to ensure a valid number of chromosome inputs.  A number of chromosome inputs <0 is invalid.  If an invalid number of chromosome inputs is give an error is displayed and CGP-Library terminates.

Parameters

See Also

setNumNodes, setNumOutputs, setArity

DLL_EXPORT void setNumNodes( struct  parameters  * params, int  numNodes )

Sets the number of chromosome nodes in the given parameters.

The given number of chromosome nodes is also parsed to ensure a valid number of chromosome nodes.  A number of chromosome nodes <0 is invalid.  If an invalid number of chromosome nodes is give an error is displayed and CGP-Library terminates.

Parameters

See Also

setNumInputs, setNumOutputs, setArity

DLL_EXPORT void setNumOutputs( struct  parameters  * params, int  numOutputs )

Sets the number of chromosome outputs in the given parameters.

The given number of chromosome outputs is also parsed to ensure a valid number of chromosome outputs.  A number of chromosome outputs <1 is invalid.  If an invalid number of chromosome outputs is give an error is displayed and CGP-Library terminates.

Parameters

See Also

setNumInputs, setNumNodes, setArity

DLL_EXPORT void setArity( struct  parameters  * params, int  arity )

Sets the arity of the chromosome nodes in the given parameters.

The given arity for each chromosome node is also parsed to ensure a valid chromosome node arity.  A chromosome node arity <1 is invalid.  If an invalid chromosome node arity is give an error is displayed and CGP-Library terminates.

Parameters

See Also

setNumInputs, setNumNodes, setNumOutputs

DLL_EXPORT void setMu( struct  parameters  * params, int  mu )

Sets the mu value in the given parameters.

The given mu value is also parsed to ensure a valid mu value. mu values <1 are invalid.  If an invalid mu value is give a warning is displayed and the mu value is left unchanged.

Parameters

DLL_EXPORT void setLambda( struct  parameters  * params, int  lambda )

Sets the lambda value in the given parameters.

The given lambda value is also parsed to ensure a valid lambda value. lambda values <1 are invalid.  If an invalid lambda value is give a warning is displayed and the lambda value is left unchanged.

Parameters

DLL_EXPORT void setEvolutionaryStrategy( struct  parameters  * params, char  evolutionaryStrategy )

Sets the evolutionary strategy in the given parameters.

The given evolutionary strategy is also parsed to ensure a valid evolutionary strategy.  Evolutionary strategies other than ‘+’ and ‘,’ are invalid.  If an invalid evolutionary strategy is give a warning is displayed and the evolutionary strategy is left unchanged.

Parameters

DLL_EXPORT void setMutationRate( struct  parameters  * params, double  mutationRate )

Sets the mutation rate in the given parameters.

The given mutation rate is also parsed to ensure a valid mutation rate.  Mutation rate <0 or >1 are invalid.  If an invalid mutation rate is give a warning is displayed and the mutation rate is left unchanged.

Parameters

DLL_EXPORT void setRecurrentConnectionProbability(     struct  parameters  * params,     double  recurrentConnectionProbability )

Sets the recurrent connection probability in the given parameters.

The recurrent connection probability specifies the probability that a mutation to a connection gene will create a recurrent connection; otherwise a standard feed forward connection is made.  The given recurrent connection probability is also parsed to ensure a valid recurrent connection probability.  Recurrent connection probability <0 or >1 are invalid.  If an invalid recurrent connection probability is give a warning is displayed and the recurrent connection probability is left unchanged.

Parameters

DLL_EXPORT void setShortcutConnections( struct  parameters  * params, int  shortcutConnections )

Sets whether shortcut connections are used in the given parameters.

Shortcut Connections specifies whether an output can connect directly to an input.  Only Shortcut Connections of values 0 (no) and 1 (yes) are valid.  If an invalid value is given, a warning is displayed and the shortcut connections value is left unchanged.

Parameters

DLL_EXPORT void setConnectionWeightRange( struct  parameters  * params, double  weightRange )

Sets the connection weight range in the given parameters.  (only used by NeuroEvolution)

Parameters

DLL_EXPORT void setCustomFitnessFunction(     struct  parameters  * params,     double  (*fitnessFunction)(struct parameters *params, struct chromosome *chromo, struct dataSet *data),     char  const  * fitnessFunctionName )

Set custom fitness function.

By default the CGP-Library used a generic supervised learning fitness function where the fitness assigned to each chromosome is the sum of the absolute differences between the actual and target outputs defined in the given dataSet.  setCustomFitnessFunction is used to redefine the fitness function to be one of the users design.

All custom fitness function prototype must take the following form.  Where params is a parameters structure, chromo is the chromosome to be assigned a fitness and data is a dataSet which may be used by the custom fitness function.

double functionName(struct parameters *params, struct chromosome *chromo, struct dataSet *data);

Parameters

If the fitnessFunction parameter is set as NULL, the fitness function will be reset to the default supervised learning fitness function.

Example

Defining a custom fitness function, full adder.  Note that the dataSet does not have to be used.

double fullAdder(struct parameters *params, struct chromosome *chromo, struct data *dat){

int i;
double error = 0;

// full adder truth table
double inputs[8][3] = {{0,0,0},{0,0,1},{0,1,0},{0,1,1},{1,0,0},{1,0,1},{1,1,0},{1,1,1}};
double outputs[8][2] = {{0,0},{1,0},{1,0},{0,1},{1,0},{0,1},{0,1},{1,1}};

    //for each line in the truth table
    for(i=0; i<8; i++){

        // calculate the chromosome outputs for each set of inputs
        executeChromosome(chromo, inputs[i]);

        // If the first chromosome outputs differ from the correct outputs increment the error
        if(outputs[i][0] != getChromosomeOutput(chromo, 0) ){
            error++;
        }

        // If the second chromosome outputs differ from the correct outputs increment the error
        if(outputs[i][1] != getChromosomeOutput(chromo, 1) ){
            error++;
        }
    }

    return error;
}

Setting the new custom fitness function as the fitness function to be used

setCustomFitnessFunction(params, fullAdder, "fullAdder");

DLL_EXPORT void setCustomSelectionScheme(     struct  parameters  * params,     void  (*selectionScheme)(struct parameters *params, struct chromosome **parents, struct chromosome **candidateChromos, int numParents, int numCandidateChromos),     char  const  * selectionSchemeName )

Sets custom selection scheme.

By default the selection scheme used by CGP-Library is select fittest, where the fittest members of the candidate chromosomes are always selected as the parents.  This type of selection scheme is commonly used by CGP.  setCustomSelectionScheme is used to redefine the selection scheme to be one of the users design.

The custom selection scheme prototype must take the following form.  Where params is a parameters structure, parents is an array of chromosomes used to store the selected parents, candidateChromos is an array of chromosomes containing the pool of chromosomes to select the parent from, numParents is the number of parents to be selected and numCandidateChromos is the number of candidate chromosomes.

void selectionSchemeNmes(struct parameters *params, struct chromosome **parents, struct chromosome **candidateChromos, int numParents, int numCandidateChromos);

Note

The ordering of the candidateChromos is children followed by parents.

Parameters

If the selectionScheme parameter is set as NULL, the selection scheme will be reset to the default select fittest selection scheme.

Example

Defining a custom selection scheme, tournament selection.

void tournament(struct parameters *params, struct chromosome **parents, struct chromosome **candidateChromos, int numParents, int numCandidateChromos){

    int i;

    // two chromosome pointers to point to the chromosomes in the torment
    struct chromosome *candidateA;
    struct chromosome *candidateB;

    // for the number of required parents
    for(i=0; i<numParents; i++){

        // randomly select chromosomes for tournament
        candidateA = candidateChromos[rand() % numCandidateChromos];
        candidateB = candidateChromos[rand() % numCandidateChromos];

        // choose the fittest chromosome to become a parent
        if(getChromosomeFitness(candidateA) <= getChromosomeFitness(candidateB)){
            copyChromosome(parents[i], candidateA);
        }
        else{
            copyChromosome(parents[i], candidateB);
        }
    }
}

Setting the new custom selection scheme as the selection scheme to be used

setCustomSelectionScheme(params, tournament, "tournament");

See Also

setCustomFitnessFunction

DLL_EXPORT void setCustomReproductionScheme(     struct  parameters  * params,     void  (*reproductionScheme)(struct parameters *params, struct chromosome **parents, struct chromosome **children, int numParents, int numChildren),     char  const  * reproductionSchemeName )

Sets custom reproduction scheme.

By default the reproduction scheme used by CGP-Library is to create each child as a mutated version of a randomly selected parent.  This type of reproduction scheme is commonly used by CGP.  setCustomReproductionScheme is used to redefine the reproduction scheme to be one of the users design.

The custom reproduction scheme prototype must take the following form.  Where params is a parameters structure, parents is an array of chromosomes which store the parents to select from, children is an array of chromosomes which will contain the children after reproduction, numParents is the number of parents available for reproduction and numChildren is the number of children to be created.

void reproductionScheme(struct parameters *params, struct chromosome **parents, struct chromosome **children, int numParents, int numChildren);

If the reproductionScheme parameter is set as NULL, the reproduction scheme will be reset to the default mutate random parent reproduction scheme.

Example

Defining a custom reproduction scheme, ...

Setting the new custom reproduction scheme as the reproduction scheme to be used

setCustomReproductionScheme(params, ..., "...");

See Also

setCustomFitnessFunction, setCustomSelectionScheme

DLL_EXPORT void setTargetFitness( struct  parameters  * params, double  targetFitness )

Sets the target fitness used when running CGP.

In all cases lower fitness values are used to represent fitter chromosomes.

Parameters

DLL_EXPORT void setMutationType( struct  parameters  * params, char  const  * mutationType )

Sets the mutation method used when mutating chromosomes.

Used to set the mutation method used when running runCGP and repeatCGP or when mutating an individual chromosome using mutateChromosome.  The type of mutation used is set the parameters structure.

If an invalid mutation type is given a warning is displayed and the mutation type is left unchanged.

Mutation Methods

These are the mutation methods which can be selected from.

• ”probabilistic”.  The default mutation method.  Mutates each chromosome gene with a given probability; set with setMutationRate.
• ”point”.  Always mutates the same number of randomly selected genes.  The number of mutated genes is the total number of genes times the mutation rate.  Note: does not mutate weight genes, see pointANN.
• ”pointANN”.  Point mutation when evolving artificial neural networks; includes mutations to weight genes.
• ”onlyActive”.  Conducts probabilistic mutation on active nodes only.  Genes belonging to inactive nodes are not mutated.
• ”single”.  Keeps mutating randomly selected genes until an active gene is mutated to a new allele.  Note: this is independent of the mutation rate set.  Note: this does not mutate weight genes.

Parameters

Example

struct parameters *params = NULL;

params = initialiseParameters(1,10,1,2);
setMutationType(params, "point");

setMutationType()

See Also

setMutationRate

DLL_EXPORT void setUpdateFrequency( struct  parameters  * params, int  updateFrequency )

Sets the frequency of the updates to the user when using runCGP.

The update frequency represents the number of generations which elapse between showing the user the current best fitness.

Note

A value of ‘0’ is a special case which causes not updates to be shown.

Parameters

DLL_EXPORT void setNumThreads( struct  parameters  * params, int  numThreads )

Sets the number of threads in the given parameters.

The given number of threads is also parsed to ensure a valid value.  Values <1 are invalid.  If an invalid value is give a warning is displayed and the value is left unchanged.

Note

In order for the CGP-Library to use multiple threads it must be compiled with openMP flag set (-fopenmp for gcc/mingw).

Note

The CGP-Library ignores the OMP_NUM_THREADS environment variable.  The only method for setting the number of threads is using setNumThreads.

Parameters

DLL_EXPORT struct chromosome *initialiseChromosome( struct  parameters  * params )

Initialises a chromosome based on the given parameters.

Parameters

Returns

A pointer to an initialised chromosome structure.

See Also

freeChromosome, initialiseChromosomeFromFile, initialiseChromosomeFromChromosome

DLL_EXPORT struct chromosome* initialiseChromosomeFromFile( char  const  * file )

Initialises a chromosome from a given previously saved chromosome.

Note

Only chromosomes which use node functions defined by the CGP-library can be loaded.  Chromosomes which use custom node functions cannot be loaded.

Parameters

Returns

A pointer to an initialised chromosome structure.

Example

struct Chromosome *chromo;
char *chromoFile = "location of Chromosome";

chromo = loadChromosome(chromoFile);

See Also

freeChromosome, initialiseChromosome, initialiseChromosomeFromChromosome,

DLL_EXPORT struct chromosome *initialiseChromosomeFromChromosome(     struct  chromosome  * chromo )

Initialises a chromosome from a given chromosome.

This functions can be used to create a copy of a chromosome.

Parameters

Returns

A pointer to an initialised chromosome structure.

See Also

freeChromosome, initialiseChromosome, initialiseChromosomeFromFile

DLL_EXPORT void freeChromosome( struct  chromosome  * chromo )

Frees chromosome instance.

Parameters

See Also

initialiseChromosome, initialiseChromosomeFromFile

DLL_EXPORT void printChromosome( struct  chromosome  * chromo, int  weights )

Displays the given chromosome to the terminal / command prompt in a human readable format.

Parameters

Example

Typical output from printChromosome.

Each input and functioning node is labelled with its index in the chromosome.  There is a textual description of the node e.g.  input for input nodes or the operation for the function nodes.  Function node operations are followed by space separated values describing each nodes inputs.  Active nodes are also labelled with an *.  Finally the last line gives the nodes used as chromosome outputs.

(0):    input
(1):    mul 0 0 *
(2):    add 0 1 *
(3):    sub 2 0 *
(4):    mul 0 1 *
(5):    add 4 3 *
(6):    sub 4 2 *
(7):    mul 6 5 *
(8):    add 5 7 *
(9):    mul 1 6
(10):   mul 5 3
(11):   add 4 1
(12):   add 10 3
(13):   add 5 11
(14):   sub 3 6
(15):   div 5 13
outputs: 8

DLL_EXPORT void executeChromosome( struct  chromosome  * chromo, const  double  * inputs )

Executes the given chromosome.

Executes the given chromosome with the given inputs.  The dimensions of the inputs arrays must match the dimensions of the chromosome inputs.  The chromosome outputs are then accessed using getChromosomeOutput.

Parameters

Example

for a chromosome with three inputs and one outputs.

struct parameters *params = NULL;
struct chromosome *chromo = NULL;

double chromoInputs[] = {1, 2};
double chromoOutput;

params = initialiseParameters(2, 10, 1, 2);
addNodeFunction(params, "add,sub,mul,sq,cube,sin");

chromo = initialiseChromosome(params);

executeChromosome(chromo, chromoInputs);

chromoOutput = getChromosomeOutput(chromo, 0);

freeParameters(params);
freeChromosome(chromo);

(end)

See Also

getChromosomeOutput

DLL_EXPORT double getChromosomeOutput( struct  chromosome  * chromo, int  output )

Gets the outputs of the given chromosome after it has been executed using executeChromosome.

After a given chromosome has been executed using executeChromosome the chromosome outputs are made available using getChromosomeOutput.

Parameters

Example

See executeChromosome

See Also

executeChromosome

DLL_EXPORT double getChromosomeNodeValue( struct  chromosome  * chromo, int  node )

Gets the node value of the given chromosome and node after it has been executed using executeChromosome.

After a given chromosome has been executed using executeChromosome the chromosome node values are made available using getChromosomeNodeValue.

Parameters

See Also

executeChromosome, getChromosomeOutput

DLL_EXPORT int isNodeActive( struct  chromosome  * chromo, int  node )

Returns whether the given node in the given chromosome is active.  1-active, 0-inactive

If the given node index is less than zero or greater then the number of nodes in the given chromosome and error message is displayed and the program will terminate.

Parameters

DLL_EXPORT void saveChromosome( struct  chromosome  * chromo, char  const  * fileName )

Saves the given chromosome to a file which can used to initialise new chromosomes.

New chromosomes can be initialised using the saved chromosomes by calling initialiseChromosomeFromFile.

Node

Only chromosome which use node functions defined by the CGP-library can be loaded.  Chromosomes which use custom node functions cannot be loaded.

Parameters

See Also

initialiseChromosomeFromFile, saveChromosomeDot saveChromosomeLatex

DLL_EXPORT void saveChromosomeDot( struct  chromosome  * chromo, int  weights, char  const  * fileName )

Saves the given chromosome to a graphviz .dot file.

graphviz (www.graphviz.org) is a free open source graph drawing tool.  Once installed graphviz can be used to draw the chromosomes saved using saveChromosomeDot with the following command.

dot -Tsvg chromosome.dot -o chromosome.svg

Parameters

See Also

saveChromosome saveChromosomeLatex

DLL_EXPORT void saveChromosomeLatex( struct  chromosome  * chromo, int  weights, char  const  * fileName )

Saves the given chromosome to a latex .tex file for visulisation and inclusion in written workes.

LaTeX (www.http://latex-project.org/intro.html) is a free open source document preparation system.  Once installed LaTeX can be used to draw the chromosomes saved using saveChromosomeLatex with the following command.

latex chromosome.tex

or

pdflatex chromosome.tex

Parameters

See Also

saveChromosome saveChromosomeLatex

DLL_EXPORT void mutateChromosome( struct  parameters  * params, struct  chromosome  * chromo )

Mutate the given chromosome using the mutation method described in the given parameters.

Parameters

Example

struct parameters *params;
struct chromosome *chromo;

params = initialiseParameters(3,10,2,2);
chromo = initialiseChromosome(params);

mutateChromosome(params, chromo);

DLL_EXPORT void removeInactiveNodes( struct  chromosome  * chromo )

Removes all of the inactive nodes from the given chromosome.

Note

This operation causes the number of nodes in the chromosome to change.

Parameters

DLL_EXPORT void setChromosomeFitness( struct  parameters  * params, struct  chromosome  * chromo, struct  dataSet  * data )

Sets the fitness of the chromosome using the fitness function given in the parameters

Parameters

See Also

getChromosomeFitness

DLL_EXPORT void resetChromosome( struct  chromosome  * chromo )

Resets all of the chromosome nodes to output zero.

Note

This is useful when using recurrent connections where you do not want the output to be a function of the current state of the chromosome.

DLL_EXPORT void copyChromosome( struct  chromosome  * chromoDest, struct  chromosome  * chromoSrc )

Copies the contents of one chromoosme into the other.

In order for copy chromosome to opperate correctly the dimensions of the chromosomes must match i.e. the number of inputs, nodes, outputs and node arity must be the same.

Parameters

See Also

initialiseChromosome

DLL_EXPORT int getNumChromosomeInputs( struct  chromosome  * chromo )

Gets the number of chromosome inputs

Parameters

Returns

Number number of chromosome inputs

See Also

initialiseChromosome

DLL_EXPORT int getNumChromosomeNodes( struct  chromosome  * chromo )

Gets the number of chromosome nodes

Parameters

Returns

Number number of chromosome nodes

See Also

initialiseChromosome

DLL_EXPORT int getNumChromosomeActiveNodes( struct  chromosome  * chromo )

Gets the number of chromosome active nodes

Parameters

Returns

Number number of chromosome active nodes

See Also

initialiseChromosome

DLL_EXPORT int getNumChromosomeOutputs( struct  chromosome  * chromo )

Gets the number of chromosome outputs

Parameters

Returns

Number number of chromosome outputs

See Also

initialiseChromosome

DLL_EXPORT int getChromosomeNodeArity( struct  chromosome  * chromo, int  index )

Gets the arity of the chromosome nodes

Parameters

Returns

Arity of chromosome nodes

See Also

initialiseChromosome

DLL_EXPORT double getChromosomeFitness( struct  chromosome  * chromo )

Gets the fitness of the given chromosome

Parameters

Returns

The fitness of the given chromosome

See Also

setChromosomeFitness getChromosomeGenerations getNumChromosomeActiveNodes

DLL_EXPORT int getNumChromosomeActiveConnections( struct  chromosome  * chromo )

Gets the number of active connections in the given chromosome

Parameters

Returns

The number of active connections

See Also

getNumChromosomeActiveNodes

DLL_EXPORT int getChromosomeGenerations( struct  chromosome  * chromo )

Gets the number of generations for which the given chromosome has been trained.

If the chromosome has not been trained then -1 is returned.

Parameters

Returns

Number of generations for which the given chromosome has been trained

See Also

getChromosomeFitness getNumChromosomeActiveNodes

DLL_EXPORT struct dataSet *initialiseDataSetFromArrays( int  numInputs, int  numOutputs, int  numSamples, double  * inputs, double  * outputs )

Initialises a dataSet structures using the given input output pairs.

The given arrays containing the input output pairs must take the form

double inputs[numSamples][numInputs]
double outputs[numSamples][numOutputs]

Where the numInputs and numOutputs are the number of inputs and outputs per sample.

Parameters

Returns

A pointer to an initialised dataSet structure.

Example

Initialising a dataSet to contain the input output pairs for a full adder truth table.

struct data *trainingData;

int numInputs = 3;
int numOutputs = 2;
int numSamples = 8;

// full adder input output pairs
double inputs[8][3] = {{0,0,0},{0,0,1},{0,1,0},{0,1,1},{1,0,0},{1,0,1},{1,1,0},{1,1,1}};
double outputs[8][2] = {{0,0},{1,0},{1,0},{0,1},{1,0},{0,1},{0,1},{1,1}};

trainingData = initialiseDataFromArrays(numInputs, numOutputs, numSamples, inputs[0], outputs[0]);

See Also

freeDataSet, initialiseDataSetFromFile, printDataSet

DLL_EXPORT struct dataSet *initialiseDataSetFromFile( char  const  * file )

Initialises a dataSet structures using the given file.

Parameters

Returns

A pointer to an initialised dataSet structure.

Example

The file containing the dataSet must take the form

2,3,4
1,2,3,4,5
6,7,8,9,10
11,12,13,14,15
16,17,18,19,20

Where the header describes the number of inputs, number of outputs and the number of samples.  The rest of the file gives the inputs and then the outputs of each sample on a new line.  All values are comma separated.

The file can then be used to initialise a dataSet structure.

struct dataSet *trainingData;

trainingData = initialiseDataFromFile("file");

See Also

freeDataSet, initialiseDataSetFromArrays, printDataSet

DLL_EXPORT void freeDataSet( struct  dataSet  * data )

Frees dataSet instance.

Parameters

See Also

initialiseDataSetFromArrays, initialiseDataSetFromFile

DLL_EXPORT void printDataSet( struct  dataSet  * data )

Prints the input output pairs held by a dataSet structure to the terminal.

Parameters

See Also

initialiseDataSetFromArrays, initialiseDataSetFromFile, freeDataSet

DLL_EXPORT void saveDataSet( struct  dataSet  * data, char  const  * fileName )

Saves the given dataSet to a file which can be read using initialiseDataSetFromFile.

Parameters

See Also

initialiseDataSetFromFile, freeDataSet

DLL_EXPORT int getNumDataSetInputs( struct  dataSet  * data )

Gets the number of dataSet inputs.

Parameters

Returns

Number number of dataSet inputs

See Also

getNumDataSetOutputs, getNumDataSetSamples

DLL_EXPORT int getNumDataSetOutputs( struct  dataSet  * data )

Gets the number of dataSet outputs.

Parameters

Returns

Number number of dataSet outputs

See Also

getNumDataSetInputs, getNumDataSetSamples

DLL_EXPORT int getNumDataSetSamples( struct  dataSet  * data )

Gets the number of samples in the given dataSet.

Parameters

Returns

Number number of dataSet samples

See Also

getNumDataSetInputs, getNumDataSetOutputs

DLL_EXPORT double *getDataSetSampleInputs( struct  dataSet  * data, int  sample )

Gets the dataSet inputs for the given sample index.

Parameters

Returns

Pointer to an array containing the sample inputs.

See Also

getDataSetSampleInput, getDataSetSampleOutputs, getDataSetSampleOutput

DLL_EXPORT double getDataSetSampleInput( struct  dataSet  * data, int  sample, int  input )

Gets the dataSet input for the given sample index and input index.

Parameters

Returns

The input value for the given input of the given sample.

See Also

getDataSetSampleInputs, getDataSetSampleOutput, getDataSetSampleOutputs

DLL_EXPORT double *getDataSetSampleOutputs( struct  dataSet  * data, int  sample )

Gets the dataSet outputs for the given sample index.

Parameters

Returns

Pointer to an array containing the sample outputs.

See Also

getDataSetSampleOutput, getDataSetSampleInputs, getDataSetSampleInput

DLL_EXPORT double getDataSetSampleOutput( struct  dataSet  * data, int  sample, int  output )

Gets the dataSet output for the given sample index and output index.

Parameters

Returns

The output value for the given output for the given sample.

See Also

getDataSetSampleOutputs, getDataSetSampleInput, getDataSetSampleInputs

DLL_EXPORT void freeResults( struct  results  * rels )

Frees results instance.

An initialised results structure is returned from repeatCGP when applied CGP to a task multiple times in order to assess average behaviour.

Parameters

See Also

repeatCGP

DLL_EXPORT void saveResults( struct  results  * rels, char  const  * fileName )

Saves the given results to a csv file.

Parameters

DLL_EXPORT struct chromosome* getChromosome( struct  results  * rels, int  run )

Gets a copy of the best chromosome found on the given run in an initialised results structure.

Parameters

Returns

Pointer to an initialised chromosome structure.

See Also

repeatCGP, getAverageFitness, getAverageActiveNodes, getAverageGenerations

DLL_EXPORT int getNumChromosomes( struct  results  * rels )

Gets number of chromosomes stored in the given results structure.

Parameters

Returns

The number of chromosomes stored in the given results structure

See Also

repeatCGP, getAverageFitness, getAverageActiveNodes, getAverageGenerations

DLL_EXPORT double getAverageFitness( struct  results  * rels )

Gets the average fitness of the best chromosome found for each run in results.

Parameters

Returns

The average fitness of the best chromosome found for each run in results.

See Also

repeatCGP, getAverageActiveNodes, getAverageGenerations

DLL_EXPORT double getMedianFitness( struct  results  * rels )

Gets the median fitness of the best chromosome found for each run in results.

Parameters

Returns

The median fitness of the best chromosome found for each run in results.

See Also

repeatCGP, getMedianActiveNodes, getMedianGenerations

DLL_EXPORT double getAverageActiveNodes( struct  results  * rels )

Gets the average number of active nodes of the best chromosome found for each run in results.

Parameters

Returns

The average number of active nodes of the best chromosome found for each run in results.

See Also

repeatCGP, getAverageFitness, getAverageGenerations

DLL_EXPORT double getMedianActiveNodes( struct  results  * rels )

Gets the median number of active nodes of the best chromosome found for each run in results.

Parameters

Returns

The median number of active nodes of the best chromosome found for each run in results.

See Also

repeatCGP, getMedianFitness, getMedianGenerations

DLL_EXPORT double getAverageGenerations( struct  results  * rels )

Gets the average number generations required to find the best best chromosome for each run in results.

Parameters

Returns

The average number generations required to find the best chromosome found for each run in results.

See Also

repeatCGP, getAverageFitness, getAverageActiveNodes

DLL_EXPORT double getMedianGenerations( struct  results  * rels )

Gets the median number generations required to find the best best chromosome for each run in results.

Parameters

Returns

The median number generations required to find the best chromosome found for each run in results.

See Also

repeatCGP, getMedianFitness, getMedianActiveNodes

DLL_EXPORT struct chromosome* runCGP( struct  parameters  * params, struct  dataSet  * data, int  numGens )

Applies CGP to the given task.

Returns the best chromosome found after applying CGP to a given task using the specified parameters.  Depending upon the update frequency given in parameters (setUpdateFrequency) the progress made by CGP will be displayed in the terminal.

Note

As runCGP returns an initialised chromosome this should later be free’d using freeChromosome.

Parameters

Returns

A pointer to an initialised chromosome.

Example

struct parameters *params;
struct dataSet *data;
struct chromosome *chromo;

params = initialiseParameters(a,b,c,d);
addNodeFunction(params, "aaa,bbb,ccc");

data = initialiseDataSetFromFile("file");

chromo = runCGP(params, data, 100);

freeParameters(params);
freeDataSet(data);
freeChromosome(chromo);

See Also

repeatCGP, initialiseParameters, initialiseDataSetFromFile, freeChromosome

DLL_EXPORT struct results* repeatCGP( struct  parameters  * params, struct  dataSet  * data, int  numGens, int  numRuns )

Repeatedly applies CGP to the given task.

Returns a results structure containing the results of applying CGP to the given task multiple times.

Note

As repeatCGP returns an initialised results structure this should later be free’d using freeResults.

Parameters

Returns

A pointer to an initialised results structure.

Example

struct parameters *params;
struct dataSet *data;
struct results *rels;

params = initialiseParameters(a,b,c,d);
addNodeFunction(params, "aaa,bbb,ccc");

data = initialiseDataSetFromFile("file");

rels = repeatCGP(params, data, 100, 50);

freeParameters(params);
freeDataSet(data);
freeResults(rels);

See Also

runCGP, initialiseParameters, initialiseDataSetFromFile, freeResults

DLL_EXPORT void setRandomNumberSeed( unsigned  int  seed )

Sets the seed used by the random number generator in CGP-Library.

By default the current time is used as the random number seed.  When a random number seed is specified the CGP-Library will produce the same results if used in the same way.

Note

setRandomNumberSeed must be called after initialiseParameters otherwise the time will be used as the random number seed.

Parameters

See Also

initialiseParameters