/// <summary>
/// Writes the indicated ADF to the file
/// </summary>
/// <param name="ADBranch">The ADF to write</param>
public override bool WriteADF(GPProgramBranchADF adf)
{
//
// Write the function declaration
m_Writer.WriteLine("int countADF" + adf.WhichFunction + "=0;");
m_Writer.WriteLine(BuildADFPrototype(adf, "GeneticProgram::"));
m_Writer.WriteLine("\t{");
m_Writer.WriteLine("\tif (countADF" + adf.WhichFunction + " >= 1) return 1.0;");
m_Writer.WriteLine("\tcountADF" + adf.WhichFunction + "++;");
m_Writer.WriteLine();
m_Writer.Write("\tdouble Result=");
WriteProgramBody(adf.Root);
//
// Close off the function
m_Writer.WriteLine(";");
m_Writer.WriteLine();
m_Writer.WriteLine("\tcountADF" + adf.WhichFunction + "--;");
m_Writer.WriteLine();
m_Writer.WriteLine("return Result;");
m_Writer.WriteLine("}");
m_Writer.WriteLine();
return(true);
}
/// <summary>
/// Writes the indicated ADF to the file
/// </summary>
/// <param name="ADBranch">The ADF to write</param>
public override bool WriteADF(GPProgramBranchADF adf)
{
//
// Write the function declaration
m_Writer.WriteLine("\tPrivate countADF" + adf.WhichFunction + " As Integer=0");
m_Writer.Write("\tPrivate Function ADF" + adf.WhichFunction + "(");
//
// Write the function parameters
WriteADFParameters(adf);
m_Writer.WriteLine(") As Double");
m_Writer.WriteLine();
m_Writer.WriteLine("\t\tIf countADF" + adf.WhichFunction + " >= 1");
m_Writer.WriteLine("\t\t\tReturn 1.0");
m_Writer.WriteLine("\t\tEnd If");
m_Writer.WriteLine("\t\tcountADF" + adf.WhichFunction + " = countADF" + adf.WhichFunction + " + 1");
m_Writer.WriteLine();
m_Writer.WriteLine("\t\tDim Result As Double");
m_Writer.Write("\t\tResult= ");
WriteProgramBody(adf.Root);
//
// Close off the function
m_Writer.WriteLine();
m_Writer.WriteLine();
m_Writer.WriteLine("\t\tcountADF" + adf.WhichFunction + " = countADF" + adf.WhichFunction + " - 1");
m_Writer.WriteLine();
m_Writer.WriteLine("\t\treturn Result");
m_Writer.WriteLine("\tEnd Function");
m_Writer.WriteLine();
return(true);
}
/// <summary>
/// Writes the indicated ADF to the file
/// </summary>
/// <param name="ADBranch">The ADF to write</param>
public override bool WriteADF(GPProgramBranchADF adf)
{
//
// Write the function declaration
m_Writer.WriteLine("int countADF" + adf.WhichFunction + "=0;");
m_Writer.Write("double ADF" + adf.WhichFunction + "(");
//
// Write the function parameters
WriteADFParameters(adf);
m_Writer.WriteLine(")");
m_Writer.WriteLine("\t{");
m_Writer.WriteLine("\tif (countADF" + adf.WhichFunction + " >= 1) return 1.0;");
m_Writer.WriteLine("\tcountADF" + adf.WhichFunction + "++;");
m_Writer.WriteLine();
m_Writer.Write("\tdouble Result=");
WriteProgramBody(adf.Root);
//
// Close off the function
m_Writer.WriteLine(";");
m_Writer.WriteLine();
m_Writer.WriteLine("\tcountADF" + adf.WhichFunction + "--;");
m_Writer.WriteLine();
m_Writer.WriteLine("return Result;");
m_Writer.WriteLine("}");
m_Writer.WriteLine();
return(true);
}
/// <summary>
/// Write an ADF prototype
/// </summary>
/// <param name="ADBranch"></param>
/// <param name="ClassRoot"></param>
/// <returns>String representation of the ADF prototype</returns>
private String BuildADFPrototype(GPProgramBranchADF adf, String ClassRoot)
{
String Prototype = "double " + ClassRoot + "ADF" + adf.WhichFunction + "(";
Prototype += BuildADFParameters(adf) + ")";
return(Prototype);
}
/// <summary>
/// A Function node really acts as a reference to make a call into
/// a Function program branch. What this method does is to first crawl
/// through each of the Function parameter subtrees and get their values
/// computed up. These values are stored internal to the function
/// to act as a sort of stack, because each of the subtrees could
/// make calls to the same Function and we don't want the results to get
/// overwritten. Once all the subtrees have been evalutated, the
/// results are written into the Function parameters and the Function program
/// branch is called.
/// </summary>
/// <param name="tree">Program tree this Function belongs to</param>
/// <param name="execBranch">Program Branch this Function is executing within</param>
public override double EvaluateAsDouble(GPProgram tree, GPProgramBranch execBranch)
{
GPProgramBranchADF adf = tree.ADF[this.WhichFunction];
base.PrepareFunctionParameters(tree, execBranch, adf);
//
// Evalute the Function program branch
return(adf.EvaluateAsDouble(tree));
}
/// <summary>
/// Declare each of the ADF parameters
/// </summary>
/// <param name="ADBranch">Which ADF to work with</param>
private void WriteADFParameters(GPProgramBranchADF adf)
{
for (short nParam = 0; nParam < adf.NumberArgs; nParam++)
{
if (nParam != 0)
{
m_Writer.Write(",");
}
m_Writer.Write("ByVal p" + Convert.ToString(nParam) + " As Double");
}
}
/// <summary>
/// Declare each of the ADF parameters
/// </summary>
/// <param name="ADBranch">Which ADF to work with</param>
/// <returns>String representation of the ADF parameters</returns>
private String BuildADFParameters(GPProgramBranchADF adf)
{
String Parameters = "";
for (short nParam = 0; nParam < adf.NumberArgs; nParam++)
{
if (nParam != 0)
{
Parameters += ",";
}
Parameters += "double p" + Convert.ToString(nParam);
}
return(Parameters);
}
public override bool WriteADF(GPProgramBranchADF adf)
{
m_xmlWriter.WriteStartElement("ADF");
//
// Record the number of parameters
m_xmlWriter.WriteStartElement("ParameterCount");
m_xmlWriter.WriteValue(adf.NumberArgs);
m_xmlWriter.WriteEndElement();
WriteProgramNode(adf.Root);
m_xmlWriter.WriteEndElement();
return(true);
}
/// <summary>
/// This method directs the construction of an ADL branch
/// </summary>
/// <param name="Branch"></param>
/// <param name="TreeBuild"></param>
/// <returns></returns>
public override bool Build(GPProgramBranch Branch, GPEnums.TreeBuild TreeBuild)
{
m_Branch = m_BranchADF = (GPProgramBranchADF)Branch;
//
// Call the recursive method to create the tree
m_Branch.Root = BuildInternal(TreeBuild, m_Branch.DepthInitial, false);
//
// Update the tree stats
m_Branch.UpdateStats();
//
// Convert the program into array representation
m_Branch.ConvertToArray(m_Config.FunctionSet);
return(true);
}
/// <summary>
/// Writes the indicated ADF to the file
/// </summary>
/// <param name="adf">The ADF to write</param>
public override bool WriteADF(GPProgramBranchADF adf)
{
WriteFunctionPrototype("ADF" + adf.WhichFunction, adf.NumberArgs, "p");
//
// Add the common blocks
WriteFortranString(" REAL Memory(" + m_Program.CountMemory + ")");
WriteFortranString(" COMMON /idxmemory/ Memory");
WriteFortranString(" INTEGER CountADF" + adf.WhichFunction);
WriteFortranString(" COMMON /ADF/ CountADF" + adf.WhichFunction);
//
// Declare the function types
WriteFortranString(" REAL SetMem");
WriteFortranString(" REAL GetMem");
foreach (KeyValuePair <String, GPLanguageWriter.tagUserDefinedFunction> kvp in m_FunctionSet)
{
if (!IsFortranIntrinsic(kvp.Key))
{
WriteFortranString(" REAL " + ((GPLanguageWriter.tagUserDefinedFunction)kvp.Value).Name);
}
}
WriteFortranString("");
WriteFortranString(" IF (CountADF" + adf.WhichFunction + " .GE. 1) THEN");
WriteFortranString(" CountADF" + adf.WhichFunction + "=1");
WriteFortranString(" RETURN");
WriteFortranString(" ENDIF");
WriteFortranString("");
WriteFortranString(" CountADF" + adf.WhichFunction + "=CountADF" + adf.WhichFunction + "+1");
WriteFortranString("");
m_Writer.Write(" ADF" + adf.WhichFunction + "=");
WriteProgramBody(adf.Root);
//
// Close off the function
WriteFortranString("");
WriteFortranString("");
WriteFortranString(" CountADF" + adf.WhichFunction + "=CountADF" + adf.WhichFunction + "-1");
WriteFortranString("");
WriteFortranString(" RETURN");
WriteFortranString(" END");
WriteFortranString("");
return(true);
}
/// <summary>
/// Cloneable interface
/// </summary>
/// <returns>Clone of the object</returns>
public Object Clone()
{
//
// Clone the RPB
GPProgramBranchRPB rpb = (GPProgramBranchRPB)m_RPB.Clone();
rpb.Parent = this;
//
// copy the main tree
GPProgram tree = new GPProgram(rpb);
m_Memory = new double[this.CountMemory];
//
// Handle the ADFs
tree.m_listADF = new List <GPProgramBranchADF>();
foreach (GPProgramBranchADF adf in m_listADF)
{
GPProgramBranchADF copy = (GPProgramBranchADF)adf.Clone();
copy.Parent = this;
tree.m_listADF.Add(copy);
}
//
// Handle the ADLs
tree.m_listADL = new List <GPProgramBranchADL>();
foreach (GPProgramBranchADL adl in m_listADL)
{
GPProgramBranchADL copy = (GPProgramBranchADL)adl.Clone();
copy.Parent = this;
tree.m_listADL.Add(copy);
}
//
// Handle the ADRs
tree.m_listADR = new List <GPProgramBranchADR>();
foreach (GPProgramBranchADR adr in m_listADR)
{
GPProgramBranchADR copy = (GPProgramBranchADR)adr.Clone();
copy.Parent = this;
tree.m_listADR.Add(copy);
}
return(tree);
}
/// <summary>
/// Create a brand spanking new baby program tree!
/// </summary>
/// <param name="Depth">Max depth the tree can be</param>
/// <param name="treeBuild">Tree building technique</param>
/// <returns>Newly constructed program</returns>
public GPProgram Construct(int nDepth, GPEnums.TreeBuild treeBuild)
{
//
// Create an empty program tree
m_Program = new GPProgram(null);
//
// We start by creating the ADFs first, because we want them available
// to the RPB when it is created.
//
// Create some ADF branches
for (short ADF = 0; ADF < m_Config.ADFSet.Count; ADF++)
{
GPProgramBranchADF adfBranch = new GPProgramBranchADF(m_Program, nDepth, ADF, m_Config.ADFSet[ADF]);
m_OperatorADF.Build(adfBranch, treeBuild);
m_Program.ADF.Add(adfBranch);
}
//
// Create some ADL branches
for (short ADL = 0; ADL < m_Config.ADLSet.Count; ADL++)
{
GPProgramBranchADL adlBranch = new GPProgramBranchADL(m_Program, nDepth, ADL, m_Config.ADLSet[ADL]);
m_OperatorADL.Build(adlBranch, treeBuild);
m_Program.ADL.Add(adlBranch);
}
//
// Create some ADR branches
for (short ADR = 0; ADR < m_Config.ADRSet.Count; ADR++)
{
GPProgramBranchADR adrBranch = new GPProgramBranchADR(m_Program, nDepth, ADR, m_Config.ADRSet[ADR]);
m_OperatorADR.Build(adrBranch, treeBuild);
m_Program.ADR.Add(adrBranch);
}
//
// Build the RPB branch
m_Program.RPB = new GPProgramBranchRPB(m_Program, m_Program.ADF.Count, nDepth, treeBuild);
m_OperatorRPB.Build(m_Program.RPB, treeBuild);
return(m_Program);
}
/// <summary>
/// Parse an ADF branch
/// </summary>
/// <param name="adfNode"></param>
/// <param name="WhichADF"></param>
/// <param name="Program"></param>
/// <returns></returns>
private GPProgramBranchADF LoadBranchADF(XmlNode adfNode, short WhichADF, GPProgram Program)
{
//
// First step, parse out the number of arguments
XmlNode xmlNode = adfNode.SelectSingleNode("ParameterCount");
byte ParameterCount = Convert.ToByte(xmlNode.InnerText);
//
// Create the Branch tree
GPProgramBranchADF adf = new GPProgramBranchADF(Program, 0, WhichADF, ParameterCount);
//
// Get the root ADF node
xmlNode = adfNode.SelectSingleNode("GPNode");
adf.Root = ReadGPNode(xmlNode);
adf.UpdateStats();
return(adf);
}
public GPProgramBranchFactoryADF(GPProgramBranchADF ADF, GPModelerServer Config)
: base(ADF, Config)
{
m_BranchADF = ADF;
}
/// <summary>
/// Build a program based upon the XML description that is provided.
/// </summary>
/// <returns></returns>
public GPProgram Construct()
{
//
// Create a program tree
GPProgram Program = new GPProgram(null);
//
// Start off with the root node
XmlElement xmlRoot = m_DocProgram.DocumentElement;
//
// Read the indexed memory size
XmlNode xmlHeader = xmlRoot.SelectSingleNode("Header");
if (xmlHeader != null)
{
XmlNode xmlMemory = xmlHeader.SelectSingleNode("MemoryCount");
Program.CountMemory = Convert.ToInt16(xmlMemory.InnerText);
}
else
{
Program.CountMemory = 1; // Some stupid default
}
//
// Load the ADRs
List <GPProgramBranchADR> ADRList = new List <GPProgramBranchADR>();
XmlNodeList xmlListADR = xmlRoot.SelectNodes("ADR");
short WhichADR = 0;
foreach (XmlNode adrNode in xmlListADR)
{
GPProgramBranchADR adrBranch = LoadBranchADR(adrNode, WhichADR, Program);
ADRList.Add(adrBranch);
WhichADR++;
}
//
// Add this as the list of ADRs for the program
Program.ADR = ADRList;
//
// Load the ADLs
List <GPProgramBranchADL> ADLList = new List <GPProgramBranchADL>();
XmlNodeList xmlListADL = xmlRoot.SelectNodes("ADL");
short WhichADL = 0;
foreach (XmlNode adlNode in xmlListADL)
{
GPProgramBranchADL adlBranch = LoadBranchADL(adlNode, WhichADL, Program);
ADLList.Add(adlBranch);
WhichADL++;
}
//
// Add this as the list of ADLs for the program
Program.ADL = ADLList;
//
// Load the ADFs
List <GPProgramBranchADF> ADFList = new List <GPProgramBranchADF>();
XmlNodeList xmlListADF = xmlRoot.SelectNodes("ADF");
short WhichADF = 0;
foreach (XmlNode adfNode in xmlListADF)
{
GPProgramBranchADF adfBranch = LoadBranchADF(adfNode, WhichADF, Program);
ADFList.Add(adfBranch);
WhichADF++;
}
//
// Don't forget to assign this list of ADFs to the program tree
Program.ADF = ADFList;
//
// Get the RPB node
XmlNode xmlRPB = xmlRoot.SelectSingleNode("RPB");
//
// Create the RPB
Program.RPB = LoadBranchRPB(xmlRPB, ADFList, Program);
return(Program);
}
public abstract bool WriteADF(GPProgramBranchADF adf);
/// <summary>
/// This method performs crossover on the ADF branch.
/// 90% of the time internal nodes are selected and 10% of the time
/// leaf nodes are selected.
/// TODO: Parameterize those percentages
///
/// If either one of the selected nodes is a function that accepts only
/// terminals as parameters, no crossover is performed.
///
/// </summary>
/// <param name="sibling"></param>
public override void Crossover(GPProgramBranch sibling)
{
GPProgramBranchADF rightADF = (GPProgramBranchADF)sibling;
//
// Step 1: Find a node in the left tree
double TypeLeft = GPUtilities.rngNextDouble();
GPProgramBranchFactory.FindResult findLeft = null;
bool DoneLeft = false;
while (!DoneLeft)
{
int NodeLeft = GPUtilities.rngNextInt(m_Branch.CountNodes);
findLeft = FindNode(null, m_Branch.Root, NodeLeft);
if (TypeLeft < 0.90 && (findLeft.Node is GPNodeFunction))
{
DoneLeft = true;
}
else if (TypeLeft >= 0.90 && (findLeft.Node is GPNodeTerminal))
{
DoneLeft = true;
}
else if (m_Branch.CountNodes == 1)
{
DoneLeft = true;
}
}
//
// If the node is a function that only accepts terminal inputs, then crossover is not allowed
if (findLeft.Node is GPNodeFunction && ((GPNodeFunction)findLeft.Node).TerminalParameters)
{
return;
}
if (findLeft.Parent != null && findLeft.Parent is GPNodeFunction && ((GPNodeFunction)findLeft.Parent).TerminalParameters)
{
return;
}
//
// Step 2: Find a node in the right tree
double TypeRight = GPUtilities.rngNextDouble();
GPProgramBranchFactory.FindResult findRight = null;
bool DoneRight = false;
while (!DoneRight)
{
int NodeRight = GPUtilities.rngNextInt(rightADF.CountNodes);
findRight = FindNode(null, rightADF.Root, NodeRight);
if (TypeRight < 0.90 && (findRight.Node is GPNodeFunction))
{
DoneRight = true;
}
else if (TypeRight >= 0.90 && (findRight.Node is GPNodeTerminal))
{
DoneRight = true;
}
else if (rightADF.CountNodes == 1)
{
DoneRight = true;
}
}
//
// If the node is a function that only accepts terminal inputs, then crossover is not allowed
if (findRight.Node is GPNodeFunction && ((GPNodeFunction)findRight.Node).TerminalParameters)
{
return;
}
if (findRight.Parent != null && findRight.Parent is GPNodeFunction && ((GPNodeFunction)findRight.Parent).TerminalParameters)
{
return;
}
//
// Step 3: Swap the references
if (findLeft.Parent == null)
{
m_Branch.Root = findRight.Node;
}
else
{
findLeft.Parent.Children[findLeft.ChildNumber] = findRight.Node;
}
if (findRight.Parent == null)
{
rightADF.Root = findLeft.Node;
}
else
{
findRight.Parent.Children[findRight.ChildNumber] = findLeft.Node;
}
//
// Update the stats for these trees
m_Branch.UpdateStats();
rightADF.UpdateStats();
}
