aboutsummaryrefslogtreecommitdiffstats
path: root/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage/src/hu/bme/mit/inf/dslreasoner/viatrasolver/partialinterpretationlanguage/neighbourhood
diff options
context:
space:
mode:
Diffstat (limited to 'Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage/src/hu/bme/mit/inf/dslreasoner/viatrasolver/partialinterpretationlanguage/neighbourhood')
-rw-r--r--Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage/src/hu/bme/mit/inf/dslreasoner/viatrasolver/partialinterpretationlanguage/neighbourhood/Descriptor.xtend242
-rw-r--r--Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage/src/hu/bme/mit/inf/dslreasoner/viatrasolver/partialinterpretationlanguage/neighbourhood/NeighbourhoodOptions.xtend22
-rw-r--r--Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage/src/hu/bme/mit/inf/dslreasoner/viatrasolver/partialinterpretationlanguage/neighbourhood/PartialInterpretation2Hash.xtend16
-rw-r--r--Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage/src/hu/bme/mit/inf/dslreasoner/viatrasolver/partialinterpretationlanguage/neighbourhood/PartialInterpretation2NeighbourhoodRepresentation.xtend491
-rw-r--r--Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage/src/hu/bme/mit/inf/dslreasoner/viatrasolver/partialinterpretationlanguage/neighbourhood/PartialInterpretation2PairwiseNeighbourhoodRepresentation.xtend68
5 files changed, 481 insertions, 358 deletions
diff --git a/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage/src/hu/bme/mit/inf/dslreasoner/viatrasolver/partialinterpretationlanguage/neighbourhood/Descriptor.xtend b/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage/src/hu/bme/mit/inf/dslreasoner/viatrasolver/partialinterpretationlanguage/neighbourhood/Descriptor.xtend
index 41482b28..685a1f5a 100644
--- a/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage/src/hu/bme/mit/inf/dslreasoner/viatrasolver/partialinterpretationlanguage/neighbourhood/Descriptor.xtend
+++ b/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage/src/hu/bme/mit/inf/dslreasoner/viatrasolver/partialinterpretationlanguage/neighbourhood/Descriptor.xtend
@@ -4,10 +4,21 @@ import java.util.HashMap
4import java.util.Map 4import java.util.Map
5import java.util.Set 5import java.util.Set
6import org.eclipse.xtend.lib.annotations.Data 6import org.eclipse.xtend.lib.annotations.Data
7import org.eclipse.xtend2.lib.StringConcatenationClient
7 8
8@Data abstract class AbstractNodeDescriptor { 9@Data abstract class AbstractNodeDescriptor {
9 long dataHash 10 int dataHash
10 11
12 protected def StringConcatenationClient prettyPrint() {
13 '''(«dataHash»)[«class.simpleName»]'''
14 }
15
16 override toString() {
17 '''
18 «prettyPrint»
19 '''
20 }
21
11// @Pure 22// @Pure
12// @Override 23// @Override
13// override public boolean equals(Object obj) { 24// override public boolean equals(Object obj) {
@@ -24,34 +35,45 @@ import org.eclipse.xtend.lib.annotations.Data
24// } 35// }
25} 36}
26 37
27@Data class LocalNodeDescriptor extends AbstractNodeDescriptor{ 38@Data class LocalNodeDescriptor extends AbstractNodeDescriptor {
28 Set<String> types 39 Set<String> types
29 String id; 40 String id;
41
30 new(String id, Set<String> types) { 42 new(String id, Set<String> types) {
31 super(calcualteDataHash(id,types)) 43 super(calcualteDataHash(id, types))
32 this.types = types 44 this.types = types
33 this.id = id 45 this.id = id
34 } 46 }
35 47
36 def private static calcualteDataHash(String id, Set<String> types) { 48 def private static calcualteDataHash(String id, Set<String> types) {
37 val int prime = 31; 49 val int prime = 31;
38 var result = 0 50 var result = 0
39 if(id !== null) 51 if (id !== null)
40 result = id.hashCode(); 52 result = id.hashCode();
41 if(types !== null) { 53 if (types !== null) {
42 result = prime * result + types.hashCode 54 result = prime * result + types.hashCode
43 } 55 }
44 return result 56 return result
45 } 57 }
46 58
47 override hashCode() { 59 override hashCode() {
48 return this.dataHash.hashCode 60 return this.dataHash
49 } 61 }
50 62
63 override equals(Object other) {
64 other.class == LocalNodeDescriptor && (other as AbstractNodeDescriptor).hashCode == hashCode
65 }
66
67 override protected prettyPrint() {
68 '''(«dataHash»)[«IF id !== null»id = "«id»"«IF types === null || !types.empty», «ENDIF»«ENDIF»«IF types === null»TYPES = null«ELSE»«FOR type : types SEPARATOR ", "»«type»«ENDFOR»«ENDIF»]'''
69 }
70
51 override toString() { 71 override toString() {
52 return class.name + this.dataHash 72 '''
73 «prettyPrint»
74 '''
53 } 75 }
54 76
55// @Pure 77// @Pure
56// @Override 78// @Override
57// override public boolean equals(Object obj) { 79// override public boolean equals(Object obj) {
@@ -66,7 +88,6 @@ import org.eclipse.xtend.lib.annotations.Data
66// return false; 88// return false;
67// return true; 89// return true;
68// } 90// }
69
70// @Pure 91// @Pure
71// override public boolean equals(Object obj) { 92// override public boolean equals(Object obj) {
72// if (this === obj) 93// if (this === obj)
@@ -97,118 +118,91 @@ import org.eclipse.xtend.lib.annotations.Data
97 String type 118 String type
98} 119}
99 120
100@Data class FurtherNodeDescriptor<NodeRep> extends AbstractNodeDescriptor{ 121@Data class FurtherNodeDescriptor<NodeRep> extends AbstractNodeDescriptor {
101 122 NodeRep previousRepresentation
102 NodeRep previousRepresentation 123 Map<IncomingRelation<NodeRep>, Integer> incomingEdges
103 Map<IncomingRelation<NodeRep>,Integer> incomingEdges 124 Map<OutgoingRelation<NodeRep>, Integer> outgoingEdges
104 Map<OutgoingRelation<NodeRep>,Integer> outgoingEdges 125
105 126 new(NodeRep previousRepresentation, Map<IncomingRelation<NodeRep>, Integer> incomingEdges,
106 new( 127 Map<OutgoingRelation<NodeRep>, Integer> outgoingEdges) {
107 NodeRep previousRepresentation, 128 super(calculateDataHash(previousRepresentation, incomingEdges, outgoingEdges))
108 Map<IncomingRelation<NodeRep>,Integer> incomingEdges, 129 this.previousRepresentation = previousRepresentation
109 Map<OutgoingRelation<NodeRep>,Integer> outgoingEdges) 130 this.incomingEdges = incomingEdges
110 { 131 this.outgoingEdges = outgoingEdges
111 super(calculateDataHash(previousRepresentation,incomingEdges,outgoingEdges))
112 this.previousRepresentation = previousRepresentation
113 this.incomingEdges = new HashMap(incomingEdges)
114 this.outgoingEdges = new HashMap(outgoingEdges)
115 }
116
117 static def private <NodeRep> int calculateDataHash(
118 NodeRep previousRepresentation,
119 Map<IncomingRelation<NodeRep>,Integer> incomingEdges,
120 Map<OutgoingRelation<NodeRep>,Integer> outgoingEdges)
121 {
122 val int prime = 31;
123 var int result = previousRepresentation.hashCode;
124 if(incomingEdges !== null)
125 result = prime * result + incomingEdges.hashCode();
126 if(outgoingEdges !== null)
127 result = prime * result + outgoingEdges.hashCode();
128 return result;
129 }
130
131 override hashCode() {
132 return this.dataHash.hashCode
133 } 132 }
134 133
135 override toString() { 134 static def private <NodeRep> int calculateDataHash(NodeRep previousRepresentation,
136 return class.name + dataHash 135 Map<IncomingRelation<NodeRep>, Integer> incomingEdges, Map<OutgoingRelation<NodeRep>, Integer> outgoingEdges) {
137// return '''[«previousRepresentation»,(«FOR 136 val int prime = 31;
138// in: incomingEdges.entrySet»(«in.key.type.name»=«in.key.from»,«in.value»)«ENDFOR»),(«FOR 137 var int result = previousRepresentation.hashCode;
139// out: outgoingEdges.entrySet»(«out.key.type.name»=«out.key.to»,«out.value»)«ENDFOR»),«FOR 138 if (incomingEdges !== null)
140// att: attributeValues»(«att.type.name»=«att.value»)«ENDFOR»]''' 139 result = prime * result + hashIncomingNeighborhood(incomingEdges)
140 if (outgoingEdges !== null)
141 result = prime * result + hashOutgoingNeighborhood(outgoingEdges)
142 return result;
141 } 143 }
142
143// @Pure
144// @Override
145// override public boolean equals(Object obj) {
146// if (this === obj)
147// return true;
148// if (obj === null)
149// return false;
150// if (getClass() != obj.getClass())
151// return false;
152// val AbstractNodeDescriptor other = obj as AbstractNodeDescriptor;
153// if (other.dataHash != this.dataHash)
154// return false;
155// return true;
156// }
157
158// @Pure
159// override public boolean equals(Object obj) {
160// if (this === obj)
161// return true;
162// if (obj === null)
163// return false;
164// if (getClass() != obj.getClass())
165// return false;
166// if (!super.equals(obj))
167// return false;
168// val FurtherNodeDescriptor<?> other = obj as FurtherNodeDescriptor<?>;
169// if (this.previousRepresentation === null) {
170// if (other.previousRepresentation != null)
171// return false;
172//
173// }
174//// } else if (!this.previousRepresentation.equals(other.previousRepresentation))
175//// return false;
176// if (this.incomingEdges === null) {
177// if (other.incomingEdges != null)
178// return false;
179// } else if (!this.incomingEdges.equals(other.incomingEdges))
180// return false;
181// if (this.outgoingEdges === null) {
182// if (other.outgoingEdges != null)
183// return false;
184// } else if (!this.outgoingEdges.equals(other.outgoingEdges))
185// return false;
186// if (this.attributeValues === null) {
187// if (other.attributeValues != null)
188// return false;
189// } else if (!this.attributeValues.equals(other.attributeValues))
190// return false;
191// return true;
192// }
193}
194 144
195/* 145 override hashCode() {
196@Data 146 return this.dataHash
197class ModelDescriptor { 147 }
198 int dataHash 148
199 int unknownElements 149 override equals(Object other) {
200 Map<? extends AbstractNodeDescriptor,Integer> knownElements 150 other.class == FurtherNodeDescriptor && (other as AbstractNodeDescriptor).hashCode == hashCode
151 }
152
153 override prettyPrint() {
154 '''
155 («dataHash»)[
156 PREV = «previousRepresentation?.prettyPrint»
157 «IF incomingEdges === null»
158 IN null
159 «ELSE»
160 «FOR edge : incomingEdges.entrySet»
161 IN «edge.value» «edge.key.type» = «edge.key.from.prettyPrint»
162 «ENDFOR»
163 «ENDIF»
164 «IF outgoingEdges === null»
165 OUT null
166 «ELSE»
167 «FOR edge : outgoingEdges.entrySet»
168 OUT «edge.value» «edge.key.type» = «edge.key.to.prettyPrint»
169 «ENDFOR»
170 «ENDIF»
171 ]'''
172 }
173
174 private def StringConcatenationClient prettyPrint(NodeRep rep) {
175 if (rep instanceof AbstractNodeDescriptor) {
176 rep.prettyPrint
177 } else {
178 '''«rep»'''
179 }
180 }
201 181
202 public new(Map<? extends AbstractNodeDescriptor,Integer> knownElements, int unknownElements) { 182 private static def <NodeRep> hashIncomingNeighborhood(Map<IncomingRelation<NodeRep>, Integer> neighborhood) {
203 this.dataHash = calculateDataHash(knownElements,unknownElements) 183 val int prime = 31
204 this.unknownElements = unknownElements 184 var int hash = 0
205 this.knownElements = knownElements 185 for (entry : neighborhood.entrySet) {
186 val relation = entry.key
187 hash += (prime * relation.from.hashCode + relation.type.hashCode).bitwiseXor(entry.value.hashCode)
188 }
189 hash
206 } 190 }
207 191
208 def private static calculateDataHash(Map<? extends AbstractNodeDescriptor,Integer> knownElements, int unknownElements) 192 private static def <NodeRep> hashOutgoingNeighborhood(Map<OutgoingRelation<NodeRep>, Integer> neighborhood) {
209 { 193 val int prime = 31
210 val int prime = 31; 194 var int hash = 0
211 return knownElements.hashCode * prime + unknownElements.hashCode 195 for (entry : neighborhood.entrySet) {
196 val relation = entry.key
197 hash += (prime * relation.to.hashCode + relation.type.hashCode).bitwiseXor(entry.value.hashCode)
198 }
199 hash
200 }
201
202 override toString() {
203 '''
204 «prettyPrint»
205 '''
212 } 206 }
213} 207}
214*/ \ No newline at end of file 208
diff --git a/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage/src/hu/bme/mit/inf/dslreasoner/viatrasolver/partialinterpretationlanguage/neighbourhood/NeighbourhoodOptions.xtend b/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage/src/hu/bme/mit/inf/dslreasoner/viatrasolver/partialinterpretationlanguage/neighbourhood/NeighbourhoodOptions.xtend
new file mode 100644
index 00000000..c6e03f75
--- /dev/null
+++ b/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage/src/hu/bme/mit/inf/dslreasoner/viatrasolver/partialinterpretationlanguage/neighbourhood/NeighbourhoodOptions.xtend
@@ -0,0 +1,22 @@
1package hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage.neighbourhood
2
3import hu.bme.mit.inf.dslreasoner.logic.model.logiclanguage.RelationDeclaration
4import hu.bme.mit.inf.dslreasoner.logic.model.logiclanguage.TypeDeclaration
5import java.util.Set
6import org.eclipse.xtend.lib.annotations.Data
7
8@Data
9class NeighbourhoodOptions {
10 public static val FixPointRange = -1
11 public static val GraphWidthRange = -2
12 public static val FullParallels = Integer.MAX_VALUE
13 public static val MaxNumbers = Integer.MAX_VALUE
14
15 public static val DEFAULT = new NeighbourhoodOptions(FixPointRange, FullParallels, MaxNumbers, null, null)
16
17 val int range
18 val int parallels
19 val int maxNumber
20 val Set<TypeDeclaration> relevantTypes
21 val Set<RelationDeclaration> relevantRelations
22}
diff --git a/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage/src/hu/bme/mit/inf/dslreasoner/viatrasolver/partialinterpretationlanguage/neighbourhood/PartialInterpretation2Hash.xtend b/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage/src/hu/bme/mit/inf/dslreasoner/viatrasolver/partialinterpretationlanguage/neighbourhood/PartialInterpretation2Hash.xtend
index d474877d..5da202eb 100644
--- a/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage/src/hu/bme/mit/inf/dslreasoner/viatrasolver/partialinterpretationlanguage/neighbourhood/PartialInterpretation2Hash.xtend
+++ b/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage/src/hu/bme/mit/inf/dslreasoner/viatrasolver/partialinterpretationlanguage/neighbourhood/PartialInterpretation2Hash.xtend
@@ -1,25 +1,33 @@
1package hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage.neighbourhood 1package hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage.neighbourhood
2 2
3import java.util.Map
4import hu.bme.mit.inf.dslreasoner.logic.model.logiclanguage.DefinedElement 3import hu.bme.mit.inf.dslreasoner.logic.model.logiclanguage.DefinedElement
4import java.util.Map
5import org.eclipse.collections.api.factory.Maps
5 6
6class PartialInterpretation2Hash extends PartialInterpretation2NeighbourhoodRepresentation<Integer, Integer>{ 7class PartialInterpretation2Hash extends PartialInterpretation2NeighbourhoodRepresentation<Integer, Integer>{
7 8
8 protected new() { 9 new() {
9 super(false, true) 10 super(false, true)
10 } 11 }
11 12
12 override protected createLocalRepresentation(Map<DefinedElement, LocalNodeDescriptor> node2Representation, Map<LocalNodeDescriptor, Integer> representation2Amount) { 13 override protected createLocalRepresentation(Map<DefinedElement, LocalNodeDescriptor> node2Representation, Map<LocalNodeDescriptor, Integer> representation2Amount) {
13 return new NeighbourhoodWithTraces( 14 return new NeighbourhoodWithTraces(
14 representation2Amount.hashCode,node2Representation.mapValues[it.hashCode], 15 representation2Amount.hashCode,node2Representation.hashValues,
15 null) 16 null)
16 } 17 }
17 18
18 override protected createFurtherRepresentation(Map<FurtherNodeDescriptor<Integer>, Integer> nodeDescriptors, Map<DefinedElement, FurtherNodeDescriptor<Integer>> node2Representation, NeighbourhoodWithTraces<Integer, Integer> previous, boolean deepRepresentation) { 19 override protected createFurtherRepresentation(Map<FurtherNodeDescriptor<Integer>, Integer> nodeDescriptors, Map<DefinedElement, FurtherNodeDescriptor<Integer>> node2Representation, NeighbourhoodWithTraces<Integer, Integer> previous, boolean deepRepresentation) {
19 return new NeighbourhoodWithTraces( 20 return new NeighbourhoodWithTraces(
20 nodeDescriptors.hashCode, 21 nodeDescriptors.hashCode,
21 node2Representation.mapValues[it.hashCode], 22 node2Representation.hashValues,
22 if(deepRepresentation) {previous} else {null}) 23 if(deepRepresentation) {previous} else {null})
23 } 24 }
24 25
26 private def <T> hashValues(Map<DefinedElement, T> map) {
27 val hashedMap = Maps.mutable.ofInitialCapacity(map.size)
28 for (entry : map.entrySet) {
29 hashedMap.put(entry.key, entry.value.hashCode)
30 }
31 hashedMap
32 }
25} 33}
diff --git a/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage/src/hu/bme/mit/inf/dslreasoner/viatrasolver/partialinterpretationlanguage/neighbourhood/PartialInterpretation2NeighbourhoodRepresentation.xtend b/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage/src/hu/bme/mit/inf/dslreasoner/viatrasolver/partialinterpretationlanguage/neighbourhood/PartialInterpretation2NeighbourhoodRepresentation.xtend
index 6dc40705..93eab816 100644
--- a/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage/src/hu/bme/mit/inf/dslreasoner/viatrasolver/partialinterpretationlanguage/neighbourhood/PartialInterpretation2NeighbourhoodRepresentation.xtend
+++ b/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage/src/hu/bme/mit/inf/dslreasoner/viatrasolver/partialinterpretationlanguage/neighbourhood/PartialInterpretation2NeighbourhoodRepresentation.xtend
@@ -4,32 +4,34 @@ import hu.bme.mit.inf.dslreasoner.logic.model.logiclanguage.DefinedElement
4import hu.bme.mit.inf.dslreasoner.logic.model.logiclanguage.RelationDeclaration 4import hu.bme.mit.inf.dslreasoner.logic.model.logiclanguage.RelationDeclaration
5import hu.bme.mit.inf.dslreasoner.logic.model.logiclanguage.TypeDeclaration 5import hu.bme.mit.inf.dslreasoner.logic.model.logiclanguage.TypeDeclaration
6import hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage.partialinterpretation.BinaryElementRelationLink 6import hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage.partialinterpretation.BinaryElementRelationLink
7import hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage.partialinterpretation.PartialComplexTypeInterpretation
7import hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage.partialinterpretation.PartialInterpretation 8import hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage.partialinterpretation.PartialInterpretation
8import java.util.HashMap 9import hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage.partialinterpretation.PartialPrimitiveInterpretation
9import java.util.HashSet 10import java.util.ArrayList
10import java.util.LinkedList
11import java.util.List 11import java.util.List
12import java.util.Map 12import java.util.Map
13import java.util.Set 13import java.util.Set
14import org.eclipse.collections.api.factory.Maps
15import org.eclipse.collections.impl.factory.Sets
14 16
15import static extension hu.bme.mit.inf.dslreasoner.util.CollectionsUtil.* 17import static extension hu.bme.mit.inf.dslreasoner.util.CollectionsUtil.*
16import hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage.partialinterpretation.PartialPrimitiveInterpretation
17import hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage.partialinterpretation.PartialComplexTypeInterpretation
18 18
19abstract class PartialInterpretation2NeighbourhoodRepresentation<ModelRepresentation,NodeRepresentation> { 19abstract class PartialInterpretation2NeighbourhoodRepresentation<ModelRepresentation, NodeRepresentation> {
20 private val boolean deepRepresentation 20 val boolean deepRepresentation
21 private val boolean mergeSimilarNeighbourhood 21 val boolean mergeSimilarNeighbourhood
22 22
23 protected new(boolean deeprepresentation, boolean mergeSimilarNeighbourhood) { 23 protected new(boolean deeprepresentation, boolean mergeSimilarNeighbourhood) {
24 this.deepRepresentation = deeprepresentation 24 this.deepRepresentation = deeprepresentation
25 this.mergeSimilarNeighbourhood = mergeSimilarNeighbourhood 25 this.mergeSimilarNeighbourhood = mergeSimilarNeighbourhood
26 } 26 }
27 27
28 public static val FixPointRage = -1 28 public static val FixPointRange = NeighbourhoodOptions.FixPointRange
29 public static val GraphWidthRange = -2 29 public static val GraphWidthRange = NeighbourhoodOptions.GraphWidthRange
30 public static val FullParallels = Integer.MAX_VALUE 30 public static val FullParallels = NeighbourhoodOptions.FullParallels
31 public static val MaxNumbers = Integer.MAX_VALUE 31 public static val MaxNumbers = NeighbourhoodOptions.MaxNumbers
32 32
33 static val FOCUSED_ELEMENT_NAME = "<<THIS>>"
34
33 /** 35 /**
34 * Creates a neighbourhood representation with traces 36 * Creates a neighbourhood representation with traces
35 * @param model The model to be represented. 37 * @param model The model to be represented.
@@ -37,10 +39,15 @@ abstract class PartialInterpretation2NeighbourhoodRepresentation<ModelRepresenta
37 * @param parallels The maximal number of parallel references to be differentiated. 39 * @param parallels The maximal number of parallel references to be differentiated.
38 * @param maxNumber The maximal number of elements in a equivalence class that chan be differentiated. 40 * @param maxNumber The maximal number of elements in a equivalence class that chan be differentiated.
39 */ 41 */
40 def public createRepresentation(PartialInterpretation model, int range, int parallels, int maxNumber) { 42 def createRepresentation(PartialInterpretation model, int range, int parallels, int maxNumber) {
41 return createRepresentation(model,range,parallels,maxNumber,null,null) 43 return createRepresentation(model, range, parallels, maxNumber, null, null)
44 }
45
46 def createRepresentation(PartialInterpretation model, NeighbourhoodOptions options) {
47 createRepresentation(model, options.range, options.parallels, options.maxNumber, options.relevantTypes,
48 options.relevantRelations)
42 } 49 }
43 50
44 /** 51 /**
45 * Creates a neighbourhood representation with traces 52 * Creates a neighbourhood representation with traces
46 * @param model The model to be represented. 53 * @param model The model to be represented.
@@ -48,72 +55,87 @@ abstract class PartialInterpretation2NeighbourhoodRepresentation<ModelRepresenta
48 * @param parallels The maximal number of parallel references to be differentiated. 55 * @param parallels The maximal number of parallel references to be differentiated.
49 * @param maxNumber The maximal number of elements in a equivalence class that chan be differentiated. 56 * @param maxNumber The maximal number of elements in a equivalence class that chan be differentiated.
50 */ 57 */
51 def public createRepresentation( 58 def createRepresentation(PartialInterpretation model, int range, int parallels, int maxNumber,
52 PartialInterpretation model, 59 Set<TypeDeclaration> relevantTypes, Set<RelationDeclaration> relevantRelations) {
53 int range, int parallels, int maxNumber, 60 createRepresentationWithFocus(model, range, parallels, maxNumber, relevantTypes, relevantRelations, null)
54 Set<TypeDeclaration> relevantTypes, Set<RelationDeclaration> relevantRelations) 61 }
55 { 62
56 val Map<DefinedElement, Set<String>> types = new HashMap 63 def createRepresentationWithFocus(PartialInterpretation model, NeighbourhoodOptions options,
57 fillTypes(model,types,relevantTypes) 64 DefinedElement focusedElement) {
58 val Map<DefinedElement, List<IncomingRelation<DefinedElement>>> IncomingRelations = new HashMap; 65 createRepresentationWithFocus(model, options.range, options.parallels, options.maxNumber, options.relevantTypes,
59 val Map<DefinedElement, List<OutgoingRelation<DefinedElement>>> OutgoingRelations = new HashMap; 66 options.relevantRelations, focusedElement)
60 fillReferences(model,IncomingRelations,OutgoingRelations,relevantRelations) 67 }
61 68
62 val res = doRecursiveNeighbourCalculation(model,types,IncomingRelations,OutgoingRelations,range,parallels,maxNumber); 69 def createRepresentationWithFocus(PartialInterpretation model, int range, int parallels, int maxNumber,
63 70 Set<TypeDeclaration> relevantTypes, Set<RelationDeclaration> relevantRelations, DefinedElement focusedElement) {
71 val initialSize = model.elements.size
72 val Map<DefinedElement, Set<String>> types = Maps.mutable.ofInitialCapacity(initialSize)
73 fillTypes(model, types, relevantTypes)
74 val Map<DefinedElement, List<IncomingRelation<DefinedElement>>> IncomingRelations = Maps.mutable.ofInitialCapacity(initialSize);
75 val Map<DefinedElement, List<OutgoingRelation<DefinedElement>>> OutgoingRelations = Maps.mutable.ofInitialCapacity(initialSize);
76 fillReferences(model, IncomingRelations, OutgoingRelations, relevantRelations)
77
78 val res = doRecursiveNeighbourCalculation(model, types, IncomingRelations, OutgoingRelations, range, parallels,
79 maxNumber, focusedElement);
80
64 return res; 81 return res;
65 } 82 }
66 83
67 def private isRelevant(TypeDeclaration t, Set<TypeDeclaration> relevantTypes) { 84 def private isRelevant(TypeDeclaration t, Set<TypeDeclaration> relevantTypes) {
68 if(relevantTypes === null) { 85 if (relevantTypes === null) {
69 return true 86 return true
70 } else { 87 } else {
71 return relevantTypes.contains(t) 88 return relevantTypes.contains(t)
72 } 89 }
73 } 90 }
91
74 def private isRelevant(RelationDeclaration r, Set<RelationDeclaration> relevantRelations) { 92 def private isRelevant(RelationDeclaration r, Set<RelationDeclaration> relevantRelations) {
75 if(relevantRelations === null) { 93 if (relevantRelations === null) {
76 return true 94 return true
77 } else { 95 } else {
78 return relevantRelations.contains(r) 96 return relevantRelations.contains(r)
79 } 97 }
80 } 98 }
99
81 /** 100 /**
82 * Gets the largest 101 * Gets the minimal neighbourhood size such that every reachable node appears in the shape of every other at least once.
83 */ 102 */
84 def private getWidth(Map<DefinedElement, Set<String>> types, 103 def private getWidth(Map<DefinedElement, Set<String>> types,
85 Map<DefinedElement, List<IncomingRelation<DefinedElement>>> IncomingRelations, 104 Map<DefinedElement, List<IncomingRelation<DefinedElement>>> IncomingRelations,
86 Map<DefinedElement, List<OutgoingRelation<DefinedElement>>> OutgoingRelations) 105 Map<DefinedElement, List<OutgoingRelation<DefinedElement>>> OutgoingRelations) {
87 { 106 val elements = types.keySet
88 val elements = types.keySet 107 var Map<DefinedElement, Set<DefinedElement>> reachable = Maps.mutable.ofInitialCapacity(elements.size)
89 val Map<DefinedElement,Set<DefinedElement>> reachable = new HashMap 108 var Map<DefinedElement, Set<DefinedElement>> newReachable = Maps.mutable.ofInitialCapacity(elements.size)
90 for(element : elements) { 109 for (element : elements) {
91 val set = new HashSet 110 val set = Sets.mutable.of
92 set.add(element) 111 set.add(element)
93 reachable.put(element,set) 112 reachable.put(element, Sets.mutable.of)
113 newReachable.put(element, set)
94 } 114 }
95 115
96 var int width = 0 116 var int width = 0
97 var boolean newAdded 117 var boolean newAdded
98 do { 118 do {
119 var tmp = reachable
120 reachable = newReachable
121 newReachable = tmp
99 newAdded = false 122 newAdded = false
100 for(element : elements) { 123 for (element : elements) {
101 val elementNeigbours = element.lookup(reachable) 124 val elementNeigbours = element.lookup(reachable)
102 val size = elementNeigbours.size 125 val newElementNeigbours = element.lookup(newReachable)
103 for(incoming : element.lookup(IncomingRelations)) { 126 newElementNeigbours.addAll(elementNeigbours)
104 elementNeigbours.addAll(incoming.from.lookup(reachable)) 127 for (incoming : element.lookup(IncomingRelations)) {
128 newElementNeigbours.addAll(incoming.from.lookup(reachable))
105 } 129 }
106 for(outgoing : element.lookup(OutgoingRelations)) { 130 for (outgoing : element.lookup(OutgoingRelations)) {
107 elementNeigbours.addAll(outgoing.to.lookup(reachable)) 131 newElementNeigbours.addAll(outgoing.to.lookup(reachable))
108 } 132 }
109 newAdded = newAdded || (elementNeigbours.size > size) 133 newAdded = newAdded || (newElementNeigbours.size > elementNeigbours.size)
110 } 134 }
111 135 width += 1
112 width +=1 136 } while (newAdded)
113 } while(newAdded)
114 return width 137 return width
115 } 138 }
116
117 /** 139 /**
118 * Creates a neighbourhood representation with traces 140 * Creates a neighbourhood representation with traces
119 * @param model The model to be represented. 141 * @param model The model to be represented.
@@ -122,68 +144,71 @@ abstract class PartialInterpretation2NeighbourhoodRepresentation<ModelRepresenta
122 * @param range The range of the neighbourhood. 144 * @param range The range of the neighbourhood.
123 * @param parallels The maximal number of parallel references to be differentiated. 145 * @param parallels The maximal number of parallel references to be differentiated.
124 */ 146 */
125 def private NeighbourhoodWithTraces<ModelRepresentation,NodeRepresentation> doRecursiveNeighbourCalculation( 147 def private NeighbourhoodWithTraces<ModelRepresentation, NodeRepresentation> doRecursiveNeighbourCalculation(
126 PartialInterpretation model, 148 PartialInterpretation model, Map<DefinedElement, Set<String>> types,
127 Map<DefinedElement, Set<String>> types,
128 Map<DefinedElement, List<IncomingRelation<DefinedElement>>> IncomingRelations, 149 Map<DefinedElement, List<IncomingRelation<DefinedElement>>> IncomingRelations,
129 Map<DefinedElement, List<OutgoingRelation<DefinedElement>>> OutgoingRelations, 150 Map<DefinedElement, List<OutgoingRelation<DefinedElement>>> OutgoingRelations, int range, int parallels,
130 int range, int parallels, int maxNumber) 151 int maxNumber, DefinedElement focusedElement) {
131 { 152 if (range == 0) {
132 if(range == 0){ 153 val r = calculateLocalNodeDescriptors(model, types, maxNumber, focusedElement)
133 val r = calculateLocalNodeDescriptors(model,types,maxNumber) 154 val res = this.createLocalRepresentation(r.value, r.key)
134 val res = this.createLocalRepresentation(r.value,r.key) 155 if (res.modelRepresentation === null) {
135 if(res.modelRepresentation === null) {
136 throw new IllegalArgumentException('''Model representation is null''') 156 throw new IllegalArgumentException('''Model representation is null''')
137 } else if(res.nodeRepresentations === null || res.nodeRepresentations.empty) { 157 } else if (res.nodeRepresentations === null || res.nodeRepresentations.empty) {
138 throw new IllegalArgumentException('''No node representation''') 158 throw new IllegalArgumentException('''No node representation''')
139 } else if(res.previousRepresentation !== null) { 159 } else if (res.previousRepresentation !== null) {
140 throw new IllegalArgumentException('''The previous representation of the first neighbourhood have to be null''') 160 throw new IllegalArgumentException('''The previous representation of the first neighbourhood have to be null''')
141 } else return res 161 } else
142 } else if(range > 0) { 162 return res
143 val previous = doRecursiveNeighbourCalculation(model,types,IncomingRelations,OutgoingRelations,range-1,parallels,maxNumber) 163 } else if (range > 0) {
144 val r = calculateFurtherNodeDescriptors(model,previous,IncomingRelations,OutgoingRelations,parallels,maxNumber) 164 val previous = doRecursiveNeighbourCalculation(model, types, IncomingRelations, OutgoingRelations,
145 //println('''Level «range» finished.''') 165 range - 1, parallels, maxNumber, focusedElement)
146 val res = createFurtherRepresentation(r.key,r.value,previous,deepRepresentation) 166 val r = calculateFurtherNodeDescriptors(model, previous, IncomingRelations, OutgoingRelations, parallels,
147 if(res.modelRepresentation === null) { 167 maxNumber)
168 // println('''Level «range» finished.''')
169 val res = createFurtherRepresentation(r.key, r.value, previous, deepRepresentation)
170 if (res.modelRepresentation === null) {
148 throw new IllegalArgumentException('''Model representation is null''') 171 throw new IllegalArgumentException('''Model representation is null''')
149 } else if(res.nodeRepresentations === null || res.nodeRepresentations.empty) { 172 } else if (res.nodeRepresentations === null || res.nodeRepresentations.empty) {
150 throw new IllegalArgumentException('''No node representation''') 173 throw new IllegalArgumentException('''No node representation''')
151 } else if(res.previousRepresentation === null && deepRepresentation) { 174 } else if (res.previousRepresentation === null && deepRepresentation) {
152 throw new IllegalArgumentException('''Need previous representations''') 175 throw new IllegalArgumentException('''Need previous representations''')
153 } else return res 176 } else
154 } else if (range == FixPointRage) { 177 return res
155 return refineUntilFixpoint(model,types,IncomingRelations,OutgoingRelations,parallels,maxNumber) 178 } else if (range == FixPointRange) {
179 return refineUntilFixpoint(model, types, IncomingRelations, OutgoingRelations, parallels, maxNumber,
180 focusedElement)
156 } else if (range == GraphWidthRange) { 181 } else if (range == GraphWidthRange) {
157 val width = this.getWidth(types,IncomingRelations,OutgoingRelations) 182 val width = this.getWidth(types, IncomingRelations, OutgoingRelations)
158 //println(width) 183 // println(width)
159 return doRecursiveNeighbourCalculation(model,types,IncomingRelations,OutgoingRelations,width,parallels,maxNumber) 184 return doRecursiveNeighbourCalculation(model, types, IncomingRelations, OutgoingRelations, width, parallels,
185 maxNumber, focusedElement)
160 } 186 }
161 } 187 }
162 188
163 def private refineUntilFixpoint( 189 def private refineUntilFixpoint(PartialInterpretation model, Map<DefinedElement, Set<String>> types,
164 PartialInterpretation model,
165 Map<DefinedElement, Set<String>> types,
166 Map<DefinedElement, List<IncomingRelation<DefinedElement>>> IncomingRelations, 190 Map<DefinedElement, List<IncomingRelation<DefinedElement>>> IncomingRelations,
167 Map<DefinedElement, List<OutgoingRelation<DefinedElement>>> OutgoingRelations, 191 Map<DefinedElement, List<OutgoingRelation<DefinedElement>>> OutgoingRelations, int parallels, int maxNumbers,
168 int parallels, int maxNumbers) 192 DefinedElement focusedElement) {
169 {
170 var lastRange = 0 193 var lastRange = 0
171 val last = calculateLocalNodeDescriptors(model,types,maxNumbers) 194 val last = calculateLocalNodeDescriptors(model, types, maxNumbers, focusedElement)
172 var lastRepresentation = this.createLocalRepresentation(last.value,last.key) 195 var lastRepresentation = this.createLocalRepresentation(last.value, last.key)
173 //println('''Level 0 finished.''') 196 // println('''Level 0 finished.''')
174 var boolean hasRefined 197 var boolean hasRefined
175 do { 198 do {
176 val nextRange = lastRange+1 199 val nextRange = lastRange + 1
177 val next = calculateFurtherNodeDescriptors(model,lastRepresentation,IncomingRelations,OutgoingRelations,parallels,maxNumbers) 200 val next = calculateFurtherNodeDescriptors(model, lastRepresentation, IncomingRelations, OutgoingRelations,
178 val nextRepresentation = createFurtherRepresentation(next.key,next.value,lastRepresentation,deepRepresentation) 201 parallels, maxNumbers)
179 202 val nextRepresentation = createFurtherRepresentation(next.key, next.value, lastRepresentation,
180 val previousNumberOfTypes =lastRepresentation.nodeRepresentations.values.toSet.size 203 deepRepresentation)
181 val nextNumberOfTypes = nextRepresentation.nodeRepresentations.values.toSet.size 204
182 hasRefined = nextNumberOfTypes > previousNumberOfTypes 205 val previousNumberOfTypes = Sets.immutable.withAll(lastRepresentation.nodeRepresentations.values).size
183 206 val nextNumberOfTypes = Sets.immutable.withAll(nextRepresentation.nodeRepresentations.values).size
207 hasRefined = nextNumberOfTypes > previousNumberOfTypes
208
184 lastRange = nextRange 209 lastRange = nextRange
185 lastRepresentation = nextRepresentation 210 lastRepresentation = nextRepresentation
186 211
187// if(hasRefined) { 212// if(hasRefined) {
188// println('''Level «nextRange» is calculated, number of types is refined: «previousNumberOfTypes» -> «nextNumberOfTypes»''') 213// println('''Level «nextRange» is calculated, number of types is refined: «previousNumberOfTypes» -> «nextNumberOfTypes»''')
189// } else { 214// } else {
@@ -192,211 +217,217 @@ abstract class PartialInterpretation2NeighbourhoodRepresentation<ModelRepresenta
192 } while (hasRefined) 217 } while (hasRefined)
193 return lastRepresentation 218 return lastRepresentation
194 } 219 }
195 220
196 def private getElements(PartialInterpretation model) { 221 def private getElements(PartialInterpretation model) {
197 return 222 return model.problem.elements + model.newElements + model.openWorldElements
198 model.problem.elements +
199 model.newElements +
200 model.openWorldElements
201 } 223 }
202 224
203 def private fillTypes(PartialInterpretation model, Map<DefinedElement, Set<String>> node2Type, Set<TypeDeclaration> relevantTypes) { 225 def private fillTypes(PartialInterpretation model, Map<DefinedElement, Set<String>> node2Type,
204 for(element : model.elements) { 226 Set<TypeDeclaration> relevantTypes) {
205 node2Type.put(element, new HashSet) 227 for (element : model.elements) {
228 node2Type.put(element, Sets.mutable.of)
206 } 229 }
207 230
208// for(typeDefinition : model.problem.types.filter(TypeDefinition)) { 231// for(typeDefinition : model.problem.types.filter(TypeDefinition)) {
209// // Dont need 232// // Dont need
210// } 233// }
211 for(typeInterpretation : model.partialtypeinterpratation) { 234 for (typeInterpretation : model.partialtypeinterpratation) {
212 if(typeInterpretation instanceof PartialPrimitiveInterpretation) { 235 if (typeInterpretation instanceof PartialPrimitiveInterpretation) {
213 236 } else if (typeInterpretation instanceof PartialComplexTypeInterpretation) {
214 } else if(typeInterpretation instanceof PartialComplexTypeInterpretation) {
215 val type = typeInterpretation.interpretationOf 237 val type = typeInterpretation.interpretationOf
216 if(type.isRelevant(relevantTypes)) { 238 if (type.isRelevant(relevantTypes)) {
217 for(element : typeInterpretation.elements) { 239 for (element : typeInterpretation.elements) {
218 element.lookup(node2Type).add(type.name) 240 element.lookup(node2Type).add(type.name)
219 } 241 }
220 } 242 }
221 } 243 }
222 } 244 }
223 } 245 }
224 246
225 /** 247 /**
226 * Indexes the references 248 * Indexes the references
227 */ 249 */
228 def private fillReferences(PartialInterpretation model, 250 def private fillReferences(PartialInterpretation model,
229 Map<DefinedElement, List<IncomingRelation<DefinedElement>>> IncomingRelations, 251 Map<DefinedElement, List<IncomingRelation<DefinedElement>>> IncomingRelations,
230 Map<DefinedElement, List<OutgoingRelation<DefinedElement>>> OutgoingRelations, 252 Map<DefinedElement, List<OutgoingRelation<DefinedElement>>> OutgoingRelations,
231 Set<RelationDeclaration> relevantRelations) 253 Set<RelationDeclaration> relevantRelations) {
232 { 254 for (object : model.elements) {
233 for(object : model.elements) { 255 IncomingRelations.put(object, new ArrayList)
234 IncomingRelations.put(object,new LinkedList) 256 OutgoingRelations.put(object, new ArrayList)
235 OutgoingRelations.put(object,new LinkedList)
236 } 257 }
237 for(relationInterpretation : model.partialrelationinterpretation) { 258 for (relationInterpretation : model.partialrelationinterpretation) {
238 val type = relationInterpretation.interpretationOf 259 val type = relationInterpretation.interpretationOf
239 if(type.isRelevant(relevantRelations)) { 260 if (type.isRelevant(relevantRelations)) {
240 for(link : relationInterpretation.relationlinks) { 261 for (link : relationInterpretation.relationlinks) {
241 if(link instanceof BinaryElementRelationLink) { 262 if (link instanceof BinaryElementRelationLink) {
242 OutgoingRelations.get(link.param1) += new OutgoingRelation(link.param2,type.name) 263 OutgoingRelations.get(link.param1) += new OutgoingRelation(link.param2, type.name)
243 IncomingRelations.get(link.param2) += new IncomingRelation(link.param1,type.name) 264 IncomingRelations.get(link.param2) += new IncomingRelation(link.param1, type.name)
244 } else throw new UnsupportedOperationException 265 } else
266 throw new UnsupportedOperationException
245 } 267 }
246 } 268 }
247 } 269 }
248 } 270 }
249 271
250 /** 272 /**
251 * Creates a local representation of the objects (aka zero range neighbourhood) 273 * Creates a local representation of the objects (aka zero range neighbourhood)
252 */ 274 */
253 def abstract protected NeighbourhoodWithTraces<ModelRepresentation,NodeRepresentation> createLocalRepresentation( 275 def abstract protected NeighbourhoodWithTraces<ModelRepresentation, NodeRepresentation> createLocalRepresentation(
254 Map<DefinedElement, LocalNodeDescriptor> node2Representation, 276 Map<DefinedElement, LocalNodeDescriptor> node2Representation,
255 Map<LocalNodeDescriptor, Integer> representation2Amount 277 Map<LocalNodeDescriptor, Integer> representation2Amount
256 ) 278 )
257 279
258 /** 280 /**
259 * Creates a 281 * Creates a
260 */ 282 */
261 def abstract protected NeighbourhoodWithTraces<ModelRepresentation,NodeRepresentation> createFurtherRepresentation( 283 def abstract protected NeighbourhoodWithTraces<ModelRepresentation, NodeRepresentation> createFurtherRepresentation(
262 Map<FurtherNodeDescriptor<NodeRepresentation>, Integer> nodeDescriptors, 284 Map<FurtherNodeDescriptor<NodeRepresentation>, Integer> nodeDescriptors,
263 Map<DefinedElement, FurtherNodeDescriptor<NodeRepresentation>> node2Representation, 285 Map<DefinedElement, FurtherNodeDescriptor<NodeRepresentation>> node2Representation,
264 NeighbourhoodWithTraces<ModelRepresentation,NodeRepresentation> previous, 286 NeighbourhoodWithTraces<ModelRepresentation, NodeRepresentation> previous,
265 boolean deepRepresentation 287 boolean deepRepresentation
266 ) 288 )
267 289
268 def private addOne(int original, int max) { 290 def private addOne(Integer originalObj, int max) {
291 if (originalObj === null) {
292 return 1
293 }
294 val original = originalObj.intValue
269 if(original == Integer.MAX_VALUE) return Integer.MAX_VALUE 295 if(original == Integer.MAX_VALUE) return Integer.MAX_VALUE
270 if(original +1 > max) return Integer.MAX_VALUE 296 if(original + 1 > max) return Integer.MAX_VALUE else return original + 1
271 else return original+1
272 } 297 }
273 298
274 private def calculateIncomingEdges(Map<DefinedElement, List<IncomingRelation<DefinedElement>>> IncomingRelations, 299 private def calculateIncomingEdges(Map<DefinedElement, List<IncomingRelation<DefinedElement>>> IncomingRelations,
275 DefinedElement object, Map<DefinedElement, ? extends NodeRepresentation> previousNodeRepresentations, int parallel) 300 DefinedElement object, Map<DefinedElement, ? extends NodeRepresentation> previousNodeRepresentations,
276 { 301 int parallel) {
277 val Map<IncomingRelation<NodeRepresentation>, Integer> res = new HashMap 302 val Map<IncomingRelation<NodeRepresentation>, Integer> res = Maps.mutable.of
278 for (incomingConcreteEdge : IncomingRelations.get(object)) { 303 for (incomingConcreteEdge : IncomingRelations.get(object)) {
279 val IncomingRelation<NodeRepresentation> e = new IncomingRelation( 304 val IncomingRelation<NodeRepresentation> e = new IncomingRelation(
280 previousNodeRepresentations.get(incomingConcreteEdge.from), incomingConcreteEdge.type) 305 previousNodeRepresentations.get(incomingConcreteEdge.from), incomingConcreteEdge.type)
281 if (res.containsKey(e)) { 306 res.compute(e, [key, value | addOne(value, parallel)])
282 res.put(e, addOne(res.get(e),parallel))
283 } else {
284 res.put(e, 1)
285 }
286 } 307 }
287 return res 308 return res
288 } 309 }
289 310
290 private def calcuateOutgoingEdges(Map<DefinedElement,List<OutgoingRelation<DefinedElement>>> OutgoingRelations, 311 private def calcuateOutgoingEdges(Map<DefinedElement, List<OutgoingRelation<DefinedElement>>> OutgoingRelations,
291 DefinedElement object, Map<DefinedElement, ? extends NodeRepresentation> previousNodeRepresentations, int parallel) 312 DefinedElement object, Map<DefinedElement, ? extends NodeRepresentation> previousNodeRepresentations,
292 { 313 int parallel) {
293 val Map<OutgoingRelation<NodeRepresentation>,Integer> res= new HashMap 314 val Map<OutgoingRelation<NodeRepresentation>, Integer> res = Maps.mutable.of
294 for(outgoingConcreteEdge : OutgoingRelations.get(object)) { 315 for (outgoingConcreteEdge : OutgoingRelations.get(object)) {
295 val OutgoingRelation<NodeRepresentation> e = 316 val OutgoingRelation<NodeRepresentation> e = new OutgoingRelation(
296 new OutgoingRelation( 317 previousNodeRepresentations.get(outgoingConcreteEdge.to), outgoingConcreteEdge.type)
297 previousNodeRepresentations.get(outgoingConcreteEdge.to), 318 res.compute(e, [key, value | addOne(value, parallel)])
298 outgoingConcreteEdge.type)
299 if(res.containsKey(e)) {
300 res.put(e,addOne(res.get(e),parallel))
301 } else {
302 res.put(e,1)
303 }
304 } 319 }
305 return res; 320 return res
306 } 321 }
307 322
308 /*def private <KEY,VALUE> void addOrCreate_Set(Map<KEY,Set<VALUE>> map, KEY key, VALUE value) { 323 /*def private <KEY,VALUE> void addOrCreate_Set(Map<KEY,Set<VALUE>> map, KEY key, VALUE value) {
309 var Set<VALUE> s; 324 * var Set<VALUE> s;
310 if(map.containsKey(key)) { 325 * if(map.containsKey(key)) {
311 s = map.get(key); 326 * s = map.get(key);
312 } else { 327 * } else {
313 s = new HashSet 328 * s = new HashSet
314 map.put(key,s) 329 * map.put(key,s)
315 } 330 * }
316 s.add(value) 331 * s.add(value)
317 }*/ 332 }*/
318 333 private def calculateFurtherNodeDescriptors(PartialInterpretation model,
319
320 private def calculateFurtherNodeDescriptors(
321 PartialInterpretation model,
322 NeighbourhoodWithTraces<ModelRepresentation, NodeRepresentation> previous, 334 NeighbourhoodWithTraces<ModelRepresentation, NodeRepresentation> previous,
323 Map<DefinedElement, List<IncomingRelation<DefinedElement>>> IncomingRelations, 335 Map<DefinedElement, List<IncomingRelation<DefinedElement>>> IncomingRelations,
324 Map<DefinedElement, List<OutgoingRelation<DefinedElement>>> OutgoingRelations, 336 Map<DefinedElement, List<OutgoingRelation<DefinedElement>>> OutgoingRelations, int parallels, int maxNumber) {
325 int parallels, int maxNumber)
326 {
327 val previousNodeRepresentations = previous.nodeRepresentations 337 val previousNodeRepresentations = previous.nodeRepresentations
328 val node2Representation = new HashMap<DefinedElement,FurtherNodeDescriptor<NodeRepresentation>> 338 val size = previousNodeRepresentations.size
329 val Map<FurtherNodeDescriptor<NodeRepresentation>,Integer> descriptor2Number = 339 val node2Representation = Maps.mutable.<DefinedElement, FurtherNodeDescriptor<NodeRepresentation>>ofInitialCapacity(size)
330 if(this.mergeSimilarNeighbourhood){ new HashMap } else { null } 340 val Map<FurtherNodeDescriptor<NodeRepresentation>, Integer> descriptor2Number = if (this.
331 val Map<FurtherNodeDescriptor<NodeRepresentation>,FurtherNodeDescriptor<NodeRepresentation>> uniqueDescription = 341 mergeSimilarNeighbourhood) {
332 if(this.mergeSimilarNeighbourhood){ new HashMap } else { null } 342 Maps.mutable.ofInitialCapacity(size)
333 343 } else {
334 for(object: model.elements) { 344 null
335 val incomingEdges = this.calculateIncomingEdges(IncomingRelations, object, previousNodeRepresentations,parallels) 345 }
336 val outgoingEdges = this.calcuateOutgoingEdges(OutgoingRelations,object, previousNodeRepresentations,parallels) 346 val Map<FurtherNodeDescriptor<NodeRepresentation>, FurtherNodeDescriptor<NodeRepresentation>> uniqueDescription = if (this.
337 347 mergeSimilarNeighbourhood) {
348 Maps.mutable.ofInitialCapacity(size)
349 } else {
350 null
351 }
352
353 for (object : model.elements) {
354 val incomingEdges = this.calculateIncomingEdges(IncomingRelations, object, previousNodeRepresentations,
355 parallels)
356 val outgoingEdges = this.calcuateOutgoingEdges(OutgoingRelations, object, previousNodeRepresentations,
357 parallels)
358
338 val previousType = previousNodeRepresentations.get(object) 359 val previousType = previousNodeRepresentations.get(object)
339 360
340 if(previousType === null) { 361 if (previousType === null) {
341 println("Error in state coder") 362 println("Error in state coder")
342 } 363 }
343 364
344 val nodeDescriptor = new FurtherNodeDescriptor( 365 val nodeDescriptor = new FurtherNodeDescriptor(previousType, incomingEdges, outgoingEdges)
345 previousType, 366
346 incomingEdges, 367 if (this.mergeSimilarNeighbourhood) {
347 outgoingEdges) 368 if (descriptor2Number.containsKey(nodeDescriptor)) {
348
349 if(this.mergeSimilarNeighbourhood) {
350 if(descriptor2Number.containsKey(nodeDescriptor)) {
351 descriptor2Number.put( 369 descriptor2Number.put(
352 nodeDescriptor, 370 nodeDescriptor,
353 addOne(descriptor2Number.get(nodeDescriptor),maxNumber) 371 addOne(descriptor2Number.get(nodeDescriptor), maxNumber)
354 ) 372 )
355 node2Representation.put(object,uniqueDescription.get(nodeDescriptor)) 373 node2Representation.put(object, uniqueDescription.get(nodeDescriptor))
356 } else { 374 } else {
357 descriptor2Number.put(nodeDescriptor,if(1>maxNumber){Integer.MAX_VALUE}else{1}) 375 descriptor2Number.put(nodeDescriptor, if (1 > maxNumber) {
358 uniqueDescription.put(nodeDescriptor,nodeDescriptor) 376 Integer.MAX_VALUE
359 node2Representation.put(object,nodeDescriptor) 377 } else {
378 1
379 })
380 uniqueDescription.put(nodeDescriptor, nodeDescriptor)
381 node2Representation.put(object, nodeDescriptor)
360 } 382 }
361 } else { 383 } else {
362 node2Representation.put(object,nodeDescriptor) 384 node2Representation.put(object, nodeDescriptor)
363 } 385 }
364 } 386 }
365 387
366 return descriptor2Number -> node2Representation 388 return descriptor2Number -> node2Representation
367 } 389 }
368 390
369 private def calculateLocalNodeDescriptors( 391 private def calculateLocalNodeDescriptors(PartialInterpretation model, Map<DefinedElement, Set<String>> types,
370 PartialInterpretation model, 392 int maxNumber, DefinedElement focusedElement) {
371 Map<DefinedElement, Set<String>> types, 393 val size = types.size
372 int maxNumber) 394 val Map<DefinedElement, LocalNodeDescriptor> node2Representation = Maps.mutable.ofInitialCapacity(size)
373 { 395 val Map<LocalNodeDescriptor, Integer> representation2Amount = if (mergeSimilarNeighbourhood) {
374 val Map<DefinedElement, LocalNodeDescriptor> node2Representation = new HashMap 396 Maps.mutable.ofInitialCapacity(size)
375 val Map<LocalNodeDescriptor, Integer> representation2Amount = 397 } else {
376 if(mergeSimilarNeighbourhood){ new HashMap } else { null } 398 null
377 val Map<LocalNodeDescriptor, LocalNodeDescriptor> uniqueRepresentation = 399 }
378 if(this.mergeSimilarNeighbourhood){ new HashMap } else { null } 400 val Map<LocalNodeDescriptor, LocalNodeDescriptor> uniqueRepresentation = if (this.mergeSimilarNeighbourhood) {
379 401 Maps.mutable.ofInitialCapacity(size)
380 for(element : model.elements) { 402 } else {
381 var newDescriptor = new LocalNodeDescriptor(element.name,element.lookup(types)) 403 null
382 if(this.mergeSimilarNeighbourhood){ 404 }
383 if(uniqueRepresentation.containsKey(newDescriptor)) { 405
406 for (element : model.elements) {
407 val name = if(element == focusedElement) FOCUSED_ELEMENT_NAME else element.name
408 var newDescriptor = new LocalNodeDescriptor(name, element.lookup(types))
409 if (this.mergeSimilarNeighbourhood) {
410 if (uniqueRepresentation.containsKey(newDescriptor)) {
384 newDescriptor = newDescriptor.lookup(uniqueRepresentation) 411 newDescriptor = newDescriptor.lookup(uniqueRepresentation)
385 node2Representation.put(element,newDescriptor) 412 node2Representation.put(element, newDescriptor)
386 representation2Amount.put( 413 representation2Amount.put(
387 newDescriptor, 414 newDescriptor,
388 addOne(newDescriptor.lookup(representation2Amount),maxNumber) 415 addOne(newDescriptor.lookup(representation2Amount), maxNumber)
389 ) 416 )
390 } else { 417 } else {
391 uniqueRepresentation.put(newDescriptor,newDescriptor) 418 uniqueRepresentation.put(newDescriptor, newDescriptor)
392 node2Representation.put(element,newDescriptor) 419 node2Representation.put(element, newDescriptor)
393 representation2Amount.put(newDescriptor, if(1>maxNumber){Integer.MAX_VALUE}else{1}) 420 representation2Amount.put(newDescriptor, if (1 > maxNumber) {
421 Integer.MAX_VALUE
422 } else {
423 1
424 })
394 } 425 }
395 } else { 426 } else {
396 node2Representation.put(element,newDescriptor) 427 node2Representation.put(element, newDescriptor)
397 } 428 }
398 } 429 }
399 430
400 return representation2Amount -> node2Representation 431 return representation2Amount -> node2Representation
401 } 432 }
402} \ No newline at end of file 433}
diff --git a/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage/src/hu/bme/mit/inf/dslreasoner/viatrasolver/partialinterpretationlanguage/neighbourhood/PartialInterpretation2PairwiseNeighbourhoodRepresentation.xtend b/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage/src/hu/bme/mit/inf/dslreasoner/viatrasolver/partialinterpretationlanguage/neighbourhood/PartialInterpretation2PairwiseNeighbourhoodRepresentation.xtend
new file mode 100644
index 00000000..c10457b0
--- /dev/null
+++ b/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage/src/hu/bme/mit/inf/dslreasoner/viatrasolver/partialinterpretationlanguage/neighbourhood/PartialInterpretation2PairwiseNeighbourhoodRepresentation.xtend
@@ -0,0 +1,68 @@
1package hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage.neighbourhood
2
3import com.google.common.collect.Maps
4import hu.bme.mit.inf.dslreasoner.logic.model.logiclanguage.DefinedElement
5import hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage.partialinterpretation.PartialInterpretation
6import java.util.HashMap
7import java.util.Map
8import org.eclipse.xtend.lib.annotations.Data
9import org.eclipse.xtend.lib.annotations.FinalFieldsConstructor
10
11@Data
12class PairwiseNeighbourhoodRepresentation<BasicNodeRepresentation> {
13 val Map<?, Integer> modelRepresentation
14 val Map<DefinedElement, BasicNodeRepresentation> basicNodeRepresentations
15 val Map<DefinedElement, ? extends Map<DefinedElement, ? extends BasicNodeRepresentation>> pairwiseNodeRepresentations
16
17 def getBasicRepresentation(DefinedElement a) {
18 basicNodeRepresentations.get(a)
19 }
20
21 def getPairwiseRepresentation(DefinedElement a, DefinedElement b) {
22 pairwiseNodeRepresentations.get(a).get(b)
23 }
24}
25
26@FinalFieldsConstructor
27class PartialInterpretation2PairwiseNeighbourhoodRepresentation<BasicNodeRepresentation> {
28 val PartialInterpretation2NeighbourhoodRepresentation<? extends Map<? extends BasicNodeRepresentation, Integer>, BasicNodeRepresentation> basicNeighbourhoodRepresenter
29
30 def createRepresentation(PartialInterpretation model, NeighbourhoodOptions options) {
31 val basicRepresentation = basicNeighbourhoodRepresenter.createRepresentation(model, options)
32 val basicModelRepresentation = basicRepresentation.modelRepresentation
33 val basicNodeRepresentations = basicRepresentation.nodeRepresentations
34 val pairwiseNodeRepresentations = Maps.newHashMapWithExpectedSize(basicNodeRepresentations.size)
35 val modelRepresentation = new HashMap<Object, Integer>
36 for (nodeWithBasicRepresentation : basicNodeRepresentations.entrySet) {
37 val node = nodeWithBasicRepresentation.key
38 val basicNodeRepresentation = nodeWithBasicRepresentation.value
39 val count = basicModelRepresentation.get(basicNodeRepresentation)
40 if (count == 1) {
41 pairwiseNodeRepresentations.put(node, basicNodeRepresentations)
42 modelRepresentation.put(basicNodeRepresentation, count)
43 } else {
44 val neighbourhoodRepresentation = basicNeighbourhoodRepresenter.
45 createRepresentationWithFocus(model, options, node)
46 pairwiseNodeRepresentations.put(node, neighbourhoodRepresentation.nodeRepresentations)
47 modelRepresentation.compute(neighbourhoodRepresentation.modelRepresentation) [ key, value |
48 if (value === null) {
49 if (1 > options.maxNumber) {
50 Integer.MAX_VALUE
51 } else {
52 1
53 }
54 } else {
55 addOne(value, options.maxNumber)
56 }
57 ]
58 }
59 }
60 new PairwiseNeighbourhoodRepresentation(modelRepresentation, basicNodeRepresentations,
61 pairwiseNodeRepresentations)
62 }
63
64 def private addOne(int original, int max) {
65 if(original == Integer.MAX_VALUE) return Integer.MAX_VALUE
66 if(original + 1 > max) return Integer.MAX_VALUE else return original + 1
67 }
68}
generated by cgit v1.2.3-54-g00ecf (git 2.45.2) at 2024-07-03 12:46:48 +0000