int ID_Self;                                          //The ID of the Current Node

                int ID_Parent;                                    //The ID of the Parent Node

                double Optimal_Fitness;              //The optimal fitness in history

                double *Optimal_Data;                 //The optimal data in history (the current node information)

                double no_Visit;                               //No. of Visit

                int Dimension;                                   //The dimension used for comparing in this node

                double Threshold;                           //Threshold

                double Survival_Rate;

                struct CLUSTER_NODE *Parent;

                struct CLUSTER_NODE *Child_Left;

                struct CLUSTER_NODE *Child_Right;

                //------------ For 'Blockader'

                int Blockader;

                //------------ For 'Local Basin'

                struct CLUSTER_NODE *Basin_Node;


typedef struct CLUSTER_NODE Cluster_Node;

typedef struct CLUSTER_TREE {

                int Current_ID;                 

                int no_Dimension;

                int no_Leaf;                        //number of node inside the tree

                double **Interval;          //array storing the whole search space

                int max_Archive_Size;

                int no_AxisBoundary;

                int *AxisBoundary_Set;

                Cluster_Node *Root;

                double **cur_Interval; //array storing the interval of current focusing node

} Cluster_Tree;

Cluster_Tree_Insertion(Cluster_Tree *cur_Tree, double *cur_Data, double cur_Fitness, Cluster_Node **target_Node)

Input:    cur_Tree  (the cluster tree holding datas)

                cur_Data  (the data to be stored into the cur_Tree)

                cur_Fitnes (fitness of the cur_Data)

output: target_Node (the address of the added node)

This function will use the cur_Data to make a new node, then insert the new node into the cur_Tree and save the address of the new added node in the target_Node.


Cluster_Tree_SearchInterval_Set(Cluster_Tree *cur_Tree)

Input: cur_Tree (the cluster tree holding datas)

Output: cur_Tree(the cluster tree holding datas)

This function will restore the current interval to the whole search space (reset the interval)


Cluster_Tree_Write(Cluster_Tree *cur_Tree, char *tree_filename)

Input:    cur_Tree


This function will print out the data in the cur_Tree into a text file.


Cluster_Tree_Construction(Cluster_Tree *cur_Tree, int cur_Dimension, int interval_Size, int max_archive_size)

 Input:   Cur_Dimension (the dimension of the tree)

                Interval_size  (the interval size)

                Max_archive_size (the maximum archive size)

Output:                cur_Tree ( the output cluster tree)

This function will construct a new cluster tree by the given parameters. The new cluster tree will be stored into cur_Tree.


Cluster_Tree_Destruction(Cluster_Tree cur_Tree)

Input: cur_Tree

This function will destruct the input cur_Tree.


Cluster_Node_Path(Cluster_Node *leaf_Node, int *no_Leaf, int cur_Dimension)

Input:    leaf_Node (the address of the leaf_Node)

                Cur_Dimension (the dimension of the tree)

                no_Leaf (the number of leaf node in the current tree)

This function will update the optimal solution found in the area under the current node, and prune the tree branch when it is saturated. It will create the path with best fitness.


Cluster_Node_Insertion(Cluster_Node *leaf_Node, double **cur_Interval, double *cur_Data, double cur_Fitness, int *no_Leaf, int cur_Dimension, int *no_AxisBoundary, int **AxisBoundary_Set, int *Current_ID)

Input:    leaf_Node (the address of the leaf_Node)

                cur_Interval  (the interval set)

                cur_Data (the chromosome to be inserted to the Cluster tree)

                cur_Fitness (the fitness of the chromosome)

                no_Left (the number of node in the cluster tree)

                no_AxisBoundary (the number of AxisBoundary) *not used

                AxisBoundary _Set (the AxisBoundary set) *not used

                Current_ID (the id of the new inserted node)

This function is used to insert a new chromosome to the cluster tree. The chromosome will first be encrypted as a node and then added into the cluster tree. After insertion, the leaf_Node will be storing the address of the new added node and the leaf_Node will be storing the number of nodes in the cluster tree.

Cluster_Node_Interval(Cluster_Node *tgr_Node, Cluster_Tree *cur_Tree)

Input:    tgr_Node  (The target node)

                cur_Tree (Th cluster tree)

This function is used to find out the interval of the tgr_Node, the intervals of the tgr_Node will be copy to the cur_Interval defined in the cluster tree.


Cluster_Node_Write(Cluster_Node *cur_Node, double ***cur_Interval, int no_dimension, FILE *tree_ptr)

Input:    cur_Node            (The address of the cur_Node)

                cur_Interval       (The interval of the current node)

                no_dimension   (The number of dimension of the tree)

                tree_ptr               (The output file)

This is the kernel function of Cluster_Tree_write, after Cluster_Tree_write call this function, this function will write all the node information in the Tree recursively.

Cluster_Node_Contruction(Cluster_Tree *cur_Tree, int cur_Dimension, int interval_Size, int max_archive_size)

Input:    cur_Tree              (The cluster tree)

                cur_Dimension (the dimension of the tree)

                interval_Size      (the interval size of this new node)


This function will build a new node by the input parameters.



Cluster_Node_Destruction(Cluster_Node cur_Node)

Input:    cur_Node  (The current node)

This function is the kernel function of the cluster_Tree_Destruction, it will be called recursively to destruct the Tree.

Cluster_Node_Difference(Cluster_Node *cur_Node, double *cur_Data, int no_dimension)

Input:    cur_Node (The address of the current Node)

                cur_Data (A set of data used to compare with the current Node)

                no_dimension (The number of dimension of the tree)

This function is used to compute the absolute distance between the optimal data in the current node with the cur_Data.

Cluster_Node *Cluster_Node_Search(Cluster_Node *root_Node, double ***cur_Interval, double *cur_Data)

Input:    root_Node         (The address of the root node in the cluster tree)

                Cur_Interval       (The interval set of the cluster tree)


This function is used to find out the cluster (node) which contains the cur_Data.



Back to main page