From 60f01f46ba232ed6416054f0a6115cb2a9b70b4e Mon Sep 17 00:00:00 2001 From: OszkarSemerath Date: Sat, 10 Jun 2017 19:05:05 +0200 Subject: Migrating Additional projects --- .../dse/BestFirstStrategyForModelGeneration.java | 372 +++++++++++++++++++++ .../dse/ModelGenerationCompositeObjective.xtend | 85 +++++ .../dse/PartialModelAsLogicInterpretation.xtend | 30 ++ .../viatrasolver/reasoner/dse/ScopeObjective.xtend | 41 +++ .../reasoner/dse/SolutionStoreWithCopy.xtend | 35 ++ .../dse/SolutionStoreWithDiversityDescriptor.xtend | 77 +++++ .../dse/UnfinishedMultiplicityObjective.xtend | 37 ++ .../reasoner/dse/UnfinishedWFObjective.xtend | 56 ++++ .../reasoner/dse/WF2ObjectiveConverter.xtend | 36 ++ 9 files changed, 769 insertions(+) create mode 100644 Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.reasoner/src/hu/bme/mit/inf/dslreasoner/viatrasolver/reasoner/dse/BestFirstStrategyForModelGeneration.java create mode 100644 Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.reasoner/src/hu/bme/mit/inf/dslreasoner/viatrasolver/reasoner/dse/ModelGenerationCompositeObjective.xtend create mode 100644 Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.reasoner/src/hu/bme/mit/inf/dslreasoner/viatrasolver/reasoner/dse/PartialModelAsLogicInterpretation.xtend create mode 100644 Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.reasoner/src/hu/bme/mit/inf/dslreasoner/viatrasolver/reasoner/dse/ScopeObjective.xtend create mode 100644 Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.reasoner/src/hu/bme/mit/inf/dslreasoner/viatrasolver/reasoner/dse/SolutionStoreWithCopy.xtend create mode 100644 Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.reasoner/src/hu/bme/mit/inf/dslreasoner/viatrasolver/reasoner/dse/SolutionStoreWithDiversityDescriptor.xtend create mode 100644 Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.reasoner/src/hu/bme/mit/inf/dslreasoner/viatrasolver/reasoner/dse/UnfinishedMultiplicityObjective.xtend create mode 100644 Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.reasoner/src/hu/bme/mit/inf/dslreasoner/viatrasolver/reasoner/dse/UnfinishedWFObjective.xtend create mode 100644 Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.reasoner/src/hu/bme/mit/inf/dslreasoner/viatrasolver/reasoner/dse/WF2ObjectiveConverter.xtend (limited to 'Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.reasoner/src/hu/bme/mit/inf/dslreasoner/viatrasolver/reasoner/dse') diff --git a/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.reasoner/src/hu/bme/mit/inf/dslreasoner/viatrasolver/reasoner/dse/BestFirstStrategyForModelGeneration.java b/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.reasoner/src/hu/bme/mit/inf/dslreasoner/viatrasolver/reasoner/dse/BestFirstStrategyForModelGeneration.java new file mode 100644 index 00000000..5a6fee2c --- /dev/null +++ b/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.reasoner/src/hu/bme/mit/inf/dslreasoner/viatrasolver/reasoner/dse/BestFirstStrategyForModelGeneration.java @@ -0,0 +1,372 @@ +/******************************************************************************* + * Copyright (c) 2010-2017, Andras Szabolcs Nagy and Daniel Varro + * All rights reserved. This program and the accompanying materials + * are made available under the terms of the Eclipse Public License v1.0 + * which accompanies this distribution, and is available at + * http://www.eclipse.org/legal/epl-v10.html + * Contributors: + * Andras Szabolcs Nagy - initial API and implementation + *******************************************************************************/ +package hu.bme.mit.inf.dslreasoner.viatrasolver.reasoner.dse; + +import java.util.ArrayList; +import java.util.Arrays; +import java.util.Collections; +import java.util.Comparator; +import java.util.Iterator; +import java.util.List; +import java.util.PriorityQueue; +import java.util.Random; + +import org.apache.log4j.Logger; +import org.eclipse.viatra.dse.api.strategy.interfaces.IStrategy; +import org.eclipse.viatra.dse.base.ThreadContext; +import org.eclipse.viatra.dse.objectives.Fitness; +import org.eclipse.viatra.dse.objectives.ObjectiveComparatorHelper; +import org.eclipse.viatra.dse.solutionstore.SolutionStore; + +import hu.bme.mit.inf.dslreasoner.logic.model.builder.LogicReasoner; +import hu.bme.mit.inf.dslreasoner.logic.model.builder.LogicSolverConfiguration; +import hu.bme.mit.inf.dslreasoner.logic.model.logicresult.ModelResult; +import hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretation2logic.PartialInterpretation2Logic; +import hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage.partialinterpretation.PartialInterpretation; +import hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage.visualisation.PartialInterpretation2Gml; +import hu.bme.mit.inf.dslreasoner.viatrasolver.reasoner.DiversityDescriptor; +import hu.bme.mit.inf.dslreasoner.workspace.ReasonerWorkspace; + +/** + * This exploration strategy eventually explorers the whole design space but goes in the most promising directions + * first, based on the {@link Fitness}. + * + * There are a few parameter to tune such as + * + * + * @author Andras Szabolcs Nagy + * + */ +public class BestFirstStrategyForModelGeneration implements IStrategy { + + private ThreadContext context; + private SolutionStore solutionStore; + private SolutionStoreWithCopy solutionStoreWithCopy; + private SolutionStoreWithDiversityDescriptor solutionStoreWithDiversityDescriptor; + private int numberOfStatecoderFail=0; + + private int maxDepth = Integer.MAX_VALUE; + private boolean isInterrupted = false; + //private boolean backTrackIfSolution = true; + private boolean onlyBetterFirst = false; + + private PriorityQueue trajectoiresToExplore; + private Logger logger = Logger.getLogger(IStrategy.class); + + private static class TrajectoryWithFitness { + + public Object[] trajectory; + public Fitness fitness; + + public TrajectoryWithFitness(Object[] trajectory, Fitness fitness) { + super(); + this.trajectory = trajectory; + this.fitness = fitness; + } + + @Override + public String toString() { + return Arrays.toString(trajectory) + fitness.toString(); + } + + } + + public BestFirstStrategyForModelGeneration(ReasonerWorkspace workspace, LogicReasoner reasoner, LogicSolverConfiguration configuration, DiversityDescriptor descriptor) { + this.maxDepth = Integer.MAX_VALUE; + this.workspace = workspace; + this.reasoner = reasoner; + this.configuration = configuration; + this.solutionStoreWithDiversityDescriptor = new SolutionStoreWithDiversityDescriptor(descriptor); + } + + @Override + public void initStrategy(ThreadContext context) { + this.context = context; + this.solutionStore = context.getGlobalContext().getSolutionStore(); + this.solutionStoreWithCopy = new SolutionStoreWithCopy(); + + + final ObjectiveComparatorHelper objectiveComparatorHelper = context.getObjectiveComparatorHelper(); + + Comparator comparator = new Comparator() { + + @Override + public int compare(TrajectoryWithFitness o1, TrajectoryWithFitness o2) { + return objectiveComparatorHelper.compare(o2.fitness, o1.fitness); + } + }; + + trajectoiresToExplore = new PriorityQueue(11, comparator); + + } + + public SolutionStoreWithCopy getSolutionStoreWithCopy() { + return solutionStoreWithCopy; + } + + public SolutionStoreWithDiversityDescriptor getSolutionStoreWithDiversityDescriptor() { + return solutionStoreWithDiversityDescriptor; + } + + public int getNumberOfStatecoderFaiL() { + return numberOfStatecoderFail; + } + + @Override + public void explore() { + final ObjectiveComparatorHelper objectiveComparatorHelper = context.getObjectiveComparatorHelper(); + + boolean globalConstraintsAreSatisfied = context.checkGlobalConstraints(); + if (!globalConstraintsAreSatisfied) { + logger.info("Global contraint is not satisifed in the first state. Terminate."); + return; + } + + final Fitness firstFittness = context.calculateFitness(); + if (firstFittness.isSatisifiesHardObjectives()) { + context.newSolution(); + logger.info("First state is a solution. Terminate."); + return; + } + + if (maxDepth == 0) { + return; + } + + final Object[] firstTrajectory = context.getTrajectory().toArray(new Object[0]); + TrajectoryWithFitness currentTrajectoryWithFittness = new TrajectoryWithFitness(firstTrajectory, firstFittness); + trajectoiresToExplore.add(currentTrajectoryWithFittness); + + mainLoop: while (!isInterrupted) { + + if (currentTrajectoryWithFittness == null) { + if (trajectoiresToExplore.isEmpty()) { + logger.debug("State space is fully traversed."); + return; + } else { + currentTrajectoryWithFittness = selectRandomState();// trajectoiresToExplore.element(); + if (logger.isDebugEnabled()) { + logger.debug("Current trajectory: " + Arrays.toString(context.getTrajectory().toArray())); + logger.debug("New trajectory is chosen: " + currentTrajectoryWithFittness); + } +// context.backtrackUntilRoot(); +// context.executeTrajectoryWithoutStateCoding(currentTrajectoryWithFittness.trajectory); + context.getDesignSpaceManager().executeTrajectoryWithMinimalBacktrackWithoutStateCoding(currentTrajectoryWithFittness.trajectory); + } + + } + + List activationIds; + try { + activationIds = new ArrayList(context.getUntraversedActivationIds()); + Collections.shuffle(activationIds); + } catch (NullPointerException e) { + numberOfStatecoderFail++; + activationIds = Collections.emptyList(); + } + + Iterator iterator = activationIds.iterator(); + +// writeCurrentState(); +// boolean consistencyCheckResult = checkConsistency(currentTrajectoryWithFittness); +// if(consistencyCheckResult == true) { +// continue mainLoop; +// } + + while (!isInterrupted && iterator.hasNext()) { + final Object nextActivation = iterator.next(); + if (!iterator.hasNext()) { + logger.debug("Last untraversed activation of the state."); + trajectoiresToExplore.remove(currentTrajectoryWithFittness); + } + + if (logger.isDebugEnabled()) { + logger.debug("Executing new activation: " + nextActivation); + } + context.executeAcitvationId(nextActivation); + +// writeCurrentState(); + + if (context.isCurrentStateAlreadyTraversed()) { + logger.info("The new state is already visited."); + context.backtrack(); + } else if (!context.checkGlobalConstraints()) { + logger.debug("Global contraint is not satisifed."); + context.backtrack(); + } else { + final Fitness nextFitness = context.calculateFitness(); + if (nextFitness.isSatisifiesHardObjectives()) { + if(solutionStoreWithDiversityDescriptor.isDifferent(context)) { + solutionStoreWithCopy.newSolution(context); + solutionStoreWithDiversityDescriptor.newSolution(context); + solutionStore.newSolution(context); + logger.debug("Found a solution."); + } + } + if (context.getDepth() > maxDepth) { + logger.debug("Reached max depth."); + context.backtrack(); + continue; + } + + TrajectoryWithFitness nextTrajectoryWithFittness = new TrajectoryWithFitness( + context.getTrajectory().toArray(), nextFitness); + trajectoiresToExplore.add(nextTrajectoryWithFittness); + + int compare = objectiveComparatorHelper.compare(currentTrajectoryWithFittness.fitness, + nextTrajectoryWithFittness.fitness); + if (compare < 0) { + logger.debug("Better fitness, moving on: " + nextFitness); + currentTrajectoryWithFittness = nextTrajectoryWithFittness; + continue mainLoop; + } else if (compare == 0) { + if (onlyBetterFirst) { + logger.debug("Equally good fitness, backtrack: " + nextFitness); + context.backtrack(); + continue; + } else { + logger.debug("Equally good fitness, moving on: " + nextFitness); + currentTrajectoryWithFittness = nextTrajectoryWithFittness; + continue mainLoop; + } + } else { + logger.debug("Worse fitness."); +// context.backtrack(); + currentTrajectoryWithFittness = null; + continue mainLoop; + } + } + } + + logger.debug("State is fully traversed."); + trajectoiresToExplore.remove(currentTrajectoryWithFittness); + currentTrajectoryWithFittness = null; + + } + logger.info("Interrupted."); + } + + @Override + public void interruptStrategy() { + isInterrupted = true; + } + + Random random = new Random(); + private TrajectoryWithFitness selectRandomState() { + int randomNumber = random.nextInt(100); + if(randomNumber < 5) { + int elements = trajectoiresToExplore.size(); + int randomElementIndex = random.nextInt(elements); + logger.debug("Randomly backtract to the " + randomElementIndex + " best solution..."); + Iterator iterator = trajectoiresToExplore.iterator(); + while(randomElementIndex!=0) { + iterator.next(); + randomElementIndex--; + } + TrajectoryWithFitness res = iterator.next(); + if(res == null) { + return trajectoiresToExplore.element(); + } else { + return res; + } + } else { + return trajectoiresToExplore.element(); + } + } + + private PartialInterpretation2Logic partialInterpretation2Logic = new PartialInterpretation2Logic(); + private LogicReasoner reasoner; + private PartialInterpretation2Gml partialInterpretation2Gml = new PartialInterpretation2Gml(); + private ReasonerWorkspace workspace; + private LogicSolverConfiguration configuration; + int numberOfPrintedModel = 0; + public ModelResult modelResultByTheSolver = null; + public void writeCurrentState() { + PartialInterpretation p = (PartialInterpretation)(context.getModel()); + int id= ++numberOfPrintedModel; + if(id%100 == 1) { + String text = this.partialInterpretation2Gml.transform(p); + this.workspace.writeText(id+".gml", text); + this.workspace.writeModel(p, id+".partialinterpretation"); + logger.debug("State "+id+" is saved."); + } + } + +// int numberOfSolverCalls = 0; +// +// protected boolean checkConsistency(TrajectoryWithFitness t) { +// if (reasoner != null) { +// int id = ++numberOfSolverCalls; +// if (id % 100 == 1) { +// try { +// PartialInterpretation interpretation = (PartialInterpretation) (context.getModel()); +// PartialInterpretation copied = EcoreUtil.copy(interpretation); +// this.partialInterpretation2Logic.transformPartialIntepretation2Logic(copied.getProblem(), copied); +// LogicProblem newProblem = copied.getProblem(); +// +// this.configuration.typeScopes.maxNewElements = interpretation.getMaxNewElements(); +// this.configuration.typeScopes.minNewElements = interpretation.getMinNewElements(); +// LogicResult result = reasoner.solve(newProblem, configuration, workspace); +// if (result instanceof InconsistencyResult) { +// logger.debug("Solver found an Inconsistency!"); +// removeSubtreeFromQueue(t); +// return true; +// } else if (result instanceof ModelResult) { +// logger.debug("Solver found a model!"); +// solutionStore.newSolution(context); + +// modelResultByTheSolver = (ModelResult) result; +// return true; +// } else { +// logger.debug("Failed consistency check."); +// return false; +// } +// } catch (Exception e) { +// // TODO Auto-generated catch block +// e.printStackTrace(); +// return false; +// } +// } +// +// } +// return false; +// } +// +// protected void removeSubtreeFromQueue(TrajectoryWithFitness t) { +// PriorityQueue previous = this.trajectoiresToExplore; +// this.trajectoiresToExplore = new PriorityQueue<>(this.comparator); +// for (TrajectoryWithFitness trajectoryWithFitness : previous) { +// if(! containsAsSubstring(trajectoryWithFitness.trajectory,t.trajectory)) { +// this.trajectoiresToExplore.add(trajectoryWithFitness); +// } else { +// logger.debug("State has been excluded due to inherent inconsistency"); +// } +// } +// } +// +// private boolean containsAsSubstring(Object[] full, Object[] substring) { +// if(substring.length > full.length) { +// return false; +// } else if(substring.length == full.length) { +// return Arrays.equals(full, substring); +// } else { +// Object[] part = Arrays.copyOfRange(full, 0, substring.length); +// return Arrays.equals(part, substring); +// } +// } +// + +} diff --git a/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.reasoner/src/hu/bme/mit/inf/dslreasoner/viatrasolver/reasoner/dse/ModelGenerationCompositeObjective.xtend b/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.reasoner/src/hu/bme/mit/inf/dslreasoner/viatrasolver/reasoner/dse/ModelGenerationCompositeObjective.xtend new file mode 100644 index 00000000..1ca2343f --- /dev/null +++ b/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.reasoner/src/hu/bme/mit/inf/dslreasoner/viatrasolver/reasoner/dse/ModelGenerationCompositeObjective.xtend @@ -0,0 +1,85 @@ +package hu.bme.mit.inf.dslreasoner.viatrasolver.reasoner.dse + +import java.util.Comparator +import java.util.List +import org.eclipse.viatra.dse.base.ThreadContext +import org.eclipse.viatra.dse.objectives.Comparators +import org.eclipse.viatra.dse.objectives.IObjective +import org.eclipse.viatra.dse.objectives.impl.BaseObjective + +//class ViatraReasonerNumbers { +// public static val scopePriority = 2 +// public static val unfinishedMultiplicityPriority = 2 +// public static val unifinshedWFPriority = 2 +// //public static val complexityPriority = 4 +// +// public static val scopeWeigth = 1.0 +// public static val unfinishedMultiplicityWeigth = 1.5 +// public static val unfinishedWFWeigth = 1.5 +// //public static val complexityWeigth = 0.1 +// +// public static val useCompositeObjective = true +// public static val compositePriority = 2 +//} + +class ModelGenerationCompositeObjective implements IObjective{ + val ScopeObjective scopeObjective + val List unfinishedMultiplicityObjectives + val UnfinishedWFObjective unfinishedWFObjective + + public new( + ScopeObjective scopeObjective, + List unfinishedMultiplicityObjectives, + UnfinishedWFObjective unfinishedWFObjective) + { + this.scopeObjective = scopeObjective + this.unfinishedMultiplicityObjectives = unfinishedMultiplicityObjectives + this.unfinishedWFObjective = unfinishedWFObjective + } + + override init(ThreadContext context) { + this.scopeObjective.init(context) + this.unfinishedMultiplicityObjectives.forEach[it.init(context)] + this.unfinishedWFObjective.init(context) + } + + override createNew() { + return new ModelGenerationCompositeObjective( + this.scopeObjective, this.unfinishedMultiplicityObjectives, this.unfinishedWFObjective) + } + + override getComparator() { Comparators.LOWER_IS_BETTER } + override getFitness(ThreadContext context) { + var sum = 0.0 + val scopeFitnes = scopeObjective.getFitness(context) + //val unfinishedMultiplicitiesFitneses = unfinishedMultiplicityObjectives.map[x|x.getFitness(context)] + val unfinishedWFsFitness = unfinishedWFObjective.getFitness(context) + + sum+=scopeFitnes + var multiplicity = 0.0 + for(multiplicityObjective : unfinishedMultiplicityObjectives) { + multiplicity+=multiplicityObjective.getFitness(context)//*0.5 + } + sum+=multiplicity + sum += unfinishedWFsFitness//*0.5 + +// println('''Sum=«sum»|Scope=«scopeFitnes»|Multiplicity=«multiplicity»|WFs=«unfinishedWFsFitness»''') + + return sum + } + + override getLevel() { 2 } + override getName() { "CompositeUnfinishednessObjective"} + + override isHardObjective() { true } + override satisifiesHardObjective(Double fitness) { fitness <= 0.001 } + + + override setComparator(Comparator comparator) { + throw new UnsupportedOperationException("TODO: auto-generated method stub") + } + override setLevel(int level) { + throw new UnsupportedOperationException("TODO: auto-generated method stub") + } + +} \ No newline at end of file diff --git a/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.reasoner/src/hu/bme/mit/inf/dslreasoner/viatrasolver/reasoner/dse/PartialModelAsLogicInterpretation.xtend b/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.reasoner/src/hu/bme/mit/inf/dslreasoner/viatrasolver/reasoner/dse/PartialModelAsLogicInterpretation.xtend new file mode 100644 index 00000000..b2a7e3f5 --- /dev/null +++ b/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.reasoner/src/hu/bme/mit/inf/dslreasoner/viatrasolver/reasoner/dse/PartialModelAsLogicInterpretation.xtend @@ -0,0 +1,30 @@ +package hu.bme.mit.inf.dslreasoner.viatrasolver.reasoner.dse + +import hu.bme.mit.inf.dslreasoner.logic.model.builder.LogicModelInterpretation +import hu.bme.mit.inf.dslreasoner.logic.model.logiclanguage.Type +import hu.bme.mit.inf.dslreasoner.logic.model.logiclanguage.FunctionDeclaration +import hu.bme.mit.inf.dslreasoner.logic.model.logiclanguage.RelationDeclaration +import hu.bme.mit.inf.dslreasoner.logic.model.logiclanguage.ConstantDeclaration + +class PartialModelAsLogicInterpretation implements LogicModelInterpretation{ + + + override getElements(Type type) { + throw new UnsupportedOperationException("TODO: auto-generated method stub") + } + + override getInterpretation(FunctionDeclaration function, Object[] parameterSubstitution) { + throw new UnsupportedOperationException("TODO: auto-generated method stub") + } + + override getInterpretation(RelationDeclaration relation, Object[] parameterSubstitution) { + throw new UnsupportedOperationException("TODO: auto-generated method stub") + } + + override getInterpretation(ConstantDeclaration constant) { + throw new UnsupportedOperationException("TODO: auto-generated method stub") + } + + override getMinimalInteger() { 0 } + override getMaximalInteger() {0 } +} \ No newline at end of file diff --git a/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.reasoner/src/hu/bme/mit/inf/dslreasoner/viatrasolver/reasoner/dse/ScopeObjective.xtend b/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.reasoner/src/hu/bme/mit/inf/dslreasoner/viatrasolver/reasoner/dse/ScopeObjective.xtend new file mode 100644 index 00000000..d3497ef2 --- /dev/null +++ b/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.reasoner/src/hu/bme/mit/inf/dslreasoner/viatrasolver/reasoner/dse/ScopeObjective.xtend @@ -0,0 +1,41 @@ +package hu.bme.mit.inf.dslreasoner.viatrasolver.reasoner.dse + +import org.eclipse.viatra.dse.objectives.IObjective +import org.eclipse.viatra.dse.base.ThreadContext +import java.util.Comparator +import hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage.partialinterpretation.PartialInterpretation + +class ScopeObjective implements IObjective{ + static val comparator = new Comparator() { + override compare(Double o1, Double o2) { + + return o2.compareTo(o1) + } + } + + //val static scopeLevel = 3 + + override createNew() { return new ScopeObjective } + override getName() { '''ScopeConstraint''' } + override init(ThreadContext context) { } + + override getComparator() { comparator } + + override getFitness(ThreadContext context) { + val interpretation = context.model as PartialInterpretation + val res = interpretation.minNewElements + return res.doubleValue + } + + override isHardObjective() { true } + override satisifiesHardObjective(Double fitness) { return fitness <=0.01 } + + override setComparator(Comparator comparator) { + throw new UnsupportedOperationException("TODO: auto-generated method stub") + } + + override setLevel(int level) { + throw new UnsupportedOperationException("TODO: auto-generated method stub") + } + override getLevel() { 2 } +} \ No newline at end of file diff --git a/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.reasoner/src/hu/bme/mit/inf/dslreasoner/viatrasolver/reasoner/dse/SolutionStoreWithCopy.xtend b/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.reasoner/src/hu/bme/mit/inf/dslreasoner/viatrasolver/reasoner/dse/SolutionStoreWithCopy.xtend new file mode 100644 index 00000000..2892723b --- /dev/null +++ b/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.reasoner/src/hu/bme/mit/inf/dslreasoner/viatrasolver/reasoner/dse/SolutionStoreWithCopy.xtend @@ -0,0 +1,35 @@ +package hu.bme.mit.inf.dslreasoner.viatrasolver.reasoner.dse + +import java.util.List +import hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage.partialinterpretation.PartialInterpretation +import java.util.LinkedList +import org.eclipse.emf.ecore.EObject +import java.util.Map +import org.eclipse.emf.ecore.util.EcoreUtil +import org.eclipse.viatra.dse.base.ThreadContext + +class SolutionStoreWithCopy { + long runtime = 0 + List solutions = new LinkedList + List> copyTraces = new LinkedList + + long initTime = System.nanoTime + + def newSolution(ThreadContext context) { + //print(System.nanoTime-initTime + ";") + val copyStart = System.nanoTime + val solution = context.model as PartialInterpretation + val copier = new EcoreUtil.Copier + val solutionCopy = copier.copy(solution) as PartialInterpretation + copier.copyReferences + solutions.add(solutionCopy) + copyTraces.add(copier) + runtime += System.nanoTime - copyStart + } + def getSumRuntime() { + return runtime + } + def getSolutions() { + solutions + } +} \ No newline at end of file diff --git a/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.reasoner/src/hu/bme/mit/inf/dslreasoner/viatrasolver/reasoner/dse/SolutionStoreWithDiversityDescriptor.xtend b/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.reasoner/src/hu/bme/mit/inf/dslreasoner/viatrasolver/reasoner/dse/SolutionStoreWithDiversityDescriptor.xtend new file mode 100644 index 00000000..ca39cada --- /dev/null +++ b/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.reasoner/src/hu/bme/mit/inf/dslreasoner/viatrasolver/reasoner/dse/SolutionStoreWithDiversityDescriptor.xtend @@ -0,0 +1,77 @@ +package hu.bme.mit.inf.dslreasoner.viatrasolver.reasoner.dse + +import hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage.neighbourhood.AbstractNodeDescriptor +import hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage.neighbourhood.NeighbourhoodWithTraces +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.reasoner.DiversityDescriptor +import java.util.LinkedList +import java.util.List +import java.util.Map +import org.eclipse.viatra.dse.base.ThreadContext + +class SolutionStoreWithDiversityDescriptor { + val DiversityDescriptor descriptor + val PartialInterpretation2ImmutableTypeLattice solutionCoder = new PartialInterpretation2ImmutableTypeLattice + val List, AbstractNodeDescriptor>> solutionCodeList = new LinkedList + + var long runtime + var int allCheck + var int successfulCheck + + public new(DiversityDescriptor descriptor) { + this.descriptor = descriptor + } + + def public isActive() { + descriptor!==null + } + + def getSumRuntime() { + return runtime + } + def getSuccessRate() { + return successfulCheck as double / allCheck + } + + def isDifferent(ThreadContext context) { + if(active) { + val start = System.nanoTime + val model = context.model as PartialInterpretation + val code = solutionCoder.createRepresentation(model, + descriptor.range, + descriptor.parallels, + descriptor.maxNumber, + descriptor.relevantTypes, + descriptor.relevantRelations) + val isDifferent = solutionCodeList.forall[previous | ! code.equals(previous)] + runtime += System.nanoTime - start + allCheck++ + if(isDifferent) { successfulCheck++ } + return isDifferent + } else { + allCheck++ + successfulCheck++ + return true + } + } + + def canBeDifferent(ThreadContext context) { + return true + } + + def newSolution(ThreadContext context) { + if(active) { + val start = System.nanoTime + val model = context.model as PartialInterpretation + val code = solutionCoder.createRepresentation(model, + descriptor.range, + descriptor.parallels, + descriptor.maxNumber, + descriptor.relevantTypes, + descriptor.relevantRelations) + solutionCodeList += code + runtime += System.nanoTime - start + } + } +} \ No newline at end of file diff --git a/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.reasoner/src/hu/bme/mit/inf/dslreasoner/viatrasolver/reasoner/dse/UnfinishedMultiplicityObjective.xtend b/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.reasoner/src/hu/bme/mit/inf/dslreasoner/viatrasolver/reasoner/dse/UnfinishedMultiplicityObjective.xtend new file mode 100644 index 00000000..aad9a448 --- /dev/null +++ b/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.reasoner/src/hu/bme/mit/inf/dslreasoner/viatrasolver/reasoner/dse/UnfinishedMultiplicityObjective.xtend @@ -0,0 +1,37 @@ +package hu.bme.mit.inf.dslreasoner.viatrasolver.reasoner.dse + +import hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra.MultiplicityGoalConstraintCalculator +import java.util.Comparator +import org.eclipse.viatra.dse.base.ThreadContext +import org.eclipse.viatra.dse.objectives.IObjective +import org.eclipse.viatra.dse.objectives.Comparators + +class UnfinishedMultiplicityObjective implements IObjective { + val MultiplicityGoalConstraintCalculator unfinishedMultiplicity; + + public new(MultiplicityGoalConstraintCalculator unfinishedMultiplicity) { + this.unfinishedMultiplicity = unfinishedMultiplicity + } + + override getName() '''unfinishedMultiplicity «unfinishedMultiplicity.name»''' + override createNew() { + return new UnfinishedMultiplicityObjective(new MultiplicityGoalConstraintCalculator(this.unfinishedMultiplicity)) + } + + override getComparator() { Comparators.LOWER_IS_BETTER } + override getFitness(ThreadContext context) { + val unfinishedMultiplicity = unfinishedMultiplicity.calculateValue + return unfinishedMultiplicity.doubleValue + } + override getLevel() { 2 } + override init(ThreadContext context) { unfinishedMultiplicity.init(context.model) } + override isHardObjective() { true } + override satisifiesHardObjective(Double fitness) { return fitness <=0.01 } + + override setComparator(Comparator comparator) { + throw new UnsupportedOperationException("TODO: auto-generated method stub") + } + override setLevel(int level) { + throw new UnsupportedOperationException("TODO: auto-generated method stub") + } +} \ No newline at end of file diff --git a/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.reasoner/src/hu/bme/mit/inf/dslreasoner/viatrasolver/reasoner/dse/UnfinishedWFObjective.xtend b/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.reasoner/src/hu/bme/mit/inf/dslreasoner/viatrasolver/reasoner/dse/UnfinishedWFObjective.xtend new file mode 100644 index 00000000..0fd20fa3 --- /dev/null +++ b/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.reasoner/src/hu/bme/mit/inf/dslreasoner/viatrasolver/reasoner/dse/UnfinishedWFObjective.xtend @@ -0,0 +1,56 @@ +package hu.bme.mit.inf.dslreasoner.viatrasolver.reasoner.dse + +import org.eclipse.viatra.dse.objectives.IObjective +import org.eclipse.viatra.query.runtime.api.IPatternMatch +import org.eclipse.viatra.query.runtime.api.ViatraQueryMatcher +import org.eclipse.viatra.query.runtime.api.IQuerySpecification +import java.util.Collection +import org.eclipse.viatra.query.runtime.api.ViatraQueryEngine +import org.eclipse.viatra.query.runtime.emf.EMFScope +import org.eclipse.viatra.dse.base.ThreadContext +import java.util.List +import org.eclipse.viatra.dse.objectives.Comparators +import java.util.ArrayList +import java.util.Comparator + +class UnfinishedWFObjective implements IObjective { + Collection>> unfinishedWFs + val List> matchers + + public new(Collection>> unfinishedWFs) { + this.unfinishedWFs = unfinishedWFs + matchers = new ArrayList(unfinishedWFs.size) + } + override getName() '''unfinishedWFs''' + override createNew() { + return new UnfinishedWFObjective(unfinishedWFs) + } + override init(ThreadContext context) { + val engine = context.queryEngine//ViatraQueryEngine.on(new EMFScope(context.model)) + for(unfinishedWF : unfinishedWFs) { + matchers += unfinishedWF.getMatcher(engine) + } + } + + override getComparator() { Comparators.LOWER_IS_BETTER } + override getFitness(ThreadContext context) { + var sumOfMatches = 0 + for(matcher : matchers) { + val number = matcher.countMatches +// println('''«matcher.patternName» = «number»''') + sumOfMatches+=number + } + return sumOfMatches.doubleValue + } + + override getLevel() { 2 } + override isHardObjective() { true } + override satisifiesHardObjective(Double fitness) { return fitness <=0.01 } + + override setComparator(Comparator comparator) { + throw new UnsupportedOperationException("TODO: auto-generated method stub") + } + override setLevel(int level) { + throw new UnsupportedOperationException("TODO: auto-generated method stub") + } +} \ No newline at end of file diff --git a/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.reasoner/src/hu/bme/mit/inf/dslreasoner/viatrasolver/reasoner/dse/WF2ObjectiveConverter.xtend b/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.reasoner/src/hu/bme/mit/inf/dslreasoner/viatrasolver/reasoner/dse/WF2ObjectiveConverter.xtend new file mode 100644 index 00000000..4fd297ca --- /dev/null +++ b/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.reasoner/src/hu/bme/mit/inf/dslreasoner/viatrasolver/reasoner/dse/WF2ObjectiveConverter.xtend @@ -0,0 +1,36 @@ +package hu.bme.mit.inf.dslreasoner.viatrasolver.reasoner.dse + +import java.util.ArrayList +import java.util.Collection +import org.eclipse.viatra.dse.objectives.Comparators +import org.eclipse.viatra.dse.objectives.IGlobalConstraint +import org.eclipse.viatra.dse.objectives.impl.ConstraintsObjective +import org.eclipse.viatra.dse.objectives.impl.ConstraintsObjective.QueryConstraint +import org.eclipse.viatra.dse.objectives.impl.ModelQueriesGlobalConstraint +import org.eclipse.viatra.query.runtime.api.IPatternMatch +import org.eclipse.viatra.query.runtime.api.IQuerySpecification +import org.eclipse.viatra.query.runtime.api.ViatraQueryMatcher + +class WF2ObjectiveConverter { + + def createCompletenessObjective( + Collection>> unfinishedWF) + { + val res = new ConstraintsObjective('''unfinishedWFs''', + unfinishedWF.map[ + new QueryConstraint(it.fullyQualifiedName,it,1.0) + ].toList + ) + res.withComparator(Comparators.LOWER_IS_BETTER) + res.level = 2 + return res + } + + def IGlobalConstraint createInvalidationObjective( + Collection>> invalidatedByWF) + { + return new ModelQueriesGlobalConstraint('''invalidatedWFs''', + new ArrayList(invalidatedByWF) + ) + } +} \ No newline at end of file -- cgit v1.2.3-70-g09d2