/// <summary>
        /// Clone the tree node.
        /// </summary>
        /// 
        /// <returns>Returns exact clone of the node.</returns>
        /// 
        public object Clone( )
        {
            GPTreeNode clone = new GPTreeNode( );

            // clone gene
            clone.Gene = this.Gene.Clone( );
            // clone its children
            if ( this.Children != null )
            {
                clone.Children = new List<GPTreeNode>( );
                // clone each child gene
                foreach ( GPTreeNode node in Children )
                {
                    clone.Children.Add( (GPTreeNode) node.Clone( ) );
                }
            }
            return clone;
        }
 /// <summary>
 /// Initializes a new instance of the <see cref="GPTreeChromosome"/> class.
 /// </summary>
 /// 
 /// <param name="source">Source genetic tree to clone from.</param>
 /// 
 /// <remarks><para>This constructor creates new genetic tree as a copy of the
 /// specified <paramref name="source"/> tree.</para></remarks>
 /// 
 protected GPTreeChromosome( GPTreeChromosome source )
 {
     root = (GPTreeNode) source.root.Clone( );
     fitness = source.fitness;
 }
 /// <summary>
 /// Trim tree node, so its depth does not exceed specified level.
 /// </summary>
 private static void Trim( GPTreeNode node, int level )
 {
     // check if the node has children
     if ( node.Children != null )
     {
         if ( level == 0 )
         {
             // remove all children
             node.Children = null;
             // and make the node of argument type
             node.Gene.Generate( GPGeneType.Argument );
         }
         else
         {
             // go further to children
             foreach ( GPTreeNode n in node.Children )
             {
                 Trim( n, level - 1 );
             }
         }
     }
 }
        /// <summary>
        /// Crossover helper routine - selects random node of chromosomes tree and
        /// swaps it with specified node.
        /// </summary>
        private GPTreeNode RandomSwap( GPTreeNode source )
        {
            GPTreeNode retNode = null;

            // swap root node ?
            if ( ( root.Children == null ) || ( rand.Next( maxLevel ) == 0 ) )
            {
                // replace current root and return it
                retNode = root;
                root = source;
            }
            else
            {
                GPTreeNode node = root;

                for ( ; ; )
                {
                    // choose random child
                    int r = rand.Next( node.Gene.ArgumentsCount );
                    GPTreeNode child = (GPTreeNode) node.Children[r];

                    // swap the random node, if it is an end node or
                    // random generator "selected" this node
                    if ( ( child.Children == null ) || ( rand.Next( maxLevel ) == 0 ) )
                    {
                        // swap the node with pair's one
                        retNode = child;
                        node.Children[r] = source;
                        break;
                    }

                    // go further by tree
                    node = child;
                }
            }
            return retNode;
        }
        /// <summary>
        /// Generate chromosome's subtree of specified level.
        /// </summary>
        /// 
        /// <param name="node">Sub tree's node to generate.</param>
        /// <param name="level">Sub tree's level to generate.</param>
        /// 
        protected void Generate( GPTreeNode node, int level )
        {
            // create gene for the node
            if ( level == 0 )
            {
                // the gene should be an argument
                node.Gene = root.Gene.CreateNew( GPGeneType.Argument );
            }
            else
            {
                // the gene can be function or argument
                node.Gene = root.Gene.CreateNew( );
            }

            // add children
            if ( node.Gene.ArgumentsCount != 0 )
            {
                node.Children = new List<GPTreeNode>( );
                for ( int i = 0; i < node.Gene.ArgumentsCount; i++ )
                {
                    // create new child
                    GPTreeNode child = new GPTreeNode( );
                    Generate( child, level - 1 );
                    // add the new child
                    node.Children.Add( child );
                }
            }
        }
        /// <summary>
        /// Mutation operator.
        /// </summary>
        /// 
        /// <remarks><para>The method performs chromosome's mutation by regenerating tree's
        /// randomly selected node.</para></remarks>
        ///
        public override void Mutate( )
        {
            // current tree level
            int			currentLevel = 0;
            // current node
            GPTreeNode	node = root;

            for ( ; ; )
            {
                // regenerate node if it does not have children
                if ( node.Children == null )
                {
                    if ( currentLevel == maxLevel )
                    {
                        // we reached maximum possible level, so the gene
                        // can be an argument only
                        node.Gene.Generate( GPGeneType.Argument );
                    }
                    else
                    {
                        // generate subtree
                        Generate( node, rand.Next( maxLevel - currentLevel ) );
                    }
                    break;
                }

                // if it is a function node, than we need to get a decision, about
                // mutation point - the node itself or one of its children
                int r = rand.Next( node.Gene.ArgumentsCount + 1 );

                if ( r == node.Gene.ArgumentsCount )
                {
                    // node itself should be regenerated
                    node.Gene.Generate( );

                    // check current type
                    if ( node.Gene.GeneType == GPGeneType.Argument )
                    {
                        node.Children = null;
                    }
                    else
                    {
                        // create children's list if it was absent
                        if ( node.Children == null )
                            node.Children = new List<GPTreeNode>( );

                        // check for missing or extra children
                        if ( node.Children.Count != node.Gene.ArgumentsCount )
                        {
                            if ( node.Children.Count > node.Gene.ArgumentsCount )
                            {
                                // remove extra children
                                node.Children.RemoveRange( node.Gene.ArgumentsCount, node.Children.Count - node.Gene.ArgumentsCount );
                            }
                            else
                            {
                                // add missing children
                                for ( int i = node.Children.Count; i < node.Gene.ArgumentsCount; i++ )
                                {
                                    // create new child
                                    GPTreeNode child = new GPTreeNode( );
                                    Generate( child, rand.Next( maxLevel - currentLevel ) );
                                    // add the new child
                                    node.Children.Add( child );
                                }
                            }
                        }
                    }
                    break;
                }

                // mutation goes further to one of the children
                node = (GPTreeNode) node.Children[r];
                currentLevel++;
            }
        }
 /// <summary>
 /// Generate random chromosome value.
 /// </summary>
 /// 
 /// <remarks><para>Regenerates chromosome's value using random number generator.</para>
 /// </remarks>
 ///
 public override void Generate( )
 {
     // randomize the root
     root.Gene.Generate( );
     // create children
     if ( root.Gene.ArgumentsCount != 0 )
     {
         root.Children = new List<GPTreeNode>( );
         for ( int i = 0; i < root.Gene.ArgumentsCount; i++ )
         {
             // create new child
             GPTreeNode child = new GPTreeNode( );
             Generate( child, rand.Next( maxInitialLevel ) );
             // add the new child
             root.Children.Add( child );
         }
     }
 }
        /// <summary>
        /// Crossover operator.
        /// </summary>
        /// 
        /// <param name="pair">Pair chromosome to crossover with.</param>
        /// 
        /// <remarks><para>The method performs crossover between two chromosomes – interchanging
        /// randomly selected sub trees.</para></remarks>
        ///
        public override void Crossover( IChromosome pair )
        {
            GPTreeChromosome p = (GPTreeChromosome) pair;

            // check for correct pair
            if ( p != null )
            {
                // do we need to use root node for crossover ?
                if ( ( root.Children == null ) || ( rand.Next( maxLevel ) == 0 ) )
                {
                    // give the root to the pair and use pair's part as a new root
                    root = p.RandomSwap( root );
                }
                else
                {
                    GPTreeNode node = root;

                    for ( ; ; )
                    {
                        // choose random child
                        int r = rand.Next( node.Gene.ArgumentsCount );
                        GPTreeNode child = (GPTreeNode) node.Children[r];

                        // swap the random node, if it is an end node or
                        // random generator "selected" this node
                        if ( ( child.Children == null ) || ( rand.Next( maxLevel ) == 0 ) )
                        {
                            // swap the node with pair's one
                            node.Children[r] = p.RandomSwap( child );
                            break;
                        }

                        // go further by tree
                        node = child;
                    }
                }
                // trim both of them
                Trim( root, maxLevel );
                Trim( p.root, maxLevel );
            }
        }
        /// <summary>
        /// Get tree representation of the chromosome.
        /// </summary>
        /// 
        /// <returns>Returns expression's tree represented by the chromosome.</returns>
        /// 
        /// <remarks><para>The method builds expression's tree for the native linear representation
        /// of the GEP chromosome.</para></remarks>
        /// 
        protected GPTreeNode GetTree( )
        {
            // function node queue. the queue contains function node,
            // which requires children. when a function node receives
            // all children, it will be removed from the queue
            Queue functionNodes = new Queue( );

            // create root node
            GPTreeNode root = new GPTreeNode( genes[0] );

            // check children amount of the root node
            if ( root.Gene.ArgumentsCount != 0 )
            {
                root.Children = new List<GPTreeNode>( );
                // place the root to the queue
                functionNodes.Enqueue( root );

                // go through genes
                for ( int i = 1; i < length; i++ )
                {
                    // create new node
                    GPTreeNode node = new GPTreeNode( genes[i] );

                    // if next gene represents function, place it to the queue
                    if ( genes[i].GeneType == GPGeneType.Function )
                    {
                        node.Children = new List<GPTreeNode>( );
                        functionNodes.Enqueue( node );
                    }

                    // get function node from the top of the queue
                    GPTreeNode parent = (GPTreeNode) functionNodes.Peek( );

                    // add new node to children of the parent node
                    parent.Children.Add( node );

                    // remove the parent node from the queue, if it is
                    // already complete
                    if ( parent.Children.Count == parent.Gene.ArgumentsCount )
                    {
                        functionNodes.Dequeue( );

                        // check the queue if it is empty
                        if ( functionNodes.Count == 0 )
                            break;
                    }
                }
            }
            // return formed tree
            return root;
        }