void makeRandomTree (treegen_t* tg, edgefn ef)
{
    resetStack(tg->sp);
    resetTree(tg->tp);
    genTree (tg->N, tg->T, tg->sp, tg->tp);
    writeTree (tg->tp, ef);
}
Exemple #2
0
int main(int argc, char** argv){
    if(validInput(argc, argv) != 1){
		return 0;
	}
	char* tree= genTree(atoi(argv[1]), argv[2][0], argv[3][0]);
	printf("%s", tree);
}
ObjectNode* genForest(int numTrees, float minR, float maxR, const mat4& initTrans, const mat4& initSkew) {
	ObjectNode* forest = new ObjectNode(nullptr, initTrans, initSkew);

	mat4 rotMat = rY(0.3 * numTrees + 2.0 * M_PI / numTrees);
	mat4 tempPosit = MatMath::ID;
	for (int i = 0; i < numTrees; ++i, rotMat *= rotMat) {
		tempPosit = rotMat * translate(0.0, 0.0, -randNum(minR, maxR));
		forest->addChild( *genTree( 3, 2, 150, 0.5, 0.5, 1.6, tempPosit, tempPosit ) );
	}

	return forest;
}
Exemple #4
0
binTree_t* genTree(uint32_t* pArray, uint32_t len)
{
    binTree_t* pRoot;
    binTree_t* pLeft;
    binTree_t* pRight;
    uint32_t pRootIndex;

    if (len == 0) {
        return NULL;
    }

    srand(time(0));
    pRootIndex = rand() % len;
//    printf("random = %d\n", pRootIndex);
    pRoot = (binTree_t*)malloc(sizeof(binTree_t));
    pRoot->value = pArray[pRootIndex];
    pRoot->left = genTree(pArray, pRootIndex);
    pRoot->right = genTree(pArray + pRootIndex + 1, len - pRootIndex - 1);

    return pRoot;
}
Exemple #5
0
int main2()
{
    printf("\n\nSize of node is %zd bytes\n\n", sizeof(Node));
    int randSeed = time(NULL);
    printf("Random Seed: %d\n", randSeed);
    srand(randSeed);
    // 3, and 4 are good. 6,7,8 are very good
    // 10 is excellent
    srand(10);
    // generate a random tree
    printf ("generating random tree of depth %d\n", g_depth);
    Node root = {0};
    START_TIMER
    genTree(&root, g_depth);
    STOP_TIMER
    printf("random tree generated, total nodes: %d, leaf nodes: %d, time: %g ms\n", gTotalNodes, gLeafNodes, gTime);



    float bestVal = 0;
    // search the best move using min-max search
    printf("searching the tree using min-max\n");
    START_TIMER
    bestVal = negaMax(&root, g_depth, g_depth);
    STOP_TIMER
    printf ("best move %d, score: %f, time: %g\n", root.bestChild, root.nodeVal, gTime);

    // search the best move using alpha-beta search
    printf("searching the tree using alpha-beta\n");
    START_TIMER
    bestVal = alphabeta(&root, g_depth, g_depth, -INF, INF);
    STOP_TIMER
    printf ("best move %d, score: %f\nnodes visited (leaves/interior/total): %d/%d/%d\n", 
            root.bestChild, root.nodeVal, gLeafNodesVisited, gInteriorNodesVisited, gLeafNodesVisited + gInteriorNodesVisited);
    printf("time taken: %g\n", gTime);

    START_TIMER
    exploreTree(&root, g_depth);
    STOP_TIMER
    printf("time taken: %g\n", gTime);    
    

    float val;
    START_TIMER
    val = SSS_star(&root, g_depth);
    STOP_TIMER
    printf("SSS* best node: %d, score: %f, nodes explored: %d, time taken: %g\n", root.bestChild, val, g_sssNodes, gTime);

    freeTree(&root);
    getchar();

    return 0;
}
Exemple #6
0
int main()
{
    for (int i = 0; i < 1000; i++)
    {
        int randSeed = i + time(NULL);

        gTotalNodes = 0;
        gLeafNodes = 0;
        gLeafNodesVisited = 0;
        gInteriorNodesVisited = 0;


        printf("Random Seed: %d\n", randSeed);
        srand(randSeed);

        printf("generating random tree of depth %d\n", g_depth);
        Node root = { 0 };
        START_TIMER
            genTree(&root, g_depth);
        STOP_TIMER
        printf("random tree generated, total nodes: %d, leaf nodes: %d, time: %g ms\n", gTotalNodes, gLeafNodes, gTime);

        float bestValAB = 0;
        float bestValET = 0;
        // search the best move using alpha-beta search
        printf("searching the tree using alpha-beta\n");
        START_TIMER
            bestValAB = alphabeta(&root, g_depth, g_depth, -INF, INF);
        STOP_TIMER
        printf("best move %d, score: %f\nnodes visited (leaves/interior/total): %d/%d/%d\n",
               root.bestChild, root.nodeVal, gLeafNodesVisited, gInteriorNodesVisited, gLeafNodesVisited + gInteriorNodesVisited);
        printf("time taken: %g\n", gTime);


        START_TIMER
            bestValET = exploreTree(&root, g_depth);
        STOP_TIMER
        printf("time taken: %g\n\n\n\n", gTime);

        if (bestValET != bestValAB)
        {
            printf("\n*Mismatch found!*\n");
            getchar();
        }

        freeTree(&root);
        //getchar();
    }
    getchar();

    return 0;
}
Exemple #7
0
int main(int argc, char *argv[])
{
	clrscr();
	showCredits();
	checkUsages(argc);
	readFromFile(argv[1]);
	genTree();
	openFile2Write(argv[1]);
	genCode();
	closeFile2Write();
	printProc("Closing destination file... ");
	printStatus("DONE",1);
	printf("\n");
	return 0;
}
Exemple #8
0
void genTree(Node *root, int depth)
{
    gTotalNodes++;

    root->frontierOffset = -1;
    root->numChildrenAtFrontier = 0;


    if (g_depth % 2 == 0)
    {
        // even depths are maximizing nodes
        root->isMaxNode = !(depth % 2);
    }
    else
    {
        root->isMaxNode = !!(depth % 2);
    }

    if (depth == 0)
    {
        gLeafNodes++;
        // generate random node val (between 0 and 100) and return
        root->nodeVal = (rand() % 10000) / 100.0f;
        return;
    }

    // allocate memory for random number of children (have at least one children for now - to be changed later!)
    int nChildren = rand() % MAX_CHILDREN + 1;

    Node *children = (Node *) malloc (nChildren * sizeof(Node));

    for (int i=0; i<nChildren; i++)
    {
        children[i].nChildsExplored = 0;
        children[i].nChildren = 0;
        children[i].children = NULL;
        children[i].nodeVal = 0.0f;
        children[i].parent = root;

        genTree (&children[i], depth - 1);
    }

    root->nChildren = nChildren;
    root->children = children;
    root->nChildsExplored = 0;
}