merge with current master, comment numerical solver related logging

6 files changed, 115 insertions, 141 deletions

diff --git a/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage/src/hu/bme/mit/inf/dslreasoner/viatrasolver/partialinterpretation2logic/InstanceModel2PartialInterpretation.xtend b/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage/src/hu/bme/mit/inf/dslreasoner/viatrasolver/partialinterpretation2logic/InstanceModel2PartialInterpretation.xtend
index 8aaaacb5..cb5b587f 100644
--- a/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage/src/hu/bme/mit/inf/dslreasoner/viatrasolver/partialinterpretation2logic/InstanceModel2PartialInterpretation.xtend
+++ b/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage/src/hu/bme/mit/inf/dslreasoner/viatrasolver/partialinterpretation2logic/InstanceModel2PartialInterpretation.xtend
@@ -1,5 +1,6 @@
 package hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretation2logic

 

+import com.google.common.collect.ImmutableList

 import hu.bme.mit.inf.dslreasoner.ecore2logic.Ecore2Logic

 import hu.bme.mit.inf.dslreasoner.ecore2logic.Ecore2Logic_Trace

 import hu.bme.mit.inf.dslreasoner.logic.model.builder.TracedOutput

@@ -12,18 +13,18 @@ import hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage.Par
 import hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage.Problem2PartialInterpretationTrace

 import hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage.partialinterpretation.PartialRelationInterpretation

 import hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage.partialinterpretation.PartialinterpretationFactory

+import java.math.BigDecimal

 import java.util.HashMap

+import java.util.HashSet

 import java.util.List

 import java.util.Map

+import java.util.Set

 import org.eclipse.emf.common.util.Enumerator

+import org.eclipse.emf.ecore.EAttribute

 import org.eclipse.emf.ecore.EObject

 import org.eclipse.emf.ecore.resource.Resource

 

 import static extension hu.bme.mit.inf.dslreasoner.util.CollectionsUtil.*

-import java.util.HashSet

-import java.util.Set

-import java.math.BigDecimal

-import org.eclipse.emf.ecore.EAttribute

 

 class InstanceModel2PartialInterpretation {

         val extension LogiclanguageFactory factory = LogiclanguageFactory.eINSTANCE

@@ -36,7 +37,19 @@ class InstanceModel2PartialInterpretation {
                 Resource resource,

                 boolean withID) 

         {

-                val objects = resource.allContents.toList

+                val objectsBuilder = ImmutableList.builder

+                val treeIterator = resource.allContents

+                val referencesUsed = ecore2Logic.allReferencesInScope(metamodelTranslationResult.trace).toSet

+                while (treeIterator.hasNext) {

+                        val object = treeIterator.next

+                        val containingReference = object.eContainmentFeature

+                        if (containingReference === null || referencesUsed.contains(containingReference)) {

+                                objectsBuilder.add(object)

+                        } else {

+                                treeIterator.prune

+                        }

+                }

+                val objects = objectsBuilder.build

                 return transform(metamodelTranslationResult,objects,withID)

         }

         

diff --git a/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage/src/hu/bme/mit/inf/dslreasoner/viatrasolver/partialinterpretationlanguage/PartialInterpretationInitialiser.xtend b/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage/src/hu/bme/mit/inf/dslreasoner/viatrasolver/partialinterpretationlanguage/PartialInterpretationInitialiser.xtend
index d37acb6d..20ff58f2 100644
--- a/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage/src/hu/bme/mit/inf/dslreasoner/viatrasolver/partialinterpretationlanguage/PartialInterpretationInitialiser.xtend
+++ b/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage/src/hu/bme/mit/inf/dslreasoner/viatrasolver/partialinterpretationlanguage/PartialInterpretationInitialiser.xtend
@@ -2,19 +2,24 @@ package hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage
 

 import hu.bme.mit.inf.dslreasoner.logic.model.builder.TracedOutput

 import hu.bme.mit.inf.dslreasoner.logic.model.builder.TypeScopes

+import hu.bme.mit.inf.dslreasoner.logic.model.logiclanguage.And

+import hu.bme.mit.inf.dslreasoner.logic.model.logiclanguage.BoolLiteral

 import hu.bme.mit.inf.dslreasoner.logic.model.logiclanguage.DefinedElement

+import hu.bme.mit.inf.dslreasoner.logic.model.logiclanguage.IntLiteral

 import hu.bme.mit.inf.dslreasoner.logic.model.logiclanguage.LogiclanguageFactory

+import hu.bme.mit.inf.dslreasoner.logic.model.logiclanguage.RealLiteral

 import hu.bme.mit.inf.dslreasoner.logic.model.logiclanguage.RelationDeclaration

+import hu.bme.mit.inf.dslreasoner.logic.model.logiclanguage.RelationDefinition

+import hu.bme.mit.inf.dslreasoner.logic.model.logiclanguage.StringLiteral

+import hu.bme.mit.inf.dslreasoner.logic.model.logiclanguage.SymbolicValue

 import hu.bme.mit.inf.dslreasoner.logic.model.logiclanguage.Type

 import hu.bme.mit.inf.dslreasoner.logic.model.logiclanguage.TypeDeclaration

 import hu.bme.mit.inf.dslreasoner.logic.model.logiclanguage.TypeDefinition

 import hu.bme.mit.inf.dslreasoner.logic.model.logicproblem.LogicProblem

 import hu.bme.mit.inf.dslreasoner.logic.model.patterns.SupertypeStar

 import hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage.partial2logicannotations.PartialModelRelation2Assertion

-import hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage.partialinterpretation.BinaryElementRelationLink

 import hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage.partialinterpretation.BooleanElement

 import hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage.partialinterpretation.IntegerElement

-import hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage.partialinterpretation.NaryRelationLink

 import hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage.partialinterpretation.PartialBooleanInterpretation

 import hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage.partialinterpretation.PartialComplexTypeInterpretation

 import hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage.partialinterpretation.PartialIntegerInterpretation

@@ -22,10 +27,10 @@ import hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage.par
 import hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage.partialinterpretation.PartialRealInterpretation

 import hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage.partialinterpretation.PartialRelationInterpretation

 import hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage.partialinterpretation.PartialStringInterpretation

+import hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage.partialinterpretation.PartialTypeInterpratation

 import hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage.partialinterpretation.PartialinterpretationFactory

 import hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage.partialinterpretation.RealElement

 import hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage.partialinterpretation.StringElement

-import hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage.partialinterpretation.UnaryElementRelationLink

 import java.math.BigDecimal

 import java.util.HashMap

 import java.util.Map

@@ -35,14 +40,6 @@ import org.eclipse.viatra.query.runtime.emf.EMFScope
 import org.eclipse.xtend.lib.annotations.Data

 

 import static extension hu.bme.mit.inf.dslreasoner.util.CollectionsUtil.*

-import hu.bme.mit.inf.dslreasoner.logic.model.logiclanguage.SymbolicValue

-import hu.bme.mit.inf.dslreasoner.logic.model.logiclanguage.And

-import hu.bme.mit.inf.dslreasoner.logic.model.logiclanguage.BoolLiteral

-import hu.bme.mit.inf.dslreasoner.logic.model.logiclanguage.IntLiteral

-import hu.bme.mit.inf.dslreasoner.logic.model.logiclanguage.RealLiteral

-import hu.bme.mit.inf.dslreasoner.logic.model.logiclanguage.StringLiteral

-import hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage.partialinterpretation.PartialTypeInterpratation

-import hu.bme.mit.inf.dslreasoner.logic.model.logiclanguage.RelationDefinition

 

 @Data class Problem2PartialInterpretationTrace {

         Map<TypeDeclaration, PartialComplexTypeInterpretation> type2Interpretation

@@ -194,7 +191,7 @@ class PartialInterpretationInitialiser {
                 interpretation.minNewElements = minNewElements

                 interpretation.maxNewElements = maxNewElements

                 // elements from problem are included

-                if(maxNewElements>0) {

+                if(maxNewElements != 0) {

                         val newElements = createDefinedElement => [it.name = "New Objects"]

                         interpretation.openWorldElements += newElements 

                 }

@@ -213,12 +210,8 @@ class PartialInterpretationInitialiser {
         def private initialiseTypeScope(PartialTypeInterpratation interpretation, Integer min, Integer max) {

                 val res = createScope

                 res.targetTypeInterpretation = interpretation

-                if(min !== null) {

-                        res.minNewElements = min

-                }

-                if(max !== null) {

-                        res.maxNewElements = max

-                }

+                res.minNewElements = min ?: 0

+                res.maxNewElements = max ?: -1

                 return res

         }

         

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 e4bdb086..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
@@ -7,7 +7,7 @@ import org.eclipse.xtend.lib.annotations.Data
 import org.eclipse.xtend2.lib.StringConcatenationClient

 

 @Data abstract class AbstractNodeDescriptor {

-        long dataHash

+        int dataHash

 

         protected def StringConcatenationClient prettyPrint() {

                 '''(«dataHash»)[«class.simpleName»]'''

@@ -57,7 +57,7 @@ import org.eclipse.xtend2.lib.StringConcatenationClient
         }

 

         override hashCode() {

-                return this.dataHash.hashCode

+                return this.dataHash

         }

 

         override equals(Object other) {

@@ -119,7 +119,6 @@ import org.eclipse.xtend2.lib.StringConcatenationClient
 }

 

 @Data class FurtherNodeDescriptor<NodeRep> extends AbstractNodeDescriptor {

-

         NodeRep previousRepresentation

         Map<IncomingRelation<NodeRep>, Integer> incomingEdges

         Map<OutgoingRelation<NodeRep>, Integer> outgoingEdges

@@ -128,8 +127,8 @@ import org.eclipse.xtend2.lib.StringConcatenationClient
                 Map<OutgoingRelation<NodeRep>, Integer> outgoingEdges) {

                 super(calculateDataHash(previousRepresentation, incomingEdges, outgoingEdges))

                 this.previousRepresentation = previousRepresentation

-                this.incomingEdges = new HashMap(incomingEdges)

-                this.outgoingEdges = new HashMap(outgoingEdges)

+                this.incomingEdges = incomingEdges

+                this.outgoingEdges = outgoingEdges

         }

 

         static def private <NodeRep> int calculateDataHash(NodeRep previousRepresentation,

@@ -137,14 +136,14 @@ import org.eclipse.xtend2.lib.StringConcatenationClient
                 val int prime = 31;

                 var int result = previousRepresentation.hashCode;

                 if (incomingEdges !== null)

-                        result = prime * result + incomingEdges.hashCode();

+                        result = prime * result + hashIncomingNeighborhood(incomingEdges)

                 if (outgoingEdges !== null)

-                        result = prime * result + outgoingEdges.hashCode();

+                        result = prime * result + hashOutgoingNeighborhood(outgoingEdges)

                 return result;

         }

 

         override hashCode() {

-                return this.dataHash.hashCode

+                return this.dataHash

         }

 

         override equals(Object other) {

@@ -179,80 +178,31 @@ import org.eclipse.xtend2.lib.StringConcatenationClient
                         '''«rep»'''

                 }

         }

+        

+        private static def <NodeRep> hashIncomingNeighborhood(Map<IncomingRelation<NodeRep>, Integer> neighborhood) {

+                val int prime = 31

+                var int hash = 0

+                for (entry : neighborhood.entrySet) {

+                        val relation = entry.key

+                        hash += (prime * relation.from.hashCode + relation.type.hashCode).bitwiseXor(entry.value.hashCode)

+                }

+                hash

+        }

+        

+        private static def <NodeRep> hashOutgoingNeighborhood(Map<OutgoingRelation<NodeRep>, Integer> neighborhood) {

+                val int prime = 31

+                var int hash = 0

+                for (entry : neighborhood.entrySet) {

+                        val relation = entry.key

+                        hash += (prime * relation.to.hashCode + relation.type.hashCode).bitwiseXor(entry.value.hashCode)

+                }

+                hash

+        }

 

         override toString() {

                 '''

                         «prettyPrint»

                 '''

         }

-

-//      @Pure

-//      @Override

-//      override public boolean equals(Object obj) {

-//              if (this === obj)

-//                      return true;

-//              if (obj === null)

-//                      return false;

-//              if (getClass() != obj.getClass())

-//                      return false;

-//              val AbstractNodeDescriptor other = obj as AbstractNodeDescriptor;

-//              if (other.dataHash != this.dataHash)

-//                      return false;

-//              return true;

-//      }

-//      @Pure

-//      override public boolean equals(Object obj) {

-//              if (this === obj)

-//                      return true;

-//              if (obj === null)

-//                      return false;

-//              if (getClass() != obj.getClass())

-//                      return false;

-//              if (!super.equals(obj))

-//                      return false;

-//              val FurtherNodeDescriptor<?> other = obj as FurtherNodeDescriptor<?>;

-//              if (this.previousRepresentation === null) {

-//                      if (other.previousRepresentation != null)

-//                              return false;

-//                      

-//              }

-////            } else if (!this.previousRepresentation.equals(other.previousRepresentation))

-////                    return false;

-//              if (this.incomingEdges === null) {

-//                      if (other.incomingEdges != null)

-//                              return false;

-//              } else if (!this.incomingEdges.equals(other.incomingEdges))

-//                      return false;

-//              if (this.outgoingEdges === null) {

-//                      if (other.outgoingEdges != null)

-//                              return false;

-//              } else if (!this.outgoingEdges.equals(other.outgoingEdges))

-//                      return false;

-//              if (this.attributeValues === null) {

-//                      if (other.attributeValues != null)

-//                              return false;

-//              } else if (!this.attributeValues.equals(other.attributeValues))

-//                      return false;

-//              return true;

-//      }

 }

-/*

- * @Data

- * class ModelDescriptor {

- *      int dataHash

- *      int unknownElements

- *      Map<? extends AbstractNodeDescriptor,Integer> knownElements

- *      

- *      public new(Map<? extends AbstractNodeDescriptor,Integer> knownElements, int unknownElements) {

- *              this.dataHash = calculateDataHash(knownElements,unknownElements)

- *              this.unknownElements = unknownElements

- *              this.knownElements = knownElements

- *      }

- *      

- *      def private static calculateDataHash(Map<? extends AbstractNodeDescriptor,Integer> knownElements, int unknownElements)

- *      {

- *              val int prime = 31;

- *              return knownElements.hashCode * prime + unknownElements.hashCode 

- *      }

- * }

- */

+

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 ddf7d712..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,7 +1,8 @@
 package hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage.neighbourhood

 

-import java.util.Map

 import hu.bme.mit.inf.dslreasoner.logic.model.logiclanguage.DefinedElement

+import java.util.Map

+import org.eclipse.collections.api.factory.Maps

 

 class PartialInterpretation2Hash extends PartialInterpretation2NeighbourhoodRepresentation<Integer, Integer>{

         

@@ -11,15 +12,22 @@ class PartialInterpretation2Hash extends PartialInterpretation2NeighbourhoodRepr
         

         override protected createLocalRepresentation(Map<DefinedElement, LocalNodeDescriptor> node2Representation, Map<LocalNodeDescriptor, Integer> representation2Amount) {

                 return new NeighbourhoodWithTraces(

-                        representation2Amount.hashCode,node2Representation.mapValues[it.hashCode],

+                        representation2Amount.hashCode,node2Representation.hashValues,

                         null)

         }

         

         override protected createFurtherRepresentation(Map<FurtherNodeDescriptor<Integer>, Integer> nodeDescriptors, Map<DefinedElement, FurtherNodeDescriptor<Integer>> node2Representation, NeighbourhoodWithTraces<Integer, Integer> previous, boolean deepRepresentation) {

                 return new NeighbourhoodWithTraces(

                         nodeDescriptors.hashCode,

-                        node2Representation.mapValues[it.hashCode],

+                        node2Representation.hashValues,

                         if(deepRepresentation) {previous} else {null})

         }

         

+        private def <T> hashValues(Map<DefinedElement, T> map) {

+                val hashedMap = Maps.mutable.ofInitialCapacity(map.size)

+                for (entry : map.entrySet) {

+                        hashedMap.put(entry.key, entry.value.hashCode)

+                }

+                hashedMap

+        }

 }

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 3048167e..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
@@ -8,11 +8,11 @@ import hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage.par
 import hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage.partialinterpretation.PartialInterpretation

 import hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage.partialinterpretation.PartialPrimitiveInterpretation

 import java.util.ArrayList

-import java.util.HashMap

-import java.util.HashSet

 import java.util.List

 import java.util.Map

 import java.util.Set

+import org.eclipse.collections.api.factory.Maps

+import org.eclipse.collections.impl.factory.Sets

 

 import static extension hu.bme.mit.inf.dslreasoner.util.CollectionsUtil.*

 

@@ -68,10 +68,11 @@ abstract class PartialInterpretation2NeighbourhoodRepresentation<ModelRepresenta
 

         def createRepresentationWithFocus(PartialInterpretation model, int range, int parallels, int maxNumber,

                 Set<TypeDeclaration> relevantTypes, Set<RelationDeclaration> relevantRelations, DefinedElement focusedElement) {

-                val Map<DefinedElement, Set<String>> types = new HashMap

+                val initialSize = model.elements.size

+                val Map<DefinedElement, Set<String>> types = Maps.mutable.ofInitialCapacity(initialSize)

                 fillTypes(model, types, relevantTypes)

-                val Map<DefinedElement, List<IncomingRelation<DefinedElement>>> IncomingRelations = new HashMap;

-                val Map<DefinedElement, List<OutgoingRelation<DefinedElement>>> OutgoingRelations = new HashMap;

+                val Map<DefinedElement, List<IncomingRelation<DefinedElement>>> IncomingRelations = Maps.mutable.ofInitialCapacity(initialSize);

+                val Map<DefinedElement, List<OutgoingRelation<DefinedElement>>> OutgoingRelations = Maps.mutable.ofInitialCapacity(initialSize);

                 fillReferences(model, IncomingRelations, OutgoingRelations, relevantRelations)

 

                 val res = doRecursiveNeighbourCalculation(model, types, IncomingRelations, OutgoingRelations, range, parallels,

@@ -103,12 +104,12 @@ abstract class PartialInterpretation2NeighbourhoodRepresentation<ModelRepresenta
                 Map<DefinedElement, List<IncomingRelation<DefinedElement>>> IncomingRelations,

                 Map<DefinedElement, List<OutgoingRelation<DefinedElement>>> OutgoingRelations) {

                 val elements = types.keySet

-                var Map<DefinedElement, Set<DefinedElement>> reachable = new HashMap

-                var Map<DefinedElement, Set<DefinedElement>> newReachable = new HashMap

+                var Map<DefinedElement, Set<DefinedElement>> reachable = Maps.mutable.ofInitialCapacity(elements.size)

+                var Map<DefinedElement, Set<DefinedElement>> newReachable = Maps.mutable.ofInitialCapacity(elements.size)

                 for (element : elements) {

-                        val set = new HashSet

+                        val set = Sets.mutable.of

                         set.add(element)

-                        reachable.put(element, new HashSet)

+                        reachable.put(element, Sets.mutable.of)

                         newReachable.put(element, set)

                 }

 

@@ -201,8 +202,8 @@ abstract class PartialInterpretation2NeighbourhoodRepresentation<ModelRepresenta
                         val nextRepresentation = createFurtherRepresentation(next.key, next.value, lastRepresentation,

                                 deepRepresentation)

 

-                        val previousNumberOfTypes = lastRepresentation.nodeRepresentations.values.toSet.size

-                        val nextNumberOfTypes = nextRepresentation.nodeRepresentations.values.toSet.size

+                        val previousNumberOfTypes = Sets.immutable.withAll(lastRepresentation.nodeRepresentations.values).size

+                        val nextNumberOfTypes = Sets.immutable.withAll(nextRepresentation.nodeRepresentations.values).size

                         hasRefined = nextNumberOfTypes > previousNumberOfTypes

 

                         lastRange = nextRange

@@ -224,7 +225,7 @@ abstract class PartialInterpretation2NeighbourhoodRepresentation<ModelRepresenta
         def private fillTypes(PartialInterpretation model, Map<DefinedElement, Set<String>> node2Type,

                 Set<TypeDeclaration> relevantTypes) {

                 for (element : model.elements) {

-                        node2Type.put(element, new HashSet)

+                        node2Type.put(element, Sets.mutable.of)

                 }

 

 //              for(typeDefinition : model.problem.types.filter(TypeDefinition)) {

@@ -286,7 +287,11 @@ abstract class PartialInterpretation2NeighbourhoodRepresentation<ModelRepresenta
                 boolean deepRepresentation

         )

 

-        def private addOne(int original, int max) {

+        def private addOne(Integer originalObj, int max) {

+                if (originalObj === null) {

+                        return 1

+                }

+                val original = originalObj.intValue

                 if(original == Integer.MAX_VALUE) return Integer.MAX_VALUE

                 if(original + 1 > max) return Integer.MAX_VALUE else return original + 1

         }

@@ -294,15 +299,11 @@ abstract class PartialInterpretation2NeighbourhoodRepresentation<ModelRepresenta
         private def calculateIncomingEdges(Map<DefinedElement, List<IncomingRelation<DefinedElement>>> IncomingRelations,

                 DefinedElement object, Map<DefinedElement, ? extends NodeRepresentation> previousNodeRepresentations,

                 int parallel) {

-                val Map<IncomingRelation<NodeRepresentation>, Integer> res = new HashMap

+                val Map<IncomingRelation<NodeRepresentation>, Integer> res = Maps.mutable.of

                 for (incomingConcreteEdge : IncomingRelations.get(object)) {

                         val IncomingRelation<NodeRepresentation> e = new IncomingRelation(

                                 previousNodeRepresentations.get(incomingConcreteEdge.from), incomingConcreteEdge.type)

-                        if (res.containsKey(e)) {

-                                res.put(e, addOne(res.get(e), parallel))

-                        } else {

-                                res.put(e, 1)

-                        }

+                        res.compute(e, [key, value | addOne(value, parallel)])

                 }

                 return res

         }

@@ -310,17 +311,13 @@ abstract class PartialInterpretation2NeighbourhoodRepresentation<ModelRepresenta
         private def calcuateOutgoingEdges(Map<DefinedElement, List<OutgoingRelation<DefinedElement>>> OutgoingRelations,

                 DefinedElement object, Map<DefinedElement, ? extends NodeRepresentation> previousNodeRepresentations,

                 int parallel) {

-                val Map<OutgoingRelation<NodeRepresentation>, Integer> res = new HashMap

+                val Map<OutgoingRelation<NodeRepresentation>, Integer> res = Maps.mutable.of

                 for (outgoingConcreteEdge : OutgoingRelations.get(object)) {

                         val OutgoingRelation<NodeRepresentation> e = new OutgoingRelation(

                                 previousNodeRepresentations.get(outgoingConcreteEdge.to), outgoingConcreteEdge.type)

-                        if (res.containsKey(e)) {

-                                res.put(e, addOne(res.get(e), parallel))

-                        } else {

-                                res.put(e, 1)

-                        }

+                        res.compute(e, [key, value | addOne(value, parallel)])

                 }

-                return res;

+                return res

         }

 

         /*def private <KEY,VALUE> void addOrCreate_Set(Map<KEY,Set<VALUE>> map, KEY key, VALUE value) {

@@ -338,16 +335,17 @@ abstract class PartialInterpretation2NeighbourhoodRepresentation<ModelRepresenta
                 Map<DefinedElement, List<IncomingRelation<DefinedElement>>> IncomingRelations,

                 Map<DefinedElement, List<OutgoingRelation<DefinedElement>>> OutgoingRelations, int parallels, int maxNumber) {

                 val previousNodeRepresentations = previous.nodeRepresentations

-                val node2Representation = new HashMap<DefinedElement, FurtherNodeDescriptor<NodeRepresentation>>

+                val size = previousNodeRepresentations.size

+                val node2Representation = Maps.mutable.<DefinedElement, FurtherNodeDescriptor<NodeRepresentation>>ofInitialCapacity(size)

                 val Map<FurtherNodeDescriptor<NodeRepresentation>, Integer> descriptor2Number = if (this.

                                 mergeSimilarNeighbourhood) {

-                                new HashMap

+                                Maps.mutable.ofInitialCapacity(size)

                         } else {

                                 null

                         }

                 val Map<FurtherNodeDescriptor<NodeRepresentation>, FurtherNodeDescriptor<NodeRepresentation>> uniqueDescription = if (this.

                                 mergeSimilarNeighbourhood) {

-                                new HashMap

+                                Maps.mutable.ofInitialCapacity(size)

                         } else {

                                 null

                         }

@@ -392,14 +390,15 @@ abstract class PartialInterpretation2NeighbourhoodRepresentation<ModelRepresenta
 

         private def calculateLocalNodeDescriptors(PartialInterpretation model, Map<DefinedElement, Set<String>> types,

                 int maxNumber, DefinedElement focusedElement) {

-                val Map<DefinedElement, LocalNodeDescriptor> node2Representation = new HashMap

+                val size = types.size

+                val Map<DefinedElement, LocalNodeDescriptor> node2Representation = Maps.mutable.ofInitialCapacity(size)

                 val Map<LocalNodeDescriptor, Integer> representation2Amount = if (mergeSimilarNeighbourhood) {

-                                new HashMap

+                                Maps.mutable.ofInitialCapacity(size)

                         } else {

                                 null

                         }

                 val Map<LocalNodeDescriptor, LocalNodeDescriptor> uniqueRepresentation = if (this.mergeSimilarNeighbourhood) {

-                                new HashMap

+                                Maps.mutable.ofInitialCapacity(size)

                         } else {

                                 null

                         }

diff --git a/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage/src/hu/bme/mit/inf/dslreasoner/viatrasolver/partialinterpretationlanguage/statecoder/NeighbourhoodBasedStateCoderFactory.xtend b/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage/src/hu/bme/mit/inf/dslreasoner/viatrasolver/partialinterpretationlanguage/statecoder/NeighbourhoodBasedStateCoderFactory.xtend
index f19ac30f..04c49506 100644
--- a/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage/src/hu/bme/mit/inf/dslreasoner/viatrasolver/partialinterpretationlanguage/statecoder/NeighbourhoodBasedStateCoderFactory.xtend
+++ b/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage/src/hu/bme/mit/inf/dslreasoner/viatrasolver/partialinterpretationlanguage/statecoder/NeighbourhoodBasedStateCoderFactory.xtend
@@ -9,6 +9,7 @@ import hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage.par
 import java.util.ArrayList
 import java.util.Map
 import org.eclipse.viatra.query.runtime.api.IPatternMatch
+import org.eclipse.viatra.query.runtime.api.IQuerySpecification
 
 class NeighbourhoodBasedStateCoderFactory extends AbstractNeighbourhoodBasedStateCoderFactory {
         new() {
@@ -38,6 +39,7 @@ class NeighbourhoodBasedHashStateCoderFactory extends AbstractNeighbourhoodBased
 
 class NeighbourhoodBasedPartialInterpretationStateCoder<ModelRep, NodeRep> extends AbstractNeighbourhoodBasedPartialInterpretationStateCoder {
         val PartialInterpretation2NeighbourhoodRepresentation<ModelRep, NodeRep> calculator
+        val Map<IQuerySpecification<?>, String> fullyQualifiedNames = newHashMap
         var Map<DefinedElement, ? extends NodeRep> nodeRepresentations = null
         var ModelRep modelRepresentation = null
 
@@ -55,27 +57,36 @@ class NeighbourhoodBasedPartialInterpretationStateCoder<ModelRep, NodeRep> exten
                 modelRepresentation = code.modelRepresentation
                 nodeRepresentations = code.nodeRepresentations
         }
+        
+        private def getFullyQualifiedNameCached(IQuerySpecification<?> specification) {
+                fullyQualifiedNames.computeIfAbsent(specification, [fullyQualifiedName])
+        }
 
         override doCreateActivationCode(IPatternMatch match) {
                 val size = match.specification.parameters.size
-                val res = new ArrayList(size)
-                var int equivalenceHash = 0
+                var int hash = 0
                 val prime = 31
 
                 for (var int index = 0; index < size; index++) {
                         val matchArgument = match.get(index)
-                        res.add(getCode(matchArgument))
+                        val code = getCode(matchArgument)
+                        val codeNumber = if (code === null) {
+                                0
+                        } else {
+                                code.hashCode
+                        }
+                        hash = prime * hash + codeNumber
                         for (var i = 0; i < index; i++) {
                                 val number = if (matchArgument === match.get(i)) {
                                                 1
                                         } else {
                                                 0
                                         }
-                                equivalenceHash = prime * equivalenceHash + number
+                                hash = prime * hash + number
                         }
                 }
 
-                match.specification.fullyQualifiedName -> (res -> equivalenceHash).hashCode
+                match.specification.fullyQualifiedNameCached -> hash
         }
 
         def private getCode(Object o) {