int main()
{
TNode *root = newNode(10);
root->left = newNode(15);
root->right = newNode(20);
root->left->left = newNode(25);
root->left->left->left = newNode(30);
#ifdef SERIALIZETREE
TNode *newRoot = NULL;
FILE *fp = fopen("./serializeTree.txt","w");
if(NULL == fp)
{
printf("fopen error write mode...return");
return -1;
}
serializeTree(root, fp);
fclose(fp);
fp = fopen("./serializeTree.txt","r");
if(NULL == fp)
{
printf("fopen error read mode...return");
return -1;
}
deserializeTree(&newRoot, fp);
fclose(fp);
serializeTree(newRoot, stdout);
#endif
return 0;
}
void serializeTree(struct Node *root, FILE *fp)
{
if(!root)
{
fprintf(fp, "%d", -1);
return;
}
fprintf(fp, "%d", root->data);
serializeTree(root->l, fp);
serializeTree(root->r, fp);
}
int* serializeTree(hpdRFnode *tree, int* buffer)
{
double* temp = (double*) buffer;
*(temp++) = tree->prediction;
*(temp++) = tree->deviance;
*(temp++) = tree->complexity;
buffer = (int *) temp;
*(buffer++) = tree->treeID;
*(buffer++) = tree->split_variable;
*(buffer++) = tree->split_criteria_length;
temp = (double *)buffer;
for(int i = 0; i < tree->split_criteria_length; i++)
temp[i] = tree->split_criteria[i];
temp += tree->split_criteria_length;
buffer = (int *) temp;
*buffer = 0;
*buffer += (tree->additional_info != NULL) << 1;
*buffer += (tree->left != NULL) << 2;
*buffer += (tree->right != NULL) << 3;
buffer++;
if(tree->additional_info)
{
*(buffer++) = tree->additional_info->attempted;
*(buffer++) = tree->additional_info->completed;
*(buffer++) = tree->additional_info->leafID;
*(buffer++) = tree->additional_info->num_obs;
*(buffer++) = tree->additional_info->depth;
temp = (double *) buffer;
for(int i = 0; i < tree->additional_info->num_obs; i++)
temp[i] = tree->additional_info->weights[i];
temp += tree->additional_info->num_obs;
buffer = (int *) temp;
for(int i = 0; i < tree->additional_info->num_obs; i++)
buffer[i] = tree->additional_info->indices[i];
buffer += tree->additional_info->num_obs;
}
if(tree->left)
buffer = serializeTree(tree->left, buffer);
if(tree->right)
buffer = serializeTree(tree->right, buffer);
return buffer;
}
void Population::migrate(std::vector<std::pair<float, std::shared_ptr<Node>>> &newPop){
std::uniform_real_distribution<double> migrateDist(0, 1);
int next = (rank + 1) % processors;
int prev = (rank - 1 < 0) ? processors - 1 : rank - 1;
std::vector<std::pair<float, std::shared_ptr<Node>>> tempPop;
if(rank % 2 == 0){
for(int i = 0; i < newPop.size() / 10; ++i){
int index = migrateDist(rng) * newPop.size();
auto treeString = serializeTree(newPop[index].second);
int size = treeString.length();
MPI_Send(&size, 1, MPI_INT, next, 0, MPI_COMM_WORLD);
MPI_Send(&treeString[0], treeString.length(), MPI_CHAR, next, 0, MPI_COMM_WORLD);
}
for(int i = 0; i < newPop.size() / 10; ++i){
int size = 0;
MPI_Recv(&size, 1, MPI_INT, prev, 0, MPI_COMM_WORLD, MPI_STATUS_IGNORE);
std::string temp;
temp.resize(size);
MPI_Recv(&temp[0], size, MPI_CHAR, prev, 0, MPI_COMM_WORLD, MPI_STATUS_IGNORE);
std::stringstream stream(temp);
tempPop.push_back(std::make_pair(0.0, deserializeTree(stream)));
}
}
else{
for(int i = 0; i < newPop.size() / 10; ++i){
int size = 0;
MPI_Recv(&size, 1, MPI_INT, prev, 0, MPI_COMM_WORLD, MPI_STATUS_IGNORE);
std::string temp;
temp.resize(size);
MPI_Recv(&temp[0], size, MPI_CHAR, prev, 0, MPI_COMM_WORLD, MPI_STATUS_IGNORE);
std::stringstream stream(temp);
tempPop.push_back(std::make_pair(0.0, deserializeTree(stream)));
}
for(int i = 0; i < newPop.size() / 10; ++i){
int index = migrateDist(rng) * newPop.size();
auto treeString = serializeTree(newPop[index].second);
int size = treeString.length();
MPI_Send(&size, 1, MPI_INT, next, 0, MPI_COMM_WORLD);
MPI_Send(&treeString[0], treeString.length(), MPI_CHAR, next, 0, MPI_COMM_WORLD);
}
}
for(auto &thing : tempPop){
newPop.push_back(thing);
}
}
/*---------------------------------------------------------------------
Return a list of comma separated values containing the Huffman tree
in depth first, post order.
---------------------------------------------------------------------*/
const std::string Huffman::getSerializedTree()
{
serializeTree(root);
std::stringstream builder;
int counter = 0;
for(std::list<int>::const_iterator itr = charList.begin(); itr != charList.end(); ++itr)
builder << *itr << ",";
return builder.str();
}
/*---------------------------------------------------------------------
Store the values of the Huffman tree in depth first, post order into a
list.
---------------------------------------------------------------------*/
void Huffman::serializeTree(ByteData* node)
{
if(node->getLeftNode() != 0)
serializeTree(node->getLeftNode());
if(node->getRightNode() != 0)
serializeTree(node->getRightNode());
if(node->getValue().getData() != NIL) ++numSerialized;
charList.push_back(node->getValue().getData());
/*Clean up*/
//if(node->getParentNode() != NULL)
//{
// if(node->getParentNode()->getLeftNode() == node)
// node->getParentNode()->setLeftNode(NULL);
// else if(node->getParentNode()->getRightNode() == node)
// node->getParentNode()->setRightNode(NULL);
//}
//delete node;
//node = NULL;
}
void Population::doGeneration(std::vector<std::tuple<int, int, int>> &points){
std::vector<std::pair<float, std::shared_ptr<Node>>> newPop;
for(auto &func : population){
score(points, func);
}
std::sort(population.begin(), population.end());
if(population[0].first < best.first){
best = std::make_pair(population[0].first, serializeTree(population[0].second));
}
for(int i = 0; i < population.size() - 1; i += 2){
crossover(population[i].second, population[i + 1].second);
mutate(population[i].second);
mutate(population[i + 1].second);
newPop.push_back(std::make_pair(0.0, population[i].second));
newPop.push_back(std::make_pair(0.0, population[i + 1].second));
}
migrate(newPop);
population = newPop;
}
int main()
{
struct Node *root = newNode(1);
root->l = newNode(2);
root->r = newNode(3);
root->l->l = newNode(4);
root->l->r = newNode(5);
root->r->l= newNode(6);
root->r->r = newNode(7);
FILE *fp = fopen("tree.txt", "w");
serializeTree(root, fp);
fclose(fp);
struct Node *root1 = NULL;
FILE *fp1 = fopen("tree.txt", "r");
deserializeTree(&root1, fp1);
fclose(fp1);
inorder(root1);
}
