/*
* 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 "CDisjunctSortingPreProcess.h"
namespace Konclude {
namespace Reasoner {
namespace Preprocess {
CDisjunctSortingPreProcess::CDisjunctSortingPreProcess() {
mOnto = nullptr;
mLastConceptId = 0;
}
CDisjunctSortingPreProcess::~CDisjunctSortingPreProcess() {
}
CConcreteOntology *CDisjunctSortingPreProcess::preprocess(CConcreteOntology *ontology, CPreProcessContext* context) {
mOnto = nullptr;
mLastConceptId = 0;
bool skipForELOntologies = CConfigDataReader::readConfigBoolean(context->getConfiguration(),"Konclude.Calculation.Preprocessing.DisjunctSorting.SkipForELFragment",true);
bool nonELConstructsUsed = ontology->getDataBoxes()->getExpressionDataBoxMapping()->getBuildConstructFlags()->isNonELConstructUsed();
if (nonELConstructsUsed || !skipForELOntologies) {
mTBox = ontology->getDataBoxes()->getTBox();
mConceptVec = mTBox->getConceptVector();
mMemMan = ontology->getDataBoxes()->getBoxContext()->getMemoryAllocationManager();
mOnto = ontology;
mSortedDisjunctCount = 0;
mPotentialDisjunctionCount = 0;
sortDisjuncts();
LOG(INFO,"::Konclude::Reasoner::Preprocess::DisjunctSorting",logTr("Sorted %1 disjuncts for %2 possible disjunctions.").arg(mSortedDisjunctCount).arg(mPotentialDisjunctionCount),this);
}
return ontology;
}
CConcreteOntology* CDisjunctSortingPreProcess::continuePreprocessing() {
if (mOnto) {
sortDisjuncts();
}
return mOnto;
}
CDisjunctSortingPreProcess* CDisjunctSortingPreProcess::sortDisjuncts() {
cint64 conCount = mTBox->getConceptCount();
for (cint64 conIdx = mLastConceptId; conIdx < conCount; ++conIdx) {
CConcept* concept = mConceptVec->getLocalData(conIdx);
if (concept) {
cint64 conOpCode = concept->getOperatorCode();
cint64 opCount = concept->getOperandCount();
if (opCount > 1) {
bool sortOperands = false;
bool disjunctionNegation = false;
if (conOpCode == CCAND || conOpCode == CCEQ) {
sortOperands = true;
disjunctionNegation = true;
}
else if (conOpCode == CCOR) {
sortOperands = true;
}
if (sortOperands) {
++mPotentialDisjunctionCount;
sortDisjuncts(concept, disjunctionNegation);
}
}
}
}
mLastConceptId = conCount;
return this;
}
void CDisjunctSortingPreProcess::addDisjunctToSort(CSortedNegLinker* conLinker, bool negated) {
CConcept* concept = conLinker->getData();
bool conNegation = conLinker->isNegated() ^ negated;
cint64 conCode = concept->getOperatorCode();
CConceptOperator* conceptOperator = concept->getConceptOperator();
if (conCode == CCATOM) {
mAtomicDisjList.append(conLinker);
} else if (conNegation && conCode == CCSUB) {
mPrimNegDisjList.append(conLinker);
//} else if (!conNegation && conCode == CCSUB) {
// mPrimDisjList.append(conLinker);
} else if (!conNegation && (conCode == CCSELF || conCode == CCVALUE)) {
mSimpleExistDisjList.append(conLinker);
} else if (!conNegation && (conCode == CCSOME || conCode == CCAQSOME || conCode == CCAQCHOOCE || conCode == CCATLEAST) || conNegation && (conCode == CCALL || conCode == CCATMOST)) {
mExistDisjList.append(conLinker);
} else if (!conNegation && conCode == CCNOMINAL) {
mPosNominalDisjList.append(conLinker);
} else if (conNegation && conCode == CCNOMINAL) {
mNegNominalDisjList.append(conLinker);
} else {
if (!conNegation && conceptOperator->hasPartialOperatorCodeFlag(CConceptOperator::CCFS_ALL_AQALL_TYPE) || conNegation && conceptOperator->hasPartialOperatorCodeFlag(CConceptOperator::CCFS_SOME_TYPE)) {
mPropDisjList.append(conLinker);
} else if (!conNegation && conceptOperator->hasPartialOperatorCodeFlag(CConceptOperator::CCFS_TRIG_AND_AQAND_TYPE)) {
mTriggerDisjList.append(conLinker);
} else if (!conNegation && conceptOperator->hasPartialOperatorCodeFlag(CConceptOperator::CCFS_IMPL_TYPE)) {
mImplDisjList.append(conLinker);
} else {
mOtherDisjList.append(conLinker);
}
}
}
void CDisjunctSortingPreProcess::sortDisjuncts(CConcept* concept, bool negated) {
CSortedNegLinker* opConcepts = concept->getOperandList();
mAtomicDisjList.clear();
mExistDisjList.clear();
mNegNominalDisjList.clear();
mPosNominalDisjList.clear();
mPrimDisjList.clear();
mPrimNegDisjList.clear();
mSimpleExistDisjList.clear();
mPropDisjList.clear();
mTriggerDisjList.clear();
mImplDisjList.clear();
mOtherDisjList.clear();
for (CSortedNegLinker* opConceptIt = concept->getOperandList(); opConceptIt; opConceptIt = opConceptIt->getNext()) {
CSortedNegLinker* opConcept = opConceptIt;
addDisjunctToSort(opConcept,negated);
++mSortedDisjunctCount;
}
CSortedNegLinker* newOperandLinker = nullptr;
CSortedNegLinker* lastNewOperandLinker = nullptr;
addDisjunctFromList(mAtomicDisjList,newOperandLinker,lastNewOperandLinker);
addDisjunctFromList(mPrimNegDisjList,newOperandLinker,lastNewOperandLinker);
addDisjunctFromList(mSimpleExistDisjList,newOperandLinker,lastNewOperandLinker);
addDisjunctFromList(mNegNominalDisjList,newOperandLinker,lastNewOperandLinker);
addDisjunctFromList(mImplDisjList,newOperandLinker,lastNewOperandLinker);
addDisjunctFromList(mTriggerDisjList,newOperandLinker,lastNewOperandLinker);
addDisjunctFromList(mPropDisjList,newOperandLinker,lastNewOperandLinker);
addDisjunctFromList(mOtherDisjList,newOperandLinker,lastNewOperandLinker);
addDisjunctFromList(mExistDisjList,newOperandLinker,lastNewOperandLinker);
addDisjunctFromList(mPosNominalDisjList,newOperandLinker,lastNewOperandLinker);
addDisjunctFromList(mPrimDisjList, newOperandLinker, lastNewOperandLinker);
concept->setOperandList(newOperandLinker);
}
void CDisjunctSortingPreProcess::addDisjunctFromList(QList< CSortedNegLinker* >& disjunctList, CSortedNegLinker*& newOperandLinker, CSortedNegLinker*& lastNewOperandLinker) {
for (QList< CSortedNegLinker* >::const_iterator it = disjunctList.constBegin(), itEnd = disjunctList.constEnd(); it != itEnd; ++it) {
CSortedNegLinker* opConLinker(*it);
opConLinker->setNext(nullptr);
if (!newOperandLinker) {
newOperandLinker = opConLinker;
} else {
lastNewOperandLinker->setNext(opConLinker);
}
lastNewOperandLinker = opConLinker;
}
}
}; // end namespace Preprocess
}; // end namespace Reasoner
}; // end namespace Konclude