From 60f01f46ba232ed6416054f0a6115cb2a9b70b4e Mon Sep 17 00:00:00 2001 From: OszkarSemerath Date: Sat, 10 Jun 2017 19:05:05 +0200 Subject: Migrating Additional projects --- .../PartialInterpretationInitialiser.xtend | 112 +++++++ .../neighbourhood/Descriptor.xtend | 214 +++++++++++++ ...rtherNodeDescriptorWithEquivalenceCounter.xtend | 16 + .../neighbourhood/NeighbourhoodWithTraces.xtend | 11 + .../neighbourhood/PartialInterpretation2Hash.xtend | 25 ++ ...artialInterpretation2ImmutableTypeLattice.xtend | 24 ++ ...mmutableTypeLatticeWithEquivalenceCounter.xtend | 56 ++++ ...nterpretation2NeighbourhoodRepresentation.xtend | 345 +++++++++++++++++++++ .../IdentifierBasedStateCoderFactory.xtend | 129 ++++++++ .../NeighbourhoodBasedStateCoderFactory.xtend | 206 ++++++++++++ .../visualisation/PartialInterpretation2Gml.xtend | 136 ++++++++ 11 files changed, 1274 insertions(+) create mode 100644 Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage/src/hu/bme/mit/inf/dslreasoner/viatrasolver/partialinterpretationlanguage/PartialInterpretationInitialiser.xtend create mode 100644 Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage/src/hu/bme/mit/inf/dslreasoner/viatrasolver/partialinterpretationlanguage/neighbourhood/Descriptor.xtend create mode 100644 Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage/src/hu/bme/mit/inf/dslreasoner/viatrasolver/partialinterpretationlanguage/neighbourhood/FurtherNodeDescriptorWithEquivalenceCounter.xtend create mode 100644 Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage/src/hu/bme/mit/inf/dslreasoner/viatrasolver/partialinterpretationlanguage/neighbourhood/NeighbourhoodWithTraces.xtend create mode 100644 Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage/src/hu/bme/mit/inf/dslreasoner/viatrasolver/partialinterpretationlanguage/neighbourhood/PartialInterpretation2Hash.xtend create mode 100644 Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage/src/hu/bme/mit/inf/dslreasoner/viatrasolver/partialinterpretationlanguage/neighbourhood/PartialInterpretation2ImmutableTypeLattice.xtend create mode 100644 Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage/src/hu/bme/mit/inf/dslreasoner/viatrasolver/partialinterpretationlanguage/neighbourhood/PartialInterpretation2ImmutableTypeLatticeWithEquivalenceCounter.xtend create mode 100644 Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage/src/hu/bme/mit/inf/dslreasoner/viatrasolver/partialinterpretationlanguage/neighbourhood/PartialInterpretation2NeighbourhoodRepresentation.xtend create mode 100644 Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage/src/hu/bme/mit/inf/dslreasoner/viatrasolver/partialinterpretationlanguage/statecoder/IdentifierBasedStateCoderFactory.xtend create mode 100644 Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage/src/hu/bme/mit/inf/dslreasoner/viatrasolver/partialinterpretationlanguage/statecoder/NeighbourhoodBasedStateCoderFactory.xtend create mode 100644 Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage/src/hu/bme/mit/inf/dslreasoner/viatrasolver/partialinterpretationlanguage/visualisation/PartialInterpretation2Gml.xtend (limited to 'Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage/src/hu/bme/mit/inf/dslreasoner') 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 new file mode 100644 index 00000000..eeccbf76 --- /dev/null +++ b/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage/src/hu/bme/mit/inf/dslreasoner/viatrasolver/partialinterpretationlanguage/PartialInterpretationInitialiser.xtend @@ -0,0 +1,112 @@ +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.logiclanguage.ConstantDeclaration +import hu.bme.mit.inf.dslreasoner.logic.model.logiclanguage.FunctionDeclaration +import hu.bme.mit.inf.dslreasoner.logic.model.logiclanguage.LogiclanguageFactory +import hu.bme.mit.inf.dslreasoner.logic.model.logiclanguage.RelationDeclaration +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.SupertypeStarMatcher +import hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage.partialinterpretation.PartialConstantInterpretation +import hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage.partialinterpretation.PartialFunctionInterpretation +import hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage.partialinterpretation.PartialInterpretation +import hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage.partialinterpretation.PartialRelationInterpretation +import hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage.partialinterpretation.PartialTypeInterpratation +import hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage.partialinterpretation.PartialinterpretationFactory +import java.util.HashMap +import java.util.Map +import org.eclipse.viatra.query.runtime.api.ViatraQueryEngine +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.* + +@Data class Problem2PartialInterpretationTrace { + Map type2Interpretation = new HashMap + Map relation2Interpretation = new HashMap +} + +class PartialInterpretationInitialiser { + val extension PartialinterpretationFactory factory = PartialinterpretationFactory.eINSTANCE + val extension LogiclanguageFactory factory2 = LogiclanguageFactory.eINSTANCE + + /** + * Initialises an empty partial interpretation from a logic problem + */ + def TracedOutput initialisePartialInterpretation( + LogicProblem problem, + int minNewElement, int maxNewElement) + { + val engine = ViatraQueryEngine.on(new EMFScope(problem)) + val trace = new Problem2PartialInterpretationTrace + + val res = createPartialInterpretation => [ + it.problem = problem + it.openWorldElementPrototype = createDefinedElement => [it.name = "Symbolic New Element"] + it.minNewElements = minNewElement + it.maxNewElements = maxNewElement + + for(typeDeclaration : problem.types.filter(TypeDeclaration)) { + it.partialtypeinterpratation += typeDeclaration.initialisePartialTypeInterpretation(engine,trace) + } + problem.connectSuperypes(trace) + + it.partialrelationinterpretation += problem.relations.filter(RelationDeclaration) + .map[initialisePartialRelationInterpretation(trace)] + it.partialfunctioninterpretation += problem.functions.filter(FunctionDeclaration) + .map[initialisePartialFunctionInterpretation(trace)] + it.partialconstantinterpretation += problem.constants.filter(ConstantDeclaration) + .map[initialisePartialConstantDeclaration(trace)] + ] + + return new TracedOutput(res,trace) + } + + /** + * Initialize type with existing elements + */ + def private initialisePartialTypeInterpretation(TypeDeclaration t, ViatraQueryEngine engine, Problem2PartialInterpretationTrace trace) { + val supertypeMatcher = SupertypeStarMatcher.on(engine) + val res = createPartialTypeInterpratation => [ + it.interpretationOf = t + it.elements += supertypeMatcher.getAllValuesOfsubtype(t) + .filter(TypeDefinition) + .map[elements].flatten + ] + trace.type2Interpretation.put(t,res) + return res + } + + def private connectSuperypes(LogicProblem problem, Problem2PartialInterpretationTrace trace) { + for(typeDeclaration : problem.types.filter(TypeDeclaration)) { + val supertypes = typeDeclaration.transitiveClosurePlus[it.supertypes] + for(supertype : supertypes.filter(TypeDeclaration)) { + typeDeclaration.lookup(trace.type2Interpretation).supertypeInterpretation += supertype.lookup(trace.type2Interpretation) + //println('''«typeDeclaration.name» --> «supertype.name»''') + } + } + } + + def private initialisePartialRelationInterpretation(RelationDeclaration r, Problem2PartialInterpretationTrace trace) { + val res = createPartialRelationInterpretation => [ + it.interpretationOf = r + if(r.parameters.size==2) { + it.param1 = r.parameters.get(0) + it.param2 = r.parameters.get(1) + } else throw new UnsupportedOperationException + ] + trace.relation2Interpretation.put(r,res) + return res + } + + def private PartialConstantInterpretation initialisePartialConstantDeclaration(ConstantDeclaration c, Problem2PartialInterpretationTrace trace) { + throw new UnsupportedOperationException + } + + def private PartialFunctionInterpretation initialisePartialFunctionInterpretation(FunctionDeclaration f, Problem2PartialInterpretationTrace trace) { + throw new UnsupportedOperationException + } +} \ No newline at end of file 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 new file mode 100644 index 00000000..41482b28 --- /dev/null +++ b/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage/src/hu/bme/mit/inf/dslreasoner/viatrasolver/partialinterpretationlanguage/neighbourhood/Descriptor.xtend @@ -0,0 +1,214 @@ +package hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage.neighbourhood + +import java.util.HashMap +import java.util.Map +import java.util.Set +import org.eclipse.xtend.lib.annotations.Data + +@Data abstract class AbstractNodeDescriptor { + long dataHash + +// @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; +// } +} + +@Data class LocalNodeDescriptor extends AbstractNodeDescriptor{ + Set types + String id; + new(String id, Set types) { + super(calcualteDataHash(id,types)) + this.types = types + this.id = id + } + + def private static calcualteDataHash(String id, Set types) { + val int prime = 31; + var result = 0 + if(id !== null) + result = id.hashCode(); + if(types !== null) { + result = prime * result + types.hashCode + } + return result + } + + override hashCode() { + return this.dataHash.hashCode + } + + override toString() { + return class.name + this.dataHash + } + +// @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 LocalNodeDescriptor other = obj as LocalNodeDescriptor; +// if (this.clazz === null) { +// if (other.clazz != null) +// return false; +// } else if (!this.clazz.equals(other.clazz)) +// return false; +// return true; +// } +} + +@Data class IncomingRelation { + FROM from + String type +} + +@Data class OutgoingRelation { + TO to + String type +} + +@Data class FurtherNodeDescriptor extends AbstractNodeDescriptor{ + + NodeRep previousRepresentation + Map,Integer> incomingEdges + Map,Integer> outgoingEdges + + new( + NodeRep previousRepresentation, + Map,Integer> incomingEdges, + Map,Integer> outgoingEdges) + { + super(calculateDataHash(previousRepresentation,incomingEdges,outgoingEdges)) + this.previousRepresentation = previousRepresentation + this.incomingEdges = new HashMap(incomingEdges) + this.outgoingEdges = new HashMap(outgoingEdges) + } + + static def private int calculateDataHash( + NodeRep previousRepresentation, + Map,Integer> incomingEdges, + Map,Integer> outgoingEdges) + { + val int prime = 31; + var int result = previousRepresentation.hashCode; + if(incomingEdges !== null) + result = prime * result + incomingEdges.hashCode(); + if(outgoingEdges !== null) + result = prime * result + outgoingEdges.hashCode(); + return result; + } + + override hashCode() { + return this.dataHash.hashCode + } + + override toString() { + return class.name + dataHash +// return '''[«previousRepresentation»,(«FOR +// in: incomingEdges.entrySet»(«in.key.type.name»=«in.key.from»,«in.value»)«ENDFOR»),(«FOR +// out: outgoingEdges.entrySet»(«out.key.type.name»=«out.key.to»,«out.value»)«ENDFOR»),«FOR +// att: attributeValues»(«att.type.name»=«att.value»)«ENDFOR»]''' + } + +// @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 knownElements + + public new(Map knownElements, int unknownElements) { + this.dataHash = calculateDataHash(knownElements,unknownElements) + this.unknownElements = unknownElements + this.knownElements = knownElements + } + + def private static calculateDataHash(Map knownElements, int unknownElements) + { + val int prime = 31; + return knownElements.hashCode * prime + unknownElements.hashCode + } +} +*/ \ No newline at end of file diff --git a/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage/src/hu/bme/mit/inf/dslreasoner/viatrasolver/partialinterpretationlanguage/neighbourhood/FurtherNodeDescriptorWithEquivalenceCounter.xtend b/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage/src/hu/bme/mit/inf/dslreasoner/viatrasolver/partialinterpretationlanguage/neighbourhood/FurtherNodeDescriptorWithEquivalenceCounter.xtend new file mode 100644 index 00000000..22e890a2 --- /dev/null +++ b/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage/src/hu/bme/mit/inf/dslreasoner/viatrasolver/partialinterpretationlanguage/neighbourhood/FurtherNodeDescriptorWithEquivalenceCounter.xtend @@ -0,0 +1,16 @@ +package hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage.neighbourhood + +import java.util.Map +import hu.bme.mit.inf.dslreasoner.logic.model.logiclanguage.DefinedElement + +class FurtherNodeDescriptorWithEquivalenceCounter extends FurtherNodeDescriptor { + + new(AbstractNodeDescriptor previousRepresentation, + Map, Integer> incomingEdges, + Map, Integer> outgoingEdges, + Map> node2Representation) + { + super(previousRepresentation, incomingEdges, outgoingEdges) + } + +} \ No newline at end of file diff --git a/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage/src/hu/bme/mit/inf/dslreasoner/viatrasolver/partialinterpretationlanguage/neighbourhood/NeighbourhoodWithTraces.xtend b/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage/src/hu/bme/mit/inf/dslreasoner/viatrasolver/partialinterpretationlanguage/neighbourhood/NeighbourhoodWithTraces.xtend new file mode 100644 index 00000000..76cc4ae1 --- /dev/null +++ b/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage/src/hu/bme/mit/inf/dslreasoner/viatrasolver/partialinterpretationlanguage/neighbourhood/NeighbourhoodWithTraces.xtend @@ -0,0 +1,11 @@ +package hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage.neighbourhood + +import hu.bme.mit.inf.dslreasoner.logic.model.logiclanguage.DefinedElement +import java.util.Map +import org.eclipse.xtend.lib.annotations.Data + +@Data class NeighbourhoodWithTraces { + ModelRep modelRepresentation + Map nodeRepresentations + NeighbourhoodWithTraces previousRepresentation +} 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 new file mode 100644 index 00000000..d474877d --- /dev/null +++ b/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage/src/hu/bme/mit/inf/dslreasoner/viatrasolver/partialinterpretationlanguage/neighbourhood/PartialInterpretation2Hash.xtend @@ -0,0 +1,25 @@ +package hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage.neighbourhood + +import java.util.Map +import hu.bme.mit.inf.dslreasoner.logic.model.logiclanguage.DefinedElement + +class PartialInterpretation2Hash extends PartialInterpretation2NeighbourhoodRepresentation{ + + protected new() { + super(false, true) + } + + override protected createLocalRepresentation(Map node2Representation, Map representation2Amount) { + return new NeighbourhoodWithTraces( + representation2Amount.hashCode,node2Representation.mapValues[it.hashCode], + null) + } + + override protected createFurtherRepresentation(Map, Integer> nodeDescriptors, Map> node2Representation, NeighbourhoodWithTraces previous, boolean deepRepresentation) { + return new NeighbourhoodWithTraces( + nodeDescriptors.hashCode, + node2Representation.mapValues[it.hashCode], + if(deepRepresentation) {previous} else {null}) + } + +} diff --git a/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage/src/hu/bme/mit/inf/dslreasoner/viatrasolver/partialinterpretationlanguage/neighbourhood/PartialInterpretation2ImmutableTypeLattice.xtend b/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage/src/hu/bme/mit/inf/dslreasoner/viatrasolver/partialinterpretationlanguage/neighbourhood/PartialInterpretation2ImmutableTypeLattice.xtend new file mode 100644 index 00000000..31181370 --- /dev/null +++ b/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage/src/hu/bme/mit/inf/dslreasoner/viatrasolver/partialinterpretationlanguage/neighbourhood/PartialInterpretation2ImmutableTypeLattice.xtend @@ -0,0 +1,24 @@ +package hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage.neighbourhood + +import hu.bme.mit.inf.dslreasoner.logic.model.logiclanguage.DefinedElement +import java.util.Map + +class PartialInterpretation2ImmutableTypeLattice extends + PartialInterpretation2NeighbourhoodRepresentation, AbstractNodeDescriptor>{ + + public new() { + super(false, true) + } + + override protected createLocalRepresentation(Map node2Representation, Map representation2Amount) { + return new NeighbourhoodWithTraces(node2Representation.immutableCopy,node2Representation.immutableCopy,null) + } + + override protected createFurtherRepresentation(Map, Integer> nodeDescriptors, Map> node2Representation, NeighbourhoodWithTraces, AbstractNodeDescriptor> previous, boolean deepRepresentation) { + if(deepRepresentation) { + return new NeighbourhoodWithTraces, AbstractNodeDescriptor>(nodeDescriptors,node2Representation,previous) + } else { + return new NeighbourhoodWithTraces, AbstractNodeDescriptor>(nodeDescriptors,node2Representation,null) + } + } +} diff --git a/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage/src/hu/bme/mit/inf/dslreasoner/viatrasolver/partialinterpretationlanguage/neighbourhood/PartialInterpretation2ImmutableTypeLatticeWithEquivalenceCounter.xtend b/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage/src/hu/bme/mit/inf/dslreasoner/viatrasolver/partialinterpretationlanguage/neighbourhood/PartialInterpretation2ImmutableTypeLatticeWithEquivalenceCounter.xtend new file mode 100644 index 00000000..251a82f0 --- /dev/null +++ b/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage/src/hu/bme/mit/inf/dslreasoner/viatrasolver/partialinterpretationlanguage/neighbourhood/PartialInterpretation2ImmutableTypeLatticeWithEquivalenceCounter.xtend @@ -0,0 +1,56 @@ +package hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage.neighbourhood + +import hu.bme.mit.inf.dslreasoner.logic.model.logiclanguage.DefinedElement +import java.util.Map +import static extension hu.bme.mit.inf.dslreasoner.util.CollectionsUtil.* +import java.util.HashMap + +class PartialInterpretation2ImmutableTypeLatticeWithEquivalenceCounter extends + PartialInterpretation2NeighbourhoodRepresentation< + Map, // <- Model Descriptor + AbstractNodeDescriptor> // <- Node Descriptor + { + + protected new() { + super(true,false) + } + + override protected createLocalRepresentation(Map node2Representation, Map representation2Amount) { + return new NeighbourhoodWithTraces(node2Representation.immutableCopy,node2Representation.immutableCopy,null) + } + + override protected createFurtherRepresentation( + Map, Integer> nodeDescriptors, + Map> node2Representation, + NeighbourhoodWithTraces, AbstractNodeDescriptor> previous, + boolean deepRepresentation + ) { + if(deepRepresentation) { + return new NeighbourhoodWithTraces, AbstractNodeDescriptor>(nodeDescriptors,node2Representation,previous) + } else { + return new NeighbourhoodWithTraces, AbstractNodeDescriptor>(nodeDescriptors,node2Representation,null) + } + } + + public def finalRepresentation(NeighbourhoodWithTraces,AbstractNodeDescriptor> representation) { + val node2Representation = representation.nodeRepresentations + val node2LocalRepresentation = new HashMap + //val localRepresentation2Node = new HashMap + for(entry: node2Representation.entrySet) { + val node = entry.key + val localNodeDescriptor = entry.value.toLocalDescriptor + node2LocalRepresentation.put(node,localNodeDescriptor) + } + + } + + public def LocalNodeDescriptor toLocalDescriptor(AbstractNodeDescriptor descriptor) { + if(descriptor instanceof LocalNodeDescriptor) { + return descriptor + } else if(descriptor instanceof FurtherNodeDescriptor) { + (descriptor.previousRepresentation as AbstractNodeDescriptor).toLocalDescriptor + } else throw new IllegalArgumentException('''Unsupported descriptor type: «descriptor.class.simpleName»''') + } + + +} 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 new file mode 100644 index 00000000..df6fb6ae --- /dev/null +++ b/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage/src/hu/bme/mit/inf/dslreasoner/viatrasolver/partialinterpretationlanguage/neighbourhood/PartialInterpretation2NeighbourhoodRepresentation.xtend @@ -0,0 +1,345 @@ +package hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage.neighbourhood + +import hu.bme.mit.inf.dslreasoner.logic.model.logiclanguage.DefinedElement +import hu.bme.mit.inf.dslreasoner.logic.model.logiclanguage.RelationDeclaration +import hu.bme.mit.inf.dslreasoner.logic.model.logiclanguage.TypeDeclaration +import hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage.partialinterpretation.BinaryElementRelationLink +import hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage.partialinterpretation.PartialInterpretation +import java.util.HashMap +import java.util.HashSet +import java.util.LinkedList +import java.util.List +import java.util.Map +import java.util.Set + +import static extension hu.bme.mit.inf.dslreasoner.util.CollectionsUtil.* + +abstract class PartialInterpretation2NeighbourhoodRepresentation { + private val boolean deepRepresentation + private val boolean mergeSimilarNeighbourhood + + protected new(boolean deeprepresentation, boolean mergeSimilarNeighbourhood) { + this.deepRepresentation = deeprepresentation + this.mergeSimilarNeighbourhood = mergeSimilarNeighbourhood + } + + public static val FixPointRage = -1 + public static val FullParallels = Integer.MAX_VALUE + public static val MaxNumbers = Integer.MAX_VALUE + + /** + * Creates a neighbourhood representation with traces + * @param model The model to be represented. + * @param range The range of the neighbourhood. + * @param parallels The maximal number of parallel references to be differentiated. + */ + def public createRepresentation(PartialInterpretation model, int range, int parallels, int maxNumber) { + return createRepresentation(model,range,parallels,maxNumber,null,null) + } + + def public createRepresentation( + PartialInterpretation model, + int range, int parallels, int maxNumber, + Set relevantTypes, Set relevantRelations) + { + val Map> types = new HashMap + fillTypes(model,types,relevantTypes) + val Map>> IncomingRelations = new HashMap; + val Map>> OutgoingRelations = new HashMap; + fillReferences(model,IncomingRelations,OutgoingRelations,relevantRelations) + + val res = doRecursiveNeighbourCalculation(model,types,IncomingRelations,OutgoingRelations,range,parallels,maxNumber); + + return res; + } + + def private isRelevant(TypeDeclaration t, Set relevantTypes) { + if(relevantTypes === null) { + return true + } else { + return relevantTypes.contains(t) + } + } + def private isRelevant(RelationDeclaration r, Set relevantRelations) { + if(relevantRelations === null) { + return true + } else { + return relevantRelations.contains(r) + } + } + + /** + * Creates a neighbourhood representation with traces + * @param model The model to be represented. + * @param IncomingRelations Requires the previously indexed incoming references. + * @param OutgoingRelations Requires the previously indexed outgoing references. + * @param range The range of the neighbourhood. + * @param parallels The maximal number of parallel references to be differentiated. + */ + def private NeighbourhoodWithTraces doRecursiveNeighbourCalculation( + PartialInterpretation model, + Map> types, + Map>> IncomingRelations, + Map>> OutgoingRelations, + int range, int parallels, int maxNumber) + { + if(range == 0){ + val r = calculateLocalNodeDescriptors(model,types,maxNumber) + val res = this.createLocalRepresentation(r.value,r.key) + if(res.modelRepresentation === null) { + throw new IllegalArgumentException('''Model representation is null''') + } else if(res.nodeRepresentations === null || res.nodeRepresentations.empty) { + throw new IllegalArgumentException('''No node representation''') + } else if(res.previousRepresentation !== null) { + throw new IllegalArgumentException('''The previous representation of the first neighbourhood have to be null''') + } else return res + } else if(range > 0) { + val previous = doRecursiveNeighbourCalculation(model,types,IncomingRelations,OutgoingRelations,range-1,parallels,maxNumber) + val r = calculateFurtherNodeDescriptors(model,previous,IncomingRelations,OutgoingRelations,parallels,maxNumber) + //println('''Level «range» finished.''') + val res = createFurtherRepresentation(r.key,r.value,previous,deepRepresentation) + if(res.modelRepresentation === null) { + throw new IllegalArgumentException('''Model representation is null''') + } else if(res.nodeRepresentations === null || res.nodeRepresentations.empty) { + throw new IllegalArgumentException('''No node representation''') + } else if(res.previousRepresentation === null && deepRepresentation) { + throw new IllegalArgumentException('''Need previous representations''') + } else return res + } else if (range == FixPointRage) { + return refineUntilFixpoint(model,types,IncomingRelations,OutgoingRelations,parallels,maxNumber) + } + } + + def private refineUntilFixpoint( + PartialInterpretation model, + Map> types, + Map>> IncomingRelations, + Map>> OutgoingRelations, + int parallels, int maxNumbers) + { + var lastRange = 0 + val last = calculateLocalNodeDescriptors(model,types,maxNumbers) + var lastRepresentation = this.createLocalRepresentation(last.value,last.key) + //println('''Level 0 finished.''') + var boolean hasRefined + do { + val nextRange = lastRange+1 + val next = calculateFurtherNodeDescriptors(model,lastRepresentation,IncomingRelations,OutgoingRelations,parallels,maxNumbers) + val nextRepresentation = createFurtherRepresentation(next.key,next.value,lastRepresentation,deepRepresentation) + + val previousNumberOfTypes =lastRepresentation.nodeRepresentations.values.toSet.size + val nextNumberOfTypes = nextRepresentation.nodeRepresentations.values.toSet.size + hasRefined = nextNumberOfTypes > previousNumberOfTypes + + lastRange = nextRange + lastRepresentation = nextRepresentation + +// if(hasRefined) { +// println('''Level «nextRange» is calculated, number of types is refined: «previousNumberOfTypes» -> «nextNumberOfTypes»''') +// } else { +// println('''Level «nextRange» is calculated, but the number of types is not refined: «previousNumberOfTypes» = «nextNumberOfTypes»''') +// } + } while (hasRefined) + return lastRepresentation + } + + def private getElements(PartialInterpretation model) { + return model.problem.elements + model.newElements + } + + def private fillTypes(PartialInterpretation model, Map> node2Type, Set relevantTypes) { + for(element : model.elements) { + node2Type.put(element, new HashSet) + } + +// for(typeDefinition : model.problem.types.filter(TypeDefinition)) { +// // Dont need +// } + for(typeInterpretation : model.partialtypeinterpratation) { + val type = typeInterpretation.interpretationOf + if(type.isRelevant(relevantTypes)) { + for(element : typeInterpretation.elements) { + element.lookup(node2Type).add(type.name) + } + } + } + } + + /** + * Indexes the references + */ + def private fillReferences(PartialInterpretation model, + Map>> IncomingRelations, + Map>> OutgoingRelations, + Set relevantRelations) + { + for(object : model.elements) { + IncomingRelations.put(object,new LinkedList) + OutgoingRelations.put(object,new LinkedList) + } + for(relationInterpretation : model.partialrelationinterpretation) { + val type = relationInterpretation.interpretationOf + if(type.isRelevant(relevantRelations)) { + for(link : relationInterpretation.relationlinks) { + if(link instanceof BinaryElementRelationLink) { + OutgoingRelations.get(link.param1) += new OutgoingRelation(link.param2,type.name) + IncomingRelations.get(link.param2) += new IncomingRelation(link.param1,type.name) + } else throw new UnsupportedOperationException + } + } + } + } + + /** + * Creates a local representation of the objects (aka zero range neighbourhood) + */ + def abstract protected NeighbourhoodWithTraces createLocalRepresentation( + Map node2Representation, + Map representation2Amount + ) + + /** + * Creates a + */ + def abstract protected NeighbourhoodWithTraces createFurtherRepresentation( + Map, Integer> nodeDescriptors, + Map> node2Representation, + NeighbourhoodWithTraces previous, + boolean deepRepresentation + ) + + def private addOne(int original, int max) { + if(original == Integer.MAX_VALUE) return Integer.MAX_VALUE + if(original +1 > max) return Integer.MAX_VALUE + else return original+1 + } + + private def calculateIncomingEdges(Map>> IncomingRelations, + DefinedElement object, Map previousNodeRepresentations, int parallel) + { + val Map, Integer> res = new HashMap + for (incomingConcreteEdge : IncomingRelations.get(object)) { + val IncomingRelation 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) + } + } + return res + } + + private def calcuateOutgoingEdges(Map>> OutgoingRelations, + DefinedElement object, Map previousNodeRepresentations, int parallel) + { + val Map,Integer> res= new HashMap + for(outgoingConcreteEdge : OutgoingRelations.get(object)) { + val OutgoingRelation 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) + } + } + return res; + } + + /*def private void addOrCreate_Set(Map> map, KEY key, VALUE value) { + var Set s; + if(map.containsKey(key)) { + s = map.get(key); + } else { + s = new HashSet + map.put(key,s) + } + s.add(value) + }*/ + + + private def calculateFurtherNodeDescriptors( + PartialInterpretation model, + NeighbourhoodWithTraces previous, + Map>> IncomingRelations, + Map>> OutgoingRelations, + int parallels, int maxNumber) + { + val previousNodeRepresentations = previous.nodeRepresentations + val node2Representation = new HashMap> + val Map,Integer> descriptor2Number = + if(this.mergeSimilarNeighbourhood){ new HashMap } else { null } + val Map,FurtherNodeDescriptor> uniqueDescription = + if(this.mergeSimilarNeighbourhood){ new HashMap } else { null } + + for(object: model.elements) { + val incomingEdges = this.calculateIncomingEdges(IncomingRelations, object, previousNodeRepresentations,parallels) + val outgoingEdges = this.calcuateOutgoingEdges(OutgoingRelations,object, previousNodeRepresentations,parallels) + + val previousType = previousNodeRepresentations.get(object) + + if(previousType === null) { + println("Error in state coder") + } + + val nodeDescriptor = new FurtherNodeDescriptor( + previousType, + incomingEdges, + outgoingEdges) + + if(this.mergeSimilarNeighbourhood) { + if(descriptor2Number.containsKey(nodeDescriptor)) { + descriptor2Number.put( + nodeDescriptor, + addOne(descriptor2Number.get(nodeDescriptor),maxNumber) + ) + node2Representation.put(object,uniqueDescription.get(nodeDescriptor)) + } else { + descriptor2Number.put(nodeDescriptor,1) + uniqueDescription.put(nodeDescriptor,nodeDescriptor) + node2Representation.put(object,nodeDescriptor) + } + } else { + node2Representation.put(object,nodeDescriptor) + } + } + + return descriptor2Number -> node2Representation + } + + private def calculateLocalNodeDescriptors( + PartialInterpretation model, + Map> types, + int maxNumber) + { + val Map node2Representation = new HashMap + val Map representation2Amount = + if(mergeSimilarNeighbourhood){ new HashMap } else { null } + val Map uniqueRepresentation = + if(this.mergeSimilarNeighbourhood){ new HashMap } else { null } + + for(element : model.elements) { + var newDescriptor = new LocalNodeDescriptor(element.name,element.lookup(types)) + if(this.mergeSimilarNeighbourhood){ + if(uniqueRepresentation.containsKey(newDescriptor)) { + newDescriptor = newDescriptor.lookup(uniqueRepresentation) + node2Representation.put(element,newDescriptor) + representation2Amount.put( + newDescriptor, + addOne(newDescriptor.lookup(representation2Amount),maxNumber) + ) + } else { + uniqueRepresentation.put(newDescriptor,newDescriptor) + node2Representation.put(element,newDescriptor) + representation2Amount.put(newDescriptor, 1) + } + } else { + node2Representation.put(element,newDescriptor) + } + } + + return representation2Amount -> node2Representation + } +} \ No newline at end of file diff --git a/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage/src/hu/bme/mit/inf/dslreasoner/viatrasolver/partialinterpretationlanguage/statecoder/IdentifierBasedStateCoderFactory.xtend b/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage/src/hu/bme/mit/inf/dslreasoner/viatrasolver/partialinterpretationlanguage/statecoder/IdentifierBasedStateCoderFactory.xtend new file mode 100644 index 00000000..c421ace6 --- /dev/null +++ b/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage/src/hu/bme/mit/inf/dslreasoner/viatrasolver/partialinterpretationlanguage/statecoder/IdentifierBasedStateCoderFactory.xtend @@ -0,0 +1,129 @@ +package hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage.statecoder + +import hu.bme.mit.inf.dslreasoner.logic.model.logiclanguage.DefinedElement +import hu.bme.mit.inf.dslreasoner.logic.model.logicproblem.LogicProblem +import hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage.partialinterpretation.BinaryElementRelationLink +import hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage.partialinterpretation.PartialInterpretation +import hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage.partialinterpretation.PartialRelationInterpretation +import hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage.partialinterpretation.PartialTypeInterpratation +import java.util.ArrayList +import java.util.Comparator +import java.util.LinkedList +import java.util.List +import java.util.SortedSet +import java.util.TreeSet +import org.eclipse.emf.common.notify.Notifier +import org.eclipse.viatra.dse.statecode.IStateCoder +import org.eclipse.viatra.dse.statecode.IStateCoderFactory +import org.eclipse.viatra.query.runtime.api.IPatternMatch +import org.eclipse.xtend.lib.annotations.Accessors +import org.eclipse.xtend.lib.annotations.Data + +class IdentifierBasedStateCoderFactory implements IStateCoderFactory{ + + val List statecoders = new LinkedList + synchronized override createStateCoder() { + val res = new IdentifierBasedStateCoder + statecoders += res + return res + } + def getSumStatecoderRuntime() { + statecoders.map[statecoderRuntime].reduce[p1, p2|p1+p2] + } +} + +@Data +class RelationStatecoder { + String relationName + SortedSet> links; + + static val comparator= new Comparator>() { + override compare(Pair o1, Pair o2) { + if(o1.key > o2.key) { + return 1 + } else if(o1.key < o2.key) { + return -1 + } else { + return Integer.compare(o1.value,o2.value) + } + } + } + + new(String relationName) { + this.relationName = relationName + links = new TreeSet(comparator) + } +} + +@Data +class IdentifierBasedStateCode { + int numberOfNewElement + SortedSet relationStatecoders + + private static val comparator = new Comparator() { + override compare(RelationStatecoder o1, RelationStatecoder o2) { + o1.relationName.compareTo(o2.relationName) + } + } + + public new(int numberOfNewElements) { + this.numberOfNewElement = numberOfNewElements + this.relationStatecoders = new TreeSet(comparator) + } +} + +class IdentifierBasedStateCoder implements IStateCoder{ + var PartialInterpretation model = null + + @Accessors(PUBLIC_GETTER) var long statecoderRuntime = 0 + + override createActivationCode(IPatternMatch match) { + val startTime = System.nanoTime + val res = new ArrayList(match.parameterNames.size) + var index = 0 + while(index < match.parameterNames.size) { + res.add(getID(match.get(index))) + index++ + } + statecoderRuntime += (System.nanoTime - startTime) + return match.specification.fullyQualifiedName -> res + } + + override createStateCode() { + val startTime = System.nanoTime + val res = new IdentifierBasedStateCode(model.newElements.size) + for(relation : model.partialrelationinterpretation) { + val relationCoder = new RelationStatecoder(relation.interpretationOf.name) + for(link: relation.relationlinks.filter(BinaryElementRelationLink)) { + relationCoder.links+=link.param1.ID -> link.param2.ID + } + res.relationStatecoders+=relationCoder + } + statecoderRuntime += (System.nanoTime - startTime) + return res + } + + def getID(Object element) { + if(element instanceof DefinedElement) { + val container = element.eContainer + if(container instanceof LogicProblem) { + return -container.elements.indexOf(element)-1 + } else if(container instanceof PartialInterpretation){ + return container.newElements.indexOf(element)+1 + } + } else if(element instanceof PartialInterpretation || element instanceof LogicProblem) { + return 0 + } else if(element instanceof PartialRelationInterpretation) { + return element.interpretationOf.name.hashCode + } else if(element instanceof PartialTypeInterpratation) { + return element.interpretationOf.name.hashCode + } else { + println(element) + throw new UnsupportedOperationException('''Unsupported type: «element.class.simpleName»''') + } + } + + override init(Notifier notifier) { + model = notifier as PartialInterpretation + } +} \ No newline at end of file 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 new file mode 100644 index 00000000..5fb85b0c --- /dev/null +++ b/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage/src/hu/bme/mit/inf/dslreasoner/viatrasolver/partialinterpretationlanguage/statecoder/NeighbourhoodBasedStateCoderFactory.xtend @@ -0,0 +1,206 @@ +package hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage.statecoder + +import hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage.neighbourhood.AbstractNodeDescriptor +import hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage.neighbourhood.PartialInterpretation2ImmutableTypeLattice +import hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage.partialinterpretation.PartialInterpretation +import hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage.partialinterpretation.PartialinterpretationPackage +import java.util.ArrayList +import java.util.LinkedList +import java.util.List +import java.util.Map +import org.eclipse.emf.common.notify.Notifier +import org.eclipse.emf.ecore.EClass +import org.eclipse.emf.ecore.EObject +import org.eclipse.emf.ecore.EStructuralFeature +import org.eclipse.viatra.dse.statecode.IStateCoder +import org.eclipse.viatra.dse.statecode.IStateCoderFactory +import org.eclipse.viatra.query.runtime.api.IPatternMatch +import org.eclipse.viatra.query.runtime.api.ViatraQueryEngine +import org.eclipse.viatra.query.runtime.base.api.FeatureListener +import org.eclipse.viatra.query.runtime.base.api.IndexingLevel +import org.eclipse.viatra.query.runtime.base.api.InstanceListener +import org.eclipse.viatra.query.runtime.emf.EMFBaseIndexWrapper +import org.eclipse.viatra.query.runtime.emf.EMFScope +import org.eclipse.xtend.lib.annotations.Accessors +import hu.bme.mit.inf.dslreasoner.logic.model.logiclanguage.DefinedElement +import hu.bme.mit.inf.dslreasoner.logic.model.logicproblem.LogicProblem +import hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage.partialinterpretation.PartialTypeInterpratation +import hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage.partialinterpretation.PartialRelationInterpretation +import java.util.Set +import hu.bme.mit.inf.dslreasoner.logic.model.logiclanguage.TypeDeclaration +import hu.bme.mit.inf.dslreasoner.logic.model.logiclanguage.RelationDeclaration +import hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage.neighbourhood.PartialInterpretation2NeighbourhoodRepresentation + +class NeighbourhoodBasedStateCoderFactory implements IStateCoderFactory { + val List statecoders = new LinkedList + + val int range + val int parallels + val int maxNumber + val Set relevantTypes + val Set relevantRelations + + public new() { + this.range = PartialInterpretation2NeighbourhoodRepresentation::FixPointRage + this.parallels = PartialInterpretation2NeighbourhoodRepresentation::FullParallels + this.maxNumber = PartialInterpretation2NeighbourhoodRepresentation::MaxNumbers + this.relevantTypes = null + this.relevantRelations = null + } + + public new(int range, int parallels, int maxNumber, Set relevantTypes, Set relevantRelations) { + this.range = range + this.parallels = parallels + this.maxNumber = maxNumber + this.relevantTypes = relevantTypes + this.relevantRelations = relevantRelations + } + + synchronized override createStateCoder() { + val res = new NeighbourhoodBasedPartialInterpretationStateCoder(statecoders.size, + range,parallels,maxNumber,relevantTypes,relevantRelations) + statecoders += res + return res + } + def getSumStatecoderRuntime() { + statecoders.map[statecoderRuntime].reduce[p1, p2|p1+p2] + } +} + +class NeighbourhoodBasedPartialInterpretationStateCoder implements IStateCoder{ + val int id; + val int range + val int parallels + val int maxNumber + val Set relevantTypes + val Set relevantRelations + + val calculator = + new PartialInterpretation2ImmutableTypeLattice + var PartialInterpretation target + + private var Map nodeRepresentations = null + private var Map modelRepresentation = null + + /*public new(int id) { + this.id = id + this.range = PartialInterpretation2NeighbourhoodRepresentation::FixPointRage + this.parallels = PartialInterpretation2NeighbourhoodRepresentation::FullParallels + this.maxNumber = maxNumber = PartialInterpretation2NeighbourhoodRepresentation::MaxNumbers + this.relevantTypes = relevantTypes + this.relevantRelations = relevantRelations + }*/ + + public new(int id, int range, int parallels, int maxNumber, Set relevantTypes, Set relevantRelations) { + this.id = id + this.range = range + this.parallels = parallels + this.maxNumber = maxNumber + this.relevantTypes = relevantTypes + this.relevantRelations = relevantRelations + } + + @Accessors(PUBLIC_GETTER) var long statecoderRuntime = 0 + +// val range = -1 +// val par = Integer.MAX_VALUE + //val deeprepresentation = false + + ///////// + // Caching version + ///////// + synchronized private def refreshStateCodes() { + if(this.nodeRepresentations === null || this.modelRepresentation === null) { + val startTime = System.nanoTime + //relevantObjects.forEach[println(it)] + val code = calculator.createRepresentation(target,range,parallels,maxNumber,relevantTypes,relevantRelations) + this.modelRepresentation = code.modelRepresentation + this.nodeRepresentations = code.nodeRepresentations + statecoderRuntime += (System.nanoTime - startTime) + } + } + synchronized override createActivationCode(IPatternMatch match) { + refreshStateCodes + + val startTime = System.nanoTime + val size = match.specification.parameters.size + val res = new ArrayList(size) + var int index = 0 + while(index < size) { + res.add(getCode(match.get(index))) + index++ + } + statecoderRuntime += (System.nanoTime - startTime) + return match.specification.fullyQualifiedName->res.hashCode + } + + def private getCode(Object o) { + if(o instanceof DefinedElement) { + this.nodeRepresentations.get(o) + } else if(o instanceof PartialInterpretation || o instanceof LogicProblem) { + return null + } else if(o instanceof PartialRelationInterpretation) { + return o.interpretationOf.name + } else if(o instanceof PartialTypeInterpratation) { + return o.interpretationOf.name + } else { + throw new UnsupportedOperationException('''Unsupported type: «o.class.simpleName»''') + } + } + + synchronized override createStateCode() { + refreshStateCodes + return this.modelRepresentation.hashCode + } + ///////// + // Caching version + ///////// + + ///////// + // Recalculating version + ///////// +// synchronized override createActivationCode(IPatternMatch match) { +// val nodes = calculator.createRepresentation(getRelevantObjects().toList,range,par).nodeRepresentations +// val res = match.toArray.map[objectInMatch | +// nodes.get(objectInMatch) +// ] +// return res +// } +// +// override createStateCode() { +// return this.calculator.createRepresentation(getRelevantObjects().toList,range,par).modelRepresentation +// } + ///////// + // Recalculating version + ///////// + + override init(Notifier notifier) { + this.target = notifier as PartialInterpretation + val queryEngine = ViatraQueryEngine.on(new EMFScope(notifier)) + val baseIndex = queryEngine.getBaseIndex() as EMFBaseIndexWrapper + val navigationHelper = baseIndex.getNavigationHelper(); + + val classes = PartialinterpretationPackage.eINSTANCE.EClassifiers.filter(EClass).toSet + val features = classes.map[it.EAllStructuralFeatures].flatten.toSet + navigationHelper.registerObservedTypes( + classes, + null, + features, + IndexingLevel.FULL); + + + navigationHelper.addFeatureListener(features, new FeatureListener() { + override public void featureInserted(EObject host, EStructuralFeature feature, Object value) { invalidate } + override public void featureDeleted(EObject host, EStructuralFeature feature, Object value) { invalidate } + }); + navigationHelper.addInstanceListener(classes, new InstanceListener() { + override public void instanceInserted(EClass clazz, EObject instance) { invalidate } + override public void instanceDeleted(EClass clazz, EObject instance) { invalidate } + }); + } + + synchronized def public invalidate() { + this.nodeRepresentations = null + this.modelRepresentation = null + } +} diff --git a/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage/src/hu/bme/mit/inf/dslreasoner/viatrasolver/partialinterpretationlanguage/visualisation/PartialInterpretation2Gml.xtend b/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage/src/hu/bme/mit/inf/dslreasoner/viatrasolver/partialinterpretationlanguage/visualisation/PartialInterpretation2Gml.xtend new file mode 100644 index 00000000..819cae00 --- /dev/null +++ b/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage/src/hu/bme/mit/inf/dslreasoner/viatrasolver/partialinterpretationlanguage/visualisation/PartialInterpretation2Gml.xtend @@ -0,0 +1,136 @@ +package hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage.visualisation + +import hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage.partialinterpretation.PartialInterpretation +import hu.bme.mit.inf.dslreasoner.logic.model.logiclanguage.DefinedElement +import java.util.Map +import java.util.HashMap +import hu.bme.mit.inf.dslreasoner.logic.model.logiclanguage.TypeDefinition +import hu.bme.mit.inf.dslreasoner.logic.model.logiclanguage.Type +import hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage.partialinterpretation.PartialRelationInterpretation +import hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage.partialinterpretation.BinaryElementRelationLink +import hu.bme.mit.inf.dslreasoner.logic.model.logiclanguage.Relation +import java.util.Set + +class PartialInterpretation2Gml { + def public transform(PartialInterpretation i) { + val p = i.problem + val Map objectToID = new HashMap + val containmentRelations = p.containmentHierarchies.map[it.containmentRelations].flatten.toSet + ''' + graph + [ + «FOR object:p.elements + i.newElements SEPARATOR '\n'» + «this.transformObject(object,object.typesOfElement(i),objectToID)» + «ENDFOR» + «FOR relation:i.partialrelationinterpretation» + «FOR link:relation.relationlinks.filter(BinaryElementRelationLink)» + «transformLink(relation,link,objectToID,containmentRelations)» + «ENDFOR» + «ENDFOR» + ] + '''.toString + } + def typesOfElement(DefinedElement e, PartialInterpretation i) { + i.problem.types.filter(TypeDefinition).filter[it.elements.contains(e)] + + i.partialtypeinterpratation.filter[it.elements.contains(e)].map[it.interpretationOf] + } + + val protected titleSize = 16 + val protected attributeSize = 14 + val protected borderDistance = 6 + val protected attributeBorderDistance = 8 + val protected ratio = 11.0/20.0 + + def protected transformObject(DefinedElement object,Iterable types,Map objectToID){ + val title = object.transormTitle + val attributes = types.map[it.name] + + var double width = title.length*titleSize + borderDistance*2; + for(x:attributes.map[length*attributeSize + borderDistance*2 + attributeBorderDistance*2]) + width = Math::max(width,x) + width = width*ratio + + val height = Math::max( + titleSize+4, + (attributes.size+1)*attributeSize + borderDistance*2) + + val id = objectToID.size + objectToID.put(object,id) + + ''' + node + [ + id «id» + graphics + [ + w «width» + h «height» + type "rectangle" + fill "#FFFFFF" + fill2 "#FFFFFF" + outline "#000000" + ] + LabelGraphics + [ + text "«title»" + outline "#000000" + fill "#FFFFFF" + fontSize «titleSize» + fontName "Monospace" + autoSizePolicy "node_width" + anchor "t" + borderDistance 0.0 + ] + LabelGraphics + [ + text " + «FOR attribute : attributes» + «attribute» + «ENDFOR»" + fontSize «attributeSize» + fontName "Consolas" + alignment "left" + anchor "tl" + borderDistance «borderDistance» + ] + ] + ''' + } + + def protected transormTitle(DefinedElement object) { + if(object.name!= null)object.name + else "null" + } + + def protected transformLink( + PartialRelationInterpretation reference, + BinaryElementRelationLink link, + Map objectToID, + Set containmentRelations) + { + ''' + edge + [ + source «objectToID.get(link.param1)» + target «objectToID.get(link.param2)» + graphics + [ + fill "#000000" + «IF containmentRelations.contains(reference.interpretationOf)» + width 3 + «ENDIF» + targetArrow "standard" + ] + LabelGraphics + [ + text "«reference.interpretationOf.name»" + fontSize 14 + fontName "Consolas" + configuration "AutoFlippingLabel" + model "six_pos" + position "thead" + ] + ] + ''' + } +} \ No newline at end of file -- cgit v1.2.3-54-g00ecf