merge with current master, comment numerical solver related logging

author: 20001LastOrder <boqi.chen@mail.mcgill.ca> 2020-11-04 01:16:22 -0500
committer: 20001LastOrder <boqi.chen@mail.mcgill.ca> 2020-11-04 01:16:22 -0500
commit: 93243cb3faf1ccd733081fcf380559ac03c9ad35 (patch)
tree: 421f9f174eb77c387b5acaa05f01e64a62cab3a7 /Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra/src/hu/bme/mit/inf/dslreasoner/viatrasolver/logic2viatra/rules/GoalConstraintProvider.xtend
parent: add realistic solver (diff)
parent: Optimizing generator with linear objective functions (diff)
download: VIATRA-Generator-93243cb3faf1ccd733081fcf380559ac03c9ad35.tar.gz
VIATRA-Generator-93243cb3faf1ccd733081fcf380559ac03c9ad35.tar.zst
VIATRA-Generator-93243cb3faf1ccd733081fcf380559ac03c9ad35.zip
1 files changed, 47 insertions, 56 deletions
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 e03a8c35..732c135d 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
@@ -2,97 +2,88 @@ package hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra.rules
 import hu.bme.mit.inf.dslreasoner.ecore2logic.ecore2logicannotations.LowerMultiplicityAssertion
 import hu.bme.mit.inf.dslreasoner.logic.model.logiclanguage.ComplexTypeReference
-import hu.bme.mit.inf.dslreasoner.logic.model.logiclanguage.Relation
 import hu.bme.mit.inf.dslreasoner.logic.model.logiclanguage.Type
 import hu.bme.mit.inf.dslreasoner.logic.model.logicproblem.LogicProblem
-import hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra.MultiplicityGoalConstraintCalculator
+import hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra.cardinality.MultiplicityGoalConstraintCalculator
 import hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra.patterns.GeneratedPatterns
 import java.util.ArrayList
 import java.util.HashMap
 import java.util.LinkedList
 import java.util.List
 import java.util.Map
-import org.eclipse.viatra.query.runtime.api.IPatternMatch
-import org.eclipse.viatra.query.runtime.api.IQuerySpecification
-import org.eclipse.viatra.query.runtime.api.ViatraQueryMatcher
-import static extension hu.bme.mit.inf.dslreasoner.util.CollectionsUtil.*
 class GoalConstraintProvider {
-        
-        def public getUnfinishedMultiplicityQueries(LogicProblem p, GeneratedPatterns patterns, boolean calculateObjectCost) {
+        def getUnfinishedMultiplicityQueries(LogicProblem p, GeneratedPatterns patterns, boolean calculateObjectCost) {
+                val objectCosts = if (calculateObjectCost) {
+                                calculateMissingObjectCost(p)
+                        } else {
+                                emptyMap
+                        }
                val res = new ArrayList()
-                
+                for (entry : patterns.multiplicityConstraintQueries.entrySet) {
-                res.addAll(patterns.unfinishedNonContainmentMulticiplicityQueries,false)
+                        val constraint = entry.key
-                if(calculateObjectCost) {
+                        if (constraint.constrainsUnfinished) {
-                        val missingObjectCost = calculateMissingObjectCost(p)
+                                val queries = entry.value
-                        res.addAll(patterns.unfinishedContainmentMulticiplicityQueries,true,missingObjectCost)
+                                val targetRelationName = constraint.relation.name
-                } else {
+                                val query = queries.existingMultiplicityQuery
-                        res.addAll(patterns.unfinishedContainmentMulticiplicityQueries,true)
+                                val containment = constraint.containment
+                                val lowerBound = constraint.lowerBound
+                                val cost = objectCosts.getOrDefault(constraint.relation, 1)
+                                res += new MultiplicityGoalConstraintCalculator(
+                                        targetRelationName,
+                                        query,
+                                        containment,
+                                        lowerBound,
+                                        cost
+                                )
+                        }
                }
                return res
        }
-        
-        def addAll(ArrayList<MultiplicityGoalConstraintCalculator> res, Map<Relation, Pair<IQuerySpecification<? extends ViatraQueryMatcher<? extends IPatternMatch>>,Integer>> queries, boolean containment) {
+        private def calculateMissingObjectCost(LogicProblem p) {
-                for(multiplicityQuery : queries.entrySet) {
-                        val targetRelationName = multiplicityQuery.key.name
-                        val query = multiplicityQuery.value.key
-                        val minValue = multiplicityQuery.value.value
-                        res += new MultiplicityGoalConstraintCalculator(targetRelationName,query,minValue,containment,1);
-                }
-        }
-        def addAll(
-                ArrayList<MultiplicityGoalConstraintCalculator> res,
-                Map<Relation, Pair<IQuerySpecification<? extends ViatraQueryMatcher<? extends IPatternMatch>>,Integer>> queries,
-                boolean containment,
-                Map<Relation, Integer> cost
-        ) {
-                for(multiplicityQuery : queries.entrySet) {
-                        val targetRelationName = multiplicityQuery.key.name
-                        val query = multiplicityQuery.value.key
-                        val minValue = multiplicityQuery.value.value
-                        res += new MultiplicityGoalConstraintCalculator(targetRelationName,query,minValue,containment,multiplicityQuery.key.lookup(cost))
-                }
-        }
-        
-        def calculateMissingObjectCost(LogicProblem p) {
                val containments = p.containmentHierarchies.head.containmentRelations
-                val containment2Lower = containments.toInvertedMap[containment | 
+                val containment2Lower = containments.toInvertedMap [ containment |
                        val lower = p.annotations.filter(LowerMultiplicityAssertion).filter[it.relation === containment].head
-                        if(lower !== null) { lower.lower }
+                        if (lower !== null) {
-                        else { 0 }
+                                lower.lower
+                        } else {
+                                0
+                        }
                ]
                val types = p.types
-                val Map<Type,List<? extends Pair<Type,Integer>>> type2NewCost = new HashMap
+                val Map<Type, List<? extends Pair<Type, Integer>>> type2NewCost = new HashMap
-                for(type:types) {
+                for (type : types) {
                        val allSupertypes = (#[type] + type.supertypes).toSet
-                        val allOutgoingContainments = containments.filter[allSupertypes.contains((it.parameters.get(0) as ComplexTypeReference).referred)]
+                        val allOutgoingContainments = containments.filter [
+                                allSupertypes.contains((it.parameters.get(0) as ComplexTypeReference).referred)
+                        ]
                        val list = new LinkedList
-                        for(outgoingContainment : allOutgoingContainments) {
+                        for (outgoingContainment : allOutgoingContainments) {
                                val value = containment2Lower.get(outgoingContainment)
-                                if(value>0) {
+                                if (value > 0) {
-                                        list.add((outgoingContainment.parameters.get(1) as ComplexTypeReference).referred
+                                        list.add((outgoingContainment.parameters.get(1) as ComplexTypeReference).referred -> value)
-                                                        ->      value)
                                }
                        }
                        type2NewCost.put(type, list)
                }
                val res = new HashMap
-                for(containment : containments) {
+                for (containment : containments) {
                        val key = containment
                        val value = (containment.parameters.get(1) as ComplexTypeReference).referred.count(type2NewCost)
 //                      println('''«key.name» --> «value» new''')
-                        res.put(key,value)
+                        res.put(key, value)
                }
                return res
        }
-        
-        private def int count(Type t, Map<Type,List<? extends Pair<Type,Integer>>> containments) {
+        private def int count(Type t, Map<Type, List<? extends Pair<Type, Integer>>> containments) {
                val list = containments.get(t)
                var r = 1
-                for(element : list) {
+                for (element : list) {
                        r += element.value * element.key.count(containments)
                }
                return r
        }
-}
-\ No newline at end of file
+}
author	20001LastOrder <boqi.chen@mail.mcgill.ca>	2020-11-04 01:16:22 -0500
committer	20001LastOrder <boqi.chen@mail.mcgill.ca>	2020-11-04 01:16:22 -0500
commit	93243cb3faf1ccd733081fcf380559ac03c9ad35 (patch)
tree	421f9f174eb77c387b5acaa05f01e64a62cab3a7 /Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra/src/hu/bme/mit/inf/dslreasoner/viatrasolver/logic2viatra/rules/GoalConstraintProvider.xtend
parent	add realistic solver (diff)
parent	Optimizing generator with linear objective functions (diff)
download	VIATRA-Generator-93243cb3faf1ccd733081fcf380559ac03c9ad35.tar.gz VIATRA-Generator-93243cb3faf1ccd733081fcf380559ac03c9ad35.tar.zst VIATRA-Generator-93243cb3faf1ccd733081fcf380559ac03c9ad35.zip

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 e03a8c35..732c135d 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
@@ -2,97 +2,88 @@ package hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra.rules
2		2
3	import hu.bme.mit.inf.dslreasoner.ecore2logic.ecore2logicannotations.LowerMultiplicityAssertion	3	import hu.bme.mit.inf.dslreasoner.ecore2logic.ecore2logicannotations.LowerMultiplicityAssertion
4	import hu.bme.mit.inf.dslreasoner.logic.model.logiclanguage.ComplexTypeReference	4	import hu.bme.mit.inf.dslreasoner.logic.model.logiclanguage.ComplexTypeReference
5	import hu.bme.mit.inf.dslreasoner.logic.model.logiclanguage.Relation
6	import hu.bme.mit.inf.dslreasoner.logic.model.logiclanguage.Type	5	import hu.bme.mit.inf.dslreasoner.logic.model.logiclanguage.Type
7	import hu.bme.mit.inf.dslreasoner.logic.model.logicproblem.LogicProblem	6	import hu.bme.mit.inf.dslreasoner.logic.model.logicproblem.LogicProblem
8	import hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra.MultiplicityGoalConstraintCalculator	7	import hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra.cardinality.MultiplicityGoalConstraintCalculator
9	import hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra.patterns.GeneratedPatterns	8	import hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra.patterns.GeneratedPatterns
10	import java.util.ArrayList	9	import java.util.ArrayList
11	import java.util.HashMap	10	import java.util.HashMap
12	import java.util.LinkedList	11	import java.util.LinkedList
13	import java.util.List	12	import java.util.List
14	import java.util.Map	13	import java.util.Map
15	import org.eclipse.viatra.query.runtime.api.IPatternMatch
16	import org.eclipse.viatra.query.runtime.api.IQuerySpecification
17	import org.eclipse.viatra.query.runtime.api.ViatraQueryMatcher
18
19	import static extension hu.bme.mit.inf.dslreasoner.util.CollectionsUtil.*
20		14
21	class GoalConstraintProvider {	15	class GoalConstraintProvider {
22		16
23	def public getUnfinishedMultiplicityQueries(LogicProblem p, GeneratedPatterns patterns, boolean calculateObjectCost) {	17	def getUnfinishedMultiplicityQueries(LogicProblem p, GeneratedPatterns patterns, boolean calculateObjectCost) {
		18	val objectCosts = if (calculateObjectCost) {
		19	calculateMissingObjectCost(p)
		20	} else {
		21	emptyMap
		22	}
24	val res = new ArrayList()	23	val res = new ArrayList()
25		24	for (entry : patterns.multiplicityConstraintQueries.entrySet) {
26	res.addAll(patterns.unfinishedNonContainmentMulticiplicityQueries,false)	25	val constraint = entry.key
27	if(calculateObjectCost) {	26	if (constraint.constrainsUnfinished) {
28	val missingObjectCost = calculateMissingObjectCost(p)	27	val queries = entry.value
29	res.addAll(patterns.unfinishedContainmentMulticiplicityQueries,true,missingObjectCost)	28	val targetRelationName = constraint.relation.name
30	} else {	29	val query = queries.existingMultiplicityQuery
31	res.addAll(patterns.unfinishedContainmentMulticiplicityQueries,true)	30	val containment = constraint.containment
		31	val lowerBound = constraint.lowerBound
		32	val cost = objectCosts.getOrDefault(constraint.relation, 1)
		33	res += new MultiplicityGoalConstraintCalculator(
		34	targetRelationName,
		35	query,
		36	containment,
		37	lowerBound,
		38	cost
		39	)
		40	}
32	}	41	}
33	return res	42	return res
34	}	43	}
35		44
36	def addAll(ArrayList<MultiplicityGoalConstraintCalculator> res, Map<Relation, Pair<IQuerySpecification<? extends ViatraQueryMatcher<? extends IPatternMatch>>,Integer>> queries, boolean containment) {	45	private def calculateMissingObjectCost(LogicProblem p) {
37	for(multiplicityQuery : queries.entrySet) {
38	val targetRelationName = multiplicityQuery.key.name
39	val query = multiplicityQuery.value.key
40	val minValue = multiplicityQuery.value.value
41	res += new MultiplicityGoalConstraintCalculator(targetRelationName,query,minValue,containment,1);
42	}
43	}
44	def addAll(
45	ArrayList<MultiplicityGoalConstraintCalculator> res,
46	Map<Relation, Pair<IQuerySpecification<? extends ViatraQueryMatcher<? extends IPatternMatch>>,Integer>> queries,
47	boolean containment,
48	Map<Relation, Integer> cost
49	) {
50	for(multiplicityQuery : queries.entrySet) {
51	val targetRelationName = multiplicityQuery.key.name
52	val query = multiplicityQuery.value.key
53	val minValue = multiplicityQuery.value.value
54	res += new MultiplicityGoalConstraintCalculator(targetRelationName,query,minValue,containment,multiplicityQuery.key.lookup(cost))
55	}
56	}
57
58	def calculateMissingObjectCost(LogicProblem p) {
59	val containments = p.containmentHierarchies.head.containmentRelations	46	val containments = p.containmentHierarchies.head.containmentRelations
60	val containment2Lower = containments.toInvertedMap[containment \|	47	val containment2Lower = containments.toInvertedMap [ containment \|
61	val lower = p.annotations.filter(LowerMultiplicityAssertion).filter[it.relation === containment].head	48	val lower = p.annotations.filter(LowerMultiplicityAssertion).filter[it.relation === containment].head
62	if(lower !== null) { lower.lower }	49	if (lower !== null) {
63	else { 0 }	50	lower.lower
		51	} else {
		52	0
		53	}
64	]	54	]
65	val types = p.types	55	val types = p.types
66	val Map<Type,List<? extends Pair<Type,Integer>>> type2NewCost = new HashMap	56	val Map<Type, List<? extends Pair<Type, Integer>>> type2NewCost = new HashMap
67	for(type:types) {	57	for (type : types) {
68	val allSupertypes = (#[type] + type.supertypes).toSet	58	val allSupertypes = (#[type] + type.supertypes).toSet
69	val allOutgoingContainments = containments.filter[allSupertypes.contains((it.parameters.get(0) as ComplexTypeReference).referred)]	59	val allOutgoingContainments = containments.filter [
		60	allSupertypes.contains((it.parameters.get(0) as ComplexTypeReference).referred)
		61	]
70	val list = new LinkedList	62	val list = new LinkedList
71	for(outgoingContainment : allOutgoingContainments) {	63	for (outgoingContainment : allOutgoingContainments) {
72	val value = containment2Lower.get(outgoingContainment)	64	val value = containment2Lower.get(outgoingContainment)
73	if(value>0) {	65	if (value > 0) {
74	list.add((outgoingContainment.parameters.get(1) as ComplexTypeReference).referred	66	list.add((outgoingContainment.parameters.get(1) as ComplexTypeReference).referred -> value)
75	-> value)
76	}	67	}
77	}	68	}
78	type2NewCost.put(type, list)	69	type2NewCost.put(type, list)
79	}	70	}
80	val res = new HashMap	71	val res = new HashMap
81	for(containment : containments) {	72	for (containment : containments) {
82	val key = containment	73	val key = containment
83	val value = (containment.parameters.get(1) as ComplexTypeReference).referred.count(type2NewCost)	74	val value = (containment.parameters.get(1) as ComplexTypeReference).referred.count(type2NewCost)
84	// println('''«key.name» --> «value» new''')	75	// println('''«key.name» --> «value» new''')
85	res.put(key,value)	76	res.put(key, value)
86	}	77	}
87	return res	78	return res
88	}	79	}
89		80
90	private def int count(Type t, Map<Type,List<? extends Pair<Type,Integer>>> containments) {	81	private def int count(Type t, Map<Type, List<? extends Pair<Type, Integer>>> containments) {
91	val list = containments.get(t)	82	val list = containments.get(t)
92	var r = 1	83	var r = 1
93	for(element : list) {	84	for (element : list) {
94	r += element.value * element.key.count(containments)	85	r += element.value * element.key.count(containments)
95	}	86	}
96	return r	87	return r
97	}	88	}
98	} \ No newline at end of file	89	}