From c0568c4373fa00e2ba2e165cfd681dd7cd61add6 Mon Sep 17 00:00:00 2001 From: Oszkar Semerath Date: Mon, 18 May 2020 21:45:19 +0200 Subject: removed every occurence of check expressions --- .../MultiplicityGoalConstraintCalculator.xtend | 15 +++++++++---- .../patterns/PConstraintTransformer.xtend | 12 +++++----- .../logic2viatra/patterns/PatternProvider.xtend | 12 +++++----- .../patterns/RelationDeclarationIndexer.xtend | 4 ++-- .../logic2viatra/patterns/UnfinishedIndexer.xtend | 12 +++++----- .../rules/GoalConstraintProvider.xtend | 26 ++++++++++++---------- .../rules/RefinementRuleProvider.xtend | 18 +++++++-------- 7 files changed, 56 insertions(+), 43 deletions(-) (limited to 'Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra') diff --git a/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra/src/hu/bme/mit/inf/dslreasoner/viatrasolver/logic2viatra/MultiplicityGoalConstraintCalculator.xtend b/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra/src/hu/bme/mit/inf/dslreasoner/viatrasolver/logic2viatra/MultiplicityGoalConstraintCalculator.xtend index 6435806d..05ce4f6e 100644 --- a/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra/src/hu/bme/mit/inf/dslreasoner/viatrasolver/logic2viatra/MultiplicityGoalConstraintCalculator.xtend +++ b/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra/src/hu/bme/mit/inf/dslreasoner/viatrasolver/logic2viatra/MultiplicityGoalConstraintCalculator.xtend @@ -10,13 +10,15 @@ class MultiplicityGoalConstraintCalculator { val String targetRelationName; val IQuerySpecification querySpecification; var ViatraQueryMatcher matcher; + val int minValue val boolean containment val int cost - public new(String targetRelationName, IQuerySpecification querySpecification, boolean containment, int cost) { + public new(String targetRelationName, IQuerySpecification querySpecification, int minValue, boolean containment, int cost) { this.targetRelationName = targetRelationName this.querySpecification = querySpecification this.matcher = null + this.minValue = minValue this.containment = containment this.cost = cost } @@ -25,6 +27,7 @@ class MultiplicityGoalConstraintCalculator { this.targetRelationName = other.targetRelationName this.querySpecification = other.querySpecification this.matcher = null + this.minValue = other.minValue this.containment = other.containment this.cost = other.cost } @@ -47,13 +50,17 @@ class MultiplicityGoalConstraintCalculator { val allMatches = this.matcher.allMatches for(match : allMatches) { - val missingMultiplicity = match.get(4) as Integer - res += missingMultiplicity + val existingMultiplicity = match.get(4) as Integer + if(existingMultiplicity < this.minValue) { + val missingMultiplicity = this.minValue-existingMultiplicity + res += missingMultiplicity + } // if(missingMultiplicity!=0) { // println(targetRelationName+ " missing multiplicity: "+missingMultiplicity) // } } - //println(targetRelationName+ " all missing multiplicities: "+res) +// if(res>0) +// println(targetRelationName+ " all missing multiplicities: "+res + "*"+cost+"="+res*cost) return res*cost } } \ No newline at end of file diff --git a/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra/src/hu/bme/mit/inf/dslreasoner/viatrasolver/logic2viatra/patterns/PConstraintTransformer.xtend b/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra/src/hu/bme/mit/inf/dslreasoner/viatrasolver/logic2viatra/patterns/PConstraintTransformer.xtend index a4dcefbf..dd5cade1 100644 --- a/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra/src/hu/bme/mit/inf/dslreasoner/viatrasolver/logic2viatra/patterns/PConstraintTransformer.xtend +++ b/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra/src/hu/bme/mit/inf/dslreasoner/viatrasolver/logic2viatra/patterns/PConstraintTransformer.xtend @@ -196,7 +196,9 @@ class PConstraintTransformer { def hasValue(PVariable v, String target, Modality m, List variableMapping) { val typeReference = variableMapping.filter[it.sourcePVariable === v].head.targetLogicVariable.range as PrimitiveTypeReference if(m.isMay) { - '''PrimitiveElement.valueSet(«v.canonizeName»,«v.valueSetted»); «hasValueExpressionByRef(typeReference,v,v.valueVariable)» check(!«v.valueSetted»||«v.valueVariable»==«target»));''' + '''PrimitiveElement.valueSet(«v.canonizeName»,«v.valueSetted»); «hasValueExpressionByRef(typeReference,v,v.valueVariable)» +««« check(!«v.valueSetted»||«v.valueVariable»==«target»)); +''' } else { // Must or current '''PrimitiveElement.valueSet(«v.canonizeName»,true);«hasValueExpressionByRef(typeReference,v,target)»''' } @@ -233,13 +235,13 @@ class PConstraintTransformer { «FOR variable: e.affectedVariables» PrimitiveElement.valueSet(«variable.canonizeName»,«variable.valueSetted»); «hasValueExpression(variableMapping,variable,variable.valueVariable)» «ENDFOR» - check( - «FOR variable: e.affectedVariables SEPARATOR " || "»!«variable.valueSetted»«ENDFOR» +««« check( +««« «FOR variable: e.affectedVariables SEPARATOR " || "»!«variable.valueSetted»«ENDFOR» ««« «IF variable2Type.values.filter(RealTypeReference).empty» ««« || ««« («expressionGenerator.translateExpression(expression,e.affectedVariables.toInvertedMap[valueVariable],variable2Type)») ««« «ENDIF» - ); +««« ); ''' } else { // Must or Current return ''' @@ -263,7 +265,7 @@ class PConstraintTransformer { «FOR variable: e.affectedVariables» PrimitiveElement.valueSet(«variable.canonizeName»,«variable.valueSetted»); «hasValueExpression(variableMapping,variable,variable.valueVariable)» «ENDFOR» - check(«FOR variable: e.affectedVariables SEPARATOR " || "»!«variable.valueSetted»«ENDFOR»); +««« check(«FOR variable: e.affectedVariables SEPARATOR " || "»!«variable.valueSetted»«ENDFOR»); ''' } diff --git a/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra/src/hu/bme/mit/inf/dslreasoner/viatrasolver/logic2viatra/patterns/PatternProvider.xtend b/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra/src/hu/bme/mit/inf/dslreasoner/viatrasolver/logic2viatra/patterns/PatternProvider.xtend index cfea499b..f3de4ccc 100644 --- a/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra/src/hu/bme/mit/inf/dslreasoner/viatrasolver/logic2viatra/patterns/PatternProvider.xtend +++ b/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra/src/hu/bme/mit/inf/dslreasoner/viatrasolver/logic2viatra/patterns/PatternProvider.xtend @@ -27,8 +27,8 @@ import java.util.HashMap @Data class GeneratedPatterns { public Map>> invalidWFQueries public Map>> unfinishedWFQueries - public Map>> unfinishedContainmentMulticiplicityQueries - public Map>> unfinishedNonContainmentMulticiplicityQueries + public Map>,Integer>> unfinishedContainmentMulticiplicityQueries + public Map>,Integer>> unfinishedNonContainmentMulticiplicityQueries public Map>> refineObjectQueries public Map>> refineTypeQueries public Map, IQuerySpecification>> refinerelationQueries @@ -93,11 +93,13 @@ class PatternProvider { val unfinishedNonContainmentMultiplicities = new HashMap for(entry : unfinishedMultiplicities.entrySet) { val relation = entry.key - val value = entry.value.lookup(queries) + val name = entry.value.key + val amount = entry.value.value + val query = name.lookup(queries) if(problem.containmentHierarchies.head.containmentRelations.contains(relation)) { - unfinishedContainmentMultiplicities.put(relation,value) + unfinishedContainmentMultiplicities.put(relation,query->amount) } else { - unfinishedNonContainmentMultiplicities.put(relation,value) + unfinishedNonContainmentMultiplicities.put(relation,query->amount) } } // val Map>> diff --git a/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra/src/hu/bme/mit/inf/dslreasoner/viatrasolver/logic2viatra/patterns/RelationDeclarationIndexer.xtend b/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra/src/hu/bme/mit/inf/dslreasoner/viatrasolver/logic2viatra/patterns/RelationDeclarationIndexer.xtend index f384cd50..cef707c5 100644 --- a/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra/src/hu/bme/mit/inf/dslreasoner/viatrasolver/logic2viatra/patterns/RelationDeclarationIndexer.xtend +++ b/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra/src/hu/bme/mit/inf/dslreasoner/viatrasolver/logic2viatra/patterns/RelationDeclarationIndexer.xtend @@ -90,13 +90,13 @@ class RelationDeclarationIndexer { // There are "numberOfExistingReferences" currently existing instances of the reference from the source, // the upper bound of the multiplicity should be considered. numberOfExistingReferences == count «referRelation(relation,"source","_",Modality.MUST)» - check(numberOfExistingReferences < «upperMultiplicities.get(relation)»); + numberOfExistingReferences != «upperMultiplicities.get(relation)»; «ENDIF» «IF inverseRelations.containsKey(relation) && upperMultiplicities.containsKey(inverseRelations.get(relation))» // There are "numberOfExistingReferences" currently existing instances of the reference to the target, // the upper bound of the opposite reference multiplicity should be considered. numberOfExistingOppositeReferences == count «base.referRelation(inverseRelations.get(relation),"target","_",Modality.MUST,fqn2PQuery)» - check(numberOfExistingOppositeReferences < «upperMultiplicities.get(inverseRelations.get(relation))»); + numberOfExistingOppositeReferences != «upperMultiplicities.get(inverseRelations.get(relation))»; «ENDIF» «IF containments.contains(relation)» // The reference is containment, then a new reference cannot be create if: diff --git a/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra/src/hu/bme/mit/inf/dslreasoner/viatrasolver/logic2viatra/patterns/UnfinishedIndexer.xtend b/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra/src/hu/bme/mit/inf/dslreasoner/viatrasolver/logic2viatra/patterns/UnfinishedIndexer.xtend index ad1c9033..1df402fa 100644 --- a/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra/src/hu/bme/mit/inf/dslreasoner/viatrasolver/logic2viatra/patterns/UnfinishedIndexer.xtend +++ b/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra/src/hu/bme/mit/inf/dslreasoner/viatrasolver/logic2viatra/patterns/UnfinishedIndexer.xtend @@ -46,14 +46,14 @@ class UnfinishedIndexer { val lowerMultiplicities = base.lowerMultiplicities(problem) return ''' «FOR lowerMultiplicity : lowerMultiplicities» - pattern «unfinishedMultiplicityName(lowerMultiplicity)»(problem:LogicProblem, interpretation:PartialInterpretation, relationIterpretation:PartialRelationInterpretation, object:DefinedElement,missingMultiplicity) { + pattern «unfinishedMultiplicityName(lowerMultiplicity)»(problem:LogicProblem, interpretation:PartialInterpretation, relationIterpretation:PartialRelationInterpretation, object:DefinedElement,numberOfExistingReferences) { find interpretation(problem,interpretation); PartialInterpretation.partialrelationinterpretation(interpretation,relationIterpretation); PartialRelationInterpretation.interpretationOf.name(relationIterpretation,"«lowerMultiplicity.relation.name»"); «base.typeIndexer.referInstanceOf(lowerMultiplicity.firstParamTypeOfRelation,Modality::MUST,"object")» numberOfExistingReferences == count «base.referRelation(lowerMultiplicity.relation,"object","_",Modality.MUST,fqn2PQuery)» - check(numberOfExistingReferences < «lowerMultiplicity.lower»); - missingMultiplicity == eval(«lowerMultiplicity.lower»-numberOfExistingReferences); +««« numberOfExistingReferences < «lowerMultiplicity.lower»; +««« missingMultiplicity == eval(«lowerMultiplicity.lower»-numberOfExistingReferences); } «ENDFOR» ''' @@ -61,8 +61,8 @@ class UnfinishedIndexer { def String unfinishedMultiplicityName(LowerMultiplicityAssertion lowerMultiplicityAssertion) '''unfinishedLowerMultiplicity_«base.canonizeName(lowerMultiplicityAssertion.relation.name)»''' - def public referUnfinishedMultiplicityQuery(LowerMultiplicityAssertion lowerMultiplicityAssertion) - '''find «unfinishedMultiplicityName(lowerMultiplicityAssertion)»(problem, interpretation ,object, missingMultiplicity);''' + //def public referUnfinishedMultiplicityQuery(LowerMultiplicityAssertion lowerMultiplicityAssertion) + // '''find «unfinishedMultiplicityName(lowerMultiplicityAssertion)»(problem, interpretation ,object, missingMultiplicity);''' def getFirstParamTypeOfRelation(LowerMultiplicityAssertion lowerMultiplicityAssertion) { val parameters = lowerMultiplicityAssertion.relation.parameters @@ -78,7 +78,7 @@ class UnfinishedIndexer { val lowerMultiplicities = base.lowerMultiplicities(problem) val map = new LinkedHashMap for(lowerMultiplicity : lowerMultiplicities) { - map.put(lowerMultiplicity.relation,unfinishedMultiplicityName(lowerMultiplicity)) + map.put(lowerMultiplicity.relation,unfinishedMultiplicityName(lowerMultiplicity)->lowerMultiplicity.lower) } return map } diff --git a/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra/src/hu/bme/mit/inf/dslreasoner/viatrasolver/logic2viatra/rules/GoalConstraintProvider.xtend b/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra/src/hu/bme/mit/inf/dslreasoner/viatrasolver/logic2viatra/rules/GoalConstraintProvider.xtend index 87f7e339..0e8d341a 100644 --- a/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra/src/hu/bme/mit/inf/dslreasoner/viatrasolver/logic2viatra/rules/GoalConstraintProvider.xtend +++ b/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra/src/hu/bme/mit/inf/dslreasoner/viatrasolver/logic2viatra/rules/GoalConstraintProvider.xtend @@ -19,38 +19,40 @@ import org.eclipse.viatra.query.runtime.api.ViatraQueryMatcher import static extension hu.bme.mit.inf.dslreasoner.util.CollectionsUtil.* class GoalConstraintProvider { - val calculateObjectCost = true + val calculateObjectCost = false def public getUnfinishedMultiplicityQueries(LogicProblem p, GeneratedPatterns patterns) { val res = new ArrayList() - res.addAll(patterns.unfinishedContainmentMulticiplicityQueries,true) + res.addAll(patterns.unfinishedNonContainmentMulticiplicityQueries,false) if(calculateObjectCost) { - val middingObjectCost = calculateMissingObjectCost(p) - res.addAll(patterns.unfinishedNonContainmentMulticiplicityQueries,false) + val missingObjectCost = calculateMissingObjectCost(p) + res.addAll(patterns.unfinishedContainmentMulticiplicityQueries,true,missingObjectCost) } else { - res.addAll(patterns.unfinishedNonContainmentMulticiplicityQueries,false) + res.addAll(patterns.unfinishedContainmentMulticiplicityQueries,true) } return res } - def addAll(ArrayList res, Map>> queries, boolean containment) { + def addAll(ArrayList res, Map>,Integer>> queries, boolean containment) { for(multiplicityQuery : queries.entrySet) { val targetRelationName = multiplicityQuery.key.name - val query = multiplicityQuery.value - res += new MultiplicityGoalConstraintCalculator(targetRelationName,query,containment,1); + val query = multiplicityQuery.value.key + val minValue = multiplicityQuery.value.value + res += new MultiplicityGoalConstraintCalculator(targetRelationName,query,minValue,containment,1); } } def addAll( ArrayList res, - Map>> queries, + Map>,Integer>> queries, boolean containment, Map cost ) { for(multiplicityQuery : queries.entrySet) { val targetRelationName = multiplicityQuery.key.name - val query = multiplicityQuery.value - res += new MultiplicityGoalConstraintCalculator(targetRelationName,query,containment,multiplicityQuery.key.lookup(cost)) + val query = multiplicityQuery.value.key + val minValue = multiplicityQuery.value.value + res += new MultiplicityGoalConstraintCalculator(targetRelationName,query,minValue,containment,multiplicityQuery.key.lookup(cost)) } } @@ -80,7 +82,7 @@ class GoalConstraintProvider { for(containment : containments) { val key = containment val value = (containment.parameters.get(1) as ComplexTypeReference).referred.count(type2NewCost) - //println('''«key.name» --> «value» new''') +// println('''«key.name» --> «value» new''') res.put(key,value) } return res diff --git a/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra/src/hu/bme/mit/inf/dslreasoner/viatrasolver/logic2viatra/rules/RefinementRuleProvider.xtend b/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra/src/hu/bme/mit/inf/dslreasoner/viatrasolver/logic2viatra/rules/RefinementRuleProvider.xtend index 16438a5a..23ea118b 100644 --- a/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra/src/hu/bme/mit/inf/dslreasoner/viatrasolver/logic2viatra/rules/RefinementRuleProvider.xtend +++ b/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra/src/hu/bme/mit/inf/dslreasoner/viatrasolver/logic2viatra/rules/RefinementRuleProvider.xtend @@ -413,9 +413,6 @@ class RefinementRuleProvider { newElement.name = '''new «interpretation.newElements.size»''' } - // Existence - interpretation.newElements+=newElement - // Types typeInterpretation.elements += newElement if(typeInterpretation instanceof PartialComplexTypeInterpretation) { @@ -431,6 +428,9 @@ class RefinementRuleProvider { // Scope propagation scopePropagator.propagateAdditionToType(typeInterpretation) + // Existence + interpretation.newElements+=newElement + // Do recursive object creation for(newConstructor : recursiceObjectCreations) { createObjectAction(nameNewElement,newConstructor,newElement,scopePropagator) @@ -454,9 +454,6 @@ class RefinementRuleProvider { newElement.name = '''new «interpretation.newElements.size»''' } - // Existence - interpretation.newElements+=newElement - // Types typeInterpretation.elements += newElement if(typeInterpretation instanceof PartialComplexTypeInterpretation) { @@ -469,6 +466,9 @@ class RefinementRuleProvider { // Scope propagation scopePropagator.propagateAdditionToType(typeInterpretation) + // Existence + interpretation.newElements+=newElement + // Do recursive object creation for(newConstructor : recursiceObjectCreations) { createObjectAction(nameNewElement,newConstructor,newElement,scopePropagator) @@ -490,9 +490,6 @@ class RefinementRuleProvider { newElement.name = '''new «interpretation.newElements.size»''' } - // Existence - interpretation.newElements+=newElement - // Types typeInterpretation.elements += newElement if(typeInterpretation instanceof PartialComplexTypeInterpretation) { @@ -502,6 +499,9 @@ class RefinementRuleProvider { // Scope propagation scopePropagator.propagateAdditionToType(typeInterpretation) + // Existence + interpretation.newElements+=newElement + // Do recursive object creation for(newConstructor : recursiceObjectCreations) { createObjectAction(nameNewElement,newConstructor,newElement,scopePropagator) -- cgit v1.2.3-70-g09d2