Example #1
0
        /// <summary>
        /// Restores a node from the array representation back into a tree representation
        /// </summary>
        /// <param name="FunctionSet"></param>
        /// <returns>Reference to the converted tree</returns>
        public GPNode ConvertNode(IGPFunctionSet FunctionSet)
        {
            //
            // Determine the type of the node
            // < 200 : User Defined function
            // 200 to 210 : Terminal
            // 253 : ADR
            // 254 : ADL
            // 255 : ADF
            if (m_TreeArrayNew[m_ArrayPos] == 255)
            {
                m_ArrayPos++;
                byte WhichADF             = m_TreeArrayNew[m_ArrayPos++];
                byte NumberArgs           = m_TreeArrayNew[m_ArrayPos++];
                GPNodeFunctionADF NodeNew = new GPNodeFunctionADF(WhichADF, NumberArgs);
                //
                // Build up the children before returning
                for (byte Child = 0; Child < NumberArgs; Child++)
                {
                    NodeNew.Children.Add(ConvertNode(FunctionSet));
                }
                return(NodeNew);
            }
            else if (m_TreeArrayNew[m_ArrayPos] == 254)
            {
                m_ArrayPos++;
                byte WhichADL             = m_TreeArrayNew[m_ArrayPos++];
                byte NumberArgs           = m_TreeArrayNew[m_ArrayPos++];
                GPNodeFunctionADL NodeNew = new GPNodeFunctionADL(WhichADL, NumberArgs);
                //
                // Build up the children before returning
                for (byte Child = 0; Child < NumberArgs; Child++)
                {
                    NodeNew.Children.Add(ConvertNode(FunctionSet));
                }
                return(NodeNew);
            }
            else if (m_TreeArrayNew[m_ArrayPos] == 253)
            {
                m_ArrayPos++;
                byte WhichADR             = m_TreeArrayNew[m_ArrayPos++];
                byte NumberArgs           = m_TreeArrayNew[m_ArrayPos++];
                GPNodeFunctionADR NodeNew = new GPNodeFunctionADR(WhichADR, NumberArgs);
                //
                // Build up the children before returning
                for (byte Child = 0; Child < NumberArgs; Child++)
                {
                    NodeNew.Children.Add(ConvertNode(FunctionSet));
                }
                return(NodeNew);
            }
            else if (m_TreeArrayNew[m_ArrayPos] < 200)
            {
                GPNodeFunction NodeNew = (GPNodeFunction)((GPNodeFunction)FunctionSet[m_TreeArrayNew[m_ArrayPos++]]).Clone();
                //
                // Build up this node's children first
                byte ChildCount = m_TreeArrayNew[m_ArrayPos++];
                for (byte Child = 0; Child < ChildCount; Child++)
                {
                    NodeNew.Children.Add(ConvertNode(FunctionSet));
                }
                return(NodeNew);
            }
            else             // Terminal
            {
                switch (m_TreeArrayNew[m_ArrayPos++])
                {
                case 200:
                    byte WhichADFParam             = m_TreeArrayNew[m_ArrayPos++];
                    GPNodeTerminalADFParam NodeADF = new GPNodeTerminalADFParam(WhichADFParam);
                    return(NodeADF);

                case 201:
                    byte WhichUserDefined = m_TreeArrayNew[m_ArrayPos++];
                    GPNodeTerminalUserDefined NodeUser = new GPNodeTerminalUserDefined(WhichUserDefined);
                    return(NodeUser);

                case 202:
                    double dValue;
                    unsafe
                    {
                        byte *ptr = (byte *)&dValue;
                        for (int pos = 0; pos < sizeof(double); pos++)
                        {
                            ptr[pos] = m_TreeArrayNew[m_ArrayPos++];
                        }
                    }
                    GPNodeTerminalDouble NodeDouble = new GPNodeTerminalDouble(dValue);
                    return(NodeDouble);

                case 203:
                    int nValue;
                    unsafe
                    {
                        byte *ptr = (byte *)&nValue;
                        for (int pos = 0; pos < sizeof(int); pos++)
                        {
                            ptr[pos] = m_TreeArrayNew[m_ArrayPos++];
                        }
                    }
                    GPNodeTerminalInteger NodeInteger = new GPNodeTerminalInteger(nValue);
                    return(NodeInteger);
                }
            }

            //
            // TODO: Throw an exception, instead of this lazy crap! :)
            return(null);
        }
Example #2
0
        /// <summary>
        /// Static method to randomly create a terminal node
        /// TODO: Need to override this method for each type, all that if logic is stupid!
        /// </summary>
        /// <param name="bADF"></param>
        /// <param name="ADFArgCount"></param>
        /// <param name="bADL"></param>
        /// <param name="ADLArgCount"></param>
        /// <param name="bADR"></param>
        /// <param name="ADRArgCount"></param>
        /// <param name="TerminalSet"></param>
        /// <param name="IntegerMin"></param>
        /// <param name="IntegerMax"></param>
        /// <returns></returns>
        public static GPNodeTerminal Initialize(
            bool bADF, short ADFArgCount,
            bool bADL, short ADLArgCount,
            bool bADR, short ADRArgCount,
            List <GPEnums.TerminalType> TerminalSet, int IntegerMin, int IntegerMax)
        {
            short          Random = 0;
            GPNodeTerminal node;

            //
            // Go through the terminal set and count up the number of user
            // define terminal types.
            short UserDefined = 0;

            for (short Terminal = 0; Terminal < TerminalSet.Count; Terminal++)
            {
                if (TerminalSet[Terminal] == GPEnums.TerminalType.UserDefined)
                {
                    UserDefined++;
                }
            }

            //
            // If we have an ADF, then see if we randomly select the terminal to
            // be a function parameter or a random constant.  The (TerminalSet.Count-UserDefined)
            // is to get down to just the random constant options.
            if (bADF)
            {
                Random = (short)GPUtilities.rngNextInt(ADFArgCount + (TerminalSet.Count - UserDefined));
                if (Random < ADFArgCount)
                {
                    node = new GPNodeTerminalADFParam(Random);
                    return(node);
                }
                //
                // Update the random selection to be one of the random constant options
                Random -= ADFArgCount;
                Random += UserDefined;
            }

            //
            // If we have an ADL, do the same kind of thing as above for ADFs
            if (bADL)
            {
                Random = (short)GPUtilities.rngNextInt(ADLArgCount + (TerminalSet.Count - UserDefined));
                if (Random < ADLArgCount)
                {
                    node = new GPNodeTerminalADLParam(Random);
                    return(node);
                }
                //
                // Update the random selection to be one of the random constant options
                Random -= ADLArgCount;
                Random += UserDefined;
            }

            //
            // Same story for ADRs
            if (bADR)
            {
                Random = (short)GPUtilities.rngNextInt(ADRArgCount + (TerminalSet.Count - UserDefined));
                if (Random < ADRArgCount)
                {
                    node = new GPNodeTerminalADRParam(Random);
                    return(node);
                }
                //
                // Update the random selection to be one of the random constant options
                Random -= ADRArgCount;
                Random += UserDefined;
            }

            //
            // If an RPB terminal, select from anything in the terminal set
            if (!bADF && !bADL && !bADR)
            {
                Random = (short)GPUtilities.rngNextInt(TerminalSet.Count);
            }

            //
            // It is a user defined terminal
            if (Random < UserDefined)
            {
                return(new GPNodeTerminalUserDefined(Random));
            }
            //
            // It is either an integer or double terminal
            if (TerminalSet[Random] == GPEnums.TerminalType.RandomDouble)
            {
                return(new GPNodeTerminalDouble(GPUtilities.rngNextDouble()));
            }
            else
            {
                return(new GPNodeTerminalInteger(GPUtilities.rngNextInt(IntegerMin, IntegerMax)));
            }
        }