TreeNode* getNode(const LocationCode<maxLevels>& code) { int level = maxLevels; // FIXME: it's really important to start from root.child (as root is a header) and ALL TESTS // PASS WHEN IT'S CHANGED TO: `node = &root;` TreeNode* node = &(root.child(0, 0)); do { if (!node->hasChildren() || node == &(node->child(code))) break; node = &(node->child(code)); } while (--level); return node; }
void TreeNodeTest::test_updateChildList() { NRoot::Ptr node(new NRoot("Root")); NGeneric::Ptr node1(new NGeneric("Node1", "MyType")); NGeneric::Ptr node2(new NGeneric("Node2", "MyType")); TreeNode * treeNode; TreeNode * child; node->addNode(node1); treeNode = new TreeNode(node, nullptr, 0); QCOMPARE( treeNode->childCount(), 1); node->addNode(node2); QCOMPARE( treeNode->childCount(), 2); child = treeNode->child(1); QVERIFY( child != nullptr ); QCOMPARE( child->nodeName(), QString("Node2")); delete treeNode; }
/*---------------------------------------------------------------------*//** ルートノード取得 **//*---------------------------------------------------------------------*/ MenuTreeNode* Menu::getMenuTreeRootNode() const { TreeNode<MenuTreeNode>* tnode = _tree->getRoot(); if(tnode == 0L) { return 0L; } tnode = tnode->child(); if(tnode == 0L) { return 0L; } return tnode->object(); }
void Executer::executeFunctionCall(TreeNode* node) { // //qDebug() << "called"; if (node->parent()->token()->type() == Token::Learn) { // in case we're defining a function currentNode = node->parent(); executeCurrent = true; return; } if (returning) { // if the function is already executed and returns now returnValue = 0; returning = false; // //qDebug() << "==> functionReturned!"; return; } if (!functionTable.contains(node->token()->look())) { addError(i18n("An unknown function named '%1' was called", node->token()->look()), *node->token(), 0); return; } CalledFunction c; c.function = node; c.variableTable = new VariableTable(); functionStack.push(c); // //qDebug() << "==> functionCalled!"; TreeNode* learnNode = functionTable[node->token()->look()]; // if the parameter numbers are not equal... if (node->childCount() != learnNode->child(1)->childCount()) { addError( i18n("The function '%1' was called with %2, while it should be called with %3", node->token()->look(), i18ncp("The function '%1' was called with %2, while it should be called with %3", "1 parameter", "%1 parameters", node->childCount()), i18ncp("The function '%1' was called with %2, while it should be called with %3", "1 parameter", "%1 parameters", learnNode->child(1)->childCount()) ), *node->token(), 0); return; } for (uint i = 0; i < node->childCount(); i++) { functionStack.top().variableTable->insert(learnNode->child(1)->child(i)->token()->look(), node->child(i)->value()); // //qDebug() << "inserted variable " << learnNode->child(1)->child(i)->token()->look() << " on function stack"; } newScope = learnNode->child(2); }
int main(int argc, char* argv[]) { Timer::instance.start(); cerr << "R " << argv[0] << endl; cerr << "RAND_MAX = " << RAND_MAX << endl; cerr << "sizeof(bool) = " << sizeof(bool) << endl; cerr << "sizeof(uint) = " << sizeof(uint) << endl; cerr << "sizeof(uint64) = " << sizeof(uint64) << endl; cerr << "sizeof(uint128) = " << sizeof(uint128) << endl; cerr << "sizeof(void*) = " << sizeof(void*) << endl; cerr << "sizeof(std::size_t) = " << sizeof(std::size_t) << endl; cerr << "sizeof(Rotation) = " << sizeof(Rotation) << endl; cerr << "sizeof(SymmetryGroup) = " << sizeof(SymmetryGroup) << endl; cerr << "sizeof(BoardPoint) = " << sizeof(BoardPoint) << endl; cerr << "sizeof(Move) = " << sizeof(Move) << endl; cerr << "sizeof(BoardMask) = " << sizeof(BoardMask) << endl; cerr << "sizeof(Board) = " << sizeof(Board) << endl; cerr << "sizeof(BoardNode) = " << sizeof(BoardNode) << endl; cerr << "sizeof(BoardNode::OrientedBoardNode) = " << sizeof(BoardNode::OrientedBoardNode) << endl; cerr << "sizeof(TreeNode) = " << sizeof(TreeNode) << endl; srand(time(0)); BoardNode::initialize(); BoardMask::initialize(); assert(BoardNode::fragmentCount() == 37); cerr << "Initialized" << endl; TreeNode root; TreeNode* node = &root; //root.loadGames("games.txt"); for(uint i = 0; i < 50; ++i) { for(uint j = 0; j < 1000; ++j) node->mcts(); Move bestMove = node->bestMove(); node = node->child(bestMove); assert(node != nullptr); } cerr << "Treenodes: " << TreeNode::numNodes() << endl; BoardNode::dumpHisto(); ofstream stats("stats.csv"); BoardNode::dumpStats(stats); return 0; GameInputOutput gio; gio.run(); cerr << "Exit" << endl; Timer::instance.stop(); return 0; }
iterator insert(StoredObject&& toStore) { TreeNode* node = getNode(toStore.location); if (node->level() > 0) { // We store one element at time so there will be a moment before node overflow when its // count will be equal capacity. Then we'll relocate all its elements to the new child // nodes. At worst scenario, all elements will be relocated to the same node, so its // count() will be again equal to capacity. The loop ends when at least one element is // relocated to the another child node. while (node->count() == nodeCapacity && node->level() > 0) { typename TreeNode::iterator it; typename TreeNode::iterator itEnd = node->end(); for (it = node->begin(); it != itEnd; ++it) { node->child(it->location).insert(std::move(*it)); } node->clear(); node = &(node->child(toStore.location)); } } return iterator(node, node->insert(std::move(toStore))); }
void TreeNodeTest::test_child() { /* The tree we will work with: Root |----> Node1 | |----> Node11 | |----> Node12 | |----> Node2 | |----> Node21 | |----> Node22 | |----> Node23 | |----> Node3 */ NRoot::Ptr node(new NRoot("Root")); NGeneric::Ptr node1(new NGeneric("Node1", "MyType")); NGeneric::Ptr node11(new NGeneric("Node11", "MyType")); NGeneric::Ptr node12(new NGeneric("Node12", "MyType")); NGeneric::Ptr node2(new NGeneric("Node2", "MyType")); NGeneric::Ptr node21(new NGeneric("Node21", "MyType")); NGeneric::Ptr node22(new NGeneric("Node22", "MyType")); NGeneric::Ptr node23(new NGeneric("Node23", "MyType")); NGeneric::Ptr node3(new NGeneric("Node3", "MyType")); TreeNode * treeNode = nullptr; TreeNode * treeNode1 = nullptr; TreeNode * treeNode11 = nullptr; TreeNode * treeNode12 = nullptr; TreeNode * treeNode2 = nullptr; TreeNode * treeNode21 = nullptr; TreeNode * treeNode22 = nullptr; TreeNode * treeNode23 = nullptr; TreeNode * treeNode3 = nullptr; node->addNode(node1); node->addNode(node2); node->addNode(node3); node1->addNode(node11); node1->addNode(node12); node2->addNode(node21); node2->addNode(node22); node2->addNode(node23); treeNode = new TreeNode(node, nullptr, 0); // // 1. check the direct children // treeNode1 = treeNode->child(0); treeNode2 = treeNode->child(1); treeNode3 = treeNode->child(2); // check that pointer are not null QVERIFY( treeNode1 != (TreeNode*) nullptr ); QVERIFY( treeNode2 != (TreeNode*) nullptr ); QVERIFY( treeNode3 != (TreeNode*) nullptr ); // their parent should be the root QCOMPARE( treeNode1->parentNode(), treeNode ); QCOMPARE( treeNode2->parentNode(), treeNode ); QCOMPARE( treeNode3->parentNode(), treeNode ); // check their name QCOMPARE( treeNode1->nodeName(), QString("Node1") ); QCOMPARE( treeNode2->nodeName(), QString("Node2") ); QCOMPARE( treeNode3->nodeName(), QString("Node3") ); // // 2. children of Node1 // treeNode11 = treeNode1->child(0); treeNode12 = treeNode1->child(1); // check that pointer are not null QVERIFY( treeNode11 != (TreeNode*) nullptr ); QVERIFY( treeNode12 != (TreeNode*) nullptr ); // their parent should be the root QCOMPARE( treeNode11->parentNode(), treeNode1 ); QCOMPARE( treeNode12->parentNode(), treeNode1 ); // check their name QCOMPARE( treeNode11->nodeName(), QString("Node11") ); QCOMPARE( treeNode12->nodeName(), QString("Node12") ); // // 3. children of Node2 // treeNode21 = treeNode2->child(0); treeNode22 = treeNode2->child(1); treeNode23 = treeNode2->child(2); // check that pointer are not null QVERIFY( treeNode21 != (TreeNode*) nullptr ); QVERIFY( treeNode22 != (TreeNode*) nullptr ); QVERIFY( treeNode23 != (TreeNode*) nullptr ); // their parent should be the root QCOMPARE( treeNode21->parentNode(), treeNode2 ); QCOMPARE( treeNode22->parentNode(), treeNode2 ); QCOMPARE( treeNode23->parentNode(), treeNode2 ); // check their name QCOMPARE( treeNode21->nodeName(), QString("Node21") ); QCOMPARE( treeNode22->nodeName(), QString("Node22") ); QCOMPARE( treeNode23->nodeName(), QString("Node23") ); // // 4. no child for Node3 (should return nullptr) // QCOMPARE( treeNode3->child(0), (TreeNode*) nullptr ); delete treeNode; // deletes the children as well }
void TreeNodeTest::test_childByName() { // same tree as for test_child() NRoot::Ptr node(new NRoot("Root")); NGeneric::Ptr node1(new NGeneric("Node1", "MyType")); NGeneric::Ptr node11(new NGeneric("Node11", "MyType")); NGeneric::Ptr node12(new NGeneric("Node12", "MyType")); NGeneric::Ptr node2(new NGeneric("Node2", "MyType")); NGeneric::Ptr node21(new NGeneric("Node21", "MyType")); NGeneric::Ptr node22(new NGeneric("Node22", "MyType")); NGeneric::Ptr node23(new NGeneric("Node23", "MyType")); NGeneric::Ptr node3(new NGeneric("Node3", "MyType")); TreeNode * treeNode = nullptr; TreeNode * treeNode1 = nullptr; TreeNode * treeNode11 = nullptr; TreeNode * treeNode12 = nullptr; TreeNode * treeNode2 = nullptr; TreeNode * treeNode21 = nullptr; TreeNode * treeNode22 = nullptr; TreeNode * treeNode23 = nullptr; TreeNode * treeNode3 = nullptr; node->addNode(node1); node->addNode(node2); node->addNode(node3); node1->addNode(node11); node1->addNode(node12); node2->addNode(node21); node2->addNode(node22); node2->addNode(node23); treeNode = new TreeNode(node, nullptr, 0); treeNode1 = treeNode->child(0); treeNode11 = treeNode1->child(0); treeNode12 = treeNode1->child(1); treeNode2 = treeNode->child(1); treeNode21 = treeNode2->child(0); treeNode22 = treeNode2->child(1); treeNode23 = treeNode2->child(2); treeNode3 = treeNode->child(2); // // 1. check the direct children // treeNode1 = treeNode->childByName("Node1"); treeNode2 = treeNode->childByName("Node2"); treeNode3 = treeNode->childByName("Node3"); // check that pointer are not null QVERIFY( treeNode1 != (TreeNode*) nullptr ); QVERIFY( treeNode2 != (TreeNode*) nullptr ); QVERIFY( treeNode3 != (TreeNode*) nullptr ); // their parent should be the root QCOMPARE( treeNode1->parentNode(), treeNode ); QCOMPARE( treeNode2->parentNode(), treeNode ); QCOMPARE( treeNode3->parentNode(), treeNode ); // check their row number QCOMPARE( treeNode1->rowNumber(), 0 ); QCOMPARE( treeNode2->rowNumber(), 1 ); QCOMPARE( treeNode3->rowNumber(), 2 ); // // 2. children of Node1 // treeNode11 = treeNode1->childByName("Node11"); treeNode12 = treeNode1->childByName("Node12"); // check that pointer are not null QVERIFY( treeNode11 != (TreeNode*) nullptr ); QVERIFY( treeNode12 != (TreeNode*) nullptr ); // their parent should be the root QCOMPARE( treeNode11->parentNode(), treeNode1 ); QCOMPARE( treeNode12->parentNode(), treeNode1 ); // check their row number QCOMPARE( treeNode11->rowNumber(), 0 ); QCOMPARE( treeNode12->rowNumber(), 1 ); // // 3. wrong name // QCOMPARE ( treeNode2->childByName("Node"), (TreeNode*) nullptr ); delete treeNode; // deletes the children as well }