Debian Codegraph @

Source/Reasoner/Answerer/Composition/CAbstractVariableMappingsCompositionComputator.cpp

raw
1 /*
2 * Copyright (C) 2013-2015, 2019 by the Konclude Developer Team.
3 *
4 * This file is part of the reasoning system Konclude.
5 * For details and support, see <http://konclude.com/>.
6 *
7 * Konclude is free software: you can redistribute it and/or modify
8 * it under the terms of version 3 of the GNU Lesser General Public
9 * License (LGPLv3) as published by the Free Software Foundation.
10 *
11 * Konclude is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 * GNU (Lesser) General Public License for more details.
15 *
16 * You should have received a copy of the GNU (Lesser) General Public
17 * License along with Konclude. If not, see <http://www.gnu.org/licenses/>.
18 *
19 */
20
21 #include "CAbstractVariableMappingsCompositionComputator.h"
22
23 namespace Konclude {
24
25 namespace Reasoner {
26
27 namespace Answerer {
28
29 namespace Composition {
30
31 CAbstractVariableMappingsCompositionComputator::CAbstractVariableMappingsCompositionComputator() {
32 }
33
34 CAbstractVariableMappingsCompositionComputator* CAbstractVariableMappingsCompositionComputator::configureComputator(COptimizedComplexExpressionOntologyAnsweringItem* ontoAnsweringItem, CAbstractVariableMappingsCompositionItemRequirementProcessor* reqProcessor, CAnswererContext* answererContext) {
35 mOntoAnsweringItem = ontoAnsweringItem;
36 mReqProcessor = reqProcessor;
37
38 mConfMappingsRepeatedlyInsufficientDependencyComputationIncreasingFactor = 1.3;
39 mConfMappingsRepeatedlyInsufficientDependencyComputationIncreasingFactor = CConfigDataReader::readConfigInteger(ontoAnsweringItem->getCalculationConfiguration(), "Konclude.Answering.MappingsRepeatedlyInsufficientDependencyComputationIncreasingFactorPercent", 130) / 100.;
40
41 return this;
42 }
43
44 CAbstractVariableMappingsCompositionComputator* CAbstractVariableMappingsCompositionComputator::computeVariableMappingsComposition(COptimizedComplexVariableCompositionItem* compVarItem, COptimizedComplexBuildingVariableCompositionsItem* buildingVarItem, CAnswererContext* answererContext, bool& processing) {
45 return this;
46 }
47
48
49
50 bool CAbstractVariableMappingsCompositionComputator::processRequirements(const QList<COntologyProcessingRequirement*>& reqList, COptimizedComplexVariableCompositionItem* compVarItem, COptimizedComplexBuildingIndividualVariableCompositionsItem* buildingVarItem, CAnswererContext* answererContext) {
51 return mReqProcessor->processCompositionItemRequirements(reqList, compVarItem, buildingVarItem, answererContext);
52 }
53
54
55 bool CAbstractVariableMappingsCompositionComputator::queueVariableItemComputation(COptimizedComplexBuildingVariableCompositionsItem* buildingVarItem, COptimizedComplexVariableCompositionItem* varCompItem) {
56 if (!varCompItem->isComputationQueued()) {
57 varCompItem->setComputationQueued(true);
58 buildingVarItem->addComputeVariableMappingItem(varCompItem);
59 return true;
60 }
61 return false;
62 }
63
64 bool CAbstractVariableMappingsCompositionComputator::rescheduleVariableCompositionItemComputation(COptimizedComplexBuildingVariableCompositionsItem* buildingVarItem, COptimizedComplexVariableCompositionItem* varCompItem, COptimizedComplexVariableCompositionItem* depSchedulingCompItem, cint64 additionalRequiredMappingCount) {
65 if (!depSchedulingCompItem->isVariableMappingsComputed()) {
66 if (additionalRequiredMappingCount != -1) {
67 depSchedulingCompItem->setVariableMappingsComputationRequirement(qMax(depSchedulingCompItem->getVariableMappingsComputationRequirement(), additionalRequiredMappingCount));
68 } else {
69 depSchedulingCompItem->setVariableMappingsComputationRequirement(-1);
70 }
71 depSchedulingCompItem->addComputationUpdateItem(varCompItem);
72 varCompItem->incDependencyUpdatingCount();
73 queueVariableItemComputation(buildingVarItem, depSchedulingCompItem);
74 return true;
75 }
76 return false;
77 }
78
79
80 COptimizedComplexVariableIndividualBindings* CAbstractVariableMappingsCompositionComputator::createBindingsForVariableCompositionItems(cint64 bindingSize, COptimizedComplexVariableCompositionItem* compVarItem, COptimizedComplexBuildingVariableCompositionsItem* buildingVarItem, CMemoryAllocationManager* memMan) {
81 if (!memMan) {
82 return new COptimizedComplexVariableIndividualBindings(bindingSize);
83 } else {
84 TIndividualInstanceItemDataBinding* bindingArray = CObjectAllocator<TIndividualInstanceItemDataBinding>::allocateAndConstructArray(memMan, bindingSize);
85 COptimizedComplexVariableIndividualBindings* bindings = CObjectAllocator<COptimizedComplexVariableIndividualBindings>::allocateAndConstruct(memMan);
86 bindings->initIndividualBindings(bindingSize, bindingArray);
87 return bindings;
88 }
89 }
90
91
92
93 COptimizedComplexVariableIndividualBindingsCardinality* CAbstractVariableMappingsCompositionComputator::createBindingsCardinalitesForVariableCompositionItems(COptimizedComplexVariableCompositionItem* compVarItem, COptimizedComplexBuildingVariableCompositionsItem* buildingVarItem, CMemoryAllocationManager* memMan) {
94 if (!memMan) {
95 return new COptimizedComplexVariableIndividualBindingsCardinality();
96 } else {
97 return CObjectAllocator<COptimizedComplexVariableIndividualBindingsCardinality>::allocateAndConstruct(memMan);
98 }
99 }
100
101
102
103 COptimizedComplexVariableIndividualBindingsCardinalityLinker* CAbstractVariableMappingsCompositionComputator::createBindingsLinkerForVariableCompositionItems(COptimizedComplexVariableIndividualBindings* bindings, COptimizedComplexVariableIndividualBindingsCardinality* cardinality, COptimizedComplexVariableCompositionItem* compVarItem, COptimizedComplexBuildingVariableCompositionsItem* buildingVarItem, CMemoryAllocationManager* memMan) {
104 if (!memMan) {
105 return new COptimizedComplexVariableIndividualBindingsCardinalityLinker(bindings, cardinality);
106 } else {
107 COptimizedComplexVariableIndividualBindingsCardinalityLinker* linker = CObjectAllocator<COptimizedComplexVariableIndividualBindingsCardinalityLinker>::allocateAndConstruct(memMan);
108 linker->initBindingsCardinalityLinker(bindings, cardinality);
109 return linker;
110 }
111 }
112
113
114
115
116
117 bool CAbstractVariableMappingsCompositionComputator::finishVariableCompositionItemComputation(COptimizedComplexBuildingVariableCompositionsItem* buildingVarItem, COptimizedComplexVariableCompositionItem* varCompItem, bool allMappingsComputed) {
118 if (allMappingsComputed) {
119 varCompItem->setVariableMappingsComputed(true);
120 }
121 if (varCompItem->getVariableMapping()->getBindingCount() <= 0 && !varCompItem->hasSplitComputations() && !varCompItem->isSplitComputationMode()) {
122 buildingVarItem->setSatisfiability(false);
123 }
124 QList<COptimizedComplexVariableCompositionItemUpdateData>* updateList = varCompItem->getComputationUpdateItemList();
125 for (COptimizedComplexVariableCompositionItemUpdateData updateData : *updateList) {
126 COptimizedComplexVariableCompositionItem* updateItem = updateData.getVariableCompositionItem();
127 COptimizedComplexBuildingVariableCompositionsItem* reschedulingBuildingVarItem = updateData.getVariableBuildingItem();
128 if (!reschedulingBuildingVarItem) {
129 reschedulingBuildingVarItem = buildingVarItem;
130 }
131 updateItem->decDependencyUpdatingCount();
132 if (updateItem->getDependencyUpdatingCount() == 0) {
133 queueVariableItemComputation(reschedulingBuildingVarItem, updateItem);
134 if (updateData.getVariableBuildingItem()) {
135 reschedulingBuildingVarItem->decWaitingSubVariableBuildingItemCount();
136 if (reschedulingBuildingVarItem->getWaitingSubVariableBuildingItemCount() == 0) {
137 if (!reschedulingBuildingVarItem->isProcessingQueued()) {
138 reschedulingBuildingVarItem->setProcessingQueued(true);
139 mOntoAnsweringItem->addProcessingVariableBuildingItem(reschedulingBuildingVarItem);
140 }
141 }
142 }
143 }
144 }
145 updateList->clear();
146 return true;
147 }
148
149 void CAbstractVariableMappingsCompositionComputator::configureDependentComputationIncreaseFactor(bool dependentItemRescheduled, bool mappingProcessed, COptimizedComplexVariableCompositionItem* compVarItem) {
150 if (dependentItemRescheduled && mappingProcessed && compVarItem->requiresMoreVariableMappingsComputation() && !compVarItem->isVariableMappingsComputed()) {
151 compVarItem->increaseRepeatedRequirementInsufficientDependencyComputationIncreaseFactor(mConfMappingsRepeatedlyInsufficientDependencyComputationIncreasingFactor);
152 } else if (!compVarItem->requiresMoreVariableMappingsComputation()) {
153 compVarItem->setRepeatedRequirementInsufficientDependencyComputationIncreaseFactor(1.);
154 }
155 }
156
157
158 }; // end namespace Composition
159
160 }; // end namespace Answerer
161
162 }; // end namespace Reasoner
163
164 }; // end namespace Konclude