/* * Copyright (C) 2013-2015, 2019 by the Konclude Developer Team. * * This file is part of the reasoning system Konclude. * For details and support, see . * * Konclude is free software: you can redistribute it and/or modify * it under the terms of version 3 of the GNU Lesser General Public * License (LGPLv3) as published by the Free Software Foundation. * * Konclude is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * GNU (Lesser) General Public License for more details. * * You should have received a copy of the GNU (Lesser) General Public * License along with Konclude. If not, see . * */ #include "CPartialPruningHierarchyNode.h" namespace Konclude { namespace Reasoner { namespace Classifier { CPartialPruningHierarchyNode::CPartialPruningHierarchyNode(CConcept *representiveConcept) : CHierarchyNode(representiveConcept) { #ifdef DEBUGHIERARCHYNODECONCEPTSTRINGS generateNodeStrings(); #endif } CPartialPruningHierarchyNode::~CPartialPruningHierarchyNode() { } CHierarchyNode *CPartialPruningHierarchyNode::repairParentNodeInsertion(CHierarchyNode *replacedParentNodeCandidate, CClassifierStatistics *statistics) { // called for the subsumer node QList parentNodes(parentNodeSet.values()); for (QList::const_iterator it = parentNodes.constBegin(), itEnd = parentNodes.constEnd(); it != itEnd; ++it) { CHierarchyNode *parentNode = *it; if (parentNode != replacedParentNodeCandidate) { if (replacedParentNodeCandidate->hasPredecessorNode(parentNode)) { // the previous parent node is not longer a direct parent removeParent(parentNode); parentNode->removeChild(this); } } } #ifdef DEBUGHIERARCHYNODECONCEPTSTRINGS generateNodeStrings(); #endif return this; } CHierarchyNode *CPartialPruningHierarchyNode::repairChildsParentNodeReplacement(CHierarchyNode *replacedParentNodeCandidate, CClassifierStatistics *statistics) { // called for the subsumed node QList childNodes(childNodeSet.values()); for (QList::const_iterator it = childNodes.constBegin(), itEnd = childNodes.constEnd(); it != itEnd; ++it) { CHierarchyNode *childNode = *it; if (childNode->hasPredecessorNode(replacedParentNodeCandidate)) { removeChild(childNode); childNode->removeParent(this); } } #ifdef DEBUGHIERARCHYNODECONCEPTSTRINGS generateNodeStrings(); #endif return this; } CHierarchyNode *CPartialPruningHierarchyNode::mergeToParentNode(CHierarchyNode *mergeParentDirection, CClassifierStatistics *statistics) { QSet mergeNodesSet; QList potMergeNodesList(getParentNodeList()); while (!potMergeNodesList.isEmpty()) { CHierarchyNode* potMergeNode = potMergeNodesList.takeFirst(); if (potMergeNode->hasPredecessorNode(mergeParentDirection) || potMergeNode == mergeParentDirection) { if (!mergeNodesSet.contains(potMergeNode)) { mergeNodesSet.insert(potMergeNode); if (potMergeNode != mergeParentDirection) { potMergeNodesList.append(potMergeNode->getParentNodeList()); } } } } foreach (CHierarchyNode* mergeNode, mergeNodesSet) { foreach (CConcept* concept, *mergeNode->getEquivalentConceptList()) { addEquivalentConcept(concept); } foreach (CHierarchyNode* parentNode, *mergeNode->getParentNodeSet()) { if (!hasParentNode(parentNode) && !mergeNodesSet.contains(parentNode)) { makeParent(parentNode); } mergeNode->removeParent(parentNode); parentNode->removeChild(mergeNode); } foreach (CHierarchyNode* childNode, *mergeNode->getChildNodeSet()) { if (!hasChildNode(childNode) && !mergeNodesSet.contains(childNode) && childNode != this) { makeChild(childNode); } mergeNode->removeChild(childNode); childNode->removeParent(mergeNode); } foreach (CHierarchyNode* predNode, *mergeNode->getPredecessorNodeSet()) { if (!hasPredecessorNode(predNode) && !mergeNodesSet.contains(predNode)) { makePredecessor(predNode); } mergeNode->removePredecessor(predNode); predNode->removeSuccessor(mergeNode); } foreach (CHierarchyNode* succNode, *mergeNode->getSuccessorNodeSet()) { if (!hasSuccessorNode(succNode) && !mergeNodesSet.contains(succNode) && succNode != this) { makeSuccessor(succNode); } mergeNode->removeSuccessor(succNode); succNode->removePredecessor(mergeNode); } foreach (CHierarchyNode* incPredNode, *mergeNode->getIncompatiblePredecessorNodeSet()) { if (!hasIncompatiblePredecessorNode(incPredNode)) { makeIncompatiblePredecessor(incPredNode); } mergeNode->removeIncompatiblePredecessorNode(incPredNode); incPredNode->removeIncompatibleSuccessorNode(mergeNode); } foreach (CHierarchyNode* incSuccNode, *mergeNode->getIncompatibleSuccessorNodeSet()) { if (!hasIncompatibleSuccessorNode(incSuccNode)) { makeIncompatibleSuccessor(incSuccNode); } mergeNode->removeIncompatibleSuccessorNode(incSuccNode); incSuccNode->removeIncompatiblePredecessorNode(mergeNode); } foreach (CHierarchyNode* disjNode, *mergeNode->getDisjointNodeSet()) { if (!hasDisjointNode(disjNode)) { makeDisjoint(disjNode); } mergeNode->removeDisjointNode(disjNode); disjNode->removeDisjointNode(mergeNode); } } foreach (CHierarchyNode* parNode1, parentNodeSet) { foreach (CHierarchyNode* parNode2, parentNodeSet) { if (parNode1 != parNode2 && parNode2->hasPredecessorNode(parNode1)) { removeParent(parNode1); parNode1->removeChild(this); } } } foreach (CHierarchyNode* childNode1, childNodeSet) { foreach (CHierarchyNode* childNode2, childNodeSet) { if (childNode1 != childNode2 && childNode1->hasPredecessorNode(childNode2)) { removeChild(childNode1); childNode1->removeParent(this); } } } //QSet parentMergeNodesSet(parentNodeSet); //QList parentMergeNodesList(parentMergeNodesSet.values()); //parentMergeNodesSet.insert(this); //bool mergedIntoDirection = false; //while (!parentMergeNodesList.isEmpty()) { // CHierarchyNode *parentNode = parentMergeNodesList.takeFirst(); // if (parentNode == this) { // bool bug = true; // } // if (parentNode == mergeParentDirection || parentNode->hasPredecessorNode(mergeParentDirection)) { // // has to merge // qint64 addParentEqConCount = parentNode->getEquivalentConceptCount(); // qint64 thisPrevEqConCount = eqConCount; // foreach (CConcept *con, *parentNode->getEquivalentConceptList()) { // eqConCount++; // eqConList.append(con); // } // if (statistics && parentNode != mergeParentDirection) { // statistics->incDerivatedTestedSubsumptionCount(addParentEqConCount*thisPrevEqConCount); // } // if (statistics) { // foreach (CHierarchyNode *precNode, predNodeSet) { // if (!parentNode->hasPredecessorNode(precNode) && parentNode != mergeParentDirection) { // statistics->incDerivatedTestedSubsumptionCount(addParentEqConCount*precNode->getEquivalentConceptCount()); // } // } // foreach (CHierarchyNode *succNode, succNodeSet) { // if (!parentNode->hasSuccessorNode(succNode)) { // statistics->incDerivatedTestedSubsumptionCount(addParentEqConCount*succNode->getEquivalentConceptCount()); // } // } // foreach (CHierarchyNode *incPrecNode, incompPredNodeSet) { // if (!parentNode->hasIncompatiblePredecessorNode(incPrecNode)) { // statistics->incPrunedTestedSubsumptionCount(addParentEqConCount*incPrecNode->getEquivalentConceptCount()); // } // } // foreach (CHierarchyNode *incSuccNode, incompSuccNodeSet) { // if (!parentNode->hasIncompatibleSuccessorNode(incSuccNode)) { // statistics->incPrunedTestedSubsumptionCount(addParentEqConCount*incSuccNode->getEquivalentConceptCount()); // } // } // } // //((CPartialPruningHierarchyNode *)parentNode)->repairChildsParentNodeReplacement(this,statistics); // QList parentList(parentNode->getParentNodeList()); // foreach (CHierarchyNode *parentParentNode, parentList) { // parentParentNode->removeChild(parentNode); // parentNode->removeParent(parentParentNode); // if (parentNodeSet.isEmpty()) { // bool bug = true; // } // if (!hasPredecessorNode(parentParentNode)) { // if (statistics && parentParentNode != mergeParentDirection) { // statistics->incDerivatedTestedSubsumptionCount(thisPrevEqConCount*parentParentNode->getEquivalentConceptCount()); // } // } // bool oldParPredecessor = false; // foreach (CHierarchyNode* oldParNode, parentNodeSet) { // if (oldParNode == parentParentNode && oldParNode->hasPredecessorNode(parentParentNode)) { // oldParPredecessor = true; // } // } // if (!oldParPredecessor) { // makeParent(parentParentNode); // if (!parentMergeNodesSet.contains(parentParentNode)) { // parentMergeNodesSet.insert(parentParentNode); // parentMergeNodesList.append(parentParentNode); // } // } // } // QList childList(parentNode->getChildNodeList()); // foreach (CHierarchyNode *parentChildNode, childList) { // parentChildNode->removeParent(parentNode); // parentNode->removeChild(parentChildNode); // if (parentNodeSet.isEmpty()) { // bool bug = true; // } // if (parentChildNode != this) { // if (!hasSuccessorNode(parentChildNode)) { // if (statistics) { // statistics->incDerivatedTestedSubsumptionCount(thisPrevEqConCount*parentChildNode->getEquivalentConceptCount()); // } // makeChild(parentChildNode); // } // } // } // QList predList(parentNode->getPredecessorNodeList()); // foreach (CHierarchyNode *parentPredeccessorNode, predList) { // parentPredeccessorNode->removeSuccessor(parentNode); // parentNode->removePredecessor(parentPredeccessorNode); // if (!hasPredecessorNode(parentPredeccessorNode)) { // if (statistics && parentPredeccessorNode != mergeParentDirection) { // statistics->incDerivatedTestedSubsumptionCount(thisPrevEqConCount*parentPredeccessorNode->getEquivalentConceptCount()); // } // makePredecessor(parentPredeccessorNode); // } // } // QSet *disjointSet(parentNode->getDisjointNodeSet()); // foreach (CHierarchyNode *disjointNode, *disjointSet) { // disjointNode->removeDisjointNode(parentNode); // parentNode->removeDisjointNode(disjointNode); // if (!hasDisjointNode(disjointNode)) { // makeDisjoint(disjointNode); // if (!hasIncompatiblePredecessorNode(disjointNode)) { // if (statistics) { // statistics->incPrunedTestedSubsumptionCount(thisPrevEqConCount*disjointNode->getEquivalentConceptCount()); // } // addIncompatiblePredecessorNode(disjointNode); // disjointNode->addIncompatibleSuccessorNode(this); // } // if (!hasIncompatibleSuccessorNode(disjointNode)) { // if (statistics) { // statistics->incPrunedTestedSubsumptionCount(thisPrevEqConCount*disjointNode->getEquivalentConceptCount()); // } // addIncompatibleSuccessorNode(disjointNode); // disjointNode->addIncompatiblePredecessorNode(this); // } // } // } // QList succList(parentNode->getSuccessorNodeList()); // foreach (CHierarchyNode *parentSuccessorNode, succList) { // parentSuccessorNode->removePredecessor(parentNode); // parentNode->removeSuccessor(parentSuccessorNode); // if (parentSuccessorNode != this) { // if (!hasSuccessorNode(parentSuccessorNode)) { // if (statistics) { // statistics->incDerivatedTestedSubsumptionCount(thisPrevEqConCount*parentSuccessorNode->getEquivalentConceptCount()); // } // makeSuccessor(parentSuccessorNode); // } // } // } // QSet *incPredList(parentNode->getIncompatiblePredecessorNodeSet()); // foreach (CHierarchyNode *parentIncompatiblePredNode, *incPredList) { // parentIncompatiblePredNode->removeIncompatibleSuccessorNode(parentNode); // parentNode->removeIncompatiblePredecessorNode(parentIncompatiblePredNode); // if (!hasIncompatiblePredecessorNode(parentIncompatiblePredNode)) { // if (statistics) { // statistics->incPrunedTestedSubsumptionCount(thisPrevEqConCount*parentIncompatiblePredNode->getEquivalentConceptCount()); // } // addIncompatiblePredecessorNode(parentIncompatiblePredNode); // parentIncompatiblePredNode->addIncompatibleSuccessorNode(this); // } // } // QSet *incSuccList(parentNode->getIncompatibleSuccessorNodeSet()); // foreach (CHierarchyNode *parentIncompatibleSuccNode, *incSuccList) { // parentIncompatibleSuccNode->removeIncompatiblePredecessorNode(parentNode); // parentNode->removeIncompatibleSuccessorNode(parentIncompatibleSuccNode); // if (!hasIncompatibleSuccessorNode(parentIncompatibleSuccNode)) { // if (statistics) { // statistics->incPrunedTestedSubsumptionCount(thisPrevEqConCount*parentIncompatibleSuccNode->getEquivalentConceptCount()); // } // addIncompatibleSuccessorNode(parentIncompatibleSuccNode); // parentIncompatibleSuccNode->addIncompatiblePredecessorNode(this); // } // } // foreach (CHierarchyNode* parNode1, parentNodeSet) { // foreach (CHierarchyNode* parNode2, parentNodeSet) { // if (parNode1 != parNode2 && parNode2->hasPredecessorNode(parNode1)) { // removeParent(parNode1); // parNode1->removeChild(this); // if (parentNodeSet.isEmpty()) { // bool bug = true; // } // } // } // } // foreach (CHierarchyNode* childNode1, childNodeSet) { // foreach (CHierarchyNode* childNode2, childNodeSet) { // if (childNode1 != childNode2 && childNode1->hasPredecessorNode(childNode2)) { // removeChild(childNode1); // childNode1->removeParent(this); // if (childNode1->getParentNodeSet()->isEmpty()) { // bool bug = true; // } // } // } // } // } else { // //repairParentNodeInsertion(parentNode,statistics); // //((CPartialPruningHierarchyNode *)parentNode)->repairChildsParentNodeReplacement(this,statistics); // if (parentNodeSet.isEmpty()) { // bool bug = true; // } // } //} #ifdef DEBUGHIERARCHYNODECONCEPTSTRINGS generateNodeStrings(); #endif return this; } CHierarchyNode *CPartialPruningHierarchyNode::propagateTransitiveRelations(CClassifierStatistics *statistics) { CHierarchyNode *updateNode = this; QSet *updateChildNodeSet = getChildNodeSet(); QSet *updateParentNodeSet = getParentNodeSet(); QSet *updatePredNodeSet = getPredecessorNodeSet(); QSet *updateSuccNodeSet = getSuccessorNodeSet(); QSet *updateDisjointSet = getDisjointNodeSet(); for (QSet::const_iterator itPred = updatePredNodeSet->constBegin(), itPredEnd = updatePredNodeSet->constEnd(); itPred != itPredEnd; ++itPred) { CHierarchyNode *predNode = (*itPred); QList updateList; // add missing predecessor nodes to children updateList += getChildNodeList(); while (!updateList.isEmpty()) { CHierarchyNode *updateNode = updateList.takeFirst(); if (!updateNode->hasPredecessorNode(predNode)) { if (statistics) { statistics->incDerivatedTestedSubsumptionCount(updateNode->getEquivalentConceptCount()*predNode->getEquivalentConceptCount()); } updateNode->makePredecessor(predNode); updateList += updateNode->getChildNodeList(); } } } for (QSet::const_iterator itDisj = updateDisjointSet->constBegin(), itDisjEnd = updateDisjointSet->constEnd(); itDisj != itDisjEnd; ++itDisj) { CHierarchyNode *disjNode = (*itDisj); QList updateList; // add missing disjoint nodes to children updateList += getChildNodeList(); while (!updateList.isEmpty()) { CHierarchyNode *updateNode = updateList.takeFirst(); if (!updateNode->hasDisjointNode(disjNode)) { updateNode->makeDisjoint(disjNode); if (!updateNode->hasIncompatiblePredecessorNode(disjNode)) { if (statistics) { statistics->incPrunedTestedSubsumptionCount(updateNode->getEquivalentConceptCount()*disjNode->getEquivalentConceptCount()); } updateNode->makeIncompatiblePredecessor(disjNode); } if (!updateNode->hasIncompatibleSuccessorNode(disjNode)) { if (statistics) { statistics->incPrunedTestedSubsumptionCount(updateNode->getEquivalentConceptCount()*disjNode->getEquivalentConceptCount()); } updateNode->makeIncompatibleSuccessor(disjNode); } updateList += updateNode->getChildNodeList(); } } } for (QSet::const_iterator itSucc = updateSuccNodeSet->constBegin(), itSuccEnd = updateSuccNodeSet->constEnd(); itSucc != itSuccEnd; ++itSucc) { CHierarchyNode *succNode = (*itSucc); QList updateList; // add missing successor nodes to parents updateList += getParentNodeList(); while (!updateList.isEmpty()) { CHierarchyNode *updateNode = updateList.takeFirst(); if (!updateNode->hasSuccessorNode(succNode)) { if (statistics) { statistics->incDerivatedTestedSubsumptionCount(updateNode->getEquivalentConceptCount()*succNode->getEquivalentConceptCount()); } updateNode->makeSuccessor(succNode); updateList += updateNode->getParentNodeList(); } } } QSet *incompSuccNodeSet = getIncompatibleSuccessorNodeSet(); for (QSet::const_iterator itIncomp = incompSuccNodeSet->constBegin(), itIncompEnd = incompSuccNodeSet->constEnd(); itIncomp != itIncompEnd; ++itIncomp) { CHierarchyNode *incompNode = (*itIncomp); QList updateList; // propagate incompatible successor node relations from current node to all children updateList += getChildNodeList(); while (!updateList.isEmpty()) { CHierarchyNode *updateNode = updateList.takeFirst(); if (!updateNode->hasIncompatibleSuccessorNode(incompNode)) { if (statistics) { statistics->incPrunedTestedSubsumptionCount(updateNode->getEquivalentConceptCount()*incompNode->getEquivalentConceptCount()); } updateNode->addIncompatibleSuccessorNode(incompNode); incompNode->addIncompatiblePredecessorNode(updateNode); QSet *updateChildNodeSet = updateNode->getChildNodeSet(); for (QSet::const_iterator itUpChild = updateChildNodeSet->constBegin(), itUpChildEnd = updateChildNodeSet->constEnd(); itUpChild != itUpChildEnd; ++itUpChild) { CHierarchyNode *updateChildNode = (*itUpChild); updateList.append(updateChildNode); } } } } QSet *incompPredNodeSet = getIncompatiblePredecessorNodeSet(); for (QSet::const_iterator itIncomp = incompPredNodeSet->constBegin(), itIncompEnd = incompPredNodeSet->constEnd(); itIncomp != itIncompEnd; ++itIncomp) { CHierarchyNode *incompNode = (*itIncomp); QList updateList; // propagate incompatible predecessor node relations from current node to all parents updateList += getParentNodeList(); while (!updateList.isEmpty()) { CHierarchyNode *updateNode = updateList.takeFirst(); if (!updateNode->hasIncompatiblePredecessorNode(incompNode)) { if (statistics) { statistics->incPrunedTestedSubsumptionCount(updateNode->getEquivalentConceptCount()*incompNode->getEquivalentConceptCount()); } updateNode->addIncompatiblePredecessorNode(incompNode); incompNode->addIncompatibleSuccessorNode(updateNode); QSet *updateParentNodeSet = updateNode->getParentNodeSet(); for (QSet::const_iterator itUpParent = updateParentNodeSet->constBegin(), itUpParentEnd = updateParentNodeSet->constEnd(); itUpParent != itUpParentEnd; ++itUpParent) { CHierarchyNode *updateParentNode = (*itUpParent); updateList.append(updateParentNode); } } } } //// derivate new incompatible equivalences to parent nodes //for (QSet::const_iterator itParent = updateParentNodeSet->constBegin(), itParentEnd = updateParentNodeSet->constEnd(); itParent != itParentEnd; ++itParent) { // CHierarchyNode *parentNode = (*itParent); // if (!hasIncompatibleSuccessorNode(parentNode)) { // for (QSet::const_iterator itUpChild = parentNode->getChildNodeSet()->constBegin(), itUpChildEnd = parentNode->getChildNodeSet()->constEnd(); itUpChild != itUpChildEnd; ++itUpChild) { // CHierarchyNode *parentChildNode = (*itUpChild); // if (hasIncompatibleSuccessorNode(parentChildNode) || hasIncompatiblePredecessorNode(parentChildNode)) { // if (statistics) { // statistics->incDerivatedTestedSubsumptionCount(getEquivalentConceptCount()*parentNode->getEquivalentConceptCount()); // } // makeIncompatiblePredecessor(parentNode); // } // } // } //} #ifdef DEBUGHIERARCHYNODECONCEPTSTRINGS generateNodeStrings(); #endif return this; } CHierarchyNode *CPartialPruningHierarchyNode::repairChildNodes(CClassifierStatistics *statistics) { foreach (CHierarchyNode* childNode1, childNodeSet) { foreach (CHierarchyNode* childNode2, childNodeSet) { if (childNode1 != childNode2 && childNode1->hasPredecessorNode(childNode2)) { removeChild(childNode1); childNode1->removeParent(this); } } } return this; } CHierarchyNode *CPartialPruningHierarchyNode::repairParentNodes(CClassifierStatistics *statistics) { foreach (CHierarchyNode* parNode1, parentNodeSet) { foreach (CHierarchyNode* parNode2, parentNodeSet) { if (parNode1 != parNode2 && parNode2->hasPredecessorNode(parNode1)) { removeParent(parNode1); parNode1->removeChild(this); } } } return this; } CHierarchyNode *CPartialPruningHierarchyNode::propagateTransitivePredecessorRelation(CHierarchyNode *transAddPredNode, CClassifierStatistics *statistics) { QList updateList; updateList.append(this); while (!updateList.isEmpty()) { CHierarchyNode *updateNode = updateList.takeFirst(); QSet *updateChildNodeSet = updateNode->getChildNodeSet(); QSet *updatePredNodeSet = updateNode->getPredecessorNodeSet(); for (QSet::const_iterator itChild = updateChildNodeSet->constBegin(), itChildEnd = updateChildNodeSet->constEnd(); itChild != itChildEnd; ++itChild) { CHierarchyNode *childNode = (*itChild); if (!childNode->hasPredecessorNode(transAddPredNode)) { if (statistics) { statistics->incDerivatedTestedSubsumptionCount(childNode->getEquivalentConceptCount()*transAddPredNode->getEquivalentConceptCount()); } childNode->makePredecessor(transAddPredNode); updateList.append(childNode); } } } #ifdef DEBUGHIERARCHYNODECONCEPTSTRINGS generateNodeStrings(); #endif return this; } CHierarchyNode *CPartialPruningHierarchyNode::pruneTransitiveRelations(CHierarchyNode *initIncompNode, CClassifierStatistics *statistics) { for (QSet::const_iterator parentIt = initIncompNode->getParentNodeSet()->constBegin(), parentItEnd = initIncompNode->getParentNodeSet()->constEnd(); parentIt != parentItEnd; ++parentIt) { CHierarchyNode *incompNodeParent = (*parentIt); if (!incompNodeParent->hasIncompatiblePredecessorNode(initIncompNode)) { if (hasPredecessorNode(incompNodeParent)) { if (statistics) { statistics->incPrunedTestedSubsumptionCount(incompNodeParent->getEquivalentConceptCount()*initIncompNode->getEquivalentConceptCount()); } incompNodeParent->makeIncompatiblePredecessor(initIncompNode); } } } QList incompChildNodeList; QSet incompNodeSet; incompChildNodeList.append(initIncompNode); incompNodeSet.insert(initIncompNode); while (!incompChildNodeList.isEmpty()) { CHierarchyNode *nextIncompNode = incompChildNodeList.takeFirst(); QSet *incNodeSet = nextIncompNode->getChildNodeSet(); for (QSet::const_iterator childIt = incNodeSet->constBegin(), childItEnd = incNodeSet->constEnd(); childIt != childItEnd; ++childIt) { CHierarchyNode *childIncompNode = (*childIt); if (!hasIncompatiblePredecessorNode(childIncompNode)) { if (!incompNodeSet.contains(childIncompNode)) { incompNodeSet.insert(childIncompNode); incompChildNodeList.append(childIncompNode); } } } } QList predList; for (QSet::const_iterator incompIt = incompNodeSet.constBegin(), incompItEnd = incompNodeSet.constEnd(); incompIt != incompItEnd; ++incompIt) { CHierarchyNode *incompNode = (*incompIt); // set incompatible to all predecessors predList.append(this); while (!predList.isEmpty()) { CHierarchyNode *predNode = predList.takeFirst(); if (!predNode->hasIncompatiblePredecessorNode(incompNode)) { if (statistics) { statistics->incPrunedTestedSubsumptionCount(predNode->getEquivalentConceptCount()*incompNode->getEquivalentConceptCount()); } predNode->addIncompatiblePredecessorNode(incompNode); incompNode->addIncompatibleSuccessorNode(predNode); QSet *parentNodeSet = predNode->getParentNodeSet(); for (QSet::const_iterator parentIt = parentNodeSet->constBegin(), parentItEnd = parentNodeSet->constEnd(); parentIt != parentItEnd; ++parentIt) { CHierarchyNode *parentNode = (*parentIt); predList.append(parentNode); } } } } #ifdef DEBUGHIERARCHYNODECONCEPTSTRINGS generateNodeStrings(); #endif return this; } }; // end namespace Classifier }; // end namespace Reasoner }; // end namespace Konclude