/* * 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 "CCommonDisjunctConceptExtractionPreProcess.h" namespace Konclude { namespace Reasoner { namespace Preprocess { CCommonDisjunctConceptExtractionPreProcess::CCommonDisjunctConceptExtractionPreProcess() { mOntology = nullptr; mLastConceptId = 0; } CCommonDisjunctConceptExtractionPreProcess::~CCommonDisjunctConceptExtractionPreProcess() { cDeleteAll(mSetContainer); } CConcreteOntology *CCommonDisjunctConceptExtractionPreProcess::preprocess(CConcreteOntology *ontology, CPreProcessContext* context) { bool skipForELOntologies = CConfigDataReader::readConfigBoolean(context->getConfiguration(),"Konclude.Calculation.Preprocessing.CommonDisjunctConceptExtraction.SkipForELFragment",true); bool nonELConstructsUsed = ontology->getDataBoxes()->getExpressionDataBoxMapping()->getBuildConstructFlags()->isNonELConstructUsed(); mOntology = nullptr; mLastConceptId = 0; if (nonELConstructsUsed || !skipForELOntologies) { mOntology = ontology; CMBox *mBox = ontology->getDataBoxes()->getMBox(); CTBox *tBox = ontology->getDataBoxes()->getTBox(); CRBox *rBox = ontology->getDataBoxes()->getRBox(); CABox *aBox = ontology->getDataBoxes()->getABox(); mConceptVector = tBox->getConceptVector(); mTopConcept = mConceptVector->getLocalData(1); mMemMan = ontology->getDataBoxes()->getBoxContext()->getMemoryAllocationManager(); mMemMan = ontology->getDataBoxes()->getBoxContext()->getMemoryAllocationManager(); mDisjunctionCommDisConHash.clear(); mStatExtractedCommDisCon = 0; mStatExtractedConceptForDisjunctionCount = 0; extractCommonDisjuncts(); LOG(INFO,"::Konclude::Reasoner::Preprocess::CommonDisjunctConceptExtractor",logTr("Extracted %1 concepts for %2 disjunctions.").arg(mStatExtractedCommDisCon).arg(mStatExtractedConceptForDisjunctionCount),this); } return ontology; } CCommonDisjunctConceptExtractionPreProcess* CCommonDisjunctConceptExtractionPreProcess::extractCommonDisjuncts() { CMBox *mBox = mOntology->getDataBoxes()->getMBox(); CImplicationReplacementVector* repVector = mBox->getImplicationReplacementVector(true); cint64 conCount = mConceptVector->getItemCount(); for (cint64 conIdx = mLastConceptId; conIdx < conCount; ++conIdx) { CConcept* concept = mConceptVector->getData(conIdx); if (concept) { cint64 conOpCode = concept->getOperatorCode(); cint64 opCount = concept->getOperandCount(); if (concept->getOperandCount() >= 1 && (conOpCode == CCAND || conOpCode == CCEQ || conOpCode == CCOR)) { bool negateConcept = conOpCode == CCAND || conOpCode == CCEQ; QSet consideredDisConConceptSet; QSet disConConceptSet; getDisjunctConcepts(concept, negateConcept, &disConConceptSet, &consideredDisConConceptSet); disConConceptSet.remove(TConNegPair(concept, negateConcept)); bool localRepData = false; CReplacementData* prevReplData = repVector->getData(conIdx, &localRepData); if (!disConConceptSet.isEmpty() || prevReplData) { CReplacementData* replData = prevReplData; if (!localRepData) { replData = CObjectAllocator::allocateAndConstruct(mMemMan); repVector->setData(conIdx, replData); replData->initReplacementData(prevReplData); } ++mStatExtractedConceptForDisjunctionCount; replData->clearCommonDisjunctConceptLinker(); for (QSet::const_iterator it = disConConceptSet.constBegin(), itEnd = disConConceptSet.constEnd(); it != itEnd; ++it) { TConNegPair conNegPair(*it); CConcept* commCon = conNegPair.first; bool commNeg = conNegPair.second; if (commCon != concept || negateConcept != commNeg) { CXNegLinker* commNegConLinker = CObjectAllocator< CXNegLinker >::allocateAndConstruct(mMemMan); commNegConLinker->initNegLinker(commCon, commNeg); replData->addCommonDisjunctConceptLinker(commNegConLinker); ++mStatExtractedCommDisCon; } } } } } } mLastConceptId = conCount; return this; } CConcreteOntology* CCommonDisjunctConceptExtractionPreProcess::continuePreprocessing() { if (mOntology) { extractCommonDisjuncts(); } return mOntology; } bool CCommonDisjunctConceptExtractionPreProcess::getDisjunctConcepts(CConcept* concept, bool negated, QSet* collectConSet, QSet* consideredConSet) { if (!consideredConSet->contains(TConNegPair(concept,negated))) { consideredConSet->insert(TConNegPair(concept,negated)); collectConSet->insert(TConNegPair(concept,negated)); cint64 opCode = concept->getOperatorCode(); if (!negated && (opCode == CCSUB || opCode == CCEQ || opCode == CCAND || (concept->getOperandCount() == 1 && opCode == CCOR)) || negated && (opCode == CCOR || (concept->getOperandCount() == 1 && (opCode == CCAND || opCode == CCEQ)))) { for (CSortedNegLinker* opLinker = concept->getOperandList(); opLinker; opLinker = opLinker->getNext()) { CConcept* opConcept = opLinker->getData(); bool opConNegation = opLinker->isNegated() ^ negated; getDisjunctConcepts(opConcept,opConNegation,collectConSet,consideredConSet); } } else if (!negated && (opCode == CCOR) || negated && (opCode == CCAND || opCode == CCEQ)) { QSet* firstDisjunctConSet = mDisjunctionCommDisConHash.value(TConNegPair(concept,negated)); if (!firstDisjunctConSet) { firstDisjunctConSet = new QSet(); QSet nextDisjunctConSet; CSortedNegLinker* opLinker = concept->getOperandList(); if (opLinker) { CConcept* firstDisjunctConcept = opLinker->getData(); bool firstDisConNegation = opLinker->isNegated() ^ negated; opLinker = opLinker->getNext(); QSet consideredConSet1(*consideredConSet); getDisjunctConcepts(firstDisjunctConcept,firstDisConNegation,firstDisjunctConSet,&consideredConSet1); while (opLinker && !firstDisjunctConSet->isEmpty()) { CConcept* nextDisjunctConcept = opLinker->getData(); bool nextDisConNegation = opLinker->isNegated() ^ negated; nextDisjunctConSet.clear(); QSet consideredConSet2(*consideredConSet); getDisjunctConcepts(nextDisjunctConcept,nextDisConNegation,&nextDisjunctConSet,&consideredConSet2); QSet::iterator it = firstDisjunctConSet->begin(); while (it != firstDisjunctConSet->end()) { TConNegPair conNegPair(*it); if (!nextDisjunctConSet.contains(conNegPair)) { it = firstDisjunctConSet->erase(it); } else { ++it; } } opLinker = opLinker->getNext(); } } mSetContainer.append(firstDisjunctConSet); mDisjunctionCommDisConHash.insert(TConNegPair(concept,negated),firstDisjunctConSet); } for (QSet::iterator it = firstDisjunctConSet->begin(); it != firstDisjunctConSet->end(); ++it) { TConNegPair conNegPair(*it); collectConSet->insert(conNegPair); } } return true; } return false; } }; // end namespace Preprocess }; // end namespace Reasoner }; // end namespace Konclude