From c13b2f8ad357f146b54ae67653d1869ab994bfcd Mon Sep 17 00:00:00 2001 From: ipatini Date: Thu, 28 Nov 2019 12:51:00 +0100 Subject: [PATCH 001/340] Added InfluxDB staff --- .../penaltycalculator/PenaltyFunction.java | 57 ++++++++++++++++++- 1 file changed, 56 insertions(+), 1 deletion(-) diff --git a/penalty-calculator/src/main/java/eu/melodic/upperware/penaltycalculator/PenaltyFunction.java b/penalty-calculator/src/main/java/eu/melodic/upperware/penaltycalculator/PenaltyFunction.java index 965adb2e1..20a475bd8 100644 --- a/penalty-calculator/src/main/java/eu/melodic/upperware/penaltycalculator/PenaltyFunction.java +++ b/penalty-calculator/src/main/java/eu/melodic/upperware/penaltycalculator/PenaltyFunction.java @@ -16,10 +16,17 @@ import lombok.Setter; import lombok.extern.slf4j.Slf4j; import org.apache.commons.math3.stat.regression.OLSMultipleLinearRegression; import org.apache.log4j.BasicConfigurator; +import org.influxdb.InfluxDB; +import org.influxdb.InfluxDBFactory; +import org.influxdb.dto.Point; +import org.influxdb.dto.Query; +import org.influxdb.dto.QueryResult; +import org.influxdb.impl.InfluxDBMapper; import org.springframework.beans.factory.annotation.Autowired; import org.springframework.stereotype.Service; import java.util.*; +import java.util.concurrent.TimeUnit; import java.util.stream.Collectors; @Slf4j @@ -128,10 +135,58 @@ public class PenaltyFunction { MemCachedClient mcc = new MemCachedClient("Test2"); // connect to Daniel's InfluxDB and created database with queries...unused yet +//XXX:BEGIN + String dbName = "cloudiator"; + log.info("INFLUX point A - START"); + InfluxDB influxDB = InfluxDBFactory.connect("http://134.60.152.213:8086", "vasilis", "EiWeif0w"); + log.info("INFLUX point B - connected"); - String arr = null; + // Flush every 2000 Points, at least every 100ms + influxDB.enableBatch(2000, 100, TimeUnit.MILLISECONDS); + + for (int i = 0; i < 5; i++) { + try { + Thread.sleep(1000); + } catch (InterruptedException e) { + e.printStackTrace(); + } + Point point2 = Point.measurement("ComponentTime") + .time(System.currentTimeMillis(), TimeUnit.MILLISECONDS) + .addField("timeDepl", Math.random() * 400L) + .addField("ComponentName", "AppResponse") + .build(); + influxDB.write(dbName, "autogen", point2); + } + log.info("INFLUX point C - Added point"); + + Query query = new Query("SELECT * FROM ComponentTime", dbName); + QueryResult queryResult = influxDB.query(query); + log.info("InfluxDB query result: {}", queryResult); + + //InfluxDB connection = connectDatabase(); + + // querying from centos_test_db DB + + InfluxDBMapper influxDBMapper = new InfluxDBMapper(influxDB); + //Query query1 = select("timeDepl").from(dbName,"ComponentTime"); + //Query query1 = new Query("SELECT timeDepl FROM ComponentTime", dbName); + log.info("INFLUX point D - InfluxDB Mapper initialized"); + + Query query1 = new Query("SELECT mean(\"value\") AS \"mean_value\" FROM \"cloudiator\".\"autogen\".\"process-start-time\" WHERE \"task\"='database' GROUP BY time(5s) FILL(null)", dbName); + //Logger.info("Executing query "+query1.getCommand()); + List ComponMeasurements = influxDBMapper.query(query1, ComponMeasurement.class); + log.info("INFLUX point E - Query ok: size={}", ComponMeasurements.size()); + ComponMeasurements.forEach(r -> log.info(" - {}", r)); + + + log.info("INFLUX point F - Query results listed"); + String arr = ComponMeasurements.toString(); + log.info("INFLUX point G - arr: {}", arr); + + //String arr = null; log.info(arr); +//XXX:END //check if we have Null Component Deployment Times and act accordingy +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ -- GitLab From ca7bf5d5c48a2056cb43082f4d32fed541d1ef78 Mon Sep 17 00:00:00 2001 From: tc360950 Date: Sat, 30 Nov 2019 15:26:23 +0100 Subject: [PATCH 002/340] Initial commit - directory structure for project --- ZPPSolver/CPParser/pom.xml | 12 ++++++++++++ ZPPSolver/GeneticSolver/pom.xml | 12 ++++++++++++ ZPPSolver/MCTSSolver/pom.xml | 12 ++++++++++++ 3 files changed, 36 insertions(+) create mode 100644 ZPPSolver/CPParser/pom.xml create mode 100644 ZPPSolver/GeneticSolver/pom.xml create mode 100644 ZPPSolver/MCTSSolver/pom.xml diff --git a/ZPPSolver/CPParser/pom.xml b/ZPPSolver/CPParser/pom.xml new file mode 100644 index 000000000..4bef7a845 --- /dev/null +++ b/ZPPSolver/CPParser/pom.xml @@ -0,0 +1,12 @@ + + + 4.0.0 + + ZPPSolver + CPParser + 1.0-SNAPSHOT + + + \ No newline at end of file diff --git a/ZPPSolver/GeneticSolver/pom.xml b/ZPPSolver/GeneticSolver/pom.xml new file mode 100644 index 000000000..3bfbc9661 --- /dev/null +++ b/ZPPSolver/GeneticSolver/pom.xml @@ -0,0 +1,12 @@ + + + 4.0.0 + + ZPPSolver + GeneticSolver + 1.0-SNAPSHOT + + + \ No newline at end of file diff --git a/ZPPSolver/MCTSSolver/pom.xml b/ZPPSolver/MCTSSolver/pom.xml new file mode 100644 index 000000000..4a05d27d3 --- /dev/null +++ b/ZPPSolver/MCTSSolver/pom.xml @@ -0,0 +1,12 @@ + + + 4.0.0 + + ZPPSolver + MCTSSolver + 1.0-SNAPSHOT + + + \ No newline at end of file -- GitLab From 0af41aaaef9f3dc2fedeb91ceea0df8a9920a769 Mon Sep 17 00:00:00 2001 From: tc360950 Date: Sat, 30 Nov 2019 17:51:37 +0100 Subject: [PATCH 003/340] Minor fixes in structure --- ZPPSolver/CPParser/pom.xml | 15 ++++++++++++--- ZPPSolver/GeneticSolver/pom.xml | 8 ++++++-- ZPPSolver/MCTSSolver/pom.xml | 8 ++++++-- pom.xml | 3 +++ 4 files changed, 27 insertions(+), 7 deletions(-) diff --git a/ZPPSolver/CPParser/pom.xml b/ZPPSolver/CPParser/pom.xml index 4bef7a845..41ff39f45 100644 --- a/ZPPSolver/CPParser/pom.xml +++ b/ZPPSolver/CPParser/pom.xml @@ -2,11 +2,20 @@ + + upperware + org.ow2.paasage + 2.5.1-SNAPSHOT + ../../pom.xml + 4.0.0 - ZPPSolver CPParser - 1.0-SNAPSHOT - + + + org.ow2.paasage + upperware-metamodel + + \ No newline at end of file diff --git a/ZPPSolver/GeneticSolver/pom.xml b/ZPPSolver/GeneticSolver/pom.xml index 3bfbc9661..9a597b957 100644 --- a/ZPPSolver/GeneticSolver/pom.xml +++ b/ZPPSolver/GeneticSolver/pom.xml @@ -2,11 +2,15 @@ + + upperware + org.ow2.paasage + 2.5.1-SNAPSHOT + ../../pom.xml + 4.0.0 - ZPPSolver GeneticSolver - 1.0-SNAPSHOT \ No newline at end of file diff --git a/ZPPSolver/MCTSSolver/pom.xml b/ZPPSolver/MCTSSolver/pom.xml index 4a05d27d3..9f99c4884 100644 --- a/ZPPSolver/MCTSSolver/pom.xml +++ b/ZPPSolver/MCTSSolver/pom.xml @@ -2,11 +2,15 @@ + + upperware + org.ow2.paasage + 2.5.1-SNAPSHOT + ../../pom.xml + 4.0.0 - ZPPSolver MCTSSolver - 1.0-SNAPSHOT \ No newline at end of file diff --git a/pom.xml b/pom.xml index e479e4826..8d0c5a8fe 100644 --- a/pom.xml +++ b/pom.xml @@ -40,6 +40,9 @@ dlms event-management mq-http-adapter + ZPPSolver/CPParser + ZPPSolver/GeneticSolver + ZPPSolver/MCTSSolver -- GitLab From a8d0e5d392489468eea74b5adcde2f093a77eb1c Mon Sep 17 00:00:00 2001 From: tc360950 Date: Sat, 30 Nov 2019 19:46:11 +0100 Subject: [PATCH 004/340] Implemented ExpressionEvaluator and ArConstraint classes --- ZPPSolver/CPParser/pom.xml | 16 +++ .../CPParser/src/main/java/ArConstraint.java | 36 ++++++ .../src/main/java/ExpressionEvaluator.java | 111 ++++++++++++++++++ .../src/test/java/ArConstraintTest.java | 39 ++++++ .../test/java/ExpressionEvaluatorTest.java | 17 +++ 5 files changed, 219 insertions(+) create mode 100644 ZPPSolver/CPParser/src/main/java/ArConstraint.java create mode 100644 ZPPSolver/CPParser/src/main/java/ExpressionEvaluator.java create mode 100644 ZPPSolver/CPParser/src/test/java/ArConstraintTest.java create mode 100644 ZPPSolver/CPParser/src/test/java/ExpressionEvaluatorTest.java diff --git a/ZPPSolver/CPParser/pom.xml b/ZPPSolver/CPParser/pom.xml index 41ff39f45..55b13e56a 100644 --- a/ZPPSolver/CPParser/pom.xml +++ b/ZPPSolver/CPParser/pom.xml @@ -16,6 +16,22 @@ org.ow2.paasage upperware-metamodel + + org.junit.jupiter + junit-jupiter + RELEASE + test + + + junit + junit + test + + + org.projectlombok + lombok + + \ No newline at end of file diff --git a/ZPPSolver/CPParser/src/main/java/ArConstraint.java b/ZPPSolver/CPParser/src/main/java/ArConstraint.java new file mode 100644 index 000000000..73c3cf057 --- /dev/null +++ b/ZPPSolver/CPParser/src/main/java/ArConstraint.java @@ -0,0 +1,36 @@ +import eu.paasage.upperware.metamodel.cp.*; +import eu.paasage.upperware.metamodel.types.*; +import lombok.Getter; + +import java.util.Collection; +import java.util.Map; + +public class ArConstraint { + + @Getter + private Collection variables; + + private ComparatorEnum comparator; + + Expression leftExpression; + + Expression rightExpression; + + private boolean checkVariables(Collection vars) { + return vars.containsAll(variables); + } + + public ArConstraint(){ + + } + + public boolean evaluate(Map variables){ + if (!checkVariables(variables.keySet())) { + throw new RuntimeException("Can't evaluate - some variables are missing"); + } + double leftExpValue = ExpressionEvaluator.evaluateExpression(leftExpression, variables); + double rightExpValue = ExpressionEvaluator.evaluateExpression(leftExpression, variables); + + return ExpressionEvaluator.evaluateComparator(comparator, leftExpValue, rightExpValue); + } +} diff --git a/ZPPSolver/CPParser/src/main/java/ExpressionEvaluator.java b/ZPPSolver/CPParser/src/main/java/ExpressionEvaluator.java new file mode 100644 index 000000000..d60d08272 --- /dev/null +++ b/ZPPSolver/CPParser/src/main/java/ExpressionEvaluator.java @@ -0,0 +1,111 @@ +import eu.paasage.upperware.metamodel.types.*; +import eu.paasage.upperware.metamodel.cp.*; +import sun.tools.jstat.Operator; + +import java.util.Collection; +import java.util.List; +import java.util.Map; +import java.util.stream.Collectors; + +public class ExpressionEvaluator { + public static final double PRECISION = 0.1; + + private static double getValueOfNumericInterface(NumericValueUpperware value) { + if (value instanceof IntegerValueUpperware) { + return (double)((IntegerValueUpperware) value).getValue(); + } else if (value instanceof LongValueUpperware) { + return (double)(int)((LongValueUpperware) value).getValue(); + } else if (value instanceof DoubleValueUpperware) { + return ((DoubleValueUpperware) value).getValue(); + } else if (value instanceof FloatValueUpperware) { + return (double)((FloatValueUpperware) value).getValue(); + } + throw new RuntimeException("Unsupported NumericValueUpperware implementation"); + } + + private static boolean isTwoArgsOperator(OperatorEnum oper) { + return (oper == OperatorEnum.MINUS || oper == OperatorEnum.DIV || oper == OperatorEnum.EQ); + } + + public static double evaluateOnOperator(OperatorEnum oper, List values) { + if (isTwoArgsOperator(oper) && values.size() != 2) { + throw new RuntimeException("MINUS, DIV, EQ operators must be evaluated on exactly two arguments"); + } + + switch (oper) { + case PLUS: + return values.stream() + .reduce((double) 0, (subtotal, element) -> subtotal + element); + case MINUS: + return values.get(0) - values.get(1); + case TIMES: + return values.stream() + .reduce((double) 1, (subtotal, element) -> subtotal * element); + case DIV: + return values.get(0) / values.get(1); // TODO czy sprawdzac dzielenie przez zero + case EQ: + double diff = values.get(0) - values.get(1); + return Math.abs(diff) <= ExpressionEvaluator.PRECISION ? 1.0 : 0.0; + } + //TODO throw + return 0.0; + } + + private static double evaluateComposedExpression(ComposedExpression exp, Map variables) { + List expressionsValues = exp.getExpressions() + .stream() + .map(e -> evaluateExpression(e, variables)) + .collect(Collectors.toList()); + return evaluateOnOperator(exp.getOperator(), expressionsValues); + } + + public static double evaluateExpression(Expression exp, Map variables) { + if (isConstant(exp)) { + return getValueOfNumericInterface(((Constant) exp).getValue()); + } else if (isCpMetric(exp)) { + return getValueOfNumericInterface(((CpMetric) exp).getValue()); + } else if (isCpVariable(exp)) { + return variables.get(exp.getId()); + } else if (isComposedExpression(exp)) { + return evaluateComposedExpression((ComposedExpression) exp, variables); + } + //TODO throw + return 0.0; + } + + public static boolean evaluateComparator(ComparatorEnum comparator, double argLeft, double argRight) { + switch (comparator) { + case GREATER_THAN: + return argLeft - argRight > ExpressionEvaluator.PRECISION; + case GREATER_OR_EQUAL_TO: + return argLeft - argRight > -ExpressionEvaluator.PRECISION; + case EQUAL_TO: + return Math.abs(argLeft - argRight) <= ExpressionEvaluator.PRECISION; + case LESS_OR_EQUAL_TO: + return argRight - argLeft > -ExpressionEvaluator.PRECISION; + case LESS_THAN: + return argRight - argLeft > ExpressionEvaluator.PRECISION;; + case DIFFERENT: + return Math.abs(argLeft - argRight) > ExpressionEvaluator.PRECISION; + + } + //TODO throws + return false; + } + + private static boolean isConstant(Expression expression){ + return expression instanceof Constant; + } + + private static boolean isCpVariable(Expression expression){ + return expression instanceof CpVariable; + } + + private static boolean isCpMetric(Expression expression){ + return expression instanceof CpMetric; + } + + private static boolean isComposedExpression(Expression expression){ + return expression instanceof ComposedExpression; + } +} diff --git a/ZPPSolver/CPParser/src/test/java/ArConstraintTest.java b/ZPPSolver/CPParser/src/test/java/ArConstraintTest.java new file mode 100644 index 000000000..313d3e970 --- /dev/null +++ b/ZPPSolver/CPParser/src/test/java/ArConstraintTest.java @@ -0,0 +1,39 @@ + +import org.junit.jupiter.api.BeforeAll; +import org.junit.jupiter.api.Test; + +import java.util.HashMap; +import java.util.Map; + +import static org.junit.jupiter.api.Assertions.*; + +class ArConstraintTest { + private static ArConstraint constraint; + + @BeforeAll + public static void setup(){ + constraint = new ArConstraint(); + } + @Test + public void shouldThrowEmptyVariables(){ + Map emptyVars = new HashMap<>(); + assertThrows(RuntimeException.class, () -> { + constraint.evaluate(emptyVars); + }); + } + + @Test + public void shouldThrowWrongVariables(){ + Map emptyVars = new HashMap<>(); + assertThrows(RuntimeException.class, () -> { + constraint.evaluate(emptyVars); + }); + } + + @Test + public void TEMP(){ + Map emptyVars = new HashMap<>(); + assertTrue(constraint.evaluate(emptyVars)); + } + +} \ No newline at end of file diff --git a/ZPPSolver/CPParser/src/test/java/ExpressionEvaluatorTest.java b/ZPPSolver/CPParser/src/test/java/ExpressionEvaluatorTest.java new file mode 100644 index 000000000..0c98c9cf6 --- /dev/null +++ b/ZPPSolver/CPParser/src/test/java/ExpressionEvaluatorTest.java @@ -0,0 +1,17 @@ +import eu.paasage.upperware.metamodel.cp.impl.ConstantImpl; +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.Test; + +import static org.junit.jupiter.api.Assertions.*; + +class ExpressionEvaluatorTest { + + @BeforeEach + void setUp() { + } + + @Test + public void constantEvaluateTest() { + + } +} \ No newline at end of file -- GitLab From a9062c8c3a3bf952dcef425e1a0e1fa8819501e8 Mon Sep 17 00:00:00 2001 From: tc360950 Date: Sun, 1 Dec 2019 16:40:05 +0100 Subject: [PATCH 005/340] Added test for ExpressionEvaluator --- ZPPSolver/CPParser/pom.xml | 5 + .../CPParser/src/main/java/ArConstraint.java | 33 +-- .../src/main/java/ArConstraintImpl.java | 50 ++++ .../src/main/java/ExpressionEvaluator.java | 11 +- .../src/test/java/ArConstraintImplTest.java | 85 +++++++ .../src/test/java/ArConstraintTest.java | 39 ---- .../test/java/ComposedExpressionImplTest.java | 27 +++ .../src/test/java/ConstantImplTest.java | 30 +++ .../src/test/java/CpMetricImplTest.java | 30 +++ .../src/test/java/CpVariableImplTest.java | 47 ++++ .../test/java/ExpressionEvaluatorTest.java | 103 ++++++++- .../java/NumericValueUpperwareImplTest.java | 215 ++++++++++++++++++ 12 files changed, 600 insertions(+), 75 deletions(-) create mode 100644 ZPPSolver/CPParser/src/main/java/ArConstraintImpl.java create mode 100644 ZPPSolver/CPParser/src/test/java/ArConstraintImplTest.java delete mode 100644 ZPPSolver/CPParser/src/test/java/ArConstraintTest.java create mode 100644 ZPPSolver/CPParser/src/test/java/ComposedExpressionImplTest.java create mode 100644 ZPPSolver/CPParser/src/test/java/ConstantImplTest.java create mode 100644 ZPPSolver/CPParser/src/test/java/CpMetricImplTest.java create mode 100644 ZPPSolver/CPParser/src/test/java/CpVariableImplTest.java create mode 100644 ZPPSolver/CPParser/src/test/java/NumericValueUpperwareImplTest.java diff --git a/ZPPSolver/CPParser/pom.xml b/ZPPSolver/CPParser/pom.xml index 55b13e56a..767c83909 100644 --- a/ZPPSolver/CPParser/pom.xml +++ b/ZPPSolver/CPParser/pom.xml @@ -31,6 +31,11 @@ org.projectlombok lombok + + antlr + antlr + test + diff --git a/ZPPSolver/CPParser/src/main/java/ArConstraint.java b/ZPPSolver/CPParser/src/main/java/ArConstraint.java index 73c3cf057..4333b8a03 100644 --- a/ZPPSolver/CPParser/src/main/java/ArConstraint.java +++ b/ZPPSolver/CPParser/src/main/java/ArConstraint.java @@ -1,36 +1,9 @@ -import eu.paasage.upperware.metamodel.cp.*; -import eu.paasage.upperware.metamodel.types.*; -import lombok.Getter; - import java.util.Collection; import java.util.Map; -public class ArConstraint { - - @Getter - private Collection variables; - - private ComparatorEnum comparator; - - Expression leftExpression; - - Expression rightExpression; - - private boolean checkVariables(Collection vars) { - return vars.containsAll(variables); - } - - public ArConstraint(){ - - } +public interface ArConstraint { - public boolean evaluate(Map variables){ - if (!checkVariables(variables.keySet())) { - throw new RuntimeException("Can't evaluate - some variables are missing"); - } - double leftExpValue = ExpressionEvaluator.evaluateExpression(leftExpression, variables); - double rightExpValue = ExpressionEvaluator.evaluateExpression(leftExpression, variables); + public Collection getVariableNames(); - return ExpressionEvaluator.evaluateComparator(comparator, leftExpValue, rightExpValue); - } + public boolean evaluate(Map variables); } diff --git a/ZPPSolver/CPParser/src/main/java/ArConstraintImpl.java b/ZPPSolver/CPParser/src/main/java/ArConstraintImpl.java new file mode 100644 index 000000000..b4e9cc5fd --- /dev/null +++ b/ZPPSolver/CPParser/src/main/java/ArConstraintImpl.java @@ -0,0 +1,50 @@ +import eu.paasage.upperware.metamodel.cp.*; +import eu.paasage.upperware.metamodel.types.*; +import lombok.Getter; + +import java.util.ArrayList; +import java.util.Collection; +import java.util.Map; + +public class ArConstraintImpl implements ArConstraint { + + private Collection variablesNames; + + private ComparatorEnum comparator; + + Expression leftExpression; + + Expression rightExpression; + + private void collectVariableNames() { + //TODO + variablesNames = new ArrayList<>(); + } + + private boolean checkVariables(Collection vars) { + return vars.containsAll(variablesNames); + } + + public ArConstraintImpl(ComparatorEnum comp, Expression exp1, Expression exp2){ + this.comparator = comp; + this.leftExpression = exp1; + this.rightExpression = exp2; + collectVariableNames(); + } + + @Override + public boolean evaluate(Map variables){ + if (!checkVariables(variables.keySet())) { + throw new RuntimeException("Can't evaluate - some variables are missing"); + } + double leftExpValue = ExpressionEvaluator.evaluateExpression(leftExpression, variables); + double rightExpValue = ExpressionEvaluator.evaluateExpression(leftExpression, variables); + + return ExpressionEvaluator.evaluateComparator(comparator, leftExpValue, rightExpValue); + } + + @Override + public Collection getVariableNames() { + return variablesNames; + } +} diff --git a/ZPPSolver/CPParser/src/main/java/ExpressionEvaluator.java b/ZPPSolver/CPParser/src/main/java/ExpressionEvaluator.java index d60d08272..55775676f 100644 --- a/ZPPSolver/CPParser/src/main/java/ExpressionEvaluator.java +++ b/ZPPSolver/CPParser/src/main/java/ExpressionEvaluator.java @@ -1,8 +1,6 @@ import eu.paasage.upperware.metamodel.types.*; import eu.paasage.upperware.metamodel.cp.*; -import sun.tools.jstat.Operator; -import java.util.Collection; import java.util.List; import java.util.Map; import java.util.stream.Collectors; @@ -42,7 +40,11 @@ public class ExpressionEvaluator { return values.stream() .reduce((double) 1, (subtotal, element) -> subtotal * element); case DIV: - return values.get(0) / values.get(1); // TODO czy sprawdzac dzielenie przez zero + if ( values.get(1) == 0.0) { + throw new RuntimeException("Division by zero encountered"); + } else { + return values.get(0) / values.get(1); + } case EQ: double diff = values.get(0) - values.get(1); return Math.abs(diff) <= ExpressionEvaluator.PRECISION ? 1.0 : 0.0; @@ -67,6 +69,7 @@ public class ExpressionEvaluator { } else if (isCpVariable(exp)) { return variables.get(exp.getId()); } else if (isComposedExpression(exp)) { + return evaluateComposedExpression((ComposedExpression) exp, variables); } //TODO throw @@ -84,7 +87,7 @@ public class ExpressionEvaluator { case LESS_OR_EQUAL_TO: return argRight - argLeft > -ExpressionEvaluator.PRECISION; case LESS_THAN: - return argRight - argLeft > ExpressionEvaluator.PRECISION;; + return argRight - argLeft > ExpressionEvaluator.PRECISION; case DIFFERENT: return Math.abs(argLeft - argRight) > ExpressionEvaluator.PRECISION; diff --git a/ZPPSolver/CPParser/src/test/java/ArConstraintImplTest.java b/ZPPSolver/CPParser/src/test/java/ArConstraintImplTest.java new file mode 100644 index 000000000..1aad84184 --- /dev/null +++ b/ZPPSolver/CPParser/src/test/java/ArConstraintImplTest.java @@ -0,0 +1,85 @@ + +import eu.paasage.upperware.metamodel.cp.*; +import eu.paasage.upperware.metamodel.types.BasicTypeEnum; +import org.eclipse.emf.common.util.BasicEList; +import org.eclipse.emf.common.util.EList; +import org.junit.jupiter.api.BeforeAll; +import org.junit.jupiter.api.Test; + +import java.util.*; + +import static org.junit.jupiter.api.Assertions.*; + +class ArConstraintImplTest { + private static List variables; + private static final String[] names = new String[]{"Variable", "qwerty", "wewrfdvdfbfdvd"}; + @BeforeAll + public static void setup(){ + variables = new ArrayList<>(); + variables.add(new CpVariableImplTest(names[0], VariableType.CORES)); + variables.add(new CpVariableImplTest(names[1], VariableType.CORES)); + variables.add(new CpVariableImplTest(names[2], VariableType.CORES)); + } + @Test + public void shouldThrowEmptyVariables(){ + Map emptyVars = new HashMap<>(); + ArConstraint constraint = new ArConstraintImpl(ComparatorEnum.DIFFERENT, variables.get(0), variables.get(1)); + assertThrows(RuntimeException.class, () -> { + constraint.evaluate(emptyVars); + }); + } + + @Test + public void shouldThrowWrongVariables(){ + Map emptyVars = new HashMap<>(); + ArConstraint constraint = new ArConstraintImpl(ComparatorEnum.DIFFERENT, variables.get(0), variables.get(1)); + Map vars = new HashMap<>(); + vars.put(names[1], 0.00123); + vars.put(names[2], 123.345); + assertThrows(RuntimeException.class, () -> { + constraint.evaluate(vars); + }); + } + + @Test + public void linearConstraintEvaluationTest(){ + Constant c = new ConstantImplTest(BasicTypeEnum.DOUBLE, new NumericValueUpperwareImplTest(1.0)); + + Map vars = new HashMap<>(); + vars.put(names[0], 2.0); + vars.put(names[1], 0.00123); + vars.put(names[2], 123.345); + + EList exprs = new BasicEList<>(); + exprs.addAll(variables); + Expression sum = new ComposedExpressionImplTest(exprs, OperatorEnum.PLUS); + + ArConstraint constraint = new ArConstraintImpl(ComparatorEnum.GREATER_OR_EQUAL_TO, sum, c); + + assertTrue(constraint.evaluate(vars)); + + constraint = new ArConstraintImpl(ComparatorEnum.GREATER_OR_EQUAL_TO, c, sum); + + assertFalse(constraint.evaluate(vars)); + } + + @Test + public void composedConstraintEvaluationTest() { + BasicEList exprs = new BasicEList<>(); + exprs.add(variables.get(0)); exprs.add(variables.get(1)); + NumericExpression times = new ComposedExpressionImplTest(exprs, OperatorEnum.TIMES); + + exprs = new BasicEList<>(); exprs.add(times); exprs.add(variables.get(2)); + NumericExpression div = new ComposedExpressionImplTest(exprs, OperatorEnum.DIV); + + exprs = new BasicEList<>(); exprs.addAll(variables); + NumericExpression sum = new ComposedExpressionImplTest(exprs, OperatorEnum.PLUS); + + Map vars = new HashMap<>(); + vars.put(names[0], 2.0); + vars.put(names[1], 3.0); + vars.put(names[2], 5.0); + ArConstraint constraint = new ArConstraintImpl(ComparatorEnum.GREATER_OR_EQUAL_TO, div, sum); + assertTrue(constraint.evaluate(vars)); + } +} \ No newline at end of file diff --git a/ZPPSolver/CPParser/src/test/java/ArConstraintTest.java b/ZPPSolver/CPParser/src/test/java/ArConstraintTest.java deleted file mode 100644 index 313d3e970..000000000 --- a/ZPPSolver/CPParser/src/test/java/ArConstraintTest.java +++ /dev/null @@ -1,39 +0,0 @@ - -import org.junit.jupiter.api.BeforeAll; -import org.junit.jupiter.api.Test; - -import java.util.HashMap; -import java.util.Map; - -import static org.junit.jupiter.api.Assertions.*; - -class ArConstraintTest { - private static ArConstraint constraint; - - @BeforeAll - public static void setup(){ - constraint = new ArConstraint(); - } - @Test - public void shouldThrowEmptyVariables(){ - Map emptyVars = new HashMap<>(); - assertThrows(RuntimeException.class, () -> { - constraint.evaluate(emptyVars); - }); - } - - @Test - public void shouldThrowWrongVariables(){ - Map emptyVars = new HashMap<>(); - assertThrows(RuntimeException.class, () -> { - constraint.evaluate(emptyVars); - }); - } - - @Test - public void TEMP(){ - Map emptyVars = new HashMap<>(); - assertTrue(constraint.evaluate(emptyVars)); - } - -} \ No newline at end of file diff --git a/ZPPSolver/CPParser/src/test/java/ComposedExpressionImplTest.java b/ZPPSolver/CPParser/src/test/java/ComposedExpressionImplTest.java new file mode 100644 index 000000000..8edd7a044 --- /dev/null +++ b/ZPPSolver/CPParser/src/test/java/ComposedExpressionImplTest.java @@ -0,0 +1,27 @@ +import eu.paasage.upperware.metamodel.cp.ComposedExpression; +import eu.paasage.upperware.metamodel.cp.NumericExpression; +import eu.paasage.upperware.metamodel.cp.OperatorEnum; +import eu.paasage.upperware.metamodel.cp.impl.NumericExpressionImpl; +import lombok.AllArgsConstructor; +import org.eclipse.emf.common.util.EList; + +@AllArgsConstructor +public class ComposedExpressionImplTest extends NumericExpressionImpl implements ComposedExpression { + private EList expressions; + private OperatorEnum operator; + + @Override + public EList getExpressions() { + return expressions; + } + + @Override + public OperatorEnum getOperator() { + return operator; + } + + @Override + public void setOperator(OperatorEnum value) { + this.operator = operator; + } +} diff --git a/ZPPSolver/CPParser/src/test/java/ConstantImplTest.java b/ZPPSolver/CPParser/src/test/java/ConstantImplTest.java new file mode 100644 index 000000000..53e4f416e --- /dev/null +++ b/ZPPSolver/CPParser/src/test/java/ConstantImplTest.java @@ -0,0 +1,30 @@ +import eu.paasage.upperware.metamodel.cp.Constant; +import eu.paasage.upperware.metamodel.cp.impl.NumericExpressionImpl; +import eu.paasage.upperware.metamodel.types.BasicTypeEnum; +import eu.paasage.upperware.metamodel.types.NumericValueUpperware; +import lombok.AllArgsConstructor; + +@AllArgsConstructor +public class ConstantImplTest extends NumericExpressionImpl implements Constant { + private BasicTypeEnum type; + private NumericValueUpperware value; + @Override + public BasicTypeEnum getType() { + return type; + } + + @Override + public void setType(BasicTypeEnum value) { + this.type = value; + } + + @Override + public NumericValueUpperware getValue() { + return value; + } + + @Override + public void setValue(NumericValueUpperware value) { + this.value = value; + } +} diff --git a/ZPPSolver/CPParser/src/test/java/CpMetricImplTest.java b/ZPPSolver/CPParser/src/test/java/CpMetricImplTest.java new file mode 100644 index 000000000..af44e2d9c --- /dev/null +++ b/ZPPSolver/CPParser/src/test/java/CpMetricImplTest.java @@ -0,0 +1,30 @@ +import eu.paasage.upperware.metamodel.cp.CpMetric; +import eu.paasage.upperware.metamodel.cp.impl.NumericExpressionImpl; +import eu.paasage.upperware.metamodel.types.BasicTypeEnum; +import eu.paasage.upperware.metamodel.types.NumericValueUpperware; +import lombok.AllArgsConstructor; + +@AllArgsConstructor +public class CpMetricImplTest extends NumericExpressionImpl implements CpMetric { + private BasicTypeEnum type; + private NumericValueUpperware value; + @Override + public BasicTypeEnum getType() { + return type; + } + + @Override + public void setType(BasicTypeEnum value) { + this.type = value; + } + + @Override + public NumericValueUpperware getValue() { + return value; + } + + @Override + public void setValue(NumericValueUpperware value) { + this.value = value; + } +} diff --git a/ZPPSolver/CPParser/src/test/java/CpVariableImplTest.java b/ZPPSolver/CPParser/src/test/java/CpVariableImplTest.java new file mode 100644 index 000000000..86d3bbdbd --- /dev/null +++ b/ZPPSolver/CPParser/src/test/java/CpVariableImplTest.java @@ -0,0 +1,47 @@ +import eu.paasage.upperware.metamodel.cp.CpVariable; +import eu.paasage.upperware.metamodel.cp.Domain; +import eu.paasage.upperware.metamodel.cp.VariableType; +import eu.paasage.upperware.metamodel.cp.impl.NumericExpressionImpl; + +public class CpVariableImplTest extends NumericExpressionImpl implements CpVariable { + private String id; + private VariableType type; + private Domain domain; + public CpVariableImplTest(String id, VariableType type) { + this.id = id; + this.type = type; + } + @Override + public String getId() { + return this.id; + } + @Override + public Domain getDomain() { + return domain; + } + + @Override + public void setDomain(Domain value) { + this.domain = domain; + } + + @Override + public VariableType getVariableType() { + return type; + } + + @Override + public void setVariableType(VariableType value) { + this.type = type; + } + + @Override + public String getComponentId() { + return id; + } + + @Override + public void setComponentId(String value) { + this.id = id; + } +} diff --git a/ZPPSolver/CPParser/src/test/java/ExpressionEvaluatorTest.java b/ZPPSolver/CPParser/src/test/java/ExpressionEvaluatorTest.java index 0c98c9cf6..61505c2ef 100644 --- a/ZPPSolver/CPParser/src/test/java/ExpressionEvaluatorTest.java +++ b/ZPPSolver/CPParser/src/test/java/ExpressionEvaluatorTest.java @@ -1,7 +1,16 @@ -import eu.paasage.upperware.metamodel.cp.impl.ConstantImpl; +import eu.paasage.upperware.metamodel.cp.*; +import eu.paasage.upperware.metamodel.types.BasicTypeEnum; +import eu.paasage.upperware.metamodel.types.NumericValueUpperware; +import org.eclipse.emf.common.util.BasicEList; +import org.eclipse.emf.common.util.EList; import org.junit.jupiter.api.BeforeEach; import org.junit.jupiter.api.Test; +import java.util.ArrayList; +import java.util.HashMap; +import java.util.List; +import java.util.Map; + import static org.junit.jupiter.api.Assertions.*; class ExpressionEvaluatorTest { @@ -11,7 +20,97 @@ class ExpressionEvaluatorTest { } @Test - public void constantEvaluateTest() { + public void divideByZeroTest() { + List args = new ArrayList<>(); + args.add(1.0); + args.add(0.0); + assertThrows(RuntimeException.class, () -> { + ExpressionEvaluator.evaluateOnOperator(OperatorEnum.DIV, args); + }); + } + + @Test + public void operatorEvaluationTest() { + double a = Math.random(); + double b = Math.random(); + List args = new ArrayList<>(); + args.add(a); + args.add(b); + OperatorEnum[] operators = new OperatorEnum[]{OperatorEnum.PLUS, OperatorEnum.MINUS, OperatorEnum.TIMES, + OperatorEnum.DIV, OperatorEnum.EQ}; + Double[] results = new Double[]{a+b, a-b, a*b, a/b, a==b ? 1.0 : 0.0}; + for (int i = 0; i < results.length; i++) { + double res = ExpressionEvaluator.evaluateOnOperator(operators[i], args); + System.out.println("Wynik: " + res + " " + i + " should be " + results[i]); + assertTrue(Math.abs(res - results[i]) <= ExpressionEvaluator.PRECISION); + } + } + + @Test + public void numericalPrecisionTest() { + double eps = 0.01*ExpressionEvaluator.PRECISION; + double a = Math.random(); + double b = Math.random(); + assertTrue(ExpressionEvaluator.evaluateComparator(ComparatorEnum.EQUAL_TO,a,a+eps)); + + assertFalse(ExpressionEvaluator.evaluateComparator(ComparatorEnum.GREATER_THAN, a , a +eps)); + + assertTrue(ExpressionEvaluator.evaluateComparator(ComparatorEnum.GREATER_OR_EQUAL_TO, a , a +eps)); + } + + @Test + public void basicExpressionEvaluationTest() { + double a = Math.random(); + NumericValueUpperware val = new NumericValueUpperwareImplTest(a); + Constant c = new ConstantImplTest(BasicTypeEnum.DOUBLE, val); + assertTrue(ExpressionEvaluator.evaluateExpression(c, new HashMap()) == a); + + CpMetric m = new CpMetricImplTest(BasicTypeEnum.DOUBLE, val); + assertTrue(ExpressionEvaluator.evaluateExpression(m, new HashMap()) == a); + } + + @Test + public void variableEvaluationTest() { + double a = Math.random(); + String name = "Variable11"; + CpVariable var = new CpVariableImplTest(name, VariableType.CPU); + Map vars = new HashMap<>(); + vars.put(name, a); + assertTrue(ExpressionEvaluator.evaluateExpression(var, vars) == a); + } + + @Test + public void composedExpressionEvaluationTest() { + //((a + b) * c - d) / e; + double[] vals = new double[] {Math.random(), Math.random(), Math.random(), Math.random(), Math.random()}; + if (vals[4] == 0.0) vals[4] = 2.3; + + double realValue = (((vals[0] + vals[2]) * vals[1]) - vals[3])/vals[4]; + + String[] names = new String[]{"Variable", "qwerty", "wewrfdvdfbfdvd"}; + Constant c = new ConstantImplTest(BasicTypeEnum.DOUBLE, new NumericValueUpperwareImplTest(vals[0])); + CpMetric m = new CpMetricImplTest(BasicTypeEnum.DOUBLE, new NumericValueUpperwareImplTest(vals[1])); + CpVariable var1 = new CpVariableImplTest(names[0], VariableType.CORES); + CpVariable var2 = new CpVariableImplTest(names[1], VariableType.CORES); + CpVariable var3 = new CpVariableImplTest(names[2], VariableType.CORES); + + EList exprs = new BasicEList<>(); + exprs.add(c); exprs.add(var1); + NumericExpression sum = new ComposedExpressionImplTest(exprs, OperatorEnum.PLUS); + exprs = new BasicEList<>(); + exprs.add(sum); exprs.add(m); + NumericExpression times = new ComposedExpressionImplTest(exprs, OperatorEnum.TIMES); + exprs = new BasicEList<>(); + exprs.add(times); exprs.add(var2); + NumericExpression minus = new ComposedExpressionImplTest(exprs, OperatorEnum.MINUS); + exprs = new BasicEList<>(); + exprs.add(minus); exprs.add(var3); + NumericExpression composed = new ComposedExpressionImplTest(exprs, OperatorEnum.DIV); + Map vars = new HashMap<>(); + vars.put(names[0], vals[2]); + vars.put(names[1], vals[3]); + vars.put(names[2], vals[4]); + assertTrue(ExpressionEvaluator.evaluateExpression(composed, vars) == realValue); } } \ No newline at end of file diff --git a/ZPPSolver/CPParser/src/test/java/NumericValueUpperwareImplTest.java b/ZPPSolver/CPParser/src/test/java/NumericValueUpperwareImplTest.java new file mode 100644 index 000000000..1bf6852fa --- /dev/null +++ b/ZPPSolver/CPParser/src/test/java/NumericValueUpperwareImplTest.java @@ -0,0 +1,215 @@ +import eu.paasage.upperware.metamodel.types.DoubleValueUpperware; +import eu.paasage.upperware.metamodel.types.NumericValueUpperware; +import lombok.AllArgsConstructor; +import org.eclipse.emf.cdo.CDOLock; +import org.eclipse.emf.cdo.CDOObjectHistory; +import org.eclipse.emf.cdo.CDOState; +import org.eclipse.emf.cdo.common.id.CDOID; +import org.eclipse.emf.cdo.common.lock.CDOLockState; +import org.eclipse.emf.cdo.common.revision.CDORevision; +import org.eclipse.emf.cdo.common.security.CDOPermission; +import org.eclipse.emf.cdo.eresource.CDOResource; +import org.eclipse.emf.cdo.view.CDOView; +import org.eclipse.emf.common.notify.Adapter; +import org.eclipse.emf.common.notify.Notification; +import org.eclipse.emf.common.util.EList; +import org.eclipse.emf.common.util.TreeIterator; +import org.eclipse.emf.ecore.*; +import org.eclipse.emf.ecore.resource.Resource; + +import java.lang.reflect.InvocationTargetException; + +@AllArgsConstructor +public class NumericValueUpperwareImplTest implements DoubleValueUpperware { + private double value; + + @Override + public double getValue() { + return value; + } + + @Override + public void setValue(double value) { + this.value = value; + } + + @Override + public CDOID cdoID() { + return null; + } + + @Override + public CDOState cdoState() { + return null; + } + + @Override + public boolean cdoConflict() { + return false; + } + + @Override + public boolean cdoInvalid() { + return false; + } + + @Override + public CDOView cdoView() { + return null; + } + + @Override + public CDORevision cdoRevision() { + return null; + } + + @Override + public CDORevision cdoRevision(boolean b) { + return null; + } + + @Override + public CDOPermission cdoPermission() { + return null; + } + + @Override + public CDOResource cdoResource() { + return null; + } + + @Override + public CDOResource cdoDirectResource() { + return null; + } + + @Override + public CDOLock cdoReadLock() { + return null; + } + + @Override + public CDOLock cdoWriteLock() { + return null; + } + + @Override + public CDOLock cdoWriteOption() { + return null; + } + + @Override + public CDOLockState cdoLockState() { + return null; + } + + @Override + public void cdoPrefetch(int i) { + + } + + @Override + public void cdoReload() { + + } + + @Override + public CDOObjectHistory cdoHistory() { + return null; + } + + @Override + public EClass eClass() { + return null; + } + + @Override + public Resource eResource() { + return null; + } + + @Override + public EObject eContainer() { + return null; + } + + @Override + public EStructuralFeature eContainingFeature() { + return null; + } + + @Override + public EReference eContainmentFeature() { + return null; + } + + @Override + public EList eContents() { + return null; + } + + @Override + public TreeIterator eAllContents() { + return null; + } + + @Override + public boolean eIsProxy() { + return false; + } + + @Override + public EList eCrossReferences() { + return null; + } + + @Override + public Object eGet(EStructuralFeature eStructuralFeature) { + return null; + } + + @Override + public Object eGet(EStructuralFeature eStructuralFeature, boolean b) { + return null; + } + + @Override + public void eSet(EStructuralFeature eStructuralFeature, Object o) { + + } + + @Override + public boolean eIsSet(EStructuralFeature eStructuralFeature) { + return false; + } + + @Override + public void eUnset(EStructuralFeature eStructuralFeature) { + + } + + @Override + public Object eInvoke(EOperation eOperation, EList eList) throws InvocationTargetException { + return null; + } + + @Override + public EList eAdapters() { + return null; + } + + @Override + public boolean eDeliver() { + return false; + } + + @Override + public void eSetDeliver(boolean b) { + + } + + @Override + public void eNotify(Notification notification) { + + } +} -- GitLab From 3bf05eae472190f7e9a55fe485c2b04c901748c8 Mon Sep 17 00:00:00 2001 From: tc360950 Date: Sun, 1 Dec 2019 17:21:41 +0100 Subject: [PATCH 006/340] Implemented ArConstraintImpl::collectVariableNames method --- .../src/main/java/ArConstraintImpl.java | 23 +++++++++++++++---- .../src/main/java/ExpressionEvaluator.java | 8 +++---- .../src/test/java/ArConstraintImplTest.java | 2 +- 3 files changed, 24 insertions(+), 9 deletions(-) diff --git a/ZPPSolver/CPParser/src/main/java/ArConstraintImpl.java b/ZPPSolver/CPParser/src/main/java/ArConstraintImpl.java index b4e9cc5fd..f3417444f 100644 --- a/ZPPSolver/CPParser/src/main/java/ArConstraintImpl.java +++ b/ZPPSolver/CPParser/src/main/java/ArConstraintImpl.java @@ -16,9 +16,24 @@ public class ArConstraintImpl implements ArConstraint { Expression rightExpression; + private void collectVariableNamesFromExpression(Expression exp) { + if (ExpressionEvaluator.isCpVariable(exp)) { + String name = ((CpVariable) exp).getId(); + if(!variablesNames.contains(name)) { + variablesNames.add(name); + } + } else if (ExpressionEvaluator.isComposedExpression(exp)) { + ((ComposedExpression) exp).getExpressions() + .stream() + .forEach( e -> { + this.collectVariableNamesFromExpression(e); + }); + } + } + private void collectVariableNames() { - //TODO - variablesNames = new ArrayList<>(); + collectVariableNamesFromExpression(leftExpression); + collectVariableNamesFromExpression(rightExpression); } private boolean checkVariables(Collection vars) { @@ -29,6 +44,7 @@ public class ArConstraintImpl implements ArConstraint { this.comparator = comp; this.leftExpression = exp1; this.rightExpression = exp2; + variablesNames = new ArrayList<>(); collectVariableNames(); } @@ -38,8 +54,7 @@ public class ArConstraintImpl implements ArConstraint { throw new RuntimeException("Can't evaluate - some variables are missing"); } double leftExpValue = ExpressionEvaluator.evaluateExpression(leftExpression, variables); - double rightExpValue = ExpressionEvaluator.evaluateExpression(leftExpression, variables); - + double rightExpValue = ExpressionEvaluator.evaluateExpression(rightExpression, variables); return ExpressionEvaluator.evaluateComparator(comparator, leftExpValue, rightExpValue); } diff --git a/ZPPSolver/CPParser/src/main/java/ExpressionEvaluator.java b/ZPPSolver/CPParser/src/main/java/ExpressionEvaluator.java index 55775676f..1c6efe3e9 100644 --- a/ZPPSolver/CPParser/src/main/java/ExpressionEvaluator.java +++ b/ZPPSolver/CPParser/src/main/java/ExpressionEvaluator.java @@ -96,19 +96,19 @@ public class ExpressionEvaluator { return false; } - private static boolean isConstant(Expression expression){ + protected static boolean isConstant(Expression expression){ return expression instanceof Constant; } - private static boolean isCpVariable(Expression expression){ + protected static boolean isCpVariable(Expression expression){ return expression instanceof CpVariable; } - private static boolean isCpMetric(Expression expression){ + protected static boolean isCpMetric(Expression expression){ return expression instanceof CpMetric; } - private static boolean isComposedExpression(Expression expression){ + protected static boolean isComposedExpression(Expression expression){ return expression instanceof ComposedExpression; } } diff --git a/ZPPSolver/CPParser/src/test/java/ArConstraintImplTest.java b/ZPPSolver/CPParser/src/test/java/ArConstraintImplTest.java index 1aad84184..b1e58da2f 100644 --- a/ZPPSolver/CPParser/src/test/java/ArConstraintImplTest.java +++ b/ZPPSolver/CPParser/src/test/java/ArConstraintImplTest.java @@ -80,6 +80,6 @@ class ArConstraintImplTest { vars.put(names[1], 3.0); vars.put(names[2], 5.0); ArConstraint constraint = new ArConstraintImpl(ComparatorEnum.GREATER_OR_EQUAL_TO, div, sum); - assertTrue(constraint.evaluate(vars)); + assertFalse(constraint.evaluate(vars)); } } \ No newline at end of file -- GitLab From 44ff296e3a3964b80fc8434066bfd8d0794efbef Mon Sep 17 00:00:00 2001 From: tc360950 Date: Sun, 1 Dec 2019 21:04:05 +0100 Subject: [PATCH 007/340] Added tests for ConstraintGraph --- .../src/main/java/ConstraintGraph.java | 16 +++ .../src/test/java/ConstraintGraphTest.java | 107 ++++++++++++++++++ 2 files changed, 123 insertions(+) create mode 100644 ZPPSolver/CPParser/src/main/java/ConstraintGraph.java create mode 100644 ZPPSolver/CPParser/src/test/java/ConstraintGraphTest.java diff --git a/ZPPSolver/CPParser/src/main/java/ConstraintGraph.java b/ZPPSolver/CPParser/src/main/java/ConstraintGraph.java new file mode 100644 index 000000000..d143e12f5 --- /dev/null +++ b/ZPPSolver/CPParser/src/main/java/ConstraintGraph.java @@ -0,0 +1,16 @@ +import java.util.Collection; + +public class ConstraintGraph { + private Collection constraints; + private Collection variables; + + public ConstraintGraph(Collection constraints, Collection vars) { + this.constraints = constraints; + this.variables = vars; + } + + public int getNumberOfNeighbours(String node, int distance) { + //TODO + return 0; + } +} diff --git a/ZPPSolver/CPParser/src/test/java/ConstraintGraphTest.java b/ZPPSolver/CPParser/src/test/java/ConstraintGraphTest.java new file mode 100644 index 000000000..4e8ec75c9 --- /dev/null +++ b/ZPPSolver/CPParser/src/test/java/ConstraintGraphTest.java @@ -0,0 +1,107 @@ +import lombok.AllArgsConstructor; +import org.junit.jupiter.api.BeforeAll; +import org.junit.jupiter.api.Test; + +import java.util.*; + +import static org.junit.jupiter.api.Assertions.*; + +class ConstraintGraphTest { + @AllArgsConstructor + private static class ConstraintMockup implements ArConstraint{ + private Collection variables; + + @Override + public Collection getVariableNames() { + return variables; + } + + @Override + public boolean evaluate(Map variables) { + return false; + } + }; + private static List variables; + @BeforeAll + static void setUp() { + String[] vars = new String[]{"var1", "var2", "var3", "var4", "var5", "var6", "var7", "var8"}; + variables = Arrays.asList(vars); + } + + @Test + public void noEdgesGraphTest() { + ConstraintGraph graph = new ConstraintGraph(new ArrayList(), variables); + for (int distance = 1; distance < 10; distance ++) { + for (String v : variables) { + assertTrue(graph.getNumberOfNeighbours(v, distance) == 0); + } + } + } + + @Test + public void graphWithCycleTest() { + Collection constraints = new ArrayList<>(); + int varsSize = variables.size(); + + for (int i =1; i <= variables.size(); i++) { + List vars = new ArrayList<>(); + vars.add(variables.get(i-1)); + vars.add(variables.get(i % varsSize)); + constraints.add(new ConstraintMockup(vars)); + } + ConstraintGraph graph = new ConstraintGraph(new ArrayList(), variables); + + for (int i = 0; i < varsSize/2 - 1; i++) { + assertTrue(graph.getNumberOfNeighbours(variables.get(0), 2*i) == 2); + } + for (int i = varsSize/2; i < 2*varsSize; i++) { + assertTrue(graph.getNumberOfNeighbours(variables.get(0), 2*i) == 0); + } + } + + @Test + public void fullGraphTest() { + int varsSize = variables.size(); + Collection constraints = new ArrayList<>(); + ArConstraint constraint = new ConstraintMockup(variables); + constraints.add(constraint); + ConstraintGraph graph = new ConstraintGraph(new ArrayList(), variables); + for (String var : variables) { + assertTrue(graph.getNumberOfNeighbours(var, 2) == varsSize -1); + } + } + + @Test + public void hugeFullyConnectedGraphTest() { + int varsSize = variables.size(); + Collection constraints = new ArrayList<>(); + int noOfConstraints = 10000; + for (int i = 0; i < noOfConstraints; i ++ ) { + constraints.add(new ConstraintMockup(variables)); + } + ConstraintGraph graph = new ConstraintGraph(new ArrayList(), variables); + for (String var : variables) { + assertTrue(graph.getNumberOfNeighbours(var, 2) == varsSize -1); + } + for (int dist = 4; dist <= 1000; dist+=2) { + assertTrue(graph.getNumberOfNeighbours(variables.get(0), dist) == 0); + } + + assertTrue(graph.getNumberOfNeighbours(variables.get(0), 1) == noOfConstraints); + } + + @Test + public void expandingGraphTest() { + Collection constraints = new ArrayList<>(); + int varsSize = variables.size(); + for(int i = 0; i < varsSize; i++) { + constraints.add(new ConstraintMockup(variables.subList(0,i))); + } + ConstraintGraph graph = new ConstraintGraph(constraints, variables); + for (int i = 0; i < varsSize; i++) { + assertTrue(graph.getNumberOfNeighbours(variables.get(i), 2) == varsSize - 1 ); + assertTrue(graph.getNumberOfNeighbours(variables.get(i), 1) == varsSize - i); + } + } + +} \ No newline at end of file -- GitLab From 2c9073a917fe4547f966895dbd7cb2b159a328b6 Mon Sep 17 00:00:00 2001 From: tc360950 Date: Mon, 2 Dec 2019 18:31:07 +0100 Subject: [PATCH 008/340] ConstraintGraph implementation --- .../src/main/java/ConstraintGraph.java | 99 ++++++++++++++++++- ...lTest.java => ArConstraintImplMockup.java} | 18 ++-- ...java => ComposedExpressionImplMockup.java} | 2 +- ...tImplTest.java => ConstantImplMockup.java} | 2 +- .../src/test/java/ConstraintGraphTest.java | 28 +++--- ...cImplTest.java => CpMetricImplMockup.java} | 2 +- ...mplTest.java => CpVariableImplMockup.java} | 4 +- .../test/java/ExpressionEvaluatorTest.java | 26 ++--- ...a => NumericValueUpperwareImplMockup.java} | 2 +- 9 files changed, 138 insertions(+), 45 deletions(-) rename ZPPSolver/CPParser/src/test/java/{ArConstraintImplTest.java => ArConstraintImplMockup.java} (78%) rename ZPPSolver/CPParser/src/test/java/{ComposedExpressionImplTest.java => ComposedExpressionImplMockup.java} (87%) rename ZPPSolver/CPParser/src/test/java/{ConstantImplTest.java => ConstantImplMockup.java} (89%) rename ZPPSolver/CPParser/src/test/java/{CpMetricImplTest.java => CpMetricImplMockup.java} (89%) rename ZPPSolver/CPParser/src/test/java/{CpVariableImplTest.java => CpVariableImplMockup.java} (86%) rename ZPPSolver/CPParser/src/test/java/{NumericValueUpperwareImplTest.java => NumericValueUpperwareImplMockup.java} (98%) diff --git a/ZPPSolver/CPParser/src/main/java/ConstraintGraph.java b/ZPPSolver/CPParser/src/main/java/ConstraintGraph.java index d143e12f5..c626ee854 100644 --- a/ZPPSolver/CPParser/src/main/java/ConstraintGraph.java +++ b/ZPPSolver/CPParser/src/main/java/ConstraintGraph.java @@ -1,16 +1,109 @@ -import java.util.Collection; +import java.util.*; public class ConstraintGraph { + /* + + */ private Collection constraints; private Collection variables; + private Map>> neighbourhoodList; + private Map> variableToConstraint; public ConstraintGraph(Collection constraints, Collection vars) { this.constraints = constraints; this.variables = vars; + initializeStructures(); + buildNeighbourhoodList(); + buildVariableToConstraintMap(); + } + + private Collection getNeighbours(String node) { + return neighbourhoodList.get(node).get(1); + } + + private void initializeKnownDistances(Map> knownDistances) { + for (String var : variables) { + knownDistances.put(var, new LinkedList()); + knownDistances.get(var).add(var); + } + } + + private void buildVariableToConstraintMap() { + for (ArConstraint c : constraints) { + for (String var : c.getVariableNames()) { + variableToConstraint.get(var).add(c); + } + } + } + + private void initializeNeighbourhoodList(int distance) { + for (String node : variables) { + neighbourhoodList.get(node).put(distance, new HashSet()); + } + } + + private void initializeStructures() { + neighbourhoodList = new HashMap<>(); + variableToConstraint = new HashMap<>(); + for (String node : variables) { + neighbourhoodList.put(node, new HashMap<>()); + variableToConstraint.put(node, new LinkedList()); + } + } + + private void calculateNeighbours(Map> knownDistances) { + initializeNeighbourhoodList(1); + for (ArConstraint constraint : constraints) { + Collection variables = constraint.getVariableNames(); + for (String var : variables) { + knownDistances.get(var).addAll(variables); + neighbourhoodList.get(var).get(1).addAll(variables); + neighbourhoodList.get(var).get(1).remove(var); + } + } + } + + private void buildNeighbourhoodList() { + Map> knownDistances = new HashMap<>(); + initializeKnownDistances(knownDistances); + calculateNeighbours(knownDistances); + int distance = 1; + do { + distance++; + initializeNeighbourhoodList(distance); + } while (neighbourhoodSweep(distance, knownDistances)); + } + + private boolean neighbourhoodSweep(int dist, Map> knownDistances){ + boolean foundPath = false; + for (String node: variables) { + Collection distantNeighbours = neighbourhoodList.get(node).get(dist - 1); + for (String neighbour : getNeighbours(node)) { + for (String distantNode : distantNeighbours) { + if (!knownDistances.get(distantNode).contains(neighbour)) { + knownDistances.get(distantNode).add(neighbour); + foundPath = true; + neighbourhoodList.get(distantNode).get(dist).add(neighbour); + } + } + } + } + return foundPath; + } + + private Collection getNeighbours(String node, int distance) { + if (neighbourhoodList.get(node).containsKey(distance)) { + return neighbourhoodList.get(node).get(distance); + } else { + return new LinkedList(); + } + } + + public Collection getConstraints(String variable) { + return variableToConstraint.get(variable); } public int getNumberOfNeighbours(String node, int distance) { - //TODO - return 0; + return getNeighbours(node, distance).size(); } } diff --git a/ZPPSolver/CPParser/src/test/java/ArConstraintImplTest.java b/ZPPSolver/CPParser/src/test/java/ArConstraintImplMockup.java similarity index 78% rename from ZPPSolver/CPParser/src/test/java/ArConstraintImplTest.java rename to ZPPSolver/CPParser/src/test/java/ArConstraintImplMockup.java index b1e58da2f..20fb25535 100644 --- a/ZPPSolver/CPParser/src/test/java/ArConstraintImplTest.java +++ b/ZPPSolver/CPParser/src/test/java/ArConstraintImplMockup.java @@ -10,15 +10,15 @@ import java.util.*; import static org.junit.jupiter.api.Assertions.*; -class ArConstraintImplTest { +class ArConstraintImplMockup { private static List variables; private static final String[] names = new String[]{"Variable", "qwerty", "wewrfdvdfbfdvd"}; @BeforeAll public static void setup(){ variables = new ArrayList<>(); - variables.add(new CpVariableImplTest(names[0], VariableType.CORES)); - variables.add(new CpVariableImplTest(names[1], VariableType.CORES)); - variables.add(new CpVariableImplTest(names[2], VariableType.CORES)); + variables.add(new CpVariableImplMockup(names[0], VariableType.CORES)); + variables.add(new CpVariableImplMockup(names[1], VariableType.CORES)); + variables.add(new CpVariableImplMockup(names[2], VariableType.CORES)); } @Test public void shouldThrowEmptyVariables(){ @@ -43,7 +43,7 @@ class ArConstraintImplTest { @Test public void linearConstraintEvaluationTest(){ - Constant c = new ConstantImplTest(BasicTypeEnum.DOUBLE, new NumericValueUpperwareImplTest(1.0)); + Constant c = new ConstantImplMockup(BasicTypeEnum.DOUBLE, new NumericValueUpperwareImplMockup(1.0)); Map vars = new HashMap<>(); vars.put(names[0], 2.0); @@ -52,7 +52,7 @@ class ArConstraintImplTest { EList exprs = new BasicEList<>(); exprs.addAll(variables); - Expression sum = new ComposedExpressionImplTest(exprs, OperatorEnum.PLUS); + Expression sum = new ComposedExpressionImplMockup(exprs, OperatorEnum.PLUS); ArConstraint constraint = new ArConstraintImpl(ComparatorEnum.GREATER_OR_EQUAL_TO, sum, c); @@ -67,13 +67,13 @@ class ArConstraintImplTest { public void composedConstraintEvaluationTest() { BasicEList exprs = new BasicEList<>(); exprs.add(variables.get(0)); exprs.add(variables.get(1)); - NumericExpression times = new ComposedExpressionImplTest(exprs, OperatorEnum.TIMES); + NumericExpression times = new ComposedExpressionImplMockup(exprs, OperatorEnum.TIMES); exprs = new BasicEList<>(); exprs.add(times); exprs.add(variables.get(2)); - NumericExpression div = new ComposedExpressionImplTest(exprs, OperatorEnum.DIV); + NumericExpression div = new ComposedExpressionImplMockup(exprs, OperatorEnum.DIV); exprs = new BasicEList<>(); exprs.addAll(variables); - NumericExpression sum = new ComposedExpressionImplTest(exprs, OperatorEnum.PLUS); + NumericExpression sum = new ComposedExpressionImplMockup(exprs, OperatorEnum.PLUS); Map vars = new HashMap<>(); vars.put(names[0], 2.0); diff --git a/ZPPSolver/CPParser/src/test/java/ComposedExpressionImplTest.java b/ZPPSolver/CPParser/src/test/java/ComposedExpressionImplMockup.java similarity index 87% rename from ZPPSolver/CPParser/src/test/java/ComposedExpressionImplTest.java rename to ZPPSolver/CPParser/src/test/java/ComposedExpressionImplMockup.java index 8edd7a044..279b32f66 100644 --- a/ZPPSolver/CPParser/src/test/java/ComposedExpressionImplTest.java +++ b/ZPPSolver/CPParser/src/test/java/ComposedExpressionImplMockup.java @@ -6,7 +6,7 @@ import lombok.AllArgsConstructor; import org.eclipse.emf.common.util.EList; @AllArgsConstructor -public class ComposedExpressionImplTest extends NumericExpressionImpl implements ComposedExpression { +public class ComposedExpressionImplMockup extends NumericExpressionImpl implements ComposedExpression { private EList expressions; private OperatorEnum operator; diff --git a/ZPPSolver/CPParser/src/test/java/ConstantImplTest.java b/ZPPSolver/CPParser/src/test/java/ConstantImplMockup.java similarity index 89% rename from ZPPSolver/CPParser/src/test/java/ConstantImplTest.java rename to ZPPSolver/CPParser/src/test/java/ConstantImplMockup.java index 53e4f416e..697e6c45e 100644 --- a/ZPPSolver/CPParser/src/test/java/ConstantImplTest.java +++ b/ZPPSolver/CPParser/src/test/java/ConstantImplMockup.java @@ -5,7 +5,7 @@ import eu.paasage.upperware.metamodel.types.NumericValueUpperware; import lombok.AllArgsConstructor; @AllArgsConstructor -public class ConstantImplTest extends NumericExpressionImpl implements Constant { +public class ConstantImplMockup extends NumericExpressionImpl implements Constant { private BasicTypeEnum type; private NumericValueUpperware value; @Override diff --git a/ZPPSolver/CPParser/src/test/java/ConstraintGraphTest.java b/ZPPSolver/CPParser/src/test/java/ConstraintGraphTest.java index 4e8ec75c9..d2ee24d5c 100644 --- a/ZPPSolver/CPParser/src/test/java/ConstraintGraphTest.java +++ b/ZPPSolver/CPParser/src/test/java/ConstraintGraphTest.java @@ -49,13 +49,13 @@ class ConstraintGraphTest { vars.add(variables.get(i % varsSize)); constraints.add(new ConstraintMockup(vars)); } - ConstraintGraph graph = new ConstraintGraph(new ArrayList(), variables); + ConstraintGraph graph = new ConstraintGraph(constraints, variables); - for (int i = 0; i < varsSize/2 - 1; i++) { - assertTrue(graph.getNumberOfNeighbours(variables.get(0), 2*i) == 2); + for (int i = 1; i < varsSize/2 - 1; i++) { + assertTrue(graph.getNumberOfNeighbours(variables.get(0), i) == 2); } - for (int i = varsSize/2; i < 2*varsSize; i++) { - assertTrue(graph.getNumberOfNeighbours(variables.get(0), 2*i) == 0); + for (int i = varsSize/2 + 1; i < 2*varsSize; i++) { + assertTrue(graph.getNumberOfNeighbours(variables.get(0), i) == 0); } } @@ -65,9 +65,9 @@ class ConstraintGraphTest { Collection constraints = new ArrayList<>(); ArConstraint constraint = new ConstraintMockup(variables); constraints.add(constraint); - ConstraintGraph graph = new ConstraintGraph(new ArrayList(), variables); + ConstraintGraph graph = new ConstraintGraph(constraints, variables); for (String var : variables) { - assertTrue(graph.getNumberOfNeighbours(var, 2) == varsSize -1); + assertTrue(graph.getNumberOfNeighbours(var, 1) == varsSize -1); } } @@ -79,15 +79,15 @@ class ConstraintGraphTest { for (int i = 0; i < noOfConstraints; i ++ ) { constraints.add(new ConstraintMockup(variables)); } - ConstraintGraph graph = new ConstraintGraph(new ArrayList(), variables); + ConstraintGraph graph = new ConstraintGraph(constraints, variables); for (String var : variables) { - assertTrue(graph.getNumberOfNeighbours(var, 2) == varsSize -1); + assertTrue(graph.getNumberOfNeighbours(var, 1) == varsSize -1); } - for (int dist = 4; dist <= 1000; dist+=2) { + for (int dist = 2; dist <= 1000; dist++) { assertTrue(graph.getNumberOfNeighbours(variables.get(0), dist) == 0); } - assertTrue(graph.getNumberOfNeighbours(variables.get(0), 1) == noOfConstraints); + assertTrue(graph.getConstraints(variables.get(0)).size() == noOfConstraints); } @Test @@ -95,12 +95,12 @@ class ConstraintGraphTest { Collection constraints = new ArrayList<>(); int varsSize = variables.size(); for(int i = 0; i < varsSize; i++) { - constraints.add(new ConstraintMockup(variables.subList(0,i))); + constraints.add(new ConstraintMockup(variables.subList(0,i+1))); } ConstraintGraph graph = new ConstraintGraph(constraints, variables); for (int i = 0; i < varsSize; i++) { - assertTrue(graph.getNumberOfNeighbours(variables.get(i), 2) == varsSize - 1 ); - assertTrue(graph.getNumberOfNeighbours(variables.get(i), 1) == varsSize - i); + assertTrue(graph.getNumberOfNeighbours(variables.get(i), 1) == varsSize - 1 ); + assertTrue(graph.getConstraints(variables.get(i)).size() == varsSize - i); } } diff --git a/ZPPSolver/CPParser/src/test/java/CpMetricImplTest.java b/ZPPSolver/CPParser/src/test/java/CpMetricImplMockup.java similarity index 89% rename from ZPPSolver/CPParser/src/test/java/CpMetricImplTest.java rename to ZPPSolver/CPParser/src/test/java/CpMetricImplMockup.java index af44e2d9c..799bded8c 100644 --- a/ZPPSolver/CPParser/src/test/java/CpMetricImplTest.java +++ b/ZPPSolver/CPParser/src/test/java/CpMetricImplMockup.java @@ -5,7 +5,7 @@ import eu.paasage.upperware.metamodel.types.NumericValueUpperware; import lombok.AllArgsConstructor; @AllArgsConstructor -public class CpMetricImplTest extends NumericExpressionImpl implements CpMetric { +public class CpMetricImplMockup extends NumericExpressionImpl implements CpMetric { private BasicTypeEnum type; private NumericValueUpperware value; @Override diff --git a/ZPPSolver/CPParser/src/test/java/CpVariableImplTest.java b/ZPPSolver/CPParser/src/test/java/CpVariableImplMockup.java similarity index 86% rename from ZPPSolver/CPParser/src/test/java/CpVariableImplTest.java rename to ZPPSolver/CPParser/src/test/java/CpVariableImplMockup.java index 86d3bbdbd..4b39c9f60 100644 --- a/ZPPSolver/CPParser/src/test/java/CpVariableImplTest.java +++ b/ZPPSolver/CPParser/src/test/java/CpVariableImplMockup.java @@ -3,11 +3,11 @@ import eu.paasage.upperware.metamodel.cp.Domain; import eu.paasage.upperware.metamodel.cp.VariableType; import eu.paasage.upperware.metamodel.cp.impl.NumericExpressionImpl; -public class CpVariableImplTest extends NumericExpressionImpl implements CpVariable { +public class CpVariableImplMockup extends NumericExpressionImpl implements CpVariable { private String id; private VariableType type; private Domain domain; - public CpVariableImplTest(String id, VariableType type) { + public CpVariableImplMockup(String id, VariableType type) { this.id = id; this.type = type; } diff --git a/ZPPSolver/CPParser/src/test/java/ExpressionEvaluatorTest.java b/ZPPSolver/CPParser/src/test/java/ExpressionEvaluatorTest.java index 61505c2ef..6a89eada5 100644 --- a/ZPPSolver/CPParser/src/test/java/ExpressionEvaluatorTest.java +++ b/ZPPSolver/CPParser/src/test/java/ExpressionEvaluatorTest.java @@ -61,11 +61,11 @@ class ExpressionEvaluatorTest { @Test public void basicExpressionEvaluationTest() { double a = Math.random(); - NumericValueUpperware val = new NumericValueUpperwareImplTest(a); - Constant c = new ConstantImplTest(BasicTypeEnum.DOUBLE, val); + NumericValueUpperware val = new NumericValueUpperwareImplMockup(a); + Constant c = new ConstantImplMockup(BasicTypeEnum.DOUBLE, val); assertTrue(ExpressionEvaluator.evaluateExpression(c, new HashMap()) == a); - CpMetric m = new CpMetricImplTest(BasicTypeEnum.DOUBLE, val); + CpMetric m = new CpMetricImplMockup(BasicTypeEnum.DOUBLE, val); assertTrue(ExpressionEvaluator.evaluateExpression(m, new HashMap()) == a); } @@ -73,7 +73,7 @@ class ExpressionEvaluatorTest { public void variableEvaluationTest() { double a = Math.random(); String name = "Variable11"; - CpVariable var = new CpVariableImplTest(name, VariableType.CPU); + CpVariable var = new CpVariableImplMockup(name, VariableType.CPU); Map vars = new HashMap<>(); vars.put(name, a); assertTrue(ExpressionEvaluator.evaluateExpression(var, vars) == a); @@ -88,24 +88,24 @@ class ExpressionEvaluatorTest { double realValue = (((vals[0] + vals[2]) * vals[1]) - vals[3])/vals[4]; String[] names = new String[]{"Variable", "qwerty", "wewrfdvdfbfdvd"}; - Constant c = new ConstantImplTest(BasicTypeEnum.DOUBLE, new NumericValueUpperwareImplTest(vals[0])); - CpMetric m = new CpMetricImplTest(BasicTypeEnum.DOUBLE, new NumericValueUpperwareImplTest(vals[1])); - CpVariable var1 = new CpVariableImplTest(names[0], VariableType.CORES); - CpVariable var2 = new CpVariableImplTest(names[1], VariableType.CORES); - CpVariable var3 = new CpVariableImplTest(names[2], VariableType.CORES); + Constant c = new ConstantImplMockup(BasicTypeEnum.DOUBLE, new NumericValueUpperwareImplMockup(vals[0])); + CpMetric m = new CpMetricImplMockup(BasicTypeEnum.DOUBLE, new NumericValueUpperwareImplMockup(vals[1])); + CpVariable var1 = new CpVariableImplMockup(names[0], VariableType.CORES); + CpVariable var2 = new CpVariableImplMockup(names[1], VariableType.CORES); + CpVariable var3 = new CpVariableImplMockup(names[2], VariableType.CORES); EList exprs = new BasicEList<>(); exprs.add(c); exprs.add(var1); - NumericExpression sum = new ComposedExpressionImplTest(exprs, OperatorEnum.PLUS); + NumericExpression sum = new ComposedExpressionImplMockup(exprs, OperatorEnum.PLUS); exprs = new BasicEList<>(); exprs.add(sum); exprs.add(m); - NumericExpression times = new ComposedExpressionImplTest(exprs, OperatorEnum.TIMES); + NumericExpression times = new ComposedExpressionImplMockup(exprs, OperatorEnum.TIMES); exprs = new BasicEList<>(); exprs.add(times); exprs.add(var2); - NumericExpression minus = new ComposedExpressionImplTest(exprs, OperatorEnum.MINUS); + NumericExpression minus = new ComposedExpressionImplMockup(exprs, OperatorEnum.MINUS); exprs = new BasicEList<>(); exprs.add(minus); exprs.add(var3); - NumericExpression composed = new ComposedExpressionImplTest(exprs, OperatorEnum.DIV); + NumericExpression composed = new ComposedExpressionImplMockup(exprs, OperatorEnum.DIV); Map vars = new HashMap<>(); vars.put(names[0], vals[2]); diff --git a/ZPPSolver/CPParser/src/test/java/NumericValueUpperwareImplTest.java b/ZPPSolver/CPParser/src/test/java/NumericValueUpperwareImplMockup.java similarity index 98% rename from ZPPSolver/CPParser/src/test/java/NumericValueUpperwareImplTest.java rename to ZPPSolver/CPParser/src/test/java/NumericValueUpperwareImplMockup.java index 1bf6852fa..edfedd589 100644 --- a/ZPPSolver/CPParser/src/test/java/NumericValueUpperwareImplTest.java +++ b/ZPPSolver/CPParser/src/test/java/NumericValueUpperwareImplMockup.java @@ -20,7 +20,7 @@ import org.eclipse.emf.ecore.resource.Resource; import java.lang.reflect.InvocationTargetException; @AllArgsConstructor -public class NumericValueUpperwareImplTest implements DoubleValueUpperware { +public class NumericValueUpperwareImplMockup implements DoubleValueUpperware { private double value; @Override -- GitLab From ea95a866ad17978506f009d3f5df17ed221eaee3 Mon Sep 17 00:00:00 2001 From: tc360950 Date: Mon, 2 Dec 2019 18:41:20 +0100 Subject: [PATCH 009/340] Refactoring --- .../src/main/java/ArConstraintImpl.java | 34 ++++++++----------- .../src/main/java/ConstraintGraph.java | 3 -- .../src/main/java/ExpressionEvaluator.java | 9 ++--- ...lMockup.java => ArConstraintImplTest.java} | 2 +- .../java/NumericValueUpperwareImplMockup.java | 1 - 5 files changed, 18 insertions(+), 31 deletions(-) rename ZPPSolver/CPParser/src/test/java/{ArConstraintImplMockup.java => ArConstraintImplTest.java} (99%) diff --git a/ZPPSolver/CPParser/src/main/java/ArConstraintImpl.java b/ZPPSolver/CPParser/src/main/java/ArConstraintImpl.java index f3417444f..be4a82ef4 100644 --- a/ZPPSolver/CPParser/src/main/java/ArConstraintImpl.java +++ b/ZPPSolver/CPParser/src/main/java/ArConstraintImpl.java @@ -1,24 +1,31 @@ import eu.paasage.upperware.metamodel.cp.*; -import eu.paasage.upperware.metamodel.types.*; -import lombok.Getter; import java.util.ArrayList; import java.util.Collection; import java.util.Map; public class ArConstraintImpl implements ArConstraint { - private Collection variablesNames; - private ComparatorEnum comparator; + private Expression leftExpression; + private Expression rightExpression; - Expression leftExpression; + public ArConstraintImpl(ComparatorEnum comp, Expression exp1, Expression exp2){ + this.comparator = comp; + this.leftExpression = exp1; + this.rightExpression = exp2; + variablesNames = new ArrayList<>(); + collectVariableNames(); + } - Expression rightExpression; + private void collectVariableNames() { + collectVariableNamesFromExpression(leftExpression); + collectVariableNamesFromExpression(rightExpression); + } private void collectVariableNamesFromExpression(Expression exp) { if (ExpressionEvaluator.isCpVariable(exp)) { - String name = ((CpVariable) exp).getId(); + String name = exp.getId(); if(!variablesNames.contains(name)) { variablesNames.add(name); } @@ -31,23 +38,10 @@ public class ArConstraintImpl implements ArConstraint { } } - private void collectVariableNames() { - collectVariableNamesFromExpression(leftExpression); - collectVariableNamesFromExpression(rightExpression); - } - private boolean checkVariables(Collection vars) { return vars.containsAll(variablesNames); } - public ArConstraintImpl(ComparatorEnum comp, Expression exp1, Expression exp2){ - this.comparator = comp; - this.leftExpression = exp1; - this.rightExpression = exp2; - variablesNames = new ArrayList<>(); - collectVariableNames(); - } - @Override public boolean evaluate(Map variables){ if (!checkVariables(variables.keySet())) { diff --git a/ZPPSolver/CPParser/src/main/java/ConstraintGraph.java b/ZPPSolver/CPParser/src/main/java/ConstraintGraph.java index c626ee854..2b258033e 100644 --- a/ZPPSolver/CPParser/src/main/java/ConstraintGraph.java +++ b/ZPPSolver/CPParser/src/main/java/ConstraintGraph.java @@ -1,9 +1,6 @@ import java.util.*; public class ConstraintGraph { - /* - - */ private Collection constraints; private Collection variables; private Map>> neighbourhoodList; diff --git a/ZPPSolver/CPParser/src/main/java/ExpressionEvaluator.java b/ZPPSolver/CPParser/src/main/java/ExpressionEvaluator.java index 1c6efe3e9..79bbd14c5 100644 --- a/ZPPSolver/CPParser/src/main/java/ExpressionEvaluator.java +++ b/ZPPSolver/CPParser/src/main/java/ExpressionEvaluator.java @@ -49,8 +49,7 @@ public class ExpressionEvaluator { double diff = values.get(0) - values.get(1); return Math.abs(diff) <= ExpressionEvaluator.PRECISION ? 1.0 : 0.0; } - //TODO throw - return 0.0; + throw new RuntimeException("Unsupported operation type"); } private static double evaluateComposedExpression(ComposedExpression exp, Map variables) { @@ -72,8 +71,7 @@ public class ExpressionEvaluator { return evaluateComposedExpression((ComposedExpression) exp, variables); } - //TODO throw - return 0.0; + throw new RuntimeException("Unsupported Expression type"); } public static boolean evaluateComparator(ComparatorEnum comparator, double argLeft, double argRight) { @@ -92,8 +90,7 @@ public class ExpressionEvaluator { return Math.abs(argLeft - argRight) > ExpressionEvaluator.PRECISION; } - //TODO throws - return false; + throw new RuntimeException("Unsupported comparator type"); } protected static boolean isConstant(Expression expression){ diff --git a/ZPPSolver/CPParser/src/test/java/ArConstraintImplMockup.java b/ZPPSolver/CPParser/src/test/java/ArConstraintImplTest.java similarity index 99% rename from ZPPSolver/CPParser/src/test/java/ArConstraintImplMockup.java rename to ZPPSolver/CPParser/src/test/java/ArConstraintImplTest.java index 20fb25535..c714ded10 100644 --- a/ZPPSolver/CPParser/src/test/java/ArConstraintImplMockup.java +++ b/ZPPSolver/CPParser/src/test/java/ArConstraintImplTest.java @@ -10,7 +10,7 @@ import java.util.*; import static org.junit.jupiter.api.Assertions.*; -class ArConstraintImplMockup { +class ArConstraintImplTest { private static List variables; private static final String[] names = new String[]{"Variable", "qwerty", "wewrfdvdfbfdvd"}; @BeforeAll diff --git a/ZPPSolver/CPParser/src/test/java/NumericValueUpperwareImplMockup.java b/ZPPSolver/CPParser/src/test/java/NumericValueUpperwareImplMockup.java index edfedd589..1f7a7772c 100644 --- a/ZPPSolver/CPParser/src/test/java/NumericValueUpperwareImplMockup.java +++ b/ZPPSolver/CPParser/src/test/java/NumericValueUpperwareImplMockup.java @@ -1,5 +1,4 @@ import eu.paasage.upperware.metamodel.types.DoubleValueUpperware; -import eu.paasage.upperware.metamodel.types.NumericValueUpperware; import lombok.AllArgsConstructor; import org.eclipse.emf.cdo.CDOLock; import org.eclipse.emf.cdo.CDOObjectHistory; -- GitLab From 06be0cb406418b4a43643be5f1bcb6c288b78771 Mon Sep 17 00:00:00 2001 From: tc360950 Date: Tue, 3 Dec 2019 11:35:59 +0100 Subject: [PATCH 010/340] Formatting --- ZPPSolver/CPParser/src/main/java/ExpressionEvaluator.java | 2 -- 1 file changed, 2 deletions(-) diff --git a/ZPPSolver/CPParser/src/main/java/ExpressionEvaluator.java b/ZPPSolver/CPParser/src/main/java/ExpressionEvaluator.java index 79bbd14c5..2e8488ef6 100644 --- a/ZPPSolver/CPParser/src/main/java/ExpressionEvaluator.java +++ b/ZPPSolver/CPParser/src/main/java/ExpressionEvaluator.java @@ -68,7 +68,6 @@ public class ExpressionEvaluator { } else if (isCpVariable(exp)) { return variables.get(exp.getId()); } else if (isComposedExpression(exp)) { - return evaluateComposedExpression((ComposedExpression) exp, variables); } throw new RuntimeException("Unsupported Expression type"); @@ -88,7 +87,6 @@ public class ExpressionEvaluator { return argRight - argLeft > ExpressionEvaluator.PRECISION; case DIFFERENT: return Math.abs(argLeft - argRight) > ExpressionEvaluator.PRECISION; - } throw new RuntimeException("Unsupported comparator type"); } -- GitLab From 48bdb6ddab094538cb1ba40b623e575bb18715e2 Mon Sep 17 00:00:00 2001 From: ipatini Date: Thu, 5 Dec 2019 22:27:45 +0200 Subject: [PATCH 011/340] Penalty Calculator - Added Spring boot maven plugin --- penalty-calculator/pom.xml | 21 +++++++++++++++++++++ 1 file changed, 21 insertions(+) diff --git a/penalty-calculator/pom.xml b/penalty-calculator/pom.xml index d0468a10b..cbc081989 100644 --- a/penalty-calculator/pom.xml +++ b/penalty-calculator/pom.xml @@ -106,4 +106,25 @@ + + ${project.artifactId} + + + org.springframework.boot + spring-boot-maven-plugin + + true + ${start-class} + + + + + repackage + + + + + + + -- GitLab From c929a83b6820993b85696ded2f4a8fc377f9c977 Mon Sep 17 00:00:00 2001 From: tc360950 Date: Sat, 7 Dec 2019 16:21:41 +0100 Subject: [PATCH 012/340] Added comments --- .../src/main/java/ArConstraintImpl.java | 3 ++ .../src/main/java/ConstraintGraph.java | 28 +++++++++++++++++++ .../src/main/java/ExpressionEvaluator.java | 10 +++++++ 3 files changed, 41 insertions(+) diff --git a/ZPPSolver/CPParser/src/main/java/ArConstraintImpl.java b/ZPPSolver/CPParser/src/main/java/ArConstraintImpl.java index be4a82ef4..7d4903e7b 100644 --- a/ZPPSolver/CPParser/src/main/java/ArConstraintImpl.java +++ b/ZPPSolver/CPParser/src/main/java/ArConstraintImpl.java @@ -5,6 +5,9 @@ import java.util.Collection; import java.util.Map; public class ArConstraintImpl implements ArConstraint { + /* + Names of variables which are used in the constraint + */ private Collection variablesNames; private ComparatorEnum comparator; private Expression leftExpression; diff --git a/ZPPSolver/CPParser/src/main/java/ConstraintGraph.java b/ZPPSolver/CPParser/src/main/java/ConstraintGraph.java index 2b258033e..da4d2d67d 100644 --- a/ZPPSolver/CPParser/src/main/java/ConstraintGraph.java +++ b/ZPPSolver/CPParser/src/main/java/ConstraintGraph.java @@ -1,8 +1,21 @@ +/* + This class implements constraint graph. + A constraint graph is created from a set of + variables and constraints (i.e. subsets of the set of variables). + Each node corresponds to a variable. Two nodes are connected by an edge + iff there exists a constraint containing both. + */ + import java.util.*; public class ConstraintGraph { private Collection constraints; private Collection variables; + /* + For variable var and natural number d + @neighbourhoodList[var][d] contains set of variables + + */ private Map>> neighbourhoodList; private Map> variableToConstraint; @@ -18,6 +31,10 @@ public class ConstraintGraph { return neighbourhoodList.get(node).get(1); } + /* + for variable var, @knownDistances[var] contains set of + variables from which the distance to var is known. + */ private void initializeKnownDistances(Map> knownDistances) { for (String var : variables) { knownDistances.put(var, new LinkedList()); @@ -71,6 +88,17 @@ public class ConstraintGraph { } while (neighbourhoodSweep(distance, knownDistances)); } + /* + This function assumes all distances up to @dist-1 have been calculated. + For each variable @var, @knownDistances[@var] contains list of variables + from which distance to @var has already been calculated. + We iterate through nodes. + Let n denote some node. For each pair u, v where dist(u,n) == 1 + and dist(v, n) == @dist - 1, if distance between v and u is not known + set it to be equal to @dist. + Returns @true if some new shortest path between nodes has been found, + @false otherwise. + */ private boolean neighbourhoodSweep(int dist, Map> knownDistances){ boolean foundPath = false; for (String node: variables) { diff --git a/ZPPSolver/CPParser/src/main/java/ExpressionEvaluator.java b/ZPPSolver/CPParser/src/main/java/ExpressionEvaluator.java index 2e8488ef6..d0fce4f7c 100644 --- a/ZPPSolver/CPParser/src/main/java/ExpressionEvaluator.java +++ b/ZPPSolver/CPParser/src/main/java/ExpressionEvaluator.java @@ -1,3 +1,8 @@ +/* + This class is used to parse and evaluate Expression + interfaces from eu.paasage.upperware.metamodel.cp.package + */ + import eu.paasage.upperware.metamodel.types.*; import eu.paasage.upperware.metamodel.cp.*; @@ -6,6 +11,11 @@ import java.util.Map; import java.util.stream.Collectors; public class ExpressionEvaluator { + /* + Precision used to compare floating point numbers. + For instance if precision is set to 0.01, + 1 and 1.005 are considered equal. + */ public static final double PRECISION = 0.1; private static double getValueOfNumericInterface(NumericValueUpperware value) { -- GitLab From 0ac4a4555182cfe7648687f31de0d96e124f171e Mon Sep 17 00:00:00 2001 From: tc360950 Date: Sat, 7 Dec 2019 16:29:00 +0100 Subject: [PATCH 013/340] Added packages --- .../CPParser/src/main/java/CPWrapper/Parser/CPParsedData.java | 4 ++++ .../CPParser/src/main/java/CPWrapper/Parser/CPParser.java | 4 ++++ .../src/main/java/{ => CPWrapper/Utils}/ArConstraint.java | 2 ++ .../src/main/java/{ => CPWrapper/Utils}/ArConstraintImpl.java | 2 ++ .../src/main/java/{ => CPWrapper/Utils}/ConstraintGraph.java | 3 +++ .../main/java/{ => CPWrapper/Utils}/ExpressionEvaluator.java | 3 ++- ZPPSolver/CPParser/src/test/java/ArConstraintImplTest.java | 2 ++ ZPPSolver/CPParser/src/test/java/ConstraintGraphTest.java | 4 +++- ZPPSolver/CPParser/src/test/java/ExpressionEvaluatorTest.java | 1 + 9 files changed, 23 insertions(+), 2 deletions(-) create mode 100644 ZPPSolver/CPParser/src/main/java/CPWrapper/Parser/CPParsedData.java create mode 100644 ZPPSolver/CPParser/src/main/java/CPWrapper/Parser/CPParser.java rename ZPPSolver/CPParser/src/main/java/{ => CPWrapper/Utils}/ArConstraint.java (88%) rename ZPPSolver/CPParser/src/main/java/{ => CPWrapper/Utils}/ArConstraintImpl.java (98%) rename ZPPSolver/CPParser/src/main/java/{ => CPWrapper/Utils}/ConstraintGraph.java (98%) rename ZPPSolver/CPParser/src/main/java/{ => CPWrapper/Utils}/ExpressionEvaluator.java (98%) diff --git a/ZPPSolver/CPParser/src/main/java/CPWrapper/Parser/CPParsedData.java b/ZPPSolver/CPParser/src/main/java/CPWrapper/Parser/CPParsedData.java new file mode 100644 index 000000000..60d2268f9 --- /dev/null +++ b/ZPPSolver/CPParser/src/main/java/CPWrapper/Parser/CPParsedData.java @@ -0,0 +1,4 @@ +package CPWrapper.Parser; + +public class CPParsedData { +} diff --git a/ZPPSolver/CPParser/src/main/java/CPWrapper/Parser/CPParser.java b/ZPPSolver/CPParser/src/main/java/CPWrapper/Parser/CPParser.java new file mode 100644 index 000000000..361318bc3 --- /dev/null +++ b/ZPPSolver/CPParser/src/main/java/CPWrapper/Parser/CPParser.java @@ -0,0 +1,4 @@ +package CPWrapper.Parser; + +public class CPParser { +} diff --git a/ZPPSolver/CPParser/src/main/java/ArConstraint.java b/ZPPSolver/CPParser/src/main/java/CPWrapper/Utils/ArConstraint.java similarity index 88% rename from ZPPSolver/CPParser/src/main/java/ArConstraint.java rename to ZPPSolver/CPParser/src/main/java/CPWrapper/Utils/ArConstraint.java index 4333b8a03..eb2600b13 100644 --- a/ZPPSolver/CPParser/src/main/java/ArConstraint.java +++ b/ZPPSolver/CPParser/src/main/java/CPWrapper/Utils/ArConstraint.java @@ -1,3 +1,5 @@ +package CPWrapper.Utils; + import java.util.Collection; import java.util.Map; diff --git a/ZPPSolver/CPParser/src/main/java/ArConstraintImpl.java b/ZPPSolver/CPParser/src/main/java/CPWrapper/Utils/ArConstraintImpl.java similarity index 98% rename from ZPPSolver/CPParser/src/main/java/ArConstraintImpl.java rename to ZPPSolver/CPParser/src/main/java/CPWrapper/Utils/ArConstraintImpl.java index 7d4903e7b..e3f396cc9 100644 --- a/ZPPSolver/CPParser/src/main/java/ArConstraintImpl.java +++ b/ZPPSolver/CPParser/src/main/java/CPWrapper/Utils/ArConstraintImpl.java @@ -1,3 +1,5 @@ +package CPWrapper.Utils; + import eu.paasage.upperware.metamodel.cp.*; import java.util.ArrayList; diff --git a/ZPPSolver/CPParser/src/main/java/ConstraintGraph.java b/ZPPSolver/CPParser/src/main/java/CPWrapper/Utils/ConstraintGraph.java similarity index 98% rename from ZPPSolver/CPParser/src/main/java/ConstraintGraph.java rename to ZPPSolver/CPParser/src/main/java/CPWrapper/Utils/ConstraintGraph.java index da4d2d67d..95b36c50f 100644 --- a/ZPPSolver/CPParser/src/main/java/ConstraintGraph.java +++ b/ZPPSolver/CPParser/src/main/java/CPWrapper/Utils/ConstraintGraph.java @@ -1,3 +1,4 @@ +package CPWrapper.Utils; /* This class implements constraint graph. A constraint graph is created from a set of @@ -6,6 +7,8 @@ iff there exists a constraint containing both. */ +import CPWrapper.Utils.ArConstraint; + import java.util.*; public class ConstraintGraph { diff --git a/ZPPSolver/CPParser/src/main/java/ExpressionEvaluator.java b/ZPPSolver/CPParser/src/main/java/CPWrapper/Utils/ExpressionEvaluator.java similarity index 98% rename from ZPPSolver/CPParser/src/main/java/ExpressionEvaluator.java rename to ZPPSolver/CPParser/src/main/java/CPWrapper/Utils/ExpressionEvaluator.java index d0fce4f7c..f11b70abf 100644 --- a/ZPPSolver/CPParser/src/main/java/ExpressionEvaluator.java +++ b/ZPPSolver/CPParser/src/main/java/CPWrapper/Utils/ExpressionEvaluator.java @@ -1,6 +1,7 @@ +package CPWrapper.Utils; /* This class is used to parse and evaluate Expression - interfaces from eu.paasage.upperware.metamodel.cp.package + interfaces from eu.paasage.upperware.metamodel.cp package */ import eu.paasage.upperware.metamodel.types.*; diff --git a/ZPPSolver/CPParser/src/test/java/ArConstraintImplTest.java b/ZPPSolver/CPParser/src/test/java/ArConstraintImplTest.java index c714ded10..fcbabc7c3 100644 --- a/ZPPSolver/CPParser/src/test/java/ArConstraintImplTest.java +++ b/ZPPSolver/CPParser/src/test/java/ArConstraintImplTest.java @@ -1,4 +1,6 @@ +import CPWrapper.Utils.ArConstraint; +import CPWrapper.Utils.ArConstraintImpl; import eu.paasage.upperware.metamodel.cp.*; import eu.paasage.upperware.metamodel.types.BasicTypeEnum; import org.eclipse.emf.common.util.BasicEList; diff --git a/ZPPSolver/CPParser/src/test/java/ConstraintGraphTest.java b/ZPPSolver/CPParser/src/test/java/ConstraintGraphTest.java index d2ee24d5c..c8da0d473 100644 --- a/ZPPSolver/CPParser/src/test/java/ConstraintGraphTest.java +++ b/ZPPSolver/CPParser/src/test/java/ConstraintGraphTest.java @@ -1,3 +1,5 @@ +import CPWrapper.Utils.ArConstraint; +import CPWrapper.Utils.ConstraintGraph; import lombok.AllArgsConstructor; import org.junit.jupiter.api.BeforeAll; import org.junit.jupiter.api.Test; @@ -8,7 +10,7 @@ import static org.junit.jupiter.api.Assertions.*; class ConstraintGraphTest { @AllArgsConstructor - private static class ConstraintMockup implements ArConstraint{ + private static class ConstraintMockup implements ArConstraint { private Collection variables; @Override diff --git a/ZPPSolver/CPParser/src/test/java/ExpressionEvaluatorTest.java b/ZPPSolver/CPParser/src/test/java/ExpressionEvaluatorTest.java index 6a89eada5..08cf495dd 100644 --- a/ZPPSolver/CPParser/src/test/java/ExpressionEvaluatorTest.java +++ b/ZPPSolver/CPParser/src/test/java/ExpressionEvaluatorTest.java @@ -1,3 +1,4 @@ +import CPWrapper.Utils.ExpressionEvaluator; import eu.paasage.upperware.metamodel.cp.*; import eu.paasage.upperware.metamodel.types.BasicTypeEnum; import eu.paasage.upperware.metamodel.types.NumericValueUpperware; -- GitLab From d311af290587490498b5d0d73f81597deb91d37b Mon Sep 17 00:00:00 2001 From: tc360950 Date: Sat, 7 Dec 2019 16:37:29 +0100 Subject: [PATCH 014/340] Added empty parsedData, CpParser classes, refactored tests' directory structure --- .../java/CPWrapper/Parser/CPParsedData.java | 22 +++++++++++++++++++ .../main/java/CPWrapper/Parser/CPParser.java | 6 +++++ .../ComposedExpressionImplMockup.java | 2 ++ .../Mockups}/ConstantImplMockup.java | 2 ++ .../Mockups}/CpMetricImplMockup.java | 2 ++ .../Mockups}/CpVariableImplMockup.java | 2 ++ .../NumericValueUpperwareImplMockup.java | 2 ++ .../java/CPWrapper/Parser/CPParserTest.java | 7 ++++++ .../Utils}/ArConstraintImplTest.java | 4 ++-- .../Utils}/ConstraintGraphTest.java | 2 ++ .../Utils}/ExpressionEvaluatorTest.java | 4 +++- 11 files changed, 52 insertions(+), 3 deletions(-) rename ZPPSolver/CPParser/src/test/java/{ => CPWrapper/Mockups}/ComposedExpressionImplMockup.java (96%) rename ZPPSolver/CPParser/src/test/java/{ => CPWrapper/Mockups}/ConstantImplMockup.java (96%) rename ZPPSolver/CPParser/src/test/java/{ => CPWrapper/Mockups}/CpMetricImplMockup.java (96%) rename ZPPSolver/CPParser/src/test/java/{ => CPWrapper/Mockups}/CpVariableImplMockup.java (97%) rename ZPPSolver/CPParser/src/test/java/{ => CPWrapper/Mockups}/NumericValueUpperwareImplMockup.java (99%) create mode 100644 ZPPSolver/CPParser/src/test/java/CPWrapper/Parser/CPParserTest.java rename ZPPSolver/CPParser/src/test/java/{ => CPWrapper/Utils}/ArConstraintImplTest.java (97%) rename ZPPSolver/CPParser/src/test/java/{ => CPWrapper/Utils}/ConstraintGraphTest.java (99%) rename ZPPSolver/CPParser/src/test/java/{ => CPWrapper/Utils}/ExpressionEvaluatorTest.java (98%) diff --git a/ZPPSolver/CPParser/src/main/java/CPWrapper/Parser/CPParsedData.java b/ZPPSolver/CPParser/src/main/java/CPWrapper/Parser/CPParsedData.java index 60d2268f9..0b0dd5394 100644 --- a/ZPPSolver/CPParser/src/main/java/CPWrapper/Parser/CPParsedData.java +++ b/ZPPSolver/CPParser/src/main/java/CPWrapper/Parser/CPParsedData.java @@ -1,4 +1,26 @@ package CPWrapper.Parser; +import CPWrapper.Utils.ArConstraint; +import eu.paasage.upperware.metamodel.cp.Constant; +import eu.paasage.upperware.metamodel.cp.CpMetric; +import eu.paasage.upperware.metamodel.cp.CpVariable; + +import java.util.Collection; + public class CPParsedData { + + protected void postConstants(Collection constants) { + + } + + protected void postMetrics(Collection metrics) { + + } + protected void postConstraints(Collection constraints) { + + } + protected void postVariables(Collection variables) { + + } + } diff --git a/ZPPSolver/CPParser/src/main/java/CPWrapper/Parser/CPParser.java b/ZPPSolver/CPParser/src/main/java/CPWrapper/Parser/CPParser.java index 361318bc3..c9d8d1a73 100644 --- a/ZPPSolver/CPParser/src/main/java/CPWrapper/Parser/CPParser.java +++ b/ZPPSolver/CPParser/src/main/java/CPWrapper/Parser/CPParser.java @@ -1,4 +1,10 @@ package CPWrapper.Parser; +import eu.paasage.upperware.metamodel.cp.ConstraintProblem; + public class CPParser { + + public CPParsedData parse(ConstraintProblem constraintProblem) { + return null; + } } diff --git a/ZPPSolver/CPParser/src/test/java/ComposedExpressionImplMockup.java b/ZPPSolver/CPParser/src/test/java/CPWrapper/Mockups/ComposedExpressionImplMockup.java similarity index 96% rename from ZPPSolver/CPParser/src/test/java/ComposedExpressionImplMockup.java rename to ZPPSolver/CPParser/src/test/java/CPWrapper/Mockups/ComposedExpressionImplMockup.java index 279b32f66..cbc58d695 100644 --- a/ZPPSolver/CPParser/src/test/java/ComposedExpressionImplMockup.java +++ b/ZPPSolver/CPParser/src/test/java/CPWrapper/Mockups/ComposedExpressionImplMockup.java @@ -1,3 +1,5 @@ +package CPWrapper.Mockups; + import eu.paasage.upperware.metamodel.cp.ComposedExpression; import eu.paasage.upperware.metamodel.cp.NumericExpression; import eu.paasage.upperware.metamodel.cp.OperatorEnum; diff --git a/ZPPSolver/CPParser/src/test/java/ConstantImplMockup.java b/ZPPSolver/CPParser/src/test/java/CPWrapper/Mockups/ConstantImplMockup.java similarity index 96% rename from ZPPSolver/CPParser/src/test/java/ConstantImplMockup.java rename to ZPPSolver/CPParser/src/test/java/CPWrapper/Mockups/ConstantImplMockup.java index 697e6c45e..7f579ea04 100644 --- a/ZPPSolver/CPParser/src/test/java/ConstantImplMockup.java +++ b/ZPPSolver/CPParser/src/test/java/CPWrapper/Mockups/ConstantImplMockup.java @@ -1,3 +1,5 @@ +package CPWrapper.Mockups; + import eu.paasage.upperware.metamodel.cp.Constant; import eu.paasage.upperware.metamodel.cp.impl.NumericExpressionImpl; import eu.paasage.upperware.metamodel.types.BasicTypeEnum; diff --git a/ZPPSolver/CPParser/src/test/java/CpMetricImplMockup.java b/ZPPSolver/CPParser/src/test/java/CPWrapper/Mockups/CpMetricImplMockup.java similarity index 96% rename from ZPPSolver/CPParser/src/test/java/CpMetricImplMockup.java rename to ZPPSolver/CPParser/src/test/java/CPWrapper/Mockups/CpMetricImplMockup.java index 799bded8c..5d60b787f 100644 --- a/ZPPSolver/CPParser/src/test/java/CpMetricImplMockup.java +++ b/ZPPSolver/CPParser/src/test/java/CPWrapper/Mockups/CpMetricImplMockup.java @@ -1,3 +1,5 @@ +package CPWrapper.Mockups; + import eu.paasage.upperware.metamodel.cp.CpMetric; import eu.paasage.upperware.metamodel.cp.impl.NumericExpressionImpl; import eu.paasage.upperware.metamodel.types.BasicTypeEnum; diff --git a/ZPPSolver/CPParser/src/test/java/CpVariableImplMockup.java b/ZPPSolver/CPParser/src/test/java/CPWrapper/Mockups/CpVariableImplMockup.java similarity index 97% rename from ZPPSolver/CPParser/src/test/java/CpVariableImplMockup.java rename to ZPPSolver/CPParser/src/test/java/CPWrapper/Mockups/CpVariableImplMockup.java index 4b39c9f60..91218af33 100644 --- a/ZPPSolver/CPParser/src/test/java/CpVariableImplMockup.java +++ b/ZPPSolver/CPParser/src/test/java/CPWrapper/Mockups/CpVariableImplMockup.java @@ -1,3 +1,5 @@ +package CPWrapper.Mockups; + import eu.paasage.upperware.metamodel.cp.CpVariable; import eu.paasage.upperware.metamodel.cp.Domain; import eu.paasage.upperware.metamodel.cp.VariableType; diff --git a/ZPPSolver/CPParser/src/test/java/NumericValueUpperwareImplMockup.java b/ZPPSolver/CPParser/src/test/java/CPWrapper/Mockups/NumericValueUpperwareImplMockup.java similarity index 99% rename from ZPPSolver/CPParser/src/test/java/NumericValueUpperwareImplMockup.java rename to ZPPSolver/CPParser/src/test/java/CPWrapper/Mockups/NumericValueUpperwareImplMockup.java index 1f7a7772c..20ecc035f 100644 --- a/ZPPSolver/CPParser/src/test/java/NumericValueUpperwareImplMockup.java +++ b/ZPPSolver/CPParser/src/test/java/CPWrapper/Mockups/NumericValueUpperwareImplMockup.java @@ -1,3 +1,5 @@ +package CPWrapper.Mockups; + import eu.paasage.upperware.metamodel.types.DoubleValueUpperware; import lombok.AllArgsConstructor; import org.eclipse.emf.cdo.CDOLock; diff --git a/ZPPSolver/CPParser/src/test/java/CPWrapper/Parser/CPParserTest.java b/ZPPSolver/CPParser/src/test/java/CPWrapper/Parser/CPParserTest.java new file mode 100644 index 000000000..ccd8dd70f --- /dev/null +++ b/ZPPSolver/CPParser/src/test/java/CPWrapper/Parser/CPParserTest.java @@ -0,0 +1,7 @@ +package CPWrapper.Parser; + +import static org.junit.jupiter.api.Assertions.*; + +class CPParserTest { + +} \ No newline at end of file diff --git a/ZPPSolver/CPParser/src/test/java/ArConstraintImplTest.java b/ZPPSolver/CPParser/src/test/java/CPWrapper/Utils/ArConstraintImplTest.java similarity index 97% rename from ZPPSolver/CPParser/src/test/java/ArConstraintImplTest.java rename to ZPPSolver/CPParser/src/test/java/CPWrapper/Utils/ArConstraintImplTest.java index fcbabc7c3..55a3ae48f 100644 --- a/ZPPSolver/CPParser/src/test/java/ArConstraintImplTest.java +++ b/ZPPSolver/CPParser/src/test/java/CPWrapper/Utils/ArConstraintImplTest.java @@ -1,6 +1,6 @@ +package CPWrapper.Utils; -import CPWrapper.Utils.ArConstraint; -import CPWrapper.Utils.ArConstraintImpl; +import CPWrapper.Mockups.*; import eu.paasage.upperware.metamodel.cp.*; import eu.paasage.upperware.metamodel.types.BasicTypeEnum; import org.eclipse.emf.common.util.BasicEList; diff --git a/ZPPSolver/CPParser/src/test/java/ConstraintGraphTest.java b/ZPPSolver/CPParser/src/test/java/CPWrapper/Utils/ConstraintGraphTest.java similarity index 99% rename from ZPPSolver/CPParser/src/test/java/ConstraintGraphTest.java rename to ZPPSolver/CPParser/src/test/java/CPWrapper/Utils/ConstraintGraphTest.java index c8da0d473..a8dba7efb 100644 --- a/ZPPSolver/CPParser/src/test/java/ConstraintGraphTest.java +++ b/ZPPSolver/CPParser/src/test/java/CPWrapper/Utils/ConstraintGraphTest.java @@ -1,3 +1,5 @@ +package CPWrapper.Utils; + import CPWrapper.Utils.ArConstraint; import CPWrapper.Utils.ConstraintGraph; import lombok.AllArgsConstructor; diff --git a/ZPPSolver/CPParser/src/test/java/ExpressionEvaluatorTest.java b/ZPPSolver/CPParser/src/test/java/CPWrapper/Utils/ExpressionEvaluatorTest.java similarity index 98% rename from ZPPSolver/CPParser/src/test/java/ExpressionEvaluatorTest.java rename to ZPPSolver/CPParser/src/test/java/CPWrapper/Utils/ExpressionEvaluatorTest.java index 08cf495dd..9f97c2c2a 100644 --- a/ZPPSolver/CPParser/src/test/java/ExpressionEvaluatorTest.java +++ b/ZPPSolver/CPParser/src/test/java/CPWrapper/Utils/ExpressionEvaluatorTest.java @@ -1,4 +1,6 @@ -import CPWrapper.Utils.ExpressionEvaluator; +package CPWrapper.Utils; + +import CPWrapper.Mockups.*; import eu.paasage.upperware.metamodel.cp.*; import eu.paasage.upperware.metamodel.types.BasicTypeEnum; import eu.paasage.upperware.metamodel.types.NumericValueUpperware; -- GitLab From 5ff090356c6e112cba96485550025ed1b40344a5 Mon Sep 17 00:00:00 2001 From: tc360950 Date: Sat, 7 Dec 2019 16:49:01 +0100 Subject: [PATCH 015/340] Implemented CPParser class --- .../main/java/CPWrapper/Parser/CPParser.java | 38 ++++++++++++++++++- 1 file changed, 36 insertions(+), 2 deletions(-) diff --git a/ZPPSolver/CPParser/src/main/java/CPWrapper/Parser/CPParser.java b/ZPPSolver/CPParser/src/main/java/CPWrapper/Parser/CPParser.java index c9d8d1a73..f65edf370 100644 --- a/ZPPSolver/CPParser/src/main/java/CPWrapper/Parser/CPParser.java +++ b/ZPPSolver/CPParser/src/main/java/CPWrapper/Parser/CPParser.java @@ -1,10 +1,44 @@ package CPWrapper.Parser; +import CPWrapper.Utils.ArConstraint; +import CPWrapper.Utils.ArConstraintImpl; import eu.paasage.upperware.metamodel.cp.ConstraintProblem; +import java.util.List; +import java.util.stream.Collectors; + public class CPParser { + private CPParsedData cpParsedData; + + public CPParser() { + cpParsedData = new CPParsedData(); + } + + public CPParsedData parse(ConstraintProblem cp) { + parseConstants(cp); + parseMetrics(cp); + parseVariables(cp); + parseConstraints(cp); + return cpParsedData; + } + + private void parseConstants(ConstraintProblem cp) { + cpParsedData.postConstants(cp.getConstants()); + } + + private void parseMetrics(ConstraintProblem cp) { + cpParsedData.postMetrics(cp.getCpMetrics()); + } + + private void parseVariables(ConstraintProblem cp) { + cpParsedData.postVariables(cp.getCpVariables()); + } - public CPParsedData parse(ConstraintProblem constraintProblem) { - return null; + private void parseConstraints(ConstraintProblem cp) { + List constraints = + cp.getConstraints().stream() + .map(compExp -> new ArConstraintImpl(compExp.getComparator(), compExp.getExp1(), compExp.getExp2())) + .collect(Collectors.toList()); + cpParsedData.postConstraints(constraints); } } -- GitLab From 4ed157ce536e3e89bcf413b01ae059f1d532aa5b Mon Sep 17 00:00:00 2001 From: tc360950 Date: Sat, 7 Dec 2019 17:07:03 +0100 Subject: [PATCH 016/340] First implementation of CPParsedData --- .../java/CPWrapper/Parser/CPParsedData.java | 49 +++++++++++++++++-- 1 file changed, 45 insertions(+), 4 deletions(-) diff --git a/ZPPSolver/CPParser/src/main/java/CPWrapper/Parser/CPParsedData.java b/ZPPSolver/CPParser/src/main/java/CPWrapper/Parser/CPParsedData.java index 0b0dd5394..438c51094 100644 --- a/ZPPSolver/CPParser/src/main/java/CPWrapper/Parser/CPParsedData.java +++ b/ZPPSolver/CPParser/src/main/java/CPWrapper/Parser/CPParsedData.java @@ -1,26 +1,67 @@ package CPWrapper.Parser; import CPWrapper.Utils.ArConstraint; +import CPWrapper.Utils.ConstraintGraph; import eu.paasage.upperware.metamodel.cp.Constant; import eu.paasage.upperware.metamodel.cp.CpMetric; import eu.paasage.upperware.metamodel.cp.CpVariable; import java.util.Collection; +import java.util.List; +import java.util.Map; +import java.util.stream.Collectors; public class CPParsedData { + private Collection constants; + private Collection metrics; + private Collection constraints; + private Collection variables; + private ConstraintGraph constraintGraph; - protected void postConstants(Collection constants) { + public boolean isFeasible(Map variables) { + for (ArConstraint c : constraints) { + if (!c.evaluate(variables)) { + return false; + } + } + return true; } - protected void postMetrics(Collection metrics) { + public int countViolatedConstraints(Map variables) { + int count = + constraints.stream() + .map(c -> c.evaluate(variables) ? 0 : 1) + .reduce( (int) 0, (subtotal, el) -> subtotal + el); + return count; + } + public int getHeuristicEvaluation(String variable) { + return 0; } - protected void postConstraints(Collection constraints) { + + + + private void initializeConstraintGraph() { + List variableNames = + variables.stream() + .map(var -> var.getId()) + .collect(Collectors.toList()); + constraintGraph = new ConstraintGraph(constraints, variableNames); } - protected void postVariables(Collection variables) { + protected void postConstants(Collection constants) { + this.constants = constants; + } + protected void postMetrics(Collection metrics) { + this.metrics = metrics; + } + protected void postConstraints(Collection constraints) { + this.constraints = constraints; + } + protected void postVariables(Collection variables) { + this.variables = variables; } } -- GitLab From ea9579f48ae7e409fc60028f33a49b57b7eb9ced Mon Sep 17 00:00:00 2001 From: tc360950 Date: Sat, 7 Dec 2019 20:26:07 +0100 Subject: [PATCH 017/340] Added tests for HeuristicVariableOrderer --- ZPPSolver/CPParser/pom.xml | 11 +++ .../src/main/java/CPWrapper/CPWrapper.java | 33 ++++++++ .../java/CPWrapper/Parser/CPParsedData.java | 31 +++++++- .../main/java/CPWrapper/Parser/CPParser.java | 1 + .../java/CPWrapper/Utils/ConstraintGraph.java | 37 ++++++++- .../Utils/HeuristicVariableOrderer.java | 60 +++++++++++++++ .../java/CPWrapper/Utils/VariableOrderer.java | 5 ++ .../CPWrapper/Mockups/ConstraintMockup.java | 22 ++++++ .../CPWrapper/Utils/ConstraintGraphTest.java | 18 +---- .../Utils/HeuristicVariableOrdererTest.java | 77 +++++++++++++++++++ 10 files changed, 274 insertions(+), 21 deletions(-) create mode 100644 ZPPSolver/CPParser/src/main/java/CPWrapper/CPWrapper.java create mode 100644 ZPPSolver/CPParser/src/main/java/CPWrapper/Utils/HeuristicVariableOrderer.java create mode 100644 ZPPSolver/CPParser/src/main/java/CPWrapper/Utils/VariableOrderer.java create mode 100644 ZPPSolver/CPParser/src/test/java/CPWrapper/Mockups/ConstraintMockup.java create mode 100644 ZPPSolver/CPParser/src/test/java/CPWrapper/Utils/HeuristicVariableOrdererTest.java diff --git a/ZPPSolver/CPParser/pom.xml b/ZPPSolver/CPParser/pom.xml index 767c83909..baa890e8a 100644 --- a/ZPPSolver/CPParser/pom.xml +++ b/ZPPSolver/CPParser/pom.xml @@ -36,6 +36,17 @@ antlr test + + eu.melodic + utility-generator + 2.5.1-SNAPSHOT + compile + + + org.javatuples + javatuples + 1.2 + diff --git a/ZPPSolver/CPParser/src/main/java/CPWrapper/CPWrapper.java b/ZPPSolver/CPParser/src/main/java/CPWrapper/CPWrapper.java new file mode 100644 index 000000000..0d0d2dea0 --- /dev/null +++ b/ZPPSolver/CPParser/src/main/java/CPWrapper/CPWrapper.java @@ -0,0 +1,33 @@ +package CPWrapper; + +import CPWrapper.Parser.CPParsedData; +import CPWrapper.Parser.CPParser; +import CPWrapper.Utils.HeuristicVariableOrderer; +import CPWrapper.Utils.VariableOrderer; +import eu.paasage.upperware.metamodel.cp.ConstraintProblem; +import eu.melodic.upperware.utilitygenerator.UtilityGeneratorApplication; + + +public class CPWrapper { + private VariableOrderer variableOrderer; + private CPParsedData cpParsedData; + private UtilityGeneratorApplication utilityGenerator; + + public void parse(ConstraintProblem constraintProblem, UtilityGeneratorApplication utility) { + CPParser cpParser = new CPParser(); + cpParsedData = cpParser.parse(constraintProblem); + this.utilityGenerator = utility; + this.variableOrderer = new HeuristicVariableOrderer(cpParsedData.getConstraintGraph()); + } + + public void setVariableOrdering(VariableOrderer vO) { + this.variableOrderer = vO; + } + + + + + private void orderVariablesRandomly() { + //TODO + } +} diff --git a/ZPPSolver/CPParser/src/main/java/CPWrapper/Parser/CPParsedData.java b/ZPPSolver/CPParser/src/main/java/CPWrapper/Parser/CPParsedData.java index 438c51094..2e23a10c7 100644 --- a/ZPPSolver/CPParser/src/main/java/CPWrapper/Parser/CPParsedData.java +++ b/ZPPSolver/CPParser/src/main/java/CPWrapper/Parser/CPParsedData.java @@ -5,8 +5,11 @@ import CPWrapper.Utils.ConstraintGraph; import eu.paasage.upperware.metamodel.cp.Constant; import eu.paasage.upperware.metamodel.cp.CpMetric; import eu.paasage.upperware.metamodel.cp.CpVariable; +import eu.paasage.upperware.metamodel.cp.Domain; +import lombok.Getter; import java.util.Collection; +import java.util.HashMap; import java.util.List; import java.util.Map; import java.util.stream.Collectors; @@ -16,8 +19,18 @@ public class CPParsedData { private Collection metrics; private Collection constraints; private Collection variables; + @Getter private ConstraintGraph constraintGraph; + private Map nameToVariable; + public Collection getVariableNames() { + return nameToVariable.keySet(); + } + + public void init() { + initializeConstraintGraph(); + initializeNameToVariable(); + } public boolean isFeasible(Map variables) { for (ArConstraint c : constraints) { @@ -36,12 +49,24 @@ public class CPParsedData { return count; } - public int getHeuristicEvaluation(String variable) { - return 0; + public int getHeuristicEvaluation(String variable, Map variables) { + return constraintGraph.getVariableHeuristicEvaluation(variable, variables); + } + + public void updateMetrics(Collection metrics) { + //TODO } - + public Domain getVariableDomain(String variable) { + return nameToVariable.get(variable).getDomain(); + } + private void initializeNameToVariable() { + nameToVariable = new HashMap(); + for (CpVariable var : variables) { + nameToVariable.put(var.getId(), var); + } + } private void initializeConstraintGraph() { List variableNames = diff --git a/ZPPSolver/CPParser/src/main/java/CPWrapper/Parser/CPParser.java b/ZPPSolver/CPParser/src/main/java/CPWrapper/Parser/CPParser.java index f65edf370..f2305d2af 100644 --- a/ZPPSolver/CPParser/src/main/java/CPWrapper/Parser/CPParser.java +++ b/ZPPSolver/CPParser/src/main/java/CPWrapper/Parser/CPParser.java @@ -19,6 +19,7 @@ public class CPParser { parseMetrics(cp); parseVariables(cp); parseConstraints(cp); + cpParsedData.init(); return cpParsedData; } diff --git a/ZPPSolver/CPParser/src/main/java/CPWrapper/Utils/ConstraintGraph.java b/ZPPSolver/CPParser/src/main/java/CPWrapper/Utils/ConstraintGraph.java index 95b36c50f..7e0ec384c 100644 --- a/ZPPSolver/CPParser/src/main/java/CPWrapper/Utils/ConstraintGraph.java +++ b/ZPPSolver/CPParser/src/main/java/CPWrapper/Utils/ConstraintGraph.java @@ -7,7 +7,6 @@ package CPWrapper.Utils; iff there exists a constraint containing both. */ -import CPWrapper.Utils.ArConstraint; import java.util.*; @@ -127,6 +126,38 @@ public class ConstraintGraph { } } + /* + Counts number of distinct variables which are either involved in + constraint @c or are a neighbour of some variable which is involved in @c. + */ + private int countConstraintVariablesAndTheirNeighbours(ArConstraint c) { + Set vars = new HashSet<>(); + for (String var : c.getVariableNames()) { + vars.addAll(neighbourhoodList.get(var).get(1)); + } + vars.addAll(c.getVariableNames()); + return vars.size(); + } + + /* + A value of a constraint is defined to be equal to 0 if + it is satisfied (under assignment @variables), p otherwise. + Where p is equal to number of distinct variables which are either involved in the constraint or + or neighbours of some variable involved in the constrained. + + Heuristic evaluation of a variable is defined to be a sum of violated constrains + which involve the variable. + */ + public int getVariableHeuristicEvaluation(String variable, Map variables) { + int result = 0; + for (ArConstraint c : variableToConstraint.get(variable)) { + if (!c.evaluate(variables)) { + result += countConstraintVariablesAndTheirNeighbours(c) - 1; + } + } + return result; + } + public Collection getConstraints(String variable) { return variableToConstraint.get(variable); } @@ -134,4 +165,8 @@ public class ConstraintGraph { public int getNumberOfNeighbours(String node, int distance) { return getNeighbours(node, distance).size(); } + + public Collection getNodes() { + return variables; + } } diff --git a/ZPPSolver/CPParser/src/main/java/CPWrapper/Utils/HeuristicVariableOrderer.java b/ZPPSolver/CPParser/src/main/java/CPWrapper/Utils/HeuristicVariableOrderer.java new file mode 100644 index 000000000..cf79678da --- /dev/null +++ b/ZPPSolver/CPParser/src/main/java/CPWrapper/Utils/HeuristicVariableOrderer.java @@ -0,0 +1,60 @@ +package CPWrapper.Utils; + +import org.javatuples.Pair; +import java.util.Collections; +import java.util.HashMap; +import java.util.Map; +import java.util.stream.Stream; + +public class HeuristicVariableOrderer implements VariableOrderer { + private Map indexToVariableName; + + public HeuristicVariableOrderer(ConstraintGraph graph) { + indexToVariableName = new HashMap<>(); + orderVariablesHeuristically(graph); + } + + @Override + public String indexToVariableName(int var) { + return indexToVariableName.get(var); + } + + private Map> evaluateVariables(ConstraintGraph constraintGraph) { + Map> nameToValue = new HashMap<>(); + for (String var : constraintGraph.getNodes()) { + int constraints = constraintGraph.getConstraints(var).size(); + int eval = constraintGraph.getNumberOfNeighbours(var, 1); + nameToValue.put(var, new Pair(constraints, eval)); + } + return nameToValue; + } + + private void orderVariablesHeuristically(ConstraintGraph constraintGraph) { + Map> nameToValue = evaluateVariables(constraintGraph); + + Stream>> sorted = + nameToValue.entrySet().stream() + .sorted(Collections.reverseOrder(Map.Entry.comparingByValue( + (p1, p2) -> { + if (p1.getValue0() < p2.getValue0()) { + return -1; + } else if (p1.getValue0() == p2.getValue0()) { + if (p1.getValue1() < p2.getValue1()) { + return -1; + } else if (p1.getValue1() == p2.getValue1()) { + return 0; + } else { + return 1; + } + } else { + return 1; + } + } + ))); + final int[] order = {0}; + sorted.forEachOrdered(p -> { + indexToVariableName.put(order[0], p.getKey()); + order[0]++; + }); + } +} diff --git a/ZPPSolver/CPParser/src/main/java/CPWrapper/Utils/VariableOrderer.java b/ZPPSolver/CPParser/src/main/java/CPWrapper/Utils/VariableOrderer.java new file mode 100644 index 000000000..ad8f375c6 --- /dev/null +++ b/ZPPSolver/CPParser/src/main/java/CPWrapper/Utils/VariableOrderer.java @@ -0,0 +1,5 @@ +package CPWrapper.Utils; + +public interface VariableOrderer { + String indexToVariableName(int var); +} diff --git a/ZPPSolver/CPParser/src/test/java/CPWrapper/Mockups/ConstraintMockup.java b/ZPPSolver/CPParser/src/test/java/CPWrapper/Mockups/ConstraintMockup.java new file mode 100644 index 000000000..8e54e4ab7 --- /dev/null +++ b/ZPPSolver/CPParser/src/test/java/CPWrapper/Mockups/ConstraintMockup.java @@ -0,0 +1,22 @@ +package CPWrapper.Mockups; + +import CPWrapper.Utils.ArConstraint; +import lombok.AllArgsConstructor; + +import java.util.Collection; +import java.util.Map; + +@AllArgsConstructor +public class ConstraintMockup implements ArConstraint { + private Collection variables; + + @Override + public Collection getVariableNames() { + return variables; + } + + @Override + public boolean evaluate(Map variables) { + return false; + } +} diff --git a/ZPPSolver/CPParser/src/test/java/CPWrapper/Utils/ConstraintGraphTest.java b/ZPPSolver/CPParser/src/test/java/CPWrapper/Utils/ConstraintGraphTest.java index a8dba7efb..fb125f179 100644 --- a/ZPPSolver/CPParser/src/test/java/CPWrapper/Utils/ConstraintGraphTest.java +++ b/ZPPSolver/CPParser/src/test/java/CPWrapper/Utils/ConstraintGraphTest.java @@ -1,8 +1,6 @@ package CPWrapper.Utils; -import CPWrapper.Utils.ArConstraint; -import CPWrapper.Utils.ConstraintGraph; -import lombok.AllArgsConstructor; +import CPWrapper.Mockups.ConstraintMockup; import org.junit.jupiter.api.BeforeAll; import org.junit.jupiter.api.Test; @@ -11,20 +9,6 @@ import java.util.*; import static org.junit.jupiter.api.Assertions.*; class ConstraintGraphTest { - @AllArgsConstructor - private static class ConstraintMockup implements ArConstraint { - private Collection variables; - - @Override - public Collection getVariableNames() { - return variables; - } - - @Override - public boolean evaluate(Map variables) { - return false; - } - }; private static List variables; @BeforeAll static void setUp() { diff --git a/ZPPSolver/CPParser/src/test/java/CPWrapper/Utils/HeuristicVariableOrdererTest.java b/ZPPSolver/CPParser/src/test/java/CPWrapper/Utils/HeuristicVariableOrdererTest.java new file mode 100644 index 000000000..6df6fd997 --- /dev/null +++ b/ZPPSolver/CPParser/src/test/java/CPWrapper/Utils/HeuristicVariableOrdererTest.java @@ -0,0 +1,77 @@ +package CPWrapper.Utils; +import CPWrapper.Mockups.ConstraintMockup; +import org.junit.jupiter.api.BeforeAll; +import org.junit.jupiter.api.Test; + +import java.util.*; + +import static org.junit.jupiter.api.Assertions.*; + +class HeuristicVariableOrdererTest { + private static List variables; + + @BeforeAll + static void setUp() { + String[] vars = new String[]{"var1", "var2", "var3", "var4", "var5", "var6", "var7", "var8"}; + variables = Arrays.asList(vars); + } + + private static ConstraintGraph createExpandingGraph() { + Collection constraints = new ArrayList<>(); + int varsSize = variables.size(); + for(int i = 0; i < varsSize; i++) { + constraints.add(new ConstraintMockup(variables.subList(0,i+1))); + } + ConstraintGraph graph = new ConstraintGraph(constraints, variables); + return graph; + } + + private static ConstraintGraph sameNumberOfConstraintsGraph() { + Collection constraints = new ArrayList<>(); + int varsSize = variables.size(); + for(int i = 0; i < varsSize; i++) { + constraints.add(new ConstraintMockup(variables.subList(0,i+1))); + for (int j = i + 1; j < varsSize; j++) { + constraints.add(new ConstraintMockup(variables.subList(j, j+1))); + } + } + ConstraintGraph graph = new ConstraintGraph(constraints, variables); + return graph; + } + + @Test + public void expandingGraphTest(){ + ConstraintGraph graph = createExpandingGraph(); + HeuristicVariableOrderer orderer = new HeuristicVariableOrderer(graph); + for (int i = 0; i < variables.size(); i++) { + assertTrue( orderer.indexToVariableName(i).equals(variables.get(i))); + } + } + + @Test + public void sameNumberOfConstraintsTest() { + ConstraintGraph graph = sameNumberOfConstraintsGraph(); + // Here the ordering is not deterministic but we can at least check if + // all the variables are indexed + HeuristicVariableOrderer orderer = new HeuristicVariableOrderer(graph); + Set vars = new HashSet<>(); + for (int i = 0; i < variables.size(); i++) { + vars.add(orderer.indexToVariableName(i)); + } + assertTrue(vars.size() == variables.size()); + } + + @Test + public void simpleGraphTest() { + Collection constraints = new ArrayList<>(); + constraints.add(new ConstraintMockup(variables.subList(0,1))); + constraints.add(new ConstraintMockup(variables.subList(1,3))); + constraints.add(new ConstraintMockup(variables.subList(2,3))); + ConstraintGraph graph = new ConstraintGraph(constraints, variables.subList(0,3)); + HeuristicVariableOrderer orderer = new HeuristicVariableOrderer(graph); + + assertTrue(orderer.indexToVariableName(0).equals(variables.get(2))); + assertTrue(orderer.indexToVariableName(1).equals(variables.get(1))); + assertTrue(orderer.indexToVariableName(2).equals(variables.get(0))); + } +} \ No newline at end of file -- GitLab From 6fabd1f85b76fd206fa0fb01a3168ed8ccd0bbc3 Mon Sep 17 00:00:00 2001 From: tc360950 Date: Mon, 9 Dec 2019 21:45:51 +0100 Subject: [PATCH 018/340] Added tests for CpWrapper --- .../src/main/java/CPWrapper/CPWrapper.java | 69 ++- .../java/CPWrapper/Parser/CPParsedData.java | 3 + .../main/java/CPWrapper/UtilityProvider.java | 9 + .../java/CPWrapper/Utils/ConstraintGraph.java | 2 + .../java/CPWrapper/Utils/DomainHandler.java | 36 ++ .../CPWrapper/Utils/ExpressionEvaluator.java | 2 +- .../test/java/CPWrapper/CPWrapperTest.java | 104 ++++ .../CPWrapper/Mockups/ArConstraintMockup.java | 22 + .../CPWrapper/Mockups/ConstraintMockup.java | 255 +++++++++- .../Mockups/ConstraintProblemMockup.java | 274 +++++++++++ .../Mockups/CpVariableImplMockup.java | 2 +- .../Mockups/NumericListDomainImplMockup.java | 239 ++++++++++ .../Mockups/RangeDomainImpMockup.java | 447 ++++++++++++++++++ .../Mockups/UtilityProviderMockup.java | 15 + .../CPWrapper/Utils/ConstraintGraphTest.java | 10 +- .../Utils/HeuristicVariableOrdererTest.java | 14 +- 16 files changed, 1468 insertions(+), 35 deletions(-) create mode 100644 ZPPSolver/CPParser/src/main/java/CPWrapper/UtilityProvider.java create mode 100644 ZPPSolver/CPParser/src/main/java/CPWrapper/Utils/DomainHandler.java create mode 100644 ZPPSolver/CPParser/src/test/java/CPWrapper/CPWrapperTest.java create mode 100644 ZPPSolver/CPParser/src/test/java/CPWrapper/Mockups/ArConstraintMockup.java create mode 100644 ZPPSolver/CPParser/src/test/java/CPWrapper/Mockups/ConstraintProblemMockup.java create mode 100644 ZPPSolver/CPParser/src/test/java/CPWrapper/Mockups/NumericListDomainImplMockup.java create mode 100644 ZPPSolver/CPParser/src/test/java/CPWrapper/Mockups/RangeDomainImpMockup.java create mode 100644 ZPPSolver/CPParser/src/test/java/CPWrapper/Mockups/UtilityProviderMockup.java diff --git a/ZPPSolver/CPParser/src/main/java/CPWrapper/CPWrapper.java b/ZPPSolver/CPParser/src/main/java/CPWrapper/CPWrapper.java index 0d0d2dea0..562079cc6 100644 --- a/ZPPSolver/CPParser/src/main/java/CPWrapper/CPWrapper.java +++ b/ZPPSolver/CPParser/src/main/java/CPWrapper/CPWrapper.java @@ -2,21 +2,28 @@ package CPWrapper; import CPWrapper.Parser.CPParsedData; import CPWrapper.Parser.CPParser; +import CPWrapper.Utils.DomainHandler; import CPWrapper.Utils.HeuristicVariableOrderer; import CPWrapper.Utils.VariableOrderer; -import eu.paasage.upperware.metamodel.cp.ConstraintProblem; -import eu.melodic.upperware.utilitygenerator.UtilityGeneratorApplication; +import eu.melodic.upperware.utilitygenerator.cdo.cp_model.DTO.VariableValueDTO; +import eu.melodic.upperware.utilitygenerator.cdo.cp_model.DTO.VariableValueDTOFactory; +import eu.paasage.upperware.metamodel.cp.*; + +import java.util.ArrayList; +import java.util.HashMap; +import java.util.List; +import java.util.Map; public class CPWrapper { private VariableOrderer variableOrderer; private CPParsedData cpParsedData; - private UtilityGeneratorApplication utilityGenerator; + private UtilityProvider utilityProvider; - public void parse(ConstraintProblem constraintProblem, UtilityGeneratorApplication utility) { + public void parse(ConstraintProblem constraintProblem, UtilityProvider utility) { CPParser cpParser = new CPParser(); cpParsedData = cpParser.parse(constraintProblem); - this.utilityGenerator = utility; + this.utilityProvider = utility; this.variableOrderer = new HeuristicVariableOrderer(cpParsedData.getConstraintGraph()); } @@ -24,10 +31,60 @@ public class CPWrapper { this.variableOrderer = vO; } + public boolean isFeasible(List assignment) { + return cpParsedData.isFeasible(getAssignmentFromValueList(assignment)); + } + + public Domain getVariableDomain(int variableIndex) { + return cpParsedData.getVariableDomain(variableOrderer.indexToVariableName(variableIndex)); + } + + private double getVariableValueFromDomainIndex(int varIndex, int value) { + String variableName = variableOrderer.indexToVariableName(varIndex); + Domain domain = cpParsedData.getVariableDomain(variableName); + if (DomainHandler.isRangeDomain(domain)) { + return DomainHandler.getRangeValue(value, (RangeDomain) domain); + } else if (DomainHandler.isNumericListDomain(domain)) { + return DomainHandler.getNumericListValue(value, (NumericListDomain) domain); + } + + throw new RuntimeException("Only domaind of types RangeDomain, NumericListDomain are supported!"); + } + private Map getAssignmentFromValueList(List assignments) { + Map vars = new HashMap<>(); + for (int i = 0; i < assignments.size(); i++) { + System.out.println("OK: " + i); + vars.put(variableOrderer.indexToVariableName(i), getVariableValueFromDomainIndex(i, assignments.get(i))); + } + return vars; + } + public int countViolatedConstraints(List assignments) { + if (assignments.size() != cpParsedData.getVariableNames().size()) { + throw new RuntimeException("Wrong number of variables in assignment"); + } - private void orderVariablesRandomly() { + return cpParsedData.countViolatedConstraints(getAssignmentFromValueList(assignments)); + } + + public int getHeuristicEvaluation(List assignments, int variableIndex) { + if (assignments.size() != cpParsedData.getVariableNames().size()) { + throw new RuntimeException("Wrong number of variables in assignment"); + } + + return cpParsedData.getHeuristicEvaluation(variableOrderer.indexToVariableName(variableIndex), + getAssignmentFromValueList(assignments)); + } + + private List assignmentToVariableValueDTOList(List assignments) { //TODO + //VariableValueDTOFactory.createElement() + return new ArrayList<>(); + } + + public double getUtility(List assignments) { + List vars = assignmentToVariableValueDTOList(assignments); + return this.utilityProvider.evaluate(vars); } } diff --git a/ZPPSolver/CPParser/src/main/java/CPWrapper/Parser/CPParsedData.java b/ZPPSolver/CPParser/src/main/java/CPWrapper/Parser/CPParsedData.java index 2e23a10c7..8fd897ffe 100644 --- a/ZPPSolver/CPParser/src/main/java/CPWrapper/Parser/CPParsedData.java +++ b/ZPPSolver/CPParser/src/main/java/CPWrapper/Parser/CPParsedData.java @@ -69,6 +69,9 @@ public class CPParsedData { } private void initializeConstraintGraph() { + for (CpVariable var: variables ) { + System.out.println("Nazwa: " + var.getId()); + } List variableNames = variables.stream() .map(var -> var.getId()) diff --git a/ZPPSolver/CPParser/src/main/java/CPWrapper/UtilityProvider.java b/ZPPSolver/CPParser/src/main/java/CPWrapper/UtilityProvider.java new file mode 100644 index 000000000..ef39757f7 --- /dev/null +++ b/ZPPSolver/CPParser/src/main/java/CPWrapper/UtilityProvider.java @@ -0,0 +1,9 @@ +package CPWrapper; + +import eu.melodic.upperware.utilitygenerator.cdo.cp_model.DTO.VariableValueDTO; + +import java.util.List; + +public interface UtilityProvider { + double evaluate(List result); +} diff --git a/ZPPSolver/CPParser/src/main/java/CPWrapper/Utils/ConstraintGraph.java b/ZPPSolver/CPParser/src/main/java/CPWrapper/Utils/ConstraintGraph.java index 7e0ec384c..daa2fdbf6 100644 --- a/ZPPSolver/CPParser/src/main/java/CPWrapper/Utils/ConstraintGraph.java +++ b/ZPPSolver/CPParser/src/main/java/CPWrapper/Utils/ConstraintGraph.java @@ -39,6 +39,7 @@ public class ConstraintGraph { */ private void initializeKnownDistances(Map> knownDistances) { for (String var : variables) { + System.out.println("probuj2e " + var + " " + variables.size()); knownDistances.put(var, new LinkedList()); knownDistances.get(var).add(var); } @@ -72,6 +73,7 @@ public class ConstraintGraph { for (ArConstraint constraint : constraints) { Collection variables = constraint.getVariableNames(); for (String var : variables) { + System.out.println("probuje " + var); knownDistances.get(var).addAll(variables); neighbourhoodList.get(var).get(1).addAll(variables); neighbourhoodList.get(var).get(1).remove(var); diff --git a/ZPPSolver/CPParser/src/main/java/CPWrapper/Utils/DomainHandler.java b/ZPPSolver/CPParser/src/main/java/CPWrapper/Utils/DomainHandler.java new file mode 100644 index 000000000..06ed59531 --- /dev/null +++ b/ZPPSolver/CPParser/src/main/java/CPWrapper/Utils/DomainHandler.java @@ -0,0 +1,36 @@ +package CPWrapper.Utils; + +import eu.paasage.upperware.metamodel.cp.Domain; +import eu.paasage.upperware.metamodel.cp.NumericListDomain; +import eu.paasage.upperware.metamodel.cp.RangeDomain; +import eu.paasage.upperware.metamodel.types.IntegerValueUpperware; +import eu.paasage.upperware.metamodel.types.NumericValueUpperware; + +import java.util.List; + +public class DomainHandler { + public static boolean isRangeDomain(Domain domain){ + return domain instanceof RangeDomain; + } + + public static boolean isNumericListDomain(Domain domain){ + return domain instanceof NumericListDomain; + } + + public static double getRangeValue(int valueIndex, RangeDomain domain) { + NumericValueUpperware min = domain.getFrom(); + if (min instanceof IntegerValueUpperware) { + return (((IntegerValueUpperware) min).getValue() + valueIndex); + } else { + throw new RuntimeException("Only integer RangeDomains are supported!"); + } + } + + public static double getNumericListValue(int valueIndex, NumericListDomain domain) { + List values = domain.getValues(); + if (values.size() <= valueIndex) { + throw new RuntimeException(); + } + return ExpressionEvaluator.getValueOfNumericInterface(values.get(valueIndex)); + } +} diff --git a/ZPPSolver/CPParser/src/main/java/CPWrapper/Utils/ExpressionEvaluator.java b/ZPPSolver/CPParser/src/main/java/CPWrapper/Utils/ExpressionEvaluator.java index f11b70abf..d6e7a2757 100644 --- a/ZPPSolver/CPParser/src/main/java/CPWrapper/Utils/ExpressionEvaluator.java +++ b/ZPPSolver/CPParser/src/main/java/CPWrapper/Utils/ExpressionEvaluator.java @@ -19,7 +19,7 @@ public class ExpressionEvaluator { */ public static final double PRECISION = 0.1; - private static double getValueOfNumericInterface(NumericValueUpperware value) { + protected static double getValueOfNumericInterface(NumericValueUpperware value) { if (value instanceof IntegerValueUpperware) { return (double)((IntegerValueUpperware) value).getValue(); } else if (value instanceof LongValueUpperware) { diff --git a/ZPPSolver/CPParser/src/test/java/CPWrapper/CPWrapperTest.java b/ZPPSolver/CPParser/src/test/java/CPWrapper/CPWrapperTest.java new file mode 100644 index 000000000..4202a8aaa --- /dev/null +++ b/ZPPSolver/CPParser/src/test/java/CPWrapper/CPWrapperTest.java @@ -0,0 +1,104 @@ +package CPWrapper; + +import CPWrapper.Mockups.*; +import eu.paasage.upperware.metamodel.cp.*; +import eu.paasage.upperware.metamodel.types.BasicTypeEnum; +import org.eclipse.emf.common.util.BasicEList; +import org.eclipse.emf.common.util.EList; +import org.junit.jupiter.api.BeforeAll; +import org.junit.jupiter.api.Test; + +import java.util.Arrays; +import java.util.List; + +import static org.junit.jupiter.api.Assertions.*; + +class CPWrapperTest { + private static CPWrapper cpWrapper; + private static List variables; + + @BeforeAll + private static void prepareSimpleConstraintProblem() { + /* + @var1 in {1,2,3,4,5} + @var2 in {0.5, 1.5, 2.5} + @var3 in {0,...,9} + @const1 = 3 + + @constraint1 : @var1 < @var3 + + @constraint2 : @var1 * @var2 * @var3 >= @const1; + + @constraint3: @var1 * @var2 >= @var3 + */ + variables = Arrays.asList(new String[]{"var1", "var2", "var3", "var4", "var5", "var6", "var7", "var8"}); + EList vars = new BasicEList<>(); + for (int i= 0; i < 3; i++) vars.add(new CpVariableImplMockup(variables.get(i), VariableType.CARDINALITY)); + RangeDomainImpMockup dom1 = new RangeDomainImpMockup(); + RangeDomainImpMockup dom3 = new RangeDomainImpMockup(); + dom1.setFrom(1);dom3.setFrom(0);dom1.setTo(5);dom3.setTo(9); + NumericListDomainImplMockup dom2 = new NumericListDomainImplMockup(); + dom2.setValues(Arrays.asList(new Double[] {0.5, 1.5, 2.5})); + List domains = Arrays.asList(new Domain[] {dom1, dom2, dom3}); + for (int i = 0; i <3 ; i++ ){ + vars.get(i).setDomain(domains.get(i)); + } + + Constant c = new ConstantImplMockup(BasicTypeEnum.DOUBLE, new NumericValueUpperwareImplMockup(3)); + + EList exprs = new BasicEList<>(); + exprs.add(vars.get(0)); exprs.add(vars.get(1)); + NumericExpression times = new ComposedExpressionImplMockup(exprs, OperatorEnum.TIMES); + ConstraintMockup constraint1 = new ConstraintMockup(); + constraint1.setExp1(vars.get(0));constraint1.setExp2(vars.get(2)); + constraint1.setComparator(ComparatorEnum.LESS_THAN); + + ConstraintMockup constraint3 = new ConstraintMockup(); + constraint3.setExp1(times);constraint3.setExp2(vars.get(2)); + constraint3.setComparator(ComparatorEnum.GREATER_OR_EQUAL_TO); + + exprs.add(vars.get(2)); + ConstraintMockup constraint2 = new ConstraintMockup(); + times = new ComposedExpressionImplMockup(exprs, OperatorEnum.TIMES); + constraint2.setExp1(times);constraint2.setExp2(c); + constraint2.setComparator(ComparatorEnum.GREATER_OR_EQUAL_TO); + + EList consts = new BasicEList<>(); + consts.add(c); + + EList varsE = new BasicEList<>(); + for (int i = 0; i < 3; i++) varsE.add(vars.get(i)); + + EList constraints = new BasicEList<>(); + constraints.addAll(Arrays.asList(new ComparisonExpression[] { constraint1, constraint2, constraint3})); + + ConstraintProblem cp = new ConstraintProblemMockup(consts,null, varsE, constraints ); + + cpWrapper = new CPWrapper(); + cpWrapper.parse(cp, new UtilityProviderMockup()); + } + + @Test + public void countViolatedConstraintsTest() { + + assertTrue( cpWrapper.countViolatedConstraints(Arrays.asList(new Integer[] {0, 0, 0})) == 2); + + assertTrue( cpWrapper.countViolatedConstraints(Arrays.asList(new Integer[] {0, 0, 2})) == 2); + + assertTrue( cpWrapper.countViolatedConstraints(Arrays.asList(new Integer[] {0, 2, 2})) == 0); + } + + @Test + public void isFeasibleTest() { + assertFalse( cpWrapper.isFeasible(Arrays.asList(new Integer[] {0, 0, 0}))); + + assertFalse( cpWrapper.isFeasible(Arrays.asList(new Integer[] {0, 0, 2}))); + + assertTrue( cpWrapper.isFeasible(Arrays.asList(new Integer[] {0, 2, 2}))); + } + + @Test + public void getHeuristicEvaluationTest() { + assertTrue( cpWrapper.getHeuristicEvaluation(Arrays.asList(new Integer[] {2,2,2}), 0) == 3); + } +} \ No newline at end of file diff --git a/ZPPSolver/CPParser/src/test/java/CPWrapper/Mockups/ArConstraintMockup.java b/ZPPSolver/CPParser/src/test/java/CPWrapper/Mockups/ArConstraintMockup.java new file mode 100644 index 000000000..6edb75048 --- /dev/null +++ b/ZPPSolver/CPParser/src/test/java/CPWrapper/Mockups/ArConstraintMockup.java @@ -0,0 +1,22 @@ +package CPWrapper.Mockups; + +import CPWrapper.Utils.ArConstraint; +import lombok.AllArgsConstructor; + +import java.util.Collection; +import java.util.Map; + +@AllArgsConstructor +public class ArConstraintMockup implements ArConstraint { + private Collection variables; + + @Override + public Collection getVariableNames() { + return variables; + } + + @Override + public boolean evaluate(Map variables) { + return false; + } +} diff --git a/ZPPSolver/CPParser/src/test/java/CPWrapper/Mockups/ConstraintMockup.java b/ZPPSolver/CPParser/src/test/java/CPWrapper/Mockups/ConstraintMockup.java index 8e54e4ab7..367ea65f7 100644 --- a/ZPPSolver/CPParser/src/test/java/CPWrapper/Mockups/ConstraintMockup.java +++ b/ZPPSolver/CPParser/src/test/java/CPWrapper/Mockups/ConstraintMockup.java @@ -1,22 +1,247 @@ package CPWrapper.Mockups; -import CPWrapper.Utils.ArConstraint; -import lombok.AllArgsConstructor; +import eu.paasage.upperware.metamodel.cp.ComparatorEnum; +import eu.paasage.upperware.metamodel.cp.ComparisonExpression; +import eu.paasage.upperware.metamodel.cp.Expression; +import org.eclipse.emf.cdo.CDOLock; +import org.eclipse.emf.cdo.CDOObjectHistory; +import org.eclipse.emf.cdo.CDOState; +import org.eclipse.emf.cdo.common.id.CDOID; +import org.eclipse.emf.cdo.common.lock.CDOLockState; +import org.eclipse.emf.cdo.common.revision.CDORevision; +import org.eclipse.emf.cdo.common.security.CDOPermission; +import org.eclipse.emf.cdo.eresource.CDOResource; +import org.eclipse.emf.cdo.view.CDOView; +import org.eclipse.emf.common.notify.Adapter; +import org.eclipse.emf.common.notify.Notification; +import org.eclipse.emf.common.util.EList; +import org.eclipse.emf.common.util.TreeIterator; +import org.eclipse.emf.ecore.*; +import org.eclipse.emf.ecore.resource.Resource; -import java.util.Collection; -import java.util.Map; +import java.lang.reflect.InvocationTargetException; -@AllArgsConstructor -public class ConstraintMockup implements ArConstraint { - private Collection variables; +public class ConstraintMockup implements ComparisonExpression { + Expression exp1; + Expression exp2; + ComparatorEnum comparator; + @Override + public Expression getExp1() { + return exp1; + } - @Override - public Collection getVariableNames() { - return variables; - } + @Override + public void setExp1(Expression value) { + exp1 = value; + } - @Override - public boolean evaluate(Map variables) { - return false; - } + @Override + public Expression getExp2() { + return exp2; + } + + @Override + public void setExp2(Expression value) { + exp2 = value; + } + + @Override + public ComparatorEnum getComparator() { + return comparator; + } + + @Override + public void setComparator(ComparatorEnum value) { + comparator = value; + } + + @Override + public String getId() { + return null; + } + + @Override + public void setId(String value) { + + } + + @Override + public CDOID cdoID() { + return null; + } + + @Override + public CDOState cdoState() { + return null; + } + + @Override + public boolean cdoConflict() { + return false; + } + + @Override + public boolean cdoInvalid() { + return false; + } + + @Override + public CDOView cdoView() { + return null; + } + + @Override + public CDORevision cdoRevision() { + return null; + } + + @Override + public CDORevision cdoRevision(boolean b) { + return null; + } + + @Override + public CDOPermission cdoPermission() { + return null; + } + + @Override + public CDOResource cdoResource() { + return null; + } + + @Override + public CDOResource cdoDirectResource() { + return null; + } + + @Override + public CDOLock cdoReadLock() { + return null; + } + + @Override + public CDOLock cdoWriteLock() { + return null; + } + + @Override + public CDOLock cdoWriteOption() { + return null; + } + + @Override + public CDOLockState cdoLockState() { + return null; + } + + @Override + public void cdoPrefetch(int i) { + + } + + @Override + public void cdoReload() { + + } + + @Override + public CDOObjectHistory cdoHistory() { + return null; + } + + @Override + public EClass eClass() { + return null; + } + + @Override + public Resource eResource() { + return null; + } + + @Override + public EObject eContainer() { + return null; + } + + @Override + public EStructuralFeature eContainingFeature() { + return null; + } + + @Override + public EReference eContainmentFeature() { + return null; + } + + @Override + public EList eContents() { + return null; + } + + @Override + public TreeIterator eAllContents() { + return null; + } + + @Override + public boolean eIsProxy() { + return false; + } + + @Override + public EList eCrossReferences() { + return null; + } + + @Override + public Object eGet(EStructuralFeature eStructuralFeature) { + return null; + } + + @Override + public Object eGet(EStructuralFeature eStructuralFeature, boolean b) { + return null; + } + + @Override + public void eSet(EStructuralFeature eStructuralFeature, Object o) { + + } + + @Override + public boolean eIsSet(EStructuralFeature eStructuralFeature) { + return false; + } + + @Override + public void eUnset(EStructuralFeature eStructuralFeature) { + + } + + @Override + public Object eInvoke(EOperation eOperation, EList eList) throws InvocationTargetException { + return null; + } + + @Override + public EList eAdapters() { + return null; + } + + @Override + public boolean eDeliver() { + return false; + } + + @Override + public void eSetDeliver(boolean b) { + + } + + @Override + public void eNotify(Notification notification) { + + } } diff --git a/ZPPSolver/CPParser/src/test/java/CPWrapper/Mockups/ConstraintProblemMockup.java b/ZPPSolver/CPParser/src/test/java/CPWrapper/Mockups/ConstraintProblemMockup.java new file mode 100644 index 000000000..51e657996 --- /dev/null +++ b/ZPPSolver/CPParser/src/test/java/CPWrapper/Mockups/ConstraintProblemMockup.java @@ -0,0 +1,274 @@ +package CPWrapper.Mockups; + +import eu.paasage.upperware.metamodel.cp.*; +import lombok.AllArgsConstructor; +import org.eclipse.emf.cdo.CDOLock; +import org.eclipse.emf.cdo.CDOObjectHistory; +import org.eclipse.emf.cdo.CDOState; +import org.eclipse.emf.cdo.common.id.CDOID; +import org.eclipse.emf.cdo.common.lock.CDOLockState; +import org.eclipse.emf.cdo.common.revision.CDORevision; +import org.eclipse.emf.cdo.common.security.CDOPermission; +import org.eclipse.emf.cdo.eresource.CDOResource; +import org.eclipse.emf.cdo.view.CDOView; +import org.eclipse.emf.common.notify.Adapter; +import org.eclipse.emf.common.notify.Notification; +import org.eclipse.emf.common.util.EList; +import org.eclipse.emf.common.util.TreeIterator; +import org.eclipse.emf.ecore.*; +import org.eclipse.emf.ecore.resource.Resource; + +import java.lang.reflect.InvocationTargetException; + +@AllArgsConstructor +public class ConstraintProblemMockup implements ConstraintProblem { + private EList constants; + private EList metrics; + private EList variables; + private EList constraints; + + @Override + public String getId() { + return null; + } + + @Override + public void setId(String value) { + + } + + @Override + public EList getGoals() { + return null; + } + + @Override + public EList getConstants() { + return constants; + } + + @Override + public EList getCpVariables() { + return variables; + } + + @Override + public EList getConstraints() { + return constraints; + } + + @Override + public EList getAuxExpressions() { + return null; + } + + @Override + public EList getCpMetrics() { + return metrics; + } + + @Override + public EList getSolution() { + return null; + } + + @Override + public int getDeployedSolutionId() { + return 0; + } + + @Override + public void setDeployedSolutionId(int value) { + + } + + @Override + public int getCandidateSolutionId() { + return 0; + } + + @Override + public void setCandidateSolutionId(int value) { + + } + + @Override + public CDOID cdoID() { + return null; + } + + @Override + public CDOState cdoState() { + return null; + } + + @Override + public boolean cdoConflict() { + return false; + } + + @Override + public boolean cdoInvalid() { + return false; + } + + @Override + public CDOView cdoView() { + return null; + } + + @Override + public CDORevision cdoRevision() { + return null; + } + + @Override + public CDORevision cdoRevision(boolean b) { + return null; + } + + @Override + public CDOPermission cdoPermission() { + return null; + } + + @Override + public CDOResource cdoResource() { + return null; + } + + @Override + public CDOResource cdoDirectResource() { + return null; + } + + @Override + public CDOLock cdoReadLock() { + return null; + } + + @Override + public CDOLock cdoWriteLock() { + return null; + } + + @Override + public CDOLock cdoWriteOption() { + return null; + } + + @Override + public CDOLockState cdoLockState() { + return null; + } + + @Override + public void cdoPrefetch(int i) { + + } + + @Override + public void cdoReload() { + + } + + @Override + public CDOObjectHistory cdoHistory() { + return null; + } + + @Override + public EClass eClass() { + return null; + } + + @Override + public Resource eResource() { + return null; + } + + @Override + public EObject eContainer() { + return null; + } + + @Override + public EStructuralFeature eContainingFeature() { + return null; + } + + @Override + public EReference eContainmentFeature() { + return null; + } + + @Override + public EList eContents() { + return null; + } + + @Override + public TreeIterator eAllContents() { + return null; + } + + @Override + public boolean eIsProxy() { + return false; + } + + @Override + public EList eCrossReferences() { + return null; + } + + @Override + public Object eGet(EStructuralFeature eStructuralFeature) { + return null; + } + + @Override + public Object eGet(EStructuralFeature eStructuralFeature, boolean b) { + return null; + } + + @Override + public void eSet(EStructuralFeature eStructuralFeature, Object o) { + + } + + @Override + public boolean eIsSet(EStructuralFeature eStructuralFeature) { + return false; + } + + @Override + public void eUnset(EStructuralFeature eStructuralFeature) { + + } + + @Override + public Object eInvoke(EOperation eOperation, EList eList) throws InvocationTargetException { + return null; + } + + @Override + public EList eAdapters() { + return null; + } + + @Override + public boolean eDeliver() { + return false; + } + + @Override + public void eSetDeliver(boolean b) { + + } + + @Override + public void eNotify(Notification notification) { + + } +} diff --git a/ZPPSolver/CPParser/src/test/java/CPWrapper/Mockups/CpVariableImplMockup.java b/ZPPSolver/CPParser/src/test/java/CPWrapper/Mockups/CpVariableImplMockup.java index 91218af33..40065b118 100644 --- a/ZPPSolver/CPParser/src/test/java/CPWrapper/Mockups/CpVariableImplMockup.java +++ b/ZPPSolver/CPParser/src/test/java/CPWrapper/Mockups/CpVariableImplMockup.java @@ -24,7 +24,7 @@ public class CpVariableImplMockup extends NumericExpressionImpl implements CpVar @Override public void setDomain(Domain value) { - this.domain = domain; + this.domain = value; } @Override diff --git a/ZPPSolver/CPParser/src/test/java/CPWrapper/Mockups/NumericListDomainImplMockup.java b/ZPPSolver/CPParser/src/test/java/CPWrapper/Mockups/NumericListDomainImplMockup.java new file mode 100644 index 000000000..05d0dc1a6 --- /dev/null +++ b/ZPPSolver/CPParser/src/test/java/CPWrapper/Mockups/NumericListDomainImplMockup.java @@ -0,0 +1,239 @@ +package CPWrapper.Mockups; + +import eu.paasage.upperware.metamodel.cp.NumericListDomain; +import eu.paasage.upperware.metamodel.types.BasicTypeEnum; +import eu.paasage.upperware.metamodel.types.NumericValueUpperware; +import org.eclipse.emf.cdo.CDOLock; +import org.eclipse.emf.cdo.CDOObjectHistory; +import org.eclipse.emf.cdo.CDOState; +import org.eclipse.emf.cdo.common.id.CDOID; +import org.eclipse.emf.cdo.common.lock.CDOLockState; +import org.eclipse.emf.cdo.common.revision.CDORevision; +import org.eclipse.emf.cdo.common.security.CDOPermission; +import org.eclipse.emf.cdo.eresource.CDOResource; +import org.eclipse.emf.cdo.view.CDOView; +import org.eclipse.emf.common.notify.Adapter; +import org.eclipse.emf.common.notify.Notification; +import org.eclipse.emf.common.util.BasicEList; +import org.eclipse.emf.common.util.EList; +import org.eclipse.emf.common.util.TreeIterator; +import org.eclipse.emf.ecore.*; +import org.eclipse.emf.ecore.resource.Resource; + +import java.lang.reflect.InvocationTargetException; +import java.util.List; + +public class NumericListDomainImplMockup implements NumericListDomain { + private EList values = new BasicEList<>(); + + @Override + public EList getValues() { + return values; + } + + public void setValues(List values) { + for (int i = 0; i < values.size(); i++) { + this.values.add(new NumericValueUpperwareImplMockup(values.get(i))); + } + } + + @Override + public BasicTypeEnum getType() { + return null; + } + + @Override + public void setType(BasicTypeEnum value) { + + } + + @Override + public NumericValueUpperware getValue() { + return null; + } + + @Override + public void setValue(NumericValueUpperware value) { + + } + + @Override + public CDOID cdoID() { + return null; + } + + @Override + public CDOState cdoState() { + return null; + } + + @Override + public boolean cdoConflict() { + return false; + } + + @Override + public boolean cdoInvalid() { + return false; + } + + @Override + public CDOView cdoView() { + return null; + } + + @Override + public CDORevision cdoRevision() { + return null; + } + + @Override + public CDORevision cdoRevision(boolean b) { + return null; + } + + @Override + public CDOPermission cdoPermission() { + return null; + } + + @Override + public CDOResource cdoResource() { + return null; + } + + @Override + public CDOResource cdoDirectResource() { + return null; + } + + @Override + public CDOLock cdoReadLock() { + return null; + } + + @Override + public CDOLock cdoWriteLock() { + return null; + } + + @Override + public CDOLock cdoWriteOption() { + return null; + } + + @Override + public CDOLockState cdoLockState() { + return null; + } + + @Override + public void cdoPrefetch(int i) { + + } + + @Override + public void cdoReload() { + + } + + @Override + public CDOObjectHistory cdoHistory() { + return null; + } + + @Override + public EClass eClass() { + return null; + } + + @Override + public Resource eResource() { + return null; + } + + @Override + public EObject eContainer() { + return null; + } + + @Override + public EStructuralFeature eContainingFeature() { + return null; + } + + @Override + public EReference eContainmentFeature() { + return null; + } + + @Override + public EList eContents() { + return null; + } + + @Override + public TreeIterator eAllContents() { + return null; + } + + @Override + public boolean eIsProxy() { + return false; + } + + @Override + public EList eCrossReferences() { + return null; + } + + @Override + public Object eGet(EStructuralFeature eStructuralFeature) { + return null; + } + + @Override + public Object eGet(EStructuralFeature eStructuralFeature, boolean b) { + return null; + } + + @Override + public void eSet(EStructuralFeature eStructuralFeature, Object o) { + + } + + @Override + public boolean eIsSet(EStructuralFeature eStructuralFeature) { + return false; + } + + @Override + public void eUnset(EStructuralFeature eStructuralFeature) { + + } + + @Override + public Object eInvoke(EOperation eOperation, EList eList) throws InvocationTargetException { + return null; + } + + @Override + public EList eAdapters() { + return null; + } + + @Override + public boolean eDeliver() { + return false; + } + + @Override + public void eSetDeliver(boolean b) { + + } + + @Override + public void eNotify(Notification notification) { + + } +} diff --git a/ZPPSolver/CPParser/src/test/java/CPWrapper/Mockups/RangeDomainImpMockup.java b/ZPPSolver/CPParser/src/test/java/CPWrapper/Mockups/RangeDomainImpMockup.java new file mode 100644 index 000000000..07716bc8c --- /dev/null +++ b/ZPPSolver/CPParser/src/test/java/CPWrapper/Mockups/RangeDomainImpMockup.java @@ -0,0 +1,447 @@ +package CPWrapper.Mockups; + +import eu.paasage.upperware.metamodel.cp.RangeDomain; +import eu.paasage.upperware.metamodel.types.BasicTypeEnum; +import eu.paasage.upperware.metamodel.types.IntegerValueUpperware; +import eu.paasage.upperware.metamodel.types.NumericValueUpperware; +import org.eclipse.emf.cdo.CDOLock; +import org.eclipse.emf.cdo.CDOObjectHistory; +import org.eclipse.emf.cdo.CDOState; +import org.eclipse.emf.cdo.common.id.CDOID; +import org.eclipse.emf.cdo.common.lock.CDOLockState; +import org.eclipse.emf.cdo.common.revision.CDORevision; +import org.eclipse.emf.cdo.common.security.CDOPermission; +import org.eclipse.emf.cdo.eresource.CDOResource; +import org.eclipse.emf.cdo.view.CDOView; +import org.eclipse.emf.common.notify.Adapter; +import org.eclipse.emf.common.notify.Notification; +import org.eclipse.emf.common.util.EList; +import org.eclipse.emf.common.util.TreeIterator; +import org.eclipse.emf.ecore.*; +import org.eclipse.emf.ecore.resource.Resource; + +import java.lang.reflect.InvocationTargetException; + +public class RangeDomainImpMockup implements RangeDomain { + private int min; + private int max; + + private class IntegerValueUpperwareImplMockup implements IntegerValueUpperware { + private int value; + @Override + public int getValue() { + return value; + } + + @Override + public void setValue(int value) { + this.value = value; + } + + @Override + public CDOID cdoID() { + return null; + } + + @Override + public CDOState cdoState() { + return null; + } + + @Override + public boolean cdoConflict() { + return false; + } + + @Override + public boolean cdoInvalid() { + return false; + } + + @Override + public CDOView cdoView() { + return null; + } + + @Override + public CDORevision cdoRevision() { + return null; + } + + @Override + public CDORevision cdoRevision(boolean b) { + return null; + } + + @Override + public CDOPermission cdoPermission() { + return null; + } + + @Override + public CDOResource cdoResource() { + return null; + } + + @Override + public CDOResource cdoDirectResource() { + return null; + } + + @Override + public CDOLock cdoReadLock() { + return null; + } + + @Override + public CDOLock cdoWriteLock() { + return null; + } + + @Override + public CDOLock cdoWriteOption() { + return null; + } + + @Override + public CDOLockState cdoLockState() { + return null; + } + + @Override + public void cdoPrefetch(int i) { + + } + + @Override + public void cdoReload() { + + } + + @Override + public CDOObjectHistory cdoHistory() { + return null; + } + + @Override + public EClass eClass() { + return null; + } + + @Override + public Resource eResource() { + return null; + } + + @Override + public EObject eContainer() { + return null; + } + + @Override + public EStructuralFeature eContainingFeature() { + return null; + } + + @Override + public EReference eContainmentFeature() { + return null; + } + + @Override + public EList eContents() { + return null; + } + + @Override + public TreeIterator eAllContents() { + return null; + } + + @Override + public boolean eIsProxy() { + return false; + } + + @Override + public EList eCrossReferences() { + return null; + } + + @Override + public Object eGet(EStructuralFeature eStructuralFeature) { + return null; + } + + @Override + public Object eGet(EStructuralFeature eStructuralFeature, boolean b) { + return null; + } + + @Override + public void eSet(EStructuralFeature eStructuralFeature, Object o) { + + } + + @Override + public boolean eIsSet(EStructuralFeature eStructuralFeature) { + return false; + } + + @Override + public void eUnset(EStructuralFeature eStructuralFeature) { + + } + + @Override + public Object eInvoke(EOperation eOperation, EList eList) throws InvocationTargetException { + return null; + } + + @Override + public EList eAdapters() { + return null; + } + + @Override + public boolean eDeliver() { + return false; + } + + @Override + public void eSetDeliver(boolean b) { + + } + + @Override + public void eNotify(Notification notification) { + + } + } + @Override + public NumericValueUpperware getFrom() { + IntegerValueUpperware val = new IntegerValueUpperwareImplMockup(); + val.setValue(min); + return (NumericValueUpperware) val; + } + + public void setTo(int v) { this.max = v;} + + public void setFrom(int v) { this.min = v;} + @Override + public void setFrom(NumericValueUpperware value) { + this.min = ((IntegerValueUpperware) value).getValue(); + } + + @Override + public NumericValueUpperware getTo() { + IntegerValueUpperware val = new IntegerValueUpperwareImplMockup(); + val.setValue(max); + return (NumericValueUpperware) val; + } + + @Override + public void setTo(NumericValueUpperware value) { + this.max = ((IntegerValueUpperware) value).getValue(); + } + + @Override + public BasicTypeEnum getType() { + return null; + } + + @Override + public void setType(BasicTypeEnum value) { + + } + + @Override + public NumericValueUpperware getValue() { + return null; + } + + @Override + public void setValue(NumericValueUpperware value) { + + } + + @Override + public CDOID cdoID() { + return null; + } + + @Override + public CDOState cdoState() { + return null; + } + + @Override + public boolean cdoConflict() { + return false; + } + + @Override + public boolean cdoInvalid() { + return false; + } + + @Override + public CDOView cdoView() { + return null; + } + + @Override + public CDORevision cdoRevision() { + return null; + } + + @Override + public CDORevision cdoRevision(boolean b) { + return null; + } + + @Override + public CDOPermission cdoPermission() { + return null; + } + + @Override + public CDOResource cdoResource() { + return null; + } + + @Override + public CDOResource cdoDirectResource() { + return null; + } + + @Override + public CDOLock cdoReadLock() { + return null; + } + + @Override + public CDOLock cdoWriteLock() { + return null; + } + + @Override + public CDOLock cdoWriteOption() { + return null; + } + + @Override + public CDOLockState cdoLockState() { + return null; + } + + @Override + public void cdoPrefetch(int i) { + + } + + @Override + public void cdoReload() { + + } + + @Override + public CDOObjectHistory cdoHistory() { + return null; + } + + @Override + public EClass eClass() { + return null; + } + + @Override + public Resource eResource() { + return null; + } + + @Override + public EObject eContainer() { + return null; + } + + @Override + public EStructuralFeature eContainingFeature() { + return null; + } + + @Override + public EReference eContainmentFeature() { + return null; + } + + @Override + public EList eContents() { + return null; + } + + @Override + public TreeIterator eAllContents() { + return null; + } + + @Override + public boolean eIsProxy() { + return false; + } + + @Override + public EList eCrossReferences() { + return null; + } + + @Override + public Object eGet(EStructuralFeature eStructuralFeature) { + return null; + } + + @Override + public Object eGet(EStructuralFeature eStructuralFeature, boolean b) { + return null; + } + + @Override + public void eSet(EStructuralFeature eStructuralFeature, Object o) { + + } + + @Override + public boolean eIsSet(EStructuralFeature eStructuralFeature) { + return false; + } + + @Override + public void eUnset(EStructuralFeature eStructuralFeature) { + + } + + @Override + public Object eInvoke(EOperation eOperation, EList eList) throws InvocationTargetException { + return null; + } + + @Override + public EList eAdapters() { + return null; + } + + @Override + public boolean eDeliver() { + return false; + } + + @Override + public void eSetDeliver(boolean b) { + + } + + @Override + public void eNotify(Notification notification) { + + } +} diff --git a/ZPPSolver/CPParser/src/test/java/CPWrapper/Mockups/UtilityProviderMockup.java b/ZPPSolver/CPParser/src/test/java/CPWrapper/Mockups/UtilityProviderMockup.java new file mode 100644 index 000000000..745097a4a --- /dev/null +++ b/ZPPSolver/CPParser/src/test/java/CPWrapper/Mockups/UtilityProviderMockup.java @@ -0,0 +1,15 @@ +package CPWrapper.Mockups; + +import CPWrapper.UtilityProvider; +import eu.melodic.upperware.utilitygenerator.UtilityGeneratorApplication; +import eu.melodic.upperware.utilitygenerator.cdo.cp_model.DTO.VariableValueDTO; + +import java.util.List; + +public class UtilityProviderMockup implements UtilityProvider { + + @Override + public double evaluate(List result) { + return 0; + } +} diff --git a/ZPPSolver/CPParser/src/test/java/CPWrapper/Utils/ConstraintGraphTest.java b/ZPPSolver/CPParser/src/test/java/CPWrapper/Utils/ConstraintGraphTest.java index fb125f179..360d6ed27 100644 --- a/ZPPSolver/CPParser/src/test/java/CPWrapper/Utils/ConstraintGraphTest.java +++ b/ZPPSolver/CPParser/src/test/java/CPWrapper/Utils/ConstraintGraphTest.java @@ -1,6 +1,6 @@ package CPWrapper.Utils; -import CPWrapper.Mockups.ConstraintMockup; +import CPWrapper.Mockups.ArConstraintMockup; import org.junit.jupiter.api.BeforeAll; import org.junit.jupiter.api.Test; @@ -35,7 +35,7 @@ class ConstraintGraphTest { List vars = new ArrayList<>(); vars.add(variables.get(i-1)); vars.add(variables.get(i % varsSize)); - constraints.add(new ConstraintMockup(vars)); + constraints.add(new ArConstraintMockup(vars)); } ConstraintGraph graph = new ConstraintGraph(constraints, variables); @@ -51,7 +51,7 @@ class ConstraintGraphTest { public void fullGraphTest() { int varsSize = variables.size(); Collection constraints = new ArrayList<>(); - ArConstraint constraint = new ConstraintMockup(variables); + ArConstraint constraint = new ArConstraintMockup(variables); constraints.add(constraint); ConstraintGraph graph = new ConstraintGraph(constraints, variables); for (String var : variables) { @@ -65,7 +65,7 @@ class ConstraintGraphTest { Collection constraints = new ArrayList<>(); int noOfConstraints = 10000; for (int i = 0; i < noOfConstraints; i ++ ) { - constraints.add(new ConstraintMockup(variables)); + constraints.add(new ArConstraintMockup(variables)); } ConstraintGraph graph = new ConstraintGraph(constraints, variables); for (String var : variables) { @@ -83,7 +83,7 @@ class ConstraintGraphTest { Collection constraints = new ArrayList<>(); int varsSize = variables.size(); for(int i = 0; i < varsSize; i++) { - constraints.add(new ConstraintMockup(variables.subList(0,i+1))); + constraints.add(new ArConstraintMockup(variables.subList(0,i+1))); } ConstraintGraph graph = new ConstraintGraph(constraints, variables); for (int i = 0; i < varsSize; i++) { diff --git a/ZPPSolver/CPParser/src/test/java/CPWrapper/Utils/HeuristicVariableOrdererTest.java b/ZPPSolver/CPParser/src/test/java/CPWrapper/Utils/HeuristicVariableOrdererTest.java index 6df6fd997..1c3277ec1 100644 --- a/ZPPSolver/CPParser/src/test/java/CPWrapper/Utils/HeuristicVariableOrdererTest.java +++ b/ZPPSolver/CPParser/src/test/java/CPWrapper/Utils/HeuristicVariableOrdererTest.java @@ -1,5 +1,5 @@ package CPWrapper.Utils; -import CPWrapper.Mockups.ConstraintMockup; +import CPWrapper.Mockups.ArConstraintMockup; import org.junit.jupiter.api.BeforeAll; import org.junit.jupiter.api.Test; @@ -20,7 +20,7 @@ class HeuristicVariableOrdererTest { Collection constraints = new ArrayList<>(); int varsSize = variables.size(); for(int i = 0; i < varsSize; i++) { - constraints.add(new ConstraintMockup(variables.subList(0,i+1))); + constraints.add(new ArConstraintMockup(variables.subList(0,i+1))); } ConstraintGraph graph = new ConstraintGraph(constraints, variables); return graph; @@ -30,9 +30,9 @@ class HeuristicVariableOrdererTest { Collection constraints = new ArrayList<>(); int varsSize = variables.size(); for(int i = 0; i < varsSize; i++) { - constraints.add(new ConstraintMockup(variables.subList(0,i+1))); + constraints.add(new ArConstraintMockup(variables.subList(0,i+1))); for (int j = i + 1; j < varsSize; j++) { - constraints.add(new ConstraintMockup(variables.subList(j, j+1))); + constraints.add(new ArConstraintMockup(variables.subList(j, j+1))); } } ConstraintGraph graph = new ConstraintGraph(constraints, variables); @@ -64,9 +64,9 @@ class HeuristicVariableOrdererTest { @Test public void simpleGraphTest() { Collection constraints = new ArrayList<>(); - constraints.add(new ConstraintMockup(variables.subList(0,1))); - constraints.add(new ConstraintMockup(variables.subList(1,3))); - constraints.add(new ConstraintMockup(variables.subList(2,3))); + constraints.add(new ArConstraintMockup(variables.subList(0,1))); + constraints.add(new ArConstraintMockup(variables.subList(1,3))); + constraints.add(new ArConstraintMockup(variables.subList(2,3))); ConstraintGraph graph = new ConstraintGraph(constraints, variables.subList(0,3)); HeuristicVariableOrderer orderer = new HeuristicVariableOrderer(graph); -- GitLab From cf3337fe3eb0d5012155c53d0d10ae34ffa9bcd0 Mon Sep 17 00:00:00 2001 From: tc360950 Date: Tue, 10 Dec 2019 16:42:15 +0100 Subject: [PATCH 019/340] Added new tests for CpWrapper --- .../test/java/CPWrapper/CPWrapperTest.java | 26 ++++++++++++++++--- .../java/CPWrapper/Parser/CPParserTest.java | 7 ----- 2 files changed, 22 insertions(+), 11 deletions(-) delete mode 100644 ZPPSolver/CPParser/src/test/java/CPWrapper/Parser/CPParserTest.java diff --git a/ZPPSolver/CPParser/src/test/java/CPWrapper/CPWrapperTest.java b/ZPPSolver/CPParser/src/test/java/CPWrapper/CPWrapperTest.java index 4202a8aaa..d4d51bebf 100644 --- a/ZPPSolver/CPParser/src/test/java/CPWrapper/CPWrapperTest.java +++ b/ZPPSolver/CPParser/src/test/java/CPWrapper/CPWrapperTest.java @@ -30,6 +30,8 @@ class CPWrapperTest { @constraint2 : @var1 * @var2 * @var3 >= @const1; @constraint3: @var1 * @var2 >= @var3 + + @constraint4: @var3 == @var3 */ variables = Arrays.asList(new String[]{"var1", "var2", "var3", "var4", "var5", "var6", "var7", "var8"}); EList vars = new BasicEList<>(); @@ -63,6 +65,10 @@ class CPWrapperTest { constraint2.setExp1(times);constraint2.setExp2(c); constraint2.setComparator(ComparatorEnum.GREATER_OR_EQUAL_TO); + ConstraintMockup constraint4 = new ConstraintMockup(); + constraint4.setExp1(vars.get(2));constraint4.setExp2(vars.get(2)); + constraint4.setComparator(ComparatorEnum.EQUAL_TO); + EList consts = new BasicEList<>(); consts.add(c); @@ -70,7 +76,7 @@ class CPWrapperTest { for (int i = 0; i < 3; i++) varsE.add(vars.get(i)); EList constraints = new BasicEList<>(); - constraints.addAll(Arrays.asList(new ComparisonExpression[] { constraint1, constraint2, constraint3})); + constraints.addAll(Arrays.asList(new ComparisonExpression[] { constraint1, constraint2, constraint3, constraint4})); ConstraintProblem cp = new ConstraintProblemMockup(consts,null, varsE, constraints ); @@ -78,6 +84,10 @@ class CPWrapperTest { cpWrapper.parse(cp, new UtilityProviderMockup()); } + /* + Variable order is var3, var1, var2, because + HeuristicVariableOrderer is used. + */ @Test public void countViolatedConstraintsTest() { @@ -85,7 +95,9 @@ class CPWrapperTest { assertTrue( cpWrapper.countViolatedConstraints(Arrays.asList(new Integer[] {0, 0, 2})) == 2); - assertTrue( cpWrapper.countViolatedConstraints(Arrays.asList(new Integer[] {0, 2, 2})) == 0); + assertTrue( cpWrapper.countViolatedConstraints(Arrays.asList(new Integer[] {2, 0, 2})) == 0); + + assertTrue( cpWrapper.countViolatedConstraints(Arrays.asList(new Integer[] {2, 2, 2})) == 1); } @Test @@ -94,11 +106,17 @@ class CPWrapperTest { assertFalse( cpWrapper.isFeasible(Arrays.asList(new Integer[] {0, 0, 2}))); - assertTrue( cpWrapper.isFeasible(Arrays.asList(new Integer[] {0, 2, 2}))); + assertTrue( cpWrapper.isFeasible(Arrays.asList(new Integer[] {2, 0, 2}))); } @Test public void getHeuristicEvaluationTest() { - assertTrue( cpWrapper.getHeuristicEvaluation(Arrays.asList(new Integer[] {2,2,2}), 0) == 3); + assertTrue( cpWrapper.getHeuristicEvaluation(Arrays.asList(new Integer[] {2,2,2}), 1) == 2); + + assertTrue( cpWrapper.getHeuristicEvaluation(Arrays.asList(new Integer[] {2,2,2}), 0) == 2); + + assertTrue( cpWrapper.getHeuristicEvaluation(Arrays.asList(new Integer[] {2,2,2}), 0) == 2); + + assertTrue( cpWrapper.getHeuristicEvaluation(Arrays.asList(new Integer[] {5,2,2}), 0) == 0); } } \ No newline at end of file diff --git a/ZPPSolver/CPParser/src/test/java/CPWrapper/Parser/CPParserTest.java b/ZPPSolver/CPParser/src/test/java/CPWrapper/Parser/CPParserTest.java deleted file mode 100644 index ccd8dd70f..000000000 --- a/ZPPSolver/CPParser/src/test/java/CPWrapper/Parser/CPParserTest.java +++ /dev/null @@ -1,7 +0,0 @@ -package CPWrapper.Parser; - -import static org.junit.jupiter.api.Assertions.*; - -class CPParserTest { - -} \ No newline at end of file -- GitLab From 5123a34ed26a694db533d60ed5daa84e3aa943c4 Mon Sep 17 00:00:00 2001 From: tc360950 Date: Tue, 10 Dec 2019 16:44:46 +0100 Subject: [PATCH 020/340] Minor fixes in comparator evaluation --- .../src/main/java/CPWrapper/Utils/ExpressionEvaluator.java | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/ZPPSolver/CPParser/src/main/java/CPWrapper/Utils/ExpressionEvaluator.java b/ZPPSolver/CPParser/src/main/java/CPWrapper/Utils/ExpressionEvaluator.java index d6e7a2757..3acb5d4ca 100644 --- a/ZPPSolver/CPParser/src/main/java/CPWrapper/Utils/ExpressionEvaluator.java +++ b/ZPPSolver/CPParser/src/main/java/CPWrapper/Utils/ExpressionEvaluator.java @@ -87,7 +87,7 @@ public class ExpressionEvaluator { public static boolean evaluateComparator(ComparatorEnum comparator, double argLeft, double argRight) { switch (comparator) { case GREATER_THAN: - return argLeft - argRight > ExpressionEvaluator.PRECISION; + return argLeft > argRight; case GREATER_OR_EQUAL_TO: return argLeft - argRight > -ExpressionEvaluator.PRECISION; case EQUAL_TO: @@ -95,7 +95,7 @@ public class ExpressionEvaluator { case LESS_OR_EQUAL_TO: return argRight - argLeft > -ExpressionEvaluator.PRECISION; case LESS_THAN: - return argRight - argLeft > ExpressionEvaluator.PRECISION; + return argLeft < argRight; case DIFFERENT: return Math.abs(argLeft - argRight) > ExpressionEvaluator.PRECISION; } -- GitLab From ec278432ebe456ee566f1acef430c0568e60e358 Mon Sep 17 00:00:00 2001 From: tc360950 Date: Tue, 10 Dec 2019 16:59:26 +0100 Subject: [PATCH 021/340] Added missing comments --- .../src/main/java/CPWrapper/Parser/CPParsedData.java | 9 ++++----- .../src/main/java/CPWrapper/Parser/CPParser.java | 6 +++++- .../src/main/java/CPWrapper/Utils/DomainHandler.java | 7 ++++++- .../java/CPWrapper/Utils/HeuristicVariableOrderer.java | 4 ++++ .../src/main/java/CPWrapper/Utils/VariableOrderer.java | 5 ++++- 5 files changed, 23 insertions(+), 8 deletions(-) diff --git a/ZPPSolver/CPParser/src/main/java/CPWrapper/Parser/CPParsedData.java b/ZPPSolver/CPParser/src/main/java/CPWrapper/Parser/CPParsedData.java index 8fd897ffe..6b93c604c 100644 --- a/ZPPSolver/CPParser/src/main/java/CPWrapper/Parser/CPParsedData.java +++ b/ZPPSolver/CPParser/src/main/java/CPWrapper/Parser/CPParsedData.java @@ -1,4 +1,7 @@ package CPWrapper.Parser; +/* + This class contains all data representing a specific constraint problem. + */ import CPWrapper.Utils.ArConstraint; import CPWrapper.Utils.ConstraintGraph; @@ -27,7 +30,7 @@ public class CPParsedData { return nameToVariable.keySet(); } - public void init() { + protected void init() { initializeConstraintGraph(); initializeNameToVariable(); } @@ -69,9 +72,6 @@ public class CPParsedData { } private void initializeConstraintGraph() { - for (CpVariable var: variables ) { - System.out.println("Nazwa: " + var.getId()); - } List variableNames = variables.stream() .map(var -> var.getId()) @@ -91,5 +91,4 @@ public class CPParsedData { protected void postVariables(Collection variables) { this.variables = variables; } - } diff --git a/ZPPSolver/CPParser/src/main/java/CPWrapper/Parser/CPParser.java b/ZPPSolver/CPParser/src/main/java/CPWrapper/Parser/CPParser.java index f2305d2af..e5bcffcc3 100644 --- a/ZPPSolver/CPParser/src/main/java/CPWrapper/Parser/CPParser.java +++ b/ZPPSolver/CPParser/src/main/java/CPWrapper/Parser/CPParser.java @@ -1,5 +1,9 @@ package CPWrapper.Parser; - +/* + This class is responsible for transforming ConstraintProblem interface into + CPParser class. The only work that is done here is transforming ComparisonExpression interface + into less abstract ArConstraint instance. + */ import CPWrapper.Utils.ArConstraint; import CPWrapper.Utils.ArConstraintImpl; import eu.paasage.upperware.metamodel.cp.ConstraintProblem; diff --git a/ZPPSolver/CPParser/src/main/java/CPWrapper/Utils/DomainHandler.java b/ZPPSolver/CPParser/src/main/java/CPWrapper/Utils/DomainHandler.java index 06ed59531..0a43dacac 100644 --- a/ZPPSolver/CPParser/src/main/java/CPWrapper/Utils/DomainHandler.java +++ b/ZPPSolver/CPParser/src/main/java/CPWrapper/Utils/DomainHandler.java @@ -1,5 +1,10 @@ package CPWrapper.Utils; - +/* + All variable domains are abstracted as finite sequences of subsequent + natural numbers - this class is responsible for turning those "domain indices" + into corresponding values. Currently only RangeDomain and NumericListDomain + domains are supported. + */ import eu.paasage.upperware.metamodel.cp.Domain; import eu.paasage.upperware.metamodel.cp.NumericListDomain; import eu.paasage.upperware.metamodel.cp.RangeDomain; diff --git a/ZPPSolver/CPParser/src/main/java/CPWrapper/Utils/HeuristicVariableOrderer.java b/ZPPSolver/CPParser/src/main/java/CPWrapper/Utils/HeuristicVariableOrderer.java index cf79678da..1adac10dd 100644 --- a/ZPPSolver/CPParser/src/main/java/CPWrapper/Utils/HeuristicVariableOrderer.java +++ b/ZPPSolver/CPParser/src/main/java/CPWrapper/Utils/HeuristicVariableOrderer.java @@ -19,6 +19,10 @@ public class HeuristicVariableOrderer implements VariableOrderer { return indexToVariableName.get(var); } + /* + For each variable record its number of constraints and number of other variables which + appear in those constraints. + */ private Map> evaluateVariables(ConstraintGraph constraintGraph) { Map> nameToValue = new HashMap<>(); for (String var : constraintGraph.getNodes()) { diff --git a/ZPPSolver/CPParser/src/main/java/CPWrapper/Utils/VariableOrderer.java b/ZPPSolver/CPParser/src/main/java/CPWrapper/Utils/VariableOrderer.java index ad8f375c6..726577568 100644 --- a/ZPPSolver/CPParser/src/main/java/CPWrapper/Utils/VariableOrderer.java +++ b/ZPPSolver/CPParser/src/main/java/CPWrapper/Utils/VariableOrderer.java @@ -1,5 +1,8 @@ package CPWrapper.Utils; - +/* + All variables are referenced through indices. Those indices correspond to + some variable ordering - which is maintained by VariableOrderer. + */ public interface VariableOrderer { String indexToVariableName(int var); } -- GitLab From dc01a362e77d38196273a3966b0d122cefda7196 Mon Sep 17 00:00:00 2001 From: tc360950 Date: Wed, 11 Dec 2019 14:29:46 +0100 Subject: [PATCH 022/340] Initial class structures --- ZPPSolver/PTSolver/pom.xml | 38 +++++++++++++++ .../src/main/java/CPComponents/PTMover.java | 15 ++++++ .../java/CPComponents/PTNeighbourhood.java | 19 ++++++++ .../main/java/CPComponents/PTObjective.java | 16 +++++++ .../java/CPComponents/PTRandomGenerator.java | 12 +++++ .../main/java/CPComponents/PTSolution.java | 48 +++++++++++++++++++ .../CPComponents/PTSolverCoordinator.java | 31 ++++++++++++ .../PTSolver/src/main/java/PTCPWrapper.java | 2 + .../src/test/java/CPSolutionTest.java | 18 +++++++ pom.xml | 1 + 10 files changed, 200 insertions(+) create mode 100644 ZPPSolver/PTSolver/pom.xml create mode 100644 ZPPSolver/PTSolver/src/main/java/CPComponents/PTMover.java create mode 100644 ZPPSolver/PTSolver/src/main/java/CPComponents/PTNeighbourhood.java create mode 100644 ZPPSolver/PTSolver/src/main/java/CPComponents/PTObjective.java create mode 100644 ZPPSolver/PTSolver/src/main/java/CPComponents/PTRandomGenerator.java create mode 100644 ZPPSolver/PTSolver/src/main/java/CPComponents/PTSolution.java create mode 100644 ZPPSolver/PTSolver/src/main/java/CPComponents/PTSolverCoordinator.java create mode 100644 ZPPSolver/PTSolver/src/main/java/PTCPWrapper.java create mode 100644 ZPPSolver/PTSolver/src/test/java/CPSolutionTest.java diff --git a/ZPPSolver/PTSolver/pom.xml b/ZPPSolver/PTSolver/pom.xml new file mode 100644 index 000000000..4cace3f1b --- /dev/null +++ b/ZPPSolver/PTSolver/pom.xml @@ -0,0 +1,38 @@ + + + + upperware + org.ow2.paasage + 2.5.1-SNAPSHOT + ../../pom.xml + + 4.0.0 + + PTSolver + + + org.jamesframework + james-core + 1.2 + + + org.projectlombok + lombok + ${lombok.version} + + + junit + junit + test + + + org.junit.jupiter + junit-jupiter + RELEASE + test + + + + \ No newline at end of file diff --git a/ZPPSolver/PTSolver/src/main/java/CPComponents/PTMover.java b/ZPPSolver/PTSolver/src/main/java/CPComponents/PTMover.java new file mode 100644 index 000000000..a43d722c6 --- /dev/null +++ b/ZPPSolver/PTSolver/src/main/java/CPComponents/PTMover.java @@ -0,0 +1,15 @@ +package CPComponents; + +import org.jamesframework.core.search.neigh.Move; + +public class PTMover implements Move { + @Override + public void apply(PTSolution cpSolution) { + + } + + @Override + public void undo(PTSolution cpSolution) { + + } +} diff --git a/ZPPSolver/PTSolver/src/main/java/CPComponents/PTNeighbourhood.java b/ZPPSolver/PTSolver/src/main/java/CPComponents/PTNeighbourhood.java new file mode 100644 index 000000000..b97458b64 --- /dev/null +++ b/ZPPSolver/PTSolver/src/main/java/CPComponents/PTNeighbourhood.java @@ -0,0 +1,19 @@ +package CPComponents; + +import org.jamesframework.core.search.neigh.Move; +import org.jamesframework.core.search.neigh.Neighbourhood; + +import java.util.List; +import java.util.Random; + +public class PTNeighbourhood implements Neighbourhood { + @Override + public Move getRandomMove(PTSolution cpSolution, Random random) { + return null; + } + + @Override + public List> getAllMoves(PTSolution cpSolution) { + return null; + } +} diff --git a/ZPPSolver/PTSolver/src/main/java/CPComponents/PTObjective.java b/ZPPSolver/PTSolver/src/main/java/CPComponents/PTObjective.java new file mode 100644 index 000000000..40bb2fb7d --- /dev/null +++ b/ZPPSolver/PTSolver/src/main/java/CPComponents/PTObjective.java @@ -0,0 +1,16 @@ +package CPComponents; + +import org.jamesframework.core.problems.objectives.Objective; +import org.jamesframework.core.problems.objectives.evaluations.Evaluation; + +public class PTObjective implements Objective { + @Override + public Evaluation evaluate(PTSolution cpSolution, PTCPWrapper ptcpWrapper) { + return null; + } + + @Override + public boolean isMinimizing() { + return false; + } +} diff --git a/ZPPSolver/PTSolver/src/main/java/CPComponents/PTRandomGenerator.java b/ZPPSolver/PTSolver/src/main/java/CPComponents/PTRandomGenerator.java new file mode 100644 index 000000000..635fcb8b6 --- /dev/null +++ b/ZPPSolver/PTSolver/src/main/java/CPComponents/PTRandomGenerator.java @@ -0,0 +1,12 @@ +package CPComponents; + +import org.jamesframework.core.problems.sol.RandomSolutionGenerator; + +import java.util.Random; + +public class PTRandomGenerator implements RandomSolutionGenerator { + @Override + public PTSolution create(Random random, PTCPWrapper ptcpWrapper) { + return null; + } +} diff --git a/ZPPSolver/PTSolver/src/main/java/CPComponents/PTSolution.java b/ZPPSolver/PTSolver/src/main/java/CPComponents/PTSolution.java new file mode 100644 index 000000000..1e23eb48e --- /dev/null +++ b/ZPPSolver/PTSolver/src/main/java/CPComponents/PTSolution.java @@ -0,0 +1,48 @@ +package CPComponents; + +import lombok.AllArgsConstructor; +import org.jamesframework.core.problems.sol.Solution; + +import java.util.ArrayList; +import java.util.Collections; +import java.util.List; +import java.util.Objects; + +@AllArgsConstructor +public class PTSolution extends Solution { + + private List varAssignments; + + @Override + public Solution copy() { + List varsClone = new ArrayList<>(); + Collections.copy(varAssignments, varsClone); + return new PTSolution(varsClone); + } + + private boolean equals(PTSolution s) { + for (int i = 0; i < varAssignments.size(); i++) { + if (s.varAssignments.get(i) != varAssignments.get(i)) { + return false; + } + } + return true; + } + + @Override + public boolean equals(Object o) { + if (o == null) { + return false; + } + if (getClass() != o.getClass()) { + return false; + } + final PTSolution other = (PTSolution) o; + return equals(other); + } + + @Override + public int hashCode() { + return Objects.hashCode(varAssignments); + } +} diff --git a/ZPPSolver/PTSolver/src/main/java/CPComponents/PTSolverCoordinator.java b/ZPPSolver/PTSolver/src/main/java/CPComponents/PTSolverCoordinator.java new file mode 100644 index 000000000..412446dad --- /dev/null +++ b/ZPPSolver/PTSolver/src/main/java/CPComponents/PTSolverCoordinator.java @@ -0,0 +1,31 @@ +package CPComponents; + +public class PTSolverCoordinator { + + public void prepareProblem() { + // create data + //TSPData data = new TSPData(dist); +// create objective + //TSPObjective obj = new TSPObjective(); +// create random solution generator + //RandomSolutionGenerator rsg = ... // see before + +// wrap in generic problem + //Problem problem = new GenericProblem<>(data, obj, rsg); + } + + public void preparePTSolver() { + // set temperature range, scaled according to average +// distance between cities and their nearest neighbours + /* double scale = computeAvgNearestNeighbourDistance(data); + double minTemp = scale * 1e-8; + double maxTemp = scale * 0.6; +// create parallel tempering search with TSP neighbourhood + int numReplicas = 10; + ParallelTempering parallelTempering = new ParallelTempering<>( + problem, + new TSP2OptNeighbourhood(), + numReplicas, minTemp, maxTemp*/ + + } +} diff --git a/ZPPSolver/PTSolver/src/main/java/PTCPWrapper.java b/ZPPSolver/PTSolver/src/main/java/PTCPWrapper.java new file mode 100644 index 000000000..0a6039195 --- /dev/null +++ b/ZPPSolver/PTSolver/src/main/java/PTCPWrapper.java @@ -0,0 +1,2 @@ +public class PTCPWrapper { +} diff --git a/ZPPSolver/PTSolver/src/test/java/CPSolutionTest.java b/ZPPSolver/PTSolver/src/test/java/CPSolutionTest.java new file mode 100644 index 000000000..f7f554008 --- /dev/null +++ b/ZPPSolver/PTSolver/src/test/java/CPSolutionTest.java @@ -0,0 +1,18 @@ + + +import java.util.Arrays; +import java.util.List; +import java.util.stream.Collectors; + +import static junit.framework.TestCase.assertTrue; + +class CPSolutionTest { + + + @org.junit.jupiter.api.Test + void name() { + + } + + +} \ No newline at end of file diff --git a/pom.xml b/pom.xml index 8d0c5a8fe..2bca1dff0 100644 --- a/pom.xml +++ b/pom.xml @@ -43,6 +43,7 @@ ZPPSolver/CPParser ZPPSolver/GeneticSolver ZPPSolver/MCTSSolver + ZPPSolver/PTSolver -- GitLab From d6f0d0a2bc52931437bb5b14fc0cff56b4f1dc43 Mon Sep 17 00:00:00 2001 From: tc360950 Date: Wed, 11 Dec 2019 14:33:48 +0100 Subject: [PATCH 023/340] Minor fixes in structure --- ZPPSolver/PTSolver/src/main/java/CPComponents/PTObjective.java | 1 + .../PTSolver/src/main/java/CPComponents/PTRandomGenerator.java | 1 + .../PTSolver/src/main/java/{ => CPWrapper}/PTCPWrapper.java | 2 ++ .../src/main/java/{CPComponents => }/PTSolverCoordinator.java | 2 -- 4 files changed, 4 insertions(+), 2 deletions(-) rename ZPPSolver/PTSolver/src/main/java/{ => CPWrapper}/PTCPWrapper.java (59%) rename ZPPSolver/PTSolver/src/main/java/{CPComponents => }/PTSolverCoordinator.java (97%) diff --git a/ZPPSolver/PTSolver/src/main/java/CPComponents/PTObjective.java b/ZPPSolver/PTSolver/src/main/java/CPComponents/PTObjective.java index 40bb2fb7d..eff2a4686 100644 --- a/ZPPSolver/PTSolver/src/main/java/CPComponents/PTObjective.java +++ b/ZPPSolver/PTSolver/src/main/java/CPComponents/PTObjective.java @@ -1,5 +1,6 @@ package CPComponents; +import CPWrapper.PTCPWrapper; import org.jamesframework.core.problems.objectives.Objective; import org.jamesframework.core.problems.objectives.evaluations.Evaluation; diff --git a/ZPPSolver/PTSolver/src/main/java/CPComponents/PTRandomGenerator.java b/ZPPSolver/PTSolver/src/main/java/CPComponents/PTRandomGenerator.java index 635fcb8b6..5bbc16393 100644 --- a/ZPPSolver/PTSolver/src/main/java/CPComponents/PTRandomGenerator.java +++ b/ZPPSolver/PTSolver/src/main/java/CPComponents/PTRandomGenerator.java @@ -1,5 +1,6 @@ package CPComponents; +import CPWrapper.PTCPWrapper; import org.jamesframework.core.problems.sol.RandomSolutionGenerator; import java.util.Random; diff --git a/ZPPSolver/PTSolver/src/main/java/PTCPWrapper.java b/ZPPSolver/PTSolver/src/main/java/CPWrapper/PTCPWrapper.java similarity index 59% rename from ZPPSolver/PTSolver/src/main/java/PTCPWrapper.java rename to ZPPSolver/PTSolver/src/main/java/CPWrapper/PTCPWrapper.java index 0a6039195..fd55d9760 100644 --- a/ZPPSolver/PTSolver/src/main/java/PTCPWrapper.java +++ b/ZPPSolver/PTSolver/src/main/java/CPWrapper/PTCPWrapper.java @@ -1,2 +1,4 @@ +package CPWrapper; + public class PTCPWrapper { } diff --git a/ZPPSolver/PTSolver/src/main/java/CPComponents/PTSolverCoordinator.java b/ZPPSolver/PTSolver/src/main/java/PTSolverCoordinator.java similarity index 97% rename from ZPPSolver/PTSolver/src/main/java/CPComponents/PTSolverCoordinator.java rename to ZPPSolver/PTSolver/src/main/java/PTSolverCoordinator.java index 412446dad..350eada0f 100644 --- a/ZPPSolver/PTSolver/src/main/java/CPComponents/PTSolverCoordinator.java +++ b/ZPPSolver/PTSolver/src/main/java/PTSolverCoordinator.java @@ -1,5 +1,3 @@ -package CPComponents; - public class PTSolverCoordinator { public void prepareProblem() { -- GitLab From 2177043108b807fec73399e34fb6c19e1f4dab86 Mon Sep 17 00:00:00 2001 From: tc360950 Date: Wed, 11 Dec 2019 15:05:05 +0100 Subject: [PATCH 024/340] Implemented all basic cmponents --- .../main/java/CPComponents/PTEvaluation.java | 13 +++++++ .../src/main/java/CPComponents/PTMover.java | 38 ++++++++++++++++++- .../java/CPComponents/PTNeighbourhood.java | 16 +++++++- .../main/java/CPComponents/PTObjective.java | 2 +- .../main/java/CPComponents/PTSolution.java | 21 +++++++++- .../src/main/java/CPWrapper/PTCPWrapper.java | 23 +++++++++++ .../src/main/java/PTSolverCoordinator.java | 1 + 7 files changed, 109 insertions(+), 5 deletions(-) create mode 100644 ZPPSolver/PTSolver/src/main/java/CPComponents/PTEvaluation.java diff --git a/ZPPSolver/PTSolver/src/main/java/CPComponents/PTEvaluation.java b/ZPPSolver/PTSolver/src/main/java/CPComponents/PTEvaluation.java new file mode 100644 index 000000000..2cb1e948c --- /dev/null +++ b/ZPPSolver/PTSolver/src/main/java/CPComponents/PTEvaluation.java @@ -0,0 +1,13 @@ +package CPComponents; + +import lombok.AllArgsConstructor; +import org.jamesframework.core.problems.objectives.evaluations.Evaluation; + +@AllArgsConstructor +public class PTEvaluation implements Evaluation { + private double value; + @Override + public double getValue() { + return value; + } +} diff --git a/ZPPSolver/PTSolver/src/main/java/CPComponents/PTMover.java b/ZPPSolver/PTSolver/src/main/java/CPComponents/PTMover.java index a43d722c6..c58cc0c9f 100644 --- a/ZPPSolver/PTSolver/src/main/java/CPComponents/PTMover.java +++ b/ZPPSolver/PTSolver/src/main/java/CPComponents/PTMover.java @@ -2,14 +2,50 @@ package CPComponents; import org.jamesframework.core.search.neigh.Move; +import java.util.Collections; +import java.util.Map; + public class PTMover implements Move { + enum MOVE_DIRECTION { + UP, + DOWN + }; + + private PTMover(Map move) { + this.move = move; + } + /* + Should always be a singleton map x ---> y. + X denotes index of variable which should be changed. + */ + private Map move; + + /* + Here we may assume that the move is possible + */ @Override public void apply(PTSolution cpSolution) { - + if (move.values().contains(MOVE_DIRECTION.UP)) { + cpSolution.increaseValue(move.keySet().iterator().next()); + } else { + cpSolution.decreaseValue(move.keySet().iterator().next()); + } } @Override public void undo(PTSolution cpSolution) { + if (move.values().contains(MOVE_DIRECTION.DOWN)) { + cpSolution.increaseValue(move.keySet().iterator().next()); + } else { + cpSolution.decreaseValue(move.keySet().iterator().next()); + } + } + + public static PTMover newUpMove(int var) { + return new PTMover(Collections.singletonMap(var, MOVE_DIRECTION.UP)); + } + public static PTMover newDownMove(int var) { + return new PTMover(Collections.singletonMap(var, MOVE_DIRECTION.DOWN)); } } diff --git a/ZPPSolver/PTSolver/src/main/java/CPComponents/PTNeighbourhood.java b/ZPPSolver/PTSolver/src/main/java/CPComponents/PTNeighbourhood.java index b97458b64..68fb8e935 100644 --- a/ZPPSolver/PTSolver/src/main/java/CPComponents/PTNeighbourhood.java +++ b/ZPPSolver/PTSolver/src/main/java/CPComponents/PTNeighbourhood.java @@ -3,17 +3,29 @@ package CPComponents; import org.jamesframework.core.search.neigh.Move; import org.jamesframework.core.search.neigh.Neighbourhood; +import java.util.ArrayList; import java.util.List; import java.util.Random; public class PTNeighbourhood implements Neighbourhood { @Override public Move getRandomMove(PTSolution cpSolution, Random random) { - return null; + List> moves = getAllMoves(cpSolution); + return moves.get(random.nextInt(moves.size())); } @Override public List> getAllMoves(PTSolution cpSolution) { - return null; + int vars = cpSolution.getVarAssignments().size(); + List moves = new ArrayList<>(); + for (int i = 0; i < vars; i++) { + if (cpSolution.canMoveUp(i)) { + moves.add(PTMover.newUpMove(i)); + } + if (cpSolution.canMoveDown(i)) { + moves.add(PTMover.newDownMove(i)); + } + } + return moves; } } diff --git a/ZPPSolver/PTSolver/src/main/java/CPComponents/PTObjective.java b/ZPPSolver/PTSolver/src/main/java/CPComponents/PTObjective.java index eff2a4686..a49f23d04 100644 --- a/ZPPSolver/PTSolver/src/main/java/CPComponents/PTObjective.java +++ b/ZPPSolver/PTSolver/src/main/java/CPComponents/PTObjective.java @@ -7,7 +7,7 @@ import org.jamesframework.core.problems.objectives.evaluations.Evaluation; public class PTObjective implements Objective { @Override public Evaluation evaluate(PTSolution cpSolution, PTCPWrapper ptcpWrapper) { - return null; + return ptcpWrapper.evaluate(cpSolution.getVarAssignments()); } @Override diff --git a/ZPPSolver/PTSolver/src/main/java/CPComponents/PTSolution.java b/ZPPSolver/PTSolver/src/main/java/CPComponents/PTSolution.java index 1e23eb48e..74eb1fd11 100644 --- a/ZPPSolver/PTSolver/src/main/java/CPComponents/PTSolution.java +++ b/ZPPSolver/PTSolver/src/main/java/CPComponents/PTSolution.java @@ -1,6 +1,7 @@ package CPComponents; import lombok.AllArgsConstructor; +import lombok.Getter; import org.jamesframework.core.problems.sol.Solution; import java.util.ArrayList; @@ -10,9 +11,27 @@ import java.util.Objects; @AllArgsConstructor public class PTSolution extends Solution { - + private static List minVariableValues; + private static List maxVariableValues; + @Getter private List varAssignments; + protected void increaseValue(int variableIndex) { + varAssignments.set(variableIndex, varAssignments.get(variableIndex) + 1); + } + + protected void decreaseValue(int variableIndex) { + varAssignments.set(variableIndex, varAssignments.get(variableIndex) - 1); + } + + public boolean canMoveUp(int var) { + return PTSolution.maxVariableValues.get(var) > varAssignments.get(var); + } + + public boolean canMoveDown(int var) { + return PTSolution.minVariableValues.get(var) < varAssignments.get(var); + } + @Override public Solution copy() { List varsClone = new ArrayList<>(); diff --git a/ZPPSolver/PTSolver/src/main/java/CPWrapper/PTCPWrapper.java b/ZPPSolver/PTSolver/src/main/java/CPWrapper/PTCPWrapper.java index fd55d9760..3c1f95532 100644 --- a/ZPPSolver/PTSolver/src/main/java/CPWrapper/PTCPWrapper.java +++ b/ZPPSolver/PTSolver/src/main/java/CPWrapper/PTCPWrapper.java @@ -1,4 +1,27 @@ package CPWrapper; +import CPComponents.PTEvaluation; +import CPComponents.PTSolution; +import org.jamesframework.core.problems.objectives.evaluations.Evaluation; + +import java.util.List; +import java.util.Random; + public class PTCPWrapper { + + public Evaluation evaluate(List assignments) { + //TODO Use cpWrapper to check constraint + //TODO Use CpWrapper to calc utility + return new PTEvaluation(0); + } + + public int getMaxValue(int variable) { + //TODO use CPWrapper - must impement a new method; + return 0; + } + + public PTSolution generateRandom(Random random, PTCPWrapper ptcpWrapper) { + //TODO must use CPWrapper + return null; + } } diff --git a/ZPPSolver/PTSolver/src/main/java/PTSolverCoordinator.java b/ZPPSolver/PTSolver/src/main/java/PTSolverCoordinator.java index 350eada0f..a4549a925 100644 --- a/ZPPSolver/PTSolver/src/main/java/PTSolverCoordinator.java +++ b/ZPPSolver/PTSolver/src/main/java/PTSolverCoordinator.java @@ -1,6 +1,7 @@ public class PTSolverCoordinator { public void prepareProblem() { + //TODO must Set PTSolution static data // create data //TSPData data = new TSPData(dist); // create objective -- GitLab From 761b8dfda25ec439ac8f33b0be4608c4f11a2cc3 Mon Sep 17 00:00:00 2001 From: tc360950 Date: Wed, 11 Dec 2019 15:40:43 +0100 Subject: [PATCH 025/340] Added new tests --- .../src/main/java/CPComponents/PTMover.java | 17 ++++++---- .../java/CPComponents/PTNeighbourhood.java | 4 ++- .../java/CPComponents/PTRandomGenerator.java | 2 +- .../main/java/CPComponents/PTSolution.java | 7 ++-- .../src/main/java/CPWrapper/PTCPWrapper.java | 2 +- .../test/java/CPComponents/PTMoverTest.java | 32 +++++++++++++++++++ .../CPComponents/PTNeighbourhoodTest.java | 32 +++++++++++++++++++ .../java/CPComponents/PTSolutionTest.java | 19 +++++++++++ 8 files changed, 103 insertions(+), 12 deletions(-) create mode 100644 ZPPSolver/PTSolver/src/test/java/CPComponents/PTMoverTest.java create mode 100644 ZPPSolver/PTSolver/src/test/java/CPComponents/PTNeighbourhoodTest.java create mode 100644 ZPPSolver/PTSolver/src/test/java/CPComponents/PTSolutionTest.java diff --git a/ZPPSolver/PTSolver/src/main/java/CPComponents/PTMover.java b/ZPPSolver/PTSolver/src/main/java/CPComponents/PTMover.java index c58cc0c9f..94b408812 100644 --- a/ZPPSolver/PTSolver/src/main/java/CPComponents/PTMover.java +++ b/ZPPSolver/PTSolver/src/main/java/CPComponents/PTMover.java @@ -1,5 +1,10 @@ package CPComponents; - +/* + Class which abstracts moves in CP search space. + There are only two types of moves: + for given variable we may either increase its value by 1 + or decrease it by 1. + */ import org.jamesframework.core.search.neigh.Move; import java.util.Collections; @@ -25,11 +30,11 @@ public class PTMover implements Move { */ @Override public void apply(PTSolution cpSolution) { - if (move.values().contains(MOVE_DIRECTION.UP)) { - cpSolution.increaseValue(move.keySet().iterator().next()); - } else { - cpSolution.decreaseValue(move.keySet().iterator().next()); - } + if (move.values().contains(MOVE_DIRECTION.UP)) { + cpSolution.increaseValue(move.keySet().iterator().next()); + } else { + cpSolution.decreaseValue(move.keySet().iterator().next()); + } } @Override diff --git a/ZPPSolver/PTSolver/src/main/java/CPComponents/PTNeighbourhood.java b/ZPPSolver/PTSolver/src/main/java/CPComponents/PTNeighbourhood.java index 68fb8e935..b5686004c 100644 --- a/ZPPSolver/PTSolver/src/main/java/CPComponents/PTNeighbourhood.java +++ b/ZPPSolver/PTSolver/src/main/java/CPComponents/PTNeighbourhood.java @@ -1,5 +1,7 @@ package CPComponents; - +/* + This class + */ import org.jamesframework.core.search.neigh.Move; import org.jamesframework.core.search.neigh.Neighbourhood; diff --git a/ZPPSolver/PTSolver/src/main/java/CPComponents/PTRandomGenerator.java b/ZPPSolver/PTSolver/src/main/java/CPComponents/PTRandomGenerator.java index 5bbc16393..56af88483 100644 --- a/ZPPSolver/PTSolver/src/main/java/CPComponents/PTRandomGenerator.java +++ b/ZPPSolver/PTSolver/src/main/java/CPComponents/PTRandomGenerator.java @@ -8,6 +8,6 @@ import java.util.Random; public class PTRandomGenerator implements RandomSolutionGenerator { @Override public PTSolution create(Random random, PTCPWrapper ptcpWrapper) { - return null; + return ptcpWrapper.generateRandom(random); } } diff --git a/ZPPSolver/PTSolver/src/main/java/CPComponents/PTSolution.java b/ZPPSolver/PTSolver/src/main/java/CPComponents/PTSolution.java index 74eb1fd11..5a66a5328 100644 --- a/ZPPSolver/PTSolver/src/main/java/CPComponents/PTSolution.java +++ b/ZPPSolver/PTSolver/src/main/java/CPComponents/PTSolution.java @@ -11,13 +11,14 @@ import java.util.Objects; @AllArgsConstructor public class PTSolution extends Solution { - private static List minVariableValues; - private static List maxVariableValues; + public static List minVariableValues; + public static List maxVariableValues; @Getter private List varAssignments; protected void increaseValue(int variableIndex) { - varAssignments.set(variableIndex, varAssignments.get(variableIndex) + 1); + int varValue = varAssignments.get(variableIndex); + varAssignments.set(variableIndex, varValue + 1); } protected void decreaseValue(int variableIndex) { diff --git a/ZPPSolver/PTSolver/src/main/java/CPWrapper/PTCPWrapper.java b/ZPPSolver/PTSolver/src/main/java/CPWrapper/PTCPWrapper.java index 3c1f95532..2f2b6a954 100644 --- a/ZPPSolver/PTSolver/src/main/java/CPWrapper/PTCPWrapper.java +++ b/ZPPSolver/PTSolver/src/main/java/CPWrapper/PTCPWrapper.java @@ -20,7 +20,7 @@ public class PTCPWrapper { return 0; } - public PTSolution generateRandom(Random random, PTCPWrapper ptcpWrapper) { + public PTSolution generateRandom(Random random) { //TODO must use CPWrapper return null; } diff --git a/ZPPSolver/PTSolver/src/test/java/CPComponents/PTMoverTest.java b/ZPPSolver/PTSolver/src/test/java/CPComponents/PTMoverTest.java new file mode 100644 index 000000000..bcf7a6638 --- /dev/null +++ b/ZPPSolver/PTSolver/src/test/java/CPComponents/PTMoverTest.java @@ -0,0 +1,32 @@ +package CPComponents; + +import org.junit.jupiter.api.Test; + +import java.util.Arrays; +import java.util.List; + +import static org.junit.jupiter.api.Assertions.*; + +class PTMoverTest { + + @Test + public void MovingTest() { + List assignments = Arrays.asList(new Integer[] {1,2,3,4,5}); + + PTSolution solution = new PTSolution(Arrays.asList(new Integer[] {1,2,3,4,5})); + + for (int i = 0; i < assignments.size() ; i++) { + PTMover m = PTMover.newUpMove(i); + m.apply(solution); + assertTrue( solution.getVarAssignments().get(i) == assignments.get(i) + 1); + } + + for (int i = 0; i < assignments.size() ; i++) { + PTMover m = PTMover.newDownMove(i); + m.apply(solution); + assertTrue( solution.getVarAssignments().get(i) == assignments.get(i)); + } + + } + +} \ No newline at end of file diff --git a/ZPPSolver/PTSolver/src/test/java/CPComponents/PTNeighbourhoodTest.java b/ZPPSolver/PTSolver/src/test/java/CPComponents/PTNeighbourhoodTest.java new file mode 100644 index 000000000..8acd41f0f --- /dev/null +++ b/ZPPSolver/PTSolver/src/test/java/CPComponents/PTNeighbourhoodTest.java @@ -0,0 +1,32 @@ +package CPComponents; + +import org.junit.jupiter.api.Test; + +import java.util.Arrays; +import java.util.List; + +import static org.junit.jupiter.api.Assertions.*; + +class PTNeighbourhoodTest { + + @Test + public void getAllMovesTest() { + List assignments = Arrays.asList(new Integer[] {1,2,3,4,5}); + List maxValues = Arrays.asList(new Integer[] {1,2,3,4,5}); + List minValues = Arrays.asList(new Integer[] {1,2,3,4,5}); + PTSolution.maxVariableValues = maxValues; + PTSolution.minVariableValues = minValues; + PTNeighbourhood neighbourhood = new PTNeighbourhood(); + PTSolution sol = new PTSolution(assignments); + assertTrue( neighbourhood.getAllMoves(sol).size() == 0); + + maxValues = Arrays.asList(new Integer[] {10,20,30,40,50}); + PTSolution.maxVariableValues= maxValues; + assertTrue( neighbourhood.getAllMoves(sol).size() == assignments.size()); + + minValues = Arrays.asList(new Integer[] {1,0,0,0,0}); + PTSolution.minVariableValues = minValues; + assertTrue( neighbourhood.getAllMoves(sol).size() == 2 * assignments.size() - 1); + } + +} \ No newline at end of file diff --git a/ZPPSolver/PTSolver/src/test/java/CPComponents/PTSolutionTest.java b/ZPPSolver/PTSolver/src/test/java/CPComponents/PTSolutionTest.java new file mode 100644 index 000000000..2bd0c217e --- /dev/null +++ b/ZPPSolver/PTSolver/src/test/java/CPComponents/PTSolutionTest.java @@ -0,0 +1,19 @@ +package CPComponents; + +import org.junit.jupiter.api.Test; + +import static org.junit.jupiter.api.Assertions.*; + +class PTSolutionTest { + + @Test + public void cloneTest() { + + } + + @Test + public void equalsTest() { + + } + +} \ No newline at end of file -- GitLab From 2052ca28faceabaf31e2f893727ae0afffc383d7 Mon Sep 17 00:00:00 2001 From: tc360950 Date: Wed, 11 Dec 2019 15:54:20 +0100 Subject: [PATCH 026/340] Added tests for PTSolution --- .../src/main/java/CPComponents/PTSolution.java | 6 ++++-- .../test/java/CPComponents/PTSolutionTest.java | 18 ++++++++++++++++-- .../PTSolver/src/test/java/CPSolutionTest.java | 18 ------------------ 3 files changed, 20 insertions(+), 22 deletions(-) delete mode 100644 ZPPSolver/PTSolver/src/test/java/CPSolutionTest.java diff --git a/ZPPSolver/PTSolver/src/main/java/CPComponents/PTSolution.java b/ZPPSolver/PTSolver/src/main/java/CPComponents/PTSolution.java index 5a66a5328..27b1d5437 100644 --- a/ZPPSolver/PTSolver/src/main/java/CPComponents/PTSolution.java +++ b/ZPPSolver/PTSolver/src/main/java/CPComponents/PTSolution.java @@ -35,12 +35,14 @@ public class PTSolution extends Solution { @Override public Solution copy() { - List varsClone = new ArrayList<>(); - Collections.copy(varAssignments, varsClone); + List varsClone = new ArrayList<>(varAssignments); return new PTSolution(varsClone); } private boolean equals(PTSolution s) { + if (s.varAssignments.size() != varAssignments.size()) { + return false; + } for (int i = 0; i < varAssignments.size(); i++) { if (s.varAssignments.get(i) != varAssignments.get(i)) { return false; diff --git a/ZPPSolver/PTSolver/src/test/java/CPComponents/PTSolutionTest.java b/ZPPSolver/PTSolver/src/test/java/CPComponents/PTSolutionTest.java index 2bd0c217e..c3a2c1304 100644 --- a/ZPPSolver/PTSolver/src/test/java/CPComponents/PTSolutionTest.java +++ b/ZPPSolver/PTSolver/src/test/java/CPComponents/PTSolutionTest.java @@ -2,18 +2,32 @@ package CPComponents; import org.junit.jupiter.api.Test; +import java.util.Arrays; + import static org.junit.jupiter.api.Assertions.*; class PTSolutionTest { @Test - public void cloneTest() { + public void copyTest() { + PTSolution sol1 = new PTSolution(Arrays.asList(new Integer[] {1,2,3,4,5,6,7,8,9})); + PTSolution sol2 = (PTSolution) sol1.copy(); + sol1.increaseValue(1); + assertFalse(sol1.getVarAssignments().get(1) == sol2.getVarAssignments().get(1)); } @Test public void equalsTest() { - + PTSolution sol1 = new PTSolution(Arrays.asList(new Integer[] {1,2,3,4,5,6,7,8,9})); + PTSolution sol2 = new PTSolution(Arrays.asList(new Integer[] {1,2,3,4,5,6,7,8,9})); + PTSolution sol3 = new PTSolution(Arrays.asList(new Integer[] {1,2,3,4,5,7,7,8,9})); + PTSolution sol4 = new PTSolution(Arrays.asList(new Integer[] {1,2,3,4})); + + assertTrue(sol1.equals(sol2)); + assertTrue(sol2.equals(sol1)); + assertFalse(sol1.equals(sol3)); + assertFalse(sol1.equals(sol4)); } } \ No newline at end of file diff --git a/ZPPSolver/PTSolver/src/test/java/CPSolutionTest.java b/ZPPSolver/PTSolver/src/test/java/CPSolutionTest.java deleted file mode 100644 index f7f554008..000000000 --- a/ZPPSolver/PTSolver/src/test/java/CPSolutionTest.java +++ /dev/null @@ -1,18 +0,0 @@ - - -import java.util.Arrays; -import java.util.List; -import java.util.stream.Collectors; - -import static junit.framework.TestCase.assertTrue; - -class CPSolutionTest { - - - @org.junit.jupiter.api.Test - void name() { - - } - - -} \ No newline at end of file -- GitLab From 639f5cb016ead1324ef12916959bd0e279e5a051 Mon Sep 17 00:00:00 2001 From: tc360950 Date: Wed, 11 Dec 2019 16:22:03 +0100 Subject: [PATCH 027/340] Added comments --- .../java/CPComponents/PTNeighbourhood.java | 4 +++- .../main/java/CPComponents/PTSolution.java | 20 ++++++++++++++----- 2 files changed, 18 insertions(+), 6 deletions(-) diff --git a/ZPPSolver/PTSolver/src/main/java/CPComponents/PTNeighbourhood.java b/ZPPSolver/PTSolver/src/main/java/CPComponents/PTNeighbourhood.java index b5686004c..14ba109d9 100644 --- a/ZPPSolver/PTSolver/src/main/java/CPComponents/PTNeighbourhood.java +++ b/ZPPSolver/PTSolver/src/main/java/CPComponents/PTNeighbourhood.java @@ -1,6 +1,8 @@ package CPComponents; /* - This class + Neighbourhood of a search space element - V - + is defined to be a set of all elements which may be transformed to + V with one move. */ import org.jamesframework.core.search.neigh.Move; import org.jamesframework.core.search.neigh.Neighbourhood; diff --git a/ZPPSolver/PTSolver/src/main/java/CPComponents/PTSolution.java b/ZPPSolver/PTSolver/src/main/java/CPComponents/PTSolution.java index 27b1d5437..e41093ce7 100644 --- a/ZPPSolver/PTSolver/src/main/java/CPComponents/PTSolution.java +++ b/ZPPSolver/PTSolver/src/main/java/CPComponents/PTSolution.java @@ -1,11 +1,12 @@ package CPComponents; - +/* + Search space element for Parallel Tempering + */ import lombok.AllArgsConstructor; import lombok.Getter; import org.jamesframework.core.problems.sol.Solution; import java.util.ArrayList; -import java.util.Collections; import java.util.List; import java.util.Objects; @@ -13,22 +14,31 @@ import java.util.Objects; public class PTSolution extends Solution { public static List minVariableValues; public static List maxVariableValues; + /* + Value at index i corresponds to i'th variable's value + */ @Getter private List varAssignments; protected void increaseValue(int variableIndex) { - int varValue = varAssignments.get(variableIndex); - varAssignments.set(variableIndex, varValue + 1); + varAssignments.set(variableIndex, varAssignments.get(variableIndex) + 1); } protected void decreaseValue(int variableIndex) { varAssignments.set(variableIndex, varAssignments.get(variableIndex) - 1); } + /* + True if increasing current @var variable value by one will not exceed + domain range + */ public boolean canMoveUp(int var) { return PTSolution.maxVariableValues.get(var) > varAssignments.get(var); } - + /* + True if decreasing current @var variable value by one will not exceed + domain range + */ public boolean canMoveDown(int var) { return PTSolution.minVariableValues.get(var) < varAssignments.get(var); } -- GitLab From 56412db7d2c1f096e4057082b583a35580178e34 Mon Sep 17 00:00:00 2001 From: tc360950 Date: Fri, 13 Dec 2019 16:58:05 +0100 Subject: [PATCH 028/340] Removed unnecessary print outs. Changed assertTrue to assertEquals where applicable --- .../java/CPWrapper/Utils/ConstraintGraph.java | 2 -- .../src/test/java/CPWrapper/CPWrapperTest.java | 16 ++++++++-------- .../CPWrapper/Utils/ConstraintGraphTest.java | 18 +++++++++--------- .../Utils/ExpressionEvaluatorTest.java | 9 ++++----- .../Utils/HeuristicVariableOrdererTest.java | 2 +- 5 files changed, 22 insertions(+), 25 deletions(-) diff --git a/ZPPSolver/CPParser/src/main/java/CPWrapper/Utils/ConstraintGraph.java b/ZPPSolver/CPParser/src/main/java/CPWrapper/Utils/ConstraintGraph.java index daa2fdbf6..7e0ec384c 100644 --- a/ZPPSolver/CPParser/src/main/java/CPWrapper/Utils/ConstraintGraph.java +++ b/ZPPSolver/CPParser/src/main/java/CPWrapper/Utils/ConstraintGraph.java @@ -39,7 +39,6 @@ public class ConstraintGraph { */ private void initializeKnownDistances(Map> knownDistances) { for (String var : variables) { - System.out.println("probuj2e " + var + " " + variables.size()); knownDistances.put(var, new LinkedList()); knownDistances.get(var).add(var); } @@ -73,7 +72,6 @@ public class ConstraintGraph { for (ArConstraint constraint : constraints) { Collection variables = constraint.getVariableNames(); for (String var : variables) { - System.out.println("probuje " + var); knownDistances.get(var).addAll(variables); neighbourhoodList.get(var).get(1).addAll(variables); neighbourhoodList.get(var).get(1).remove(var); diff --git a/ZPPSolver/CPParser/src/test/java/CPWrapper/CPWrapperTest.java b/ZPPSolver/CPParser/src/test/java/CPWrapper/CPWrapperTest.java index d4d51bebf..52d8335d8 100644 --- a/ZPPSolver/CPParser/src/test/java/CPWrapper/CPWrapperTest.java +++ b/ZPPSolver/CPParser/src/test/java/CPWrapper/CPWrapperTest.java @@ -91,13 +91,13 @@ class CPWrapperTest { @Test public void countViolatedConstraintsTest() { - assertTrue( cpWrapper.countViolatedConstraints(Arrays.asList(new Integer[] {0, 0, 0})) == 2); + assertEquals( cpWrapper.countViolatedConstraints(Arrays.asList(new Integer[] {0, 0, 0})), 2); - assertTrue( cpWrapper.countViolatedConstraints(Arrays.asList(new Integer[] {0, 0, 2})) == 2); + assertEquals( cpWrapper.countViolatedConstraints(Arrays.asList(new Integer[] {0, 0, 2})), 2); - assertTrue( cpWrapper.countViolatedConstraints(Arrays.asList(new Integer[] {2, 0, 2})) == 0); + assertEquals( cpWrapper.countViolatedConstraints(Arrays.asList(new Integer[] {2, 0, 2})), 0); - assertTrue( cpWrapper.countViolatedConstraints(Arrays.asList(new Integer[] {2, 2, 2})) == 1); + assertEquals( cpWrapper.countViolatedConstraints(Arrays.asList(new Integer[] {2, 2, 2})), 1); } @Test @@ -111,12 +111,12 @@ class CPWrapperTest { @Test public void getHeuristicEvaluationTest() { - assertTrue( cpWrapper.getHeuristicEvaluation(Arrays.asList(new Integer[] {2,2,2}), 1) == 2); + assertEquals( cpWrapper.getHeuristicEvaluation(Arrays.asList(new Integer[] {2,2,2}), 1), 2); - assertTrue( cpWrapper.getHeuristicEvaluation(Arrays.asList(new Integer[] {2,2,2}), 0) == 2); + assertEquals( cpWrapper.getHeuristicEvaluation(Arrays.asList(new Integer[] {2,2,2}), 0), 2); - assertTrue( cpWrapper.getHeuristicEvaluation(Arrays.asList(new Integer[] {2,2,2}), 0) == 2); + assertEquals( cpWrapper.getHeuristicEvaluation(Arrays.asList(new Integer[] {2,2,2}), 0), 2); - assertTrue( cpWrapper.getHeuristicEvaluation(Arrays.asList(new Integer[] {5,2,2}), 0) == 0); + assertEquals( cpWrapper.getHeuristicEvaluation(Arrays.asList(new Integer[] {5,2,2}), 0), 0); } } \ No newline at end of file diff --git a/ZPPSolver/CPParser/src/test/java/CPWrapper/Utils/ConstraintGraphTest.java b/ZPPSolver/CPParser/src/test/java/CPWrapper/Utils/ConstraintGraphTest.java index 360d6ed27..1b2801e19 100644 --- a/ZPPSolver/CPParser/src/test/java/CPWrapper/Utils/ConstraintGraphTest.java +++ b/ZPPSolver/CPParser/src/test/java/CPWrapper/Utils/ConstraintGraphTest.java @@ -21,7 +21,7 @@ class ConstraintGraphTest { ConstraintGraph graph = new ConstraintGraph(new ArrayList(), variables); for (int distance = 1; distance < 10; distance ++) { for (String v : variables) { - assertTrue(graph.getNumberOfNeighbours(v, distance) == 0); + assertEquals(graph.getNumberOfNeighbours(v, distance), 0); } } } @@ -40,10 +40,10 @@ class ConstraintGraphTest { ConstraintGraph graph = new ConstraintGraph(constraints, variables); for (int i = 1; i < varsSize/2 - 1; i++) { - assertTrue(graph.getNumberOfNeighbours(variables.get(0), i) == 2); + assertEquals(graph.getNumberOfNeighbours(variables.get(0), i), 2); } for (int i = varsSize/2 + 1; i < 2*varsSize; i++) { - assertTrue(graph.getNumberOfNeighbours(variables.get(0), i) == 0); + assertEquals(graph.getNumberOfNeighbours(variables.get(0), i), 0); } } @@ -55,7 +55,7 @@ class ConstraintGraphTest { constraints.add(constraint); ConstraintGraph graph = new ConstraintGraph(constraints, variables); for (String var : variables) { - assertTrue(graph.getNumberOfNeighbours(var, 1) == varsSize -1); + assertEquals(graph.getNumberOfNeighbours(var, 1), varsSize -1); } } @@ -69,13 +69,13 @@ class ConstraintGraphTest { } ConstraintGraph graph = new ConstraintGraph(constraints, variables); for (String var : variables) { - assertTrue(graph.getNumberOfNeighbours(var, 1) == varsSize -1); + assertEquals(graph.getNumberOfNeighbours(var, 1), varsSize - 1); } for (int dist = 2; dist <= 1000; dist++) { - assertTrue(graph.getNumberOfNeighbours(variables.get(0), dist) == 0); + assertEquals(graph.getNumberOfNeighbours(variables.get(0), dist), 0); } - assertTrue(graph.getConstraints(variables.get(0)).size() == noOfConstraints); + assertEquals(graph.getConstraints(variables.get(0)).size(), noOfConstraints); } @Test @@ -87,8 +87,8 @@ class ConstraintGraphTest { } ConstraintGraph graph = new ConstraintGraph(constraints, variables); for (int i = 0; i < varsSize; i++) { - assertTrue(graph.getNumberOfNeighbours(variables.get(i), 1) == varsSize - 1 ); - assertTrue(graph.getConstraints(variables.get(i)).size() == varsSize - i); + assertEquals(graph.getNumberOfNeighbours(variables.get(i), 1), varsSize - 1 ); + assertEquals(graph.getConstraints(variables.get(i)).size(), varsSize - i); } } diff --git a/ZPPSolver/CPParser/src/test/java/CPWrapper/Utils/ExpressionEvaluatorTest.java b/ZPPSolver/CPParser/src/test/java/CPWrapper/Utils/ExpressionEvaluatorTest.java index 9f97c2c2a..bbfbd4617 100644 --- a/ZPPSolver/CPParser/src/test/java/CPWrapper/Utils/ExpressionEvaluatorTest.java +++ b/ZPPSolver/CPParser/src/test/java/CPWrapper/Utils/ExpressionEvaluatorTest.java @@ -44,7 +44,6 @@ class ExpressionEvaluatorTest { Double[] results = new Double[]{a+b, a-b, a*b, a/b, a==b ? 1.0 : 0.0}; for (int i = 0; i < results.length; i++) { double res = ExpressionEvaluator.evaluateOnOperator(operators[i], args); - System.out.println("Wynik: " + res + " " + i + " should be " + results[i]); assertTrue(Math.abs(res - results[i]) <= ExpressionEvaluator.PRECISION); } } @@ -66,10 +65,10 @@ class ExpressionEvaluatorTest { double a = Math.random(); NumericValueUpperware val = new NumericValueUpperwareImplMockup(a); Constant c = new ConstantImplMockup(BasicTypeEnum.DOUBLE, val); - assertTrue(ExpressionEvaluator.evaluateExpression(c, new HashMap()) == a); + assertEquals(ExpressionEvaluator.evaluateExpression(c, new HashMap()), a); CpMetric m = new CpMetricImplMockup(BasicTypeEnum.DOUBLE, val); - assertTrue(ExpressionEvaluator.evaluateExpression(m, new HashMap()) == a); + assertEquals(ExpressionEvaluator.evaluateExpression(m, new HashMap()), a); } @Test @@ -79,7 +78,7 @@ class ExpressionEvaluatorTest { CpVariable var = new CpVariableImplMockup(name, VariableType.CPU); Map vars = new HashMap<>(); vars.put(name, a); - assertTrue(ExpressionEvaluator.evaluateExpression(var, vars) == a); + assertEquals(ExpressionEvaluator.evaluateExpression(var, vars) , a); } @Test @@ -114,6 +113,6 @@ class ExpressionEvaluatorTest { vars.put(names[0], vals[2]); vars.put(names[1], vals[3]); vars.put(names[2], vals[4]); - assertTrue(ExpressionEvaluator.evaluateExpression(composed, vars) == realValue); + assertEquals(ExpressionEvaluator.evaluateExpression(composed, vars) , realValue); } } \ No newline at end of file diff --git a/ZPPSolver/CPParser/src/test/java/CPWrapper/Utils/HeuristicVariableOrdererTest.java b/ZPPSolver/CPParser/src/test/java/CPWrapper/Utils/HeuristicVariableOrdererTest.java index 1c3277ec1..14f713d0b 100644 --- a/ZPPSolver/CPParser/src/test/java/CPWrapper/Utils/HeuristicVariableOrdererTest.java +++ b/ZPPSolver/CPParser/src/test/java/CPWrapper/Utils/HeuristicVariableOrdererTest.java @@ -58,7 +58,7 @@ class HeuristicVariableOrdererTest { for (int i = 0; i < variables.size(); i++) { vars.add(orderer.indexToVariableName(i)); } - assertTrue(vars.size() == variables.size()); + assertEquals(vars.size(), variables.size()); } @Test -- GitLab From cb674a6cf9dc5ef5b5254e519850dc22209f6612 Mon Sep 17 00:00:00 2001 From: tc360950 Date: Fri, 13 Dec 2019 17:00:28 +0100 Subject: [PATCH 029/340] Removed redundant variables from HeuristicVariableOrdererTest --- .../java/CPWrapper/Utils/HeuristicVariableOrdererTest.java | 6 ++---- 1 file changed, 2 insertions(+), 4 deletions(-) diff --git a/ZPPSolver/CPParser/src/test/java/CPWrapper/Utils/HeuristicVariableOrdererTest.java b/ZPPSolver/CPParser/src/test/java/CPWrapper/Utils/HeuristicVariableOrdererTest.java index 14f713d0b..49e700bb7 100644 --- a/ZPPSolver/CPParser/src/test/java/CPWrapper/Utils/HeuristicVariableOrdererTest.java +++ b/ZPPSolver/CPParser/src/test/java/CPWrapper/Utils/HeuristicVariableOrdererTest.java @@ -22,8 +22,7 @@ class HeuristicVariableOrdererTest { for(int i = 0; i < varsSize; i++) { constraints.add(new ArConstraintMockup(variables.subList(0,i+1))); } - ConstraintGraph graph = new ConstraintGraph(constraints, variables); - return graph; + return new ConstraintGraph(constraints, variables); } private static ConstraintGraph sameNumberOfConstraintsGraph() { @@ -35,8 +34,7 @@ class HeuristicVariableOrdererTest { constraints.add(new ArConstraintMockup(variables.subList(j, j+1))); } } - ConstraintGraph graph = new ConstraintGraph(constraints, variables); - return graph; + return new ConstraintGraph(constraints, variables); } @Test -- GitLab From 6345d0c5bc48255dca287a04dd9b8e4bfe675242 Mon Sep 17 00:00:00 2001 From: tc360950 Date: Fri, 13 Dec 2019 17:06:46 +0100 Subject: [PATCH 030/340] Enhanced map statements --- .../src/main/java/CPWrapper/CPWrapper.java | 1 - .../main/java/CPWrapper/Parser/CPParsedData.java | 15 +++++---------- 2 files changed, 5 insertions(+), 11 deletions(-) diff --git a/ZPPSolver/CPParser/src/main/java/CPWrapper/CPWrapper.java b/ZPPSolver/CPParser/src/main/java/CPWrapper/CPWrapper.java index 562079cc6..faa08c6c7 100644 --- a/ZPPSolver/CPParser/src/main/java/CPWrapper/CPWrapper.java +++ b/ZPPSolver/CPParser/src/main/java/CPWrapper/CPWrapper.java @@ -54,7 +54,6 @@ public class CPWrapper { private Map getAssignmentFromValueList(List assignments) { Map vars = new HashMap<>(); for (int i = 0; i < assignments.size(); i++) { - System.out.println("OK: " + i); vars.put(variableOrderer.indexToVariableName(i), getVariableValueFromDomainIndex(i, assignments.get(i))); } return vars; diff --git a/ZPPSolver/CPParser/src/main/java/CPWrapper/Parser/CPParsedData.java b/ZPPSolver/CPParser/src/main/java/CPWrapper/Parser/CPParsedData.java index 6b93c604c..d03678eda 100644 --- a/ZPPSolver/CPParser/src/main/java/CPWrapper/Parser/CPParsedData.java +++ b/ZPPSolver/CPParser/src/main/java/CPWrapper/Parser/CPParsedData.java @@ -5,10 +5,7 @@ package CPWrapper.Parser; import CPWrapper.Utils.ArConstraint; import CPWrapper.Utils.ConstraintGraph; -import eu.paasage.upperware.metamodel.cp.Constant; -import eu.paasage.upperware.metamodel.cp.CpMetric; -import eu.paasage.upperware.metamodel.cp.CpVariable; -import eu.paasage.upperware.metamodel.cp.Domain; +import eu.paasage.upperware.metamodel.cp.*; import lombok.Getter; import java.util.Collection; @@ -45,11 +42,9 @@ public class CPParsedData { } public int countViolatedConstraints(Map variables) { - int count = - constraints.stream() - .map(c -> c.evaluate(variables) ? 0 : 1) - .reduce( (int) 0, (subtotal, el) -> subtotal + el); - return count; + return constraints.stream() + .map(c -> c.evaluate(variables) ? 0 : 1) + .reduce( 0, Integer::sum); } public int getHeuristicEvaluation(String variable, Map variables) { @@ -74,7 +69,7 @@ public class CPParsedData { private void initializeConstraintGraph() { List variableNames = variables.stream() - .map(var -> var.getId()) + .map(CPElement::getId) .collect(Collectors.toList()); constraintGraph = new ConstraintGraph(constraints, variableNames); } -- GitLab From a1473334a844e75d9b921a5f4453694183b69d07 Mon Sep 17 00:00:00 2001 From: tc360950 Date: Fri, 13 Dec 2019 17:09:09 +0100 Subject: [PATCH 031/340] Removed redundant public method identifiers in interfaces. Changed protected methods to default --- .../src/main/java/CPWrapper/Parser/CPParsedData.java | 8 ++++---- .../src/main/java/CPWrapper/Utils/ArConstraint.java | 4 ++-- .../main/java/CPWrapper/Utils/ExpressionEvaluator.java | 10 +++++----- 3 files changed, 11 insertions(+), 11 deletions(-) diff --git a/ZPPSolver/CPParser/src/main/java/CPWrapper/Parser/CPParsedData.java b/ZPPSolver/CPParser/src/main/java/CPWrapper/Parser/CPParsedData.java index d03678eda..f30d1cab3 100644 --- a/ZPPSolver/CPParser/src/main/java/CPWrapper/Parser/CPParsedData.java +++ b/ZPPSolver/CPParser/src/main/java/CPWrapper/Parser/CPParsedData.java @@ -74,16 +74,16 @@ public class CPParsedData { constraintGraph = new ConstraintGraph(constraints, variableNames); } - protected void postConstants(Collection constants) { + void postConstants(Collection constants) { this.constants = constants; } - protected void postMetrics(Collection metrics) { + void postMetrics(Collection metrics) { this.metrics = metrics; } - protected void postConstraints(Collection constraints) { + void postConstraints(Collection constraints) { this.constraints = constraints; } - protected void postVariables(Collection variables) { + void postVariables(Collection variables) { this.variables = variables; } } diff --git a/ZPPSolver/CPParser/src/main/java/CPWrapper/Utils/ArConstraint.java b/ZPPSolver/CPParser/src/main/java/CPWrapper/Utils/ArConstraint.java index eb2600b13..b5c9bd35d 100644 --- a/ZPPSolver/CPParser/src/main/java/CPWrapper/Utils/ArConstraint.java +++ b/ZPPSolver/CPParser/src/main/java/CPWrapper/Utils/ArConstraint.java @@ -5,7 +5,7 @@ import java.util.Map; public interface ArConstraint { - public Collection getVariableNames(); + Collection getVariableNames(); - public boolean evaluate(Map variables); + boolean evaluate(Map variables); } diff --git a/ZPPSolver/CPParser/src/main/java/CPWrapper/Utils/ExpressionEvaluator.java b/ZPPSolver/CPParser/src/main/java/CPWrapper/Utils/ExpressionEvaluator.java index 3acb5d4ca..12dde9d9d 100644 --- a/ZPPSolver/CPParser/src/main/java/CPWrapper/Utils/ExpressionEvaluator.java +++ b/ZPPSolver/CPParser/src/main/java/CPWrapper/Utils/ExpressionEvaluator.java @@ -19,7 +19,7 @@ public class ExpressionEvaluator { */ public static final double PRECISION = 0.1; - protected static double getValueOfNumericInterface(NumericValueUpperware value) { + static double getValueOfNumericInterface(NumericValueUpperware value) { if (value instanceof IntegerValueUpperware) { return (double)((IntegerValueUpperware) value).getValue(); } else if (value instanceof LongValueUpperware) { @@ -102,19 +102,19 @@ public class ExpressionEvaluator { throw new RuntimeException("Unsupported comparator type"); } - protected static boolean isConstant(Expression expression){ + static boolean isConstant(Expression expression){ return expression instanceof Constant; } - protected static boolean isCpVariable(Expression expression){ + static boolean isCpVariable(Expression expression){ return expression instanceof CpVariable; } - protected static boolean isCpMetric(Expression expression){ + static boolean isCpMetric(Expression expression){ return expression instanceof CpMetric; } - protected static boolean isComposedExpression(Expression expression){ + static boolean isComposedExpression(Expression expression){ return expression instanceof ComposedExpression; } } -- GitLab From dd8c16038bd444fc0ff4761c3d16458b891beae1 Mon Sep 17 00:00:00 2001 From: tc360950 Date: Fri, 13 Dec 2019 17:13:05 +0100 Subject: [PATCH 032/340] Fixes in stream processing for ExpressionEvalator, ArConstraintImpl --- .../src/main/java/CPWrapper/Utils/ArConstraintImpl.java | 6 +----- .../src/main/java/CPWrapper/Utils/ExpressionEvaluator.java | 2 +- 2 files changed, 2 insertions(+), 6 deletions(-) diff --git a/ZPPSolver/CPParser/src/main/java/CPWrapper/Utils/ArConstraintImpl.java b/ZPPSolver/CPParser/src/main/java/CPWrapper/Utils/ArConstraintImpl.java index e3f396cc9..b4ea3db02 100644 --- a/ZPPSolver/CPParser/src/main/java/CPWrapper/Utils/ArConstraintImpl.java +++ b/ZPPSolver/CPParser/src/main/java/CPWrapper/Utils/ArConstraintImpl.java @@ -35,11 +35,7 @@ public class ArConstraintImpl implements ArConstraint { variablesNames.add(name); } } else if (ExpressionEvaluator.isComposedExpression(exp)) { - ((ComposedExpression) exp).getExpressions() - .stream() - .forEach( e -> { - this.collectVariableNamesFromExpression(e); - }); + ((ComposedExpression) exp).getExpressions().forEach(this::collectVariableNamesFromExpression); } } diff --git a/ZPPSolver/CPParser/src/main/java/CPWrapper/Utils/ExpressionEvaluator.java b/ZPPSolver/CPParser/src/main/java/CPWrapper/Utils/ExpressionEvaluator.java index 12dde9d9d..b918cad98 100644 --- a/ZPPSolver/CPParser/src/main/java/CPWrapper/Utils/ExpressionEvaluator.java +++ b/ZPPSolver/CPParser/src/main/java/CPWrapper/Utils/ExpressionEvaluator.java @@ -44,7 +44,7 @@ public class ExpressionEvaluator { switch (oper) { case PLUS: return values.stream() - .reduce((double) 0, (subtotal, element) -> subtotal + element); + .reduce((double) 0, Double::sum); case MINUS: return values.get(0) - values.get(1); case TIMES: -- GitLab From 7a78c7ed85d720d34a6d4e7f38a9b233ee1186b7 Mon Sep 17 00:00:00 2001 From: tc360950 Date: Fri, 13 Dec 2019 17:19:08 +0100 Subject: [PATCH 033/340] Refactoring in HeuristicVariableOrderer --- .../CPWrapper/Utils/HeuristicVariableOrderer.java | 14 +++----------- .../Utils/HeuristicVariableOrdererTest.java | 3 +-- 2 files changed, 4 insertions(+), 13 deletions(-) diff --git a/ZPPSolver/CPParser/src/main/java/CPWrapper/Utils/HeuristicVariableOrderer.java b/ZPPSolver/CPParser/src/main/java/CPWrapper/Utils/HeuristicVariableOrderer.java index 1adac10dd..aa422f5a1 100644 --- a/ZPPSolver/CPParser/src/main/java/CPWrapper/Utils/HeuristicVariableOrderer.java +++ b/ZPPSolver/CPParser/src/main/java/CPWrapper/Utils/HeuristicVariableOrderer.java @@ -40,18 +40,10 @@ public class HeuristicVariableOrderer implements VariableOrderer { nameToValue.entrySet().stream() .sorted(Collections.reverseOrder(Map.Entry.comparingByValue( (p1, p2) -> { - if (p1.getValue0() < p2.getValue0()) { - return -1; - } else if (p1.getValue0() == p2.getValue0()) { - if (p1.getValue1() < p2.getValue1()) { - return -1; - } else if (p1.getValue1() == p2.getValue1()) { - return 0; - } else { - return 1; - } + if (p1.getValue0().equals(p2.getValue0())) { + return p1.getValue1().compareTo(p2.getValue1()); } else { - return 1; + return p1.getValue0().compareTo(p2.getValue0()); } } ))); diff --git a/ZPPSolver/CPParser/src/test/java/CPWrapper/Utils/HeuristicVariableOrdererTest.java b/ZPPSolver/CPParser/src/test/java/CPWrapper/Utils/HeuristicVariableOrdererTest.java index 49e700bb7..3a33bde17 100644 --- a/ZPPSolver/CPParser/src/test/java/CPWrapper/Utils/HeuristicVariableOrdererTest.java +++ b/ZPPSolver/CPParser/src/test/java/CPWrapper/Utils/HeuristicVariableOrdererTest.java @@ -12,8 +12,7 @@ class HeuristicVariableOrdererTest { @BeforeAll static void setUp() { - String[] vars = new String[]{"var1", "var2", "var3", "var4", "var5", "var6", "var7", "var8"}; - variables = Arrays.asList(vars); + variables = Arrays.asList("var1", "var2", "var3", "var4", "var5", "var6", "var7", "var8"); } private static ConstraintGraph createExpandingGraph() { -- GitLab From eba717c029247ead35f0ba6cc4f5b1f912587f80 Mon Sep 17 00:00:00 2001 From: tc360950 Date: Fri, 13 Dec 2019 17:26:15 +0100 Subject: [PATCH 034/340] Changed ExpressionEvaluator's evaluateExpression method access modifier to protected --- .../main/java/CPWrapper/Utils/ArConstraintImpl.java | 4 +--- .../java/CPWrapper/Utils/ExpressionEvaluator.java | 12 +++++++++--- 2 files changed, 10 insertions(+), 6 deletions(-) diff --git a/ZPPSolver/CPParser/src/main/java/CPWrapper/Utils/ArConstraintImpl.java b/ZPPSolver/CPParser/src/main/java/CPWrapper/Utils/ArConstraintImpl.java index b4ea3db02..fe4b6ecb2 100644 --- a/ZPPSolver/CPParser/src/main/java/CPWrapper/Utils/ArConstraintImpl.java +++ b/ZPPSolver/CPParser/src/main/java/CPWrapper/Utils/ArConstraintImpl.java @@ -48,9 +48,7 @@ public class ArConstraintImpl implements ArConstraint { if (!checkVariables(variables.keySet())) { throw new RuntimeException("Can't evaluate - some variables are missing"); } - double leftExpValue = ExpressionEvaluator.evaluateExpression(leftExpression, variables); - double rightExpValue = ExpressionEvaluator.evaluateExpression(rightExpression, variables); - return ExpressionEvaluator.evaluateComparator(comparator, leftExpValue, rightExpValue); + return ExpressionEvaluator.evaluateComparator(comparator, leftExpression, rightExpression, variables); } @Override diff --git a/ZPPSolver/CPParser/src/main/java/CPWrapper/Utils/ExpressionEvaluator.java b/ZPPSolver/CPParser/src/main/java/CPWrapper/Utils/ExpressionEvaluator.java index b918cad98..a224dcab3 100644 --- a/ZPPSolver/CPParser/src/main/java/CPWrapper/Utils/ExpressionEvaluator.java +++ b/ZPPSolver/CPParser/src/main/java/CPWrapper/Utils/ExpressionEvaluator.java @@ -36,7 +36,7 @@ public class ExpressionEvaluator { return (oper == OperatorEnum.MINUS || oper == OperatorEnum.DIV || oper == OperatorEnum.EQ); } - public static double evaluateOnOperator(OperatorEnum oper, List values) { + static double evaluateOnOperator(OperatorEnum oper, List values) { if (isTwoArgsOperator(oper) && values.size() != 2) { throw new RuntimeException("MINUS, DIV, EQ operators must be evaluated on exactly two arguments"); } @@ -71,7 +71,7 @@ public class ExpressionEvaluator { return evaluateOnOperator(exp.getOperator(), expressionsValues); } - public static double evaluateExpression(Expression exp, Map variables) { + static double evaluateExpression(Expression exp, Map variables) { if (isConstant(exp)) { return getValueOfNumericInterface(((Constant) exp).getValue()); } else if (isCpMetric(exp)) { @@ -84,7 +84,13 @@ public class ExpressionEvaluator { throw new RuntimeException("Unsupported Expression type"); } - public static boolean evaluateComparator(ComparatorEnum comparator, double argLeft, double argRight) { + public static boolean evaluateComparator(ComparatorEnum comparator, Expression leftExp, Expression rightExp, Map variables) { + double leftExpValue = evaluateExpression(leftExp, variables); + double rightExpValue = evaluateExpression(rightExp, variables); + return evaluateComparator(comparator, leftExpValue, rightExpValue); + } + + static boolean evaluateComparator(ComparatorEnum comparator, double argLeft, double argRight) { switch (comparator) { case GREATER_THAN: return argLeft > argRight; -- GitLab From d676e24f1cdb631fcb7b3c758e75743b94543fb0 Mon Sep 17 00:00:00 2001 From: tc360950 Date: Sat, 14 Dec 2019 18:30:47 +0100 Subject: [PATCH 035/340] Changed assertTre to assrtEquals where applicable --- ZPPSolver/PTSolver/src/main/java/CPComponents/PTMover.java | 3 +++ .../PTSolver/src/main/java/CPComponents/PTObjective.java | 3 +++ .../PTSolver/src/test/java/CPComponents/PTMoverTest.java | 4 ++-- .../src/test/java/CPComponents/PTNeighbourhoodTest.java | 6 +++--- 4 files changed, 11 insertions(+), 5 deletions(-) diff --git a/ZPPSolver/PTSolver/src/main/java/CPComponents/PTMover.java b/ZPPSolver/PTSolver/src/main/java/CPComponents/PTMover.java index 94b408812..827cd89fb 100644 --- a/ZPPSolver/PTSolver/src/main/java/CPComponents/PTMover.java +++ b/ZPPSolver/PTSolver/src/main/java/CPComponents/PTMover.java @@ -37,6 +37,9 @@ public class PTMover implements Move { } } + /* + Here we may assume that the move is possible + */ @Override public void undo(PTSolution cpSolution) { if (move.values().contains(MOVE_DIRECTION.DOWN)) { diff --git a/ZPPSolver/PTSolver/src/main/java/CPComponents/PTObjective.java b/ZPPSolver/PTSolver/src/main/java/CPComponents/PTObjective.java index a49f23d04..e6be77a20 100644 --- a/ZPPSolver/PTSolver/src/main/java/CPComponents/PTObjective.java +++ b/ZPPSolver/PTSolver/src/main/java/CPComponents/PTObjective.java @@ -10,6 +10,9 @@ public class PTObjective implements Objective { return ptcpWrapper.evaluate(cpSolution.getVarAssignments()); } + /* + True if are goal is to minimize the objective + */ @Override public boolean isMinimizing() { return false; diff --git a/ZPPSolver/PTSolver/src/test/java/CPComponents/PTMoverTest.java b/ZPPSolver/PTSolver/src/test/java/CPComponents/PTMoverTest.java index bcf7a6638..fb590790e 100644 --- a/ZPPSolver/PTSolver/src/test/java/CPComponents/PTMoverTest.java +++ b/ZPPSolver/PTSolver/src/test/java/CPComponents/PTMoverTest.java @@ -18,13 +18,13 @@ class PTMoverTest { for (int i = 0; i < assignments.size() ; i++) { PTMover m = PTMover.newUpMove(i); m.apply(solution); - assertTrue( solution.getVarAssignments().get(i) == assignments.get(i) + 1); + assertEquals( (int) solution.getVarAssignments().get(i), assignments.get(i).intValue() + 1); } for (int i = 0; i < assignments.size() ; i++) { PTMover m = PTMover.newDownMove(i); m.apply(solution); - assertTrue( solution.getVarAssignments().get(i) == assignments.get(i)); + assertEquals( solution.getVarAssignments().get(i), assignments.get(i)); } } diff --git a/ZPPSolver/PTSolver/src/test/java/CPComponents/PTNeighbourhoodTest.java b/ZPPSolver/PTSolver/src/test/java/CPComponents/PTNeighbourhoodTest.java index 8acd41f0f..cf9cc0486 100644 --- a/ZPPSolver/PTSolver/src/test/java/CPComponents/PTNeighbourhoodTest.java +++ b/ZPPSolver/PTSolver/src/test/java/CPComponents/PTNeighbourhoodTest.java @@ -18,15 +18,15 @@ class PTNeighbourhoodTest { PTSolution.minVariableValues = minValues; PTNeighbourhood neighbourhood = new PTNeighbourhood(); PTSolution sol = new PTSolution(assignments); - assertTrue( neighbourhood.getAllMoves(sol).size() == 0); + assertEquals( neighbourhood.getAllMoves(sol).size(), 0); maxValues = Arrays.asList(new Integer[] {10,20,30,40,50}); PTSolution.maxVariableValues= maxValues; - assertTrue( neighbourhood.getAllMoves(sol).size() == assignments.size()); + assertEquals( neighbourhood.getAllMoves(sol).size(), assignments.size()); minValues = Arrays.asList(new Integer[] {1,0,0,0,0}); PTSolution.minVariableValues = minValues; - assertTrue( neighbourhood.getAllMoves(sol).size() == 2 * assignments.size() - 1); + assertEquals( neighbourhood.getAllMoves(sol).size(), 2 * assignments.size() - 1); } } \ No newline at end of file -- GitLab From aaf0d35a7fc83dd4df6ff74a0f3fda604c7e91d0 Mon Sep 17 00:00:00 2001 From: ipatini Date: Sun, 15 Dec 2019 12:55:52 +0200 Subject: [PATCH 036/340] Penalty Calculator - Bugfix in PenaltyTests. Added two test configurations --- .../penaltycalculator/PenaltyTests.java | 2 +- penalty-calculator/test1.json | 246 ++++++++++++++++++ penalty-calculator/test2.json | 164 ++++++++++++ 3 files changed, 411 insertions(+), 1 deletion(-) create mode 100644 penalty-calculator/test1.json create mode 100644 penalty-calculator/test2.json diff --git a/penalty-calculator/src/main/java/eu/melodic/upperware/penaltycalculator/PenaltyTests.java b/penalty-calculator/src/main/java/eu/melodic/upperware/penaltycalculator/PenaltyTests.java index 8c887fa01..666f41feb 100644 --- a/penalty-calculator/src/main/java/eu/melodic/upperware/penaltycalculator/PenaltyTests.java +++ b/penalty-calculator/src/main/java/eu/melodic/upperware/penaltycalculator/PenaltyTests.java @@ -49,7 +49,7 @@ public class PenaltyTests implements CommandLineRunner { Collection collection_1 = readConfigElementsFromFile(args[0]); log.info("Collection-1:\n{}", PenaltyFunction.toString(collection_1)); - Collection collection_2 = readConfigElementsFromFile(args[0]); + Collection collection_2 = readConfigElementsFromFile(args[1]); log.info("Collection-2:\n{}", PenaltyFunction.toString(collection_2)); PenaltyFunctionResult penaltyResults = penaltyCalculator.evaluatePenaltyFunction(collection_1, collection_2); diff --git a/penalty-calculator/test1.json b/penalty-calculator/test1.json new file mode 100644 index 000000000..7afa1bb59 --- /dev/null +++ b/penalty-calculator/test1.json @@ -0,0 +1,246 @@ +[ + { + "id": "CE1", + "nodeCandidate": { + "price": 5, + "cloud": { + "endpoint": "https://endpoint.example.com", + "cloudType": "PRIVATE", + "api": { + "providerName": "openstack-nova" + }, + "credential": { + "user": "tenant:username", + "secret": "MySuperSecurePassword" + }, + "cloudConfiguration": { + "nodeGroup": "cloudiator", + "properties": [] + }, + "id": "1a79a4d60de6718e8e5b326e338ae533" + }, + "image": { + "id": "1a79a4d60de6718e8e5b326e338ae573/RegionOne/1", + "name": "Ubuntu 16.04 LTS AMD 64", + "providerId": "1", + "operatingSystem": { + "operatingSystemType": "LINUX", + "operatingSystemFamily": "UBUNTU", + "operatingSystemArchitecture": "AMD64", + "operatingSystemVersion": "16.04" + }, + "location": { + "id": "1a79a4d60de6718e8e5b326e338ae533/RegionOne", + "name": "RegionOne", + "providerId": "RegionOne", + "locationScope": "ZONE", + "isAssignable": true, + "geoLocation": { + "city": "string", + "country": "string", + "latitude": 0, + "longitude": 0 + } + } + }, + "hardware": { + "id": "1a79a4d60de6718e8e5b326e338ae593/RegionOne/1", + "name": "t1.micro", + "providerId": "1", + "cores": 1, + "ram": 1024, + "disk": 100, + "location": { + "id": "1a79a4d60de6718e8e5b326e338ae593/RegionOne", + "name": "RegionOne", + "providerId": "RegionOne", + "locationScope": "ZONE", + "isAssignable": true, + "geoLocation": { + "city": "string", + "country": "string", + "latitude": 0, + "longitude": 0 + } + } + }, + "location": { + "id": "1a79a4d60de6718e8e5b326e338ae533/RegionOne", + "name": "RegionOne", + "providerId": "RegionOne", + "locationScope": "ZONE", + "isAssignable": true, + "geoLocation": { + "city": "string", + "country": "string", + "latitude": 0, + "longitude": 0 + } + } + }, + "cardinality": 2 + }, + { + "id": "CE2", + "nodeCandidate": { + "price": 10, + "cloud": { + "endpoint": "https://endpoint.example.com", + "cloudType": "PRIVATE", + "api": { + "providerName": "openstack-nova" + }, + "credential": { + "user": "tenant:username", + "secret": "MySuperSecurePassword" + }, + "cloudConfiguration": { + "nodeGroup": "cloudiator", + "properties": [] + }, + "id": "1a79a4d60de6718e8e5b326e338ae533" + }, + "image": { + "id": "1a79a4d60de6718e8e5b326e338ae533/RegionOne/1", + "name": "Ubuntu 16.04 LTS AMD 64", + "providerId": "1", + "operatingSystem": { + "operatingSystemType": "LINUX", + "operatingSystemFamily": "UBUNTU", + "operatingSystemArchitecture": "AMD64", + "operatingSystemVersion": "16.04" + }, + "location": { + "id": "1a79a4d60de6718e8e5b326e338ae533/RegionOne", + "name": "RegionOne", + "providerId": "RegionOne", + "locationScope": "ZONE", + "isAssignable": true, + "geoLocation": { + "city": "string", + "country": "string", + "latitude": 0, + "longitude": 0 + } + } + }, + "hardware": { + "id": "1a79a4d60de6718e8e5b326e338be533/RegionOne/1", + "name": "t1.medium", + "providerId": "2", + "cores": 2, + "ram": 4096, + "disk": 100, + "location": { + "id": "1a79a4d60de6718e8e5b326e338be533/RegionOne", + "name": "RegionOne", + "providerId": "RegionOne", + "locationScope": "ZONE", + "isAssignable": true, + "geoLocation": { + "city": "string", + "country": "string", + "latitude": 0, + "longitude": 0 + } + } + }, + "location": { + "id": "1a79a4d60de6718e8e5b326e338be533/RegionOne", + "name": "RegionOne", + "providerId": "RegionOne", + "locationScope": "ZONE", + "isAssignable": true, + "geoLocation": { + "city": "string", + "country": "string", + "latitude": 0, + "longitude": 0 + } + } + }, + "cardinality": 5 + }, + + { + "id": "CE3", + "nodeCandidate": { + "price": 10, + "cloud": { + "endpoint": "https://endpoint.example.com", + "cloudType": "PRIVATE", + "api": { + "providerName": "openstack-nova" + }, + "credential": { + "user": "tenant:username", + "secret": "MySuperSecurePassword" + }, + "cloudConfiguration": { + "nodeGroup": "cloudiator", + "properties": [] + }, + "id": "1a79a4d60de6718e8e5b326e338ae533" + }, + "image": { + "id": "1a79a4d60de6718e8e5b326e338ae533/RegionOne/1", + "name": "Ubuntu 16.04 LTS AMD 64", + "providerId": "1", + "operatingSystem": { + "operatingSystemType": "LINUX", + "operatingSystemFamily": "UBUNTU", + "operatingSystemArchitecture": "AMD64", + "operatingSystemVersion": "16.04" + }, + "location": { + "id": "1a79a4d60de6718e8e5b326e338ae533/RegionOne", + "name": "RegionOne", + "providerId": "RegionOne", + "locationScope": "ZONE", + "isAssignable": true, + "geoLocation": { + "city": "string", + "country": "string", + "latitude": 0, + "longitude": 0 + } + } + }, + "hardware": { + "id": "1a79a4d60de6718e8e5b326e338ae533/RegionOne/1", + "name": "t1.medium", + "providerId": "2", + "cores": 3, + "ram": 4096, + "disk": 100, + "location": { + "id": "1a79a4d60de6718e8e5b326e338ae533/RegionOne", + "name": "RegionOne", + "providerId": "RegionOne", + "locationScope": "ZONE", + "isAssignable": true, + "geoLocation": { + "city": "string", + "country": "string", + "latitude": 0, + "longitude": 0 + } + } + }, + "location": { + "id": "1a79a4d60de6718e8e5b326e338ae533/RegionOne", + "name": "RegionOne", + "providerId": "RegionOne", + "locationScope": "ZONE", + "isAssignable": true, + "geoLocation": { + "city": "string", + "country": "string", + "latitude": 0, + "longitude": 0 + } + } + }, + "cardinality": 5 + } +] \ No newline at end of file diff --git a/penalty-calculator/test2.json b/penalty-calculator/test2.json new file mode 100644 index 000000000..cb261722d --- /dev/null +++ b/penalty-calculator/test2.json @@ -0,0 +1,164 @@ +[ + { + "id": "CE1", + "nodeCandidate": { + "price": 5, + "cloud": { + "endpoint": "https://endpoint.example.com", + "cloudType": "PRIVATE", + "api": { + "providerName": "openstack-nova" + }, + "credential": { + "user": "tenant:username", + "secret": "MySuperSecurePassword" + }, + "cloudConfiguration": { + "nodeGroup": "cloudiator", + "properties": [] + }, + "id": "1a79a4d60de6718e8e5b326e338ae533" + }, + "image": { + "id": "1a79a4d60de6718e8e5b326e338ae533/RegionOne/1", + "name": "Ubuntu 16.04 LTS AMD 64", + "providerId": "1", + "operatingSystem": { + "operatingSystemType": "LINUX", + "operatingSystemFamily": "UBUNTU", + "operatingSystemArchitecture": "AMD64", + "operatingSystemVersion": "16.04" + }, + "location": { + "id": "1a79a4d60de6718e8e5b326e338ae533/RegionOne", + "name": "RegionOne", + "providerId": "RegionOne", + "locationScope": "ZONE", + "isAssignable": true, + "geoLocation": { + "city": "string", + "country": "string", + "latitude": 0, + "longitude": 0 + } + } + }, + "hardware": { + "id": "1a79a4d60de6718e8e5b326e338ae533/RegionOne/1", + "name": "t1.microxxx", + "providerId": "1", + "cores": 1, + "ram": 1, + "disk": 100, + "location": { + "id": "1a79a4d60de6718e8e5b326e338ae533/RegionOne", + "name": "RegionOne", + "providerId": "RegionOne", + "locationScope": "ZONE", + "isAssignable": true, + "geoLocation": { + "city": "string", + "country": "string", + "latitude": 0, + "longitude": 0 + } + } + }, + "location": { + "id": "1a79a4d60de6718e8e5b326e338ae533/RegionOne", + "name": "RegionOne", + "providerId": "RegionOne", + "locationScope": "ZONE", + "isAssignable": true, + "geoLocation": { + "city": "string", + "country": "string", + "latitude": 0, + "longitude": 0 + } + } + }, + "cardinality": 2 + }, + { + "id": "CE2", + "nodeCandidate": { + "price": 15, + "cloud": { + "endpoint": "https://endpoint.example.com", + "cloudType": "PRIVATE", + "api": { + "providerName": "openstack-nova" + }, + "credential": { + "user": "tenant:username", + "secret": "MySuperSecurePassword" + }, + "cloudConfiguration": { + "nodeGroup": "cloudiator", + "properties": [] + }, + "id": "1a79a4d60de6718e8e5b326e338ae533" + }, + "image": { + "id": "1a79a4d60de6718e8e5b326e338ae533/RegionOne/1", + "name": "Ubuntu 16.04 LTS AMD 64", + "providerId": "1", + "operatingSystem": { + "operatingSystemType": "LINUX", + "operatingSystemFamily": "UBUNTU", + "operatingSystemArchitecture": "AMD64", + "operatingSystemVersion": "16.04" + }, + "location": { + "id": "1a79a4d60de6718e8e5b326e338ae533/RegionOne", + "name": "RegionOne", + "providerId": "RegionOne", + "locationScope": "ZONE", + "isAssignable": true, + "geoLocation": { + "city": "string", + "country": "string", + "latitude": 0, + "longitude": 0 + } + } + }, + "hardware": { + "id": "1a79a4d60de6718e8e5b326e338ae533/RegionOne/1", + "name": "t1.large", + "providerId": "3", + "cores": 2, + "ram": 8192, + "disk": 100, + "location": { + "id": "1a79a4d60de6718e8e5b326e338ae533/RegionOne", + "name": "RegionOne", + "providerId": "RegionOne", + "locationScope": "ZONE", + "isAssignable": true, + "geoLocation": { + "city": "string", + "country": "string", + "latitude": 0, + "longitude": 0 + } + } + }, + "location": { + "id": "1a79a4d60de6718e8e5b326e338ae533/RegionOne", + "name": "RegionOne", + "providerId": "RegionOne", + "locationScope": "ZONE", + "isAssignable": true, + "geoLocation": { + "city": "string", + "country": "string", + "latitude": 0, + "longitude": 0 + } + } + }, + "cardinality": 6 + } +] \ No newline at end of file -- GitLab From 12a49ebe57ecd78827646986f5d595a812c36718 Mon Sep 17 00:00:00 2001 From: ipatini Date: Sun, 15 Dec 2019 14:17:13 +0200 Subject: [PATCH 037/340] Penalty Calculator - Added query results processing --- .../penaltycalculator/PenaltyFunction.java | 44 +++++++++++++++++-- 1 file changed, 40 insertions(+), 4 deletions(-) diff --git a/penalty-calculator/src/main/java/eu/melodic/upperware/penaltycalculator/PenaltyFunction.java b/penalty-calculator/src/main/java/eu/melodic/upperware/penaltycalculator/PenaltyFunction.java index e36c6c35f..d54dc63ae 100644 --- a/penalty-calculator/src/main/java/eu/melodic/upperware/penaltycalculator/PenaltyFunction.java +++ b/penalty-calculator/src/main/java/eu/melodic/upperware/penaltycalculator/PenaltyFunction.java @@ -25,6 +25,7 @@ import org.influxdb.impl.InfluxDBMapper; import org.springframework.beans.factory.annotation.Autowired; import org.springframework.stereotype.Service; +import java.time.Instant; import java.util.*; import java.util.concurrent.TimeUnit; import java.util.stream.Collectors; @@ -182,15 +183,50 @@ public class PenaltyFunction { //Query query1 = new Query("SELECT timeDepl FROM ComponentTime", dbName); log.info("INFLUX point D - InfluxDB Mapper initialized"); - Query query1 = new Query("SELECT mean(\"value\") AS \"mean_value\" FROM \"cloudiator\".\"autogen\".\"process-start-time\" WHERE \"task\"='database' GROUP BY time(5s) FILL(null)", dbName); + /*//Query query1 = new Query("SELECT mean(\"value\") AS \"mean_value\" FROM \"cloudiator\".\"autogen\".\"process-start-time\" WHERE \"task\"='database' GROUP BY time(5s) FILL(null)", dbName); + Query query1 = new Query("SELECT \"time\" AS \"time\", \"task\" AS \"ComponentName\", \"value\" AS \"timeDepl\" FROM \"cloudiator\".\"autogen\".\"process-start-time\" WHERE \"task\"='database'", dbName); //Logger.info("Executing query "+query1.getCommand()); List ComponMeasurements = influxDBMapper.query(query1, ComponMeasurement.class); log.info("INFLUX point E - Query ok: size={}", ComponMeasurements.size()); - ComponMeasurements.forEach(r -> log.info(" - {}", r)); - + ComponMeasurements.forEach(r -> log.info(" - {}", r));*/ + + Query query1 = new Query("SELECT \"time\" AS \"time\", \"task\" AS \"ComponentName\", \"value\" AS \"timeDepl\" FROM \"cloudiator\".\"autogen\".\"process-start-time\" WHERE \"task\"='database'", dbName); + QueryResult queryResult1 = influxDB.query(query1); + //log.info("INFLUX point E-2 - Results: {}", queryResult1); + List listComponMeasurements = new ArrayList<>(); + queryResult1.getResults().forEach(result -> { + log.info(">>>>>>>>>>> result: {}", result.toString()); + result.getSeries().forEach(series -> { + String name = series.getName(); + Class clazz = series.getClass(); + log.info("################# series: name={}, class={}", name, clazz); + List columns = series.getColumns(); + log.info("################# series: cols={}", columns); + //Map tags = series.getTags(); + //log.info("################# series: tags={}", tags); + List> values = series.getValues(); + //log.info("################# values: {}", values); + + values.forEach(row -> { + for (int i=0; i {} = {} / {}", columns.get(i), row.get(i), row.get(i).getClass()); + + eu.melodic.upperware.penaltycalculator.ComponMeasurement cm; + cm = new eu.melodic.upperware.penaltycalculator.ComponMeasurement(); + cm.setTime(Instant.parse(row.get(0).toString())); + cm.setComponentName(row.get(1).toString()); + cm.timeDepl(Double.parseDouble(row.get(2).toString())); + + listComponMeasurements.add(cm); + } + }); + }); + }); + log.info("@@@@@@@@@@@@@@@@@@@@@@@@@>>>> listComponMeasurements: {}", listComponMeasurements); log.info("INFLUX point F - Query results listed"); - String arr = ComponMeasurements.toString(); + //String arr = ComponMeasurements.toString(); + String arr = listComponMeasurements.toString(); log.info("INFLUX point G - arr: {}", arr); //String arr = null; -- GitLab From 40aef9dfe00952ad3044ec6421df606379399cf9 Mon Sep 17 00:00:00 2001 From: ipatini Date: Sun, 15 Dec 2019 14:25:20 +0200 Subject: [PATCH 038/340] Penalty Calculator - Improved ComponMeasurement extraction from query results --- .../penaltycalculator/ComponMeasurement.java | 8 +-- .../penaltycalculator/PenaltyFunction.java | 49 ++++++++----------- 2 files changed, 26 insertions(+), 31 deletions(-) diff --git a/penalty-calculator/src/main/java/eu/melodic/upperware/penaltycalculator/ComponMeasurement.java b/penalty-calculator/src/main/java/eu/melodic/upperware/penaltycalculator/ComponMeasurement.java index 0738bc83f..9f1eb3236 100644 --- a/penalty-calculator/src/main/java/eu/melodic/upperware/penaltycalculator/ComponMeasurement.java +++ b/penalty-calculator/src/main/java/eu/melodic/upperware/penaltycalculator/ComponMeasurement.java @@ -9,12 +9,14 @@ package eu.melodic.upperware.penaltycalculator; +import lombok.Data; import org.influxdb.annotation.Column; import org.influxdb.annotation.Measurement; import java.time.Instant; import java.util.concurrent.TimeUnit; - + +@Data @Measurement(name = "ComponentTime", timeUnit = TimeUnit.SECONDS) public class ComponMeasurement { @@ -27,7 +29,7 @@ public class ComponMeasurement { @Column(name = "timeDepl") private double timeDepl; - public Instant getTime() { + /*public Instant getTime() { return time; } @@ -51,5 +53,5 @@ public class ComponMeasurement { this.timeDepl = timeDepl; } - public String toString() { return timeDepl+""; } + public String toString() { return timeDepl+""; }*/ } \ No newline at end of file diff --git a/penalty-calculator/src/main/java/eu/melodic/upperware/penaltycalculator/PenaltyFunction.java b/penalty-calculator/src/main/java/eu/melodic/upperware/penaltycalculator/PenaltyFunction.java index d54dc63ae..1039ecc53 100644 --- a/penalty-calculator/src/main/java/eu/melodic/upperware/penaltycalculator/PenaltyFunction.java +++ b/penalty-calculator/src/main/java/eu/melodic/upperware/penaltycalculator/PenaltyFunction.java @@ -194,35 +194,28 @@ public class PenaltyFunction { QueryResult queryResult1 = influxDB.query(query1); //log.info("INFLUX point E-2 - Results: {}", queryResult1); List listComponMeasurements = new ArrayList<>(); - queryResult1.getResults().forEach(result -> { - log.info(">>>>>>>>>>> result: {}", result.toString()); - result.getSeries().forEach(series -> { - String name = series.getName(); - Class clazz = series.getClass(); - log.info("################# series: name={}, class={}", name, clazz); - List columns = series.getColumns(); - log.info("################# series: cols={}", columns); - //Map tags = series.getTags(); - //log.info("################# series: tags={}", tags); - List> values = series.getValues(); - //log.info("################# values: {}", values); - - values.forEach(row -> { - for (int i=0; i {} = {} / {}", columns.get(i), row.get(i), row.get(i).getClass()); - - eu.melodic.upperware.penaltycalculator.ComponMeasurement cm; - cm = new eu.melodic.upperware.penaltycalculator.ComponMeasurement(); - cm.setTime(Instant.parse(row.get(0).toString())); - cm.setComponentName(row.get(1).toString()); - cm.timeDepl(Double.parseDouble(row.get(2).toString())); - - listComponMeasurements.add(cm); - } - }); - }); + QueryResult.Series series = queryResult1.getResults().get(0).getSeries().get(0); + String seriesName = series.getName(); + List seriesColumns = series.getColumns(); + log.info("################# series: name={}, columns={}", seriesName, seriesColumns); + List> seriesValues = series.getValues(); + //log.info("################# values: {}", seriesValues); + + seriesValues.forEach(row -> { + for (int i=0; i {} = {} / {}", seriesColumns.get(i), row.get(i), row.get(i).getClass()); + + eu.melodic.upperware.penaltycalculator.ComponMeasurement cm; + cm = new eu.melodic.upperware.penaltycalculator.ComponMeasurement(); + cm.setTime(Instant.parse(row.get(0).toString())); + cm.setComponentName(row.get(1).toString()); + cm.setTimeDepl(Double.parseDouble(row.get(2).toString())); + + listComponMeasurements.add(cm); + } }); - log.info("@@@@@@@@@@@@@@@@@@@@@@@@@>>>> listComponMeasurements: {}", listComponMeasurements); + log.info("INFLUX point E-new - Query ok: size={}", listComponMeasurements.size()); + log.info("ComponMeasurements: {}", listComponMeasurements); log.info("INFLUX point F - Query results listed"); //String arr = ComponMeasurements.toString(); -- GitLab From 6d43a7f4a49db917742e96411d67ca166c582ab1 Mon Sep 17 00:00:00 2001 From: "DESKTOP-3098C5A\\VasilAngelo" Date: Sun, 15 Dec 2019 20:25:01 +0200 Subject: [PATCH 039/340] added the Component Deployment time in final penalty time --- .../penaltycalculator/ComponMeasurement.java | 4 +-- .../penaltycalculator/PenaltyFunction.java | 25 ++++++++++--------- .../penaltycalculator/PenaltyTests.java | 4 +-- 3 files changed, 17 insertions(+), 16 deletions(-) diff --git a/penalty-calculator/src/main/java/eu/melodic/upperware/penaltycalculator/ComponMeasurement.java b/penalty-calculator/src/main/java/eu/melodic/upperware/penaltycalculator/ComponMeasurement.java index 9f1eb3236..a8a72ae11 100644 --- a/penalty-calculator/src/main/java/eu/melodic/upperware/penaltycalculator/ComponMeasurement.java +++ b/penalty-calculator/src/main/java/eu/melodic/upperware/penaltycalculator/ComponMeasurement.java @@ -29,7 +29,7 @@ public class ComponMeasurement { @Column(name = "timeDepl") private double timeDepl; - /*public Instant getTime() { + public Instant getTime() { return time; } @@ -53,5 +53,5 @@ public class ComponMeasurement { this.timeDepl = timeDepl; } - public String toString() { return timeDepl+""; }*/ + public String toString() { return timeDepl+""; } } \ No newline at end of file diff --git a/penalty-calculator/src/main/java/eu/melodic/upperware/penaltycalculator/PenaltyFunction.java b/penalty-calculator/src/main/java/eu/melodic/upperware/penaltycalculator/PenaltyFunction.java index 1039ecc53..ec819390b 100644 --- a/penalty-calculator/src/main/java/eu/melodic/upperware/penaltycalculator/PenaltyFunction.java +++ b/penalty-calculator/src/main/java/eu/melodic/upperware/penaltycalculator/PenaltyFunction.java @@ -151,7 +151,7 @@ public class PenaltyFunction { log.info("INFLUX point A - START"); InfluxDB influxDB = InfluxDBFactory.connect("http://134.60.152.213:8086", "vasilis", "EiWeif0w"); log.info("INFLUX point B - connected"); - + // Flush every 2000 Points, at least every 100ms influxDB.enableBatch(2000, 100, TimeUnit.MILLISECONDS); @@ -242,25 +242,25 @@ public class PenaltyFunction { double sum = 0; int cnt = 0; double avg = 0; - /* - for (ComponMeasurement cm : ComponMeasurements) { + + for (ComponMeasurement cmmm : listComponMeasurements) { - sum += cm.timeDepl(); + sum += cmmm.timeDepl(); cnt++; } if (cnt > 0) { avg = sum / cnt; } else - throw new RuntimeException("some error message"); */ + throw new RuntimeException("some error message"); log.info("cnt={}", cnt); log.info("avg={}", avg); //Find the maximum Component Deployment time double maxx = 0; - /* - for (ComponMeasurement cmm : ComponMeasurements) { + + for (ComponMeasurement cmm : listComponMeasurements) { if (maxx < cmm.timeDepl()) { maxx = cmm.timeDepl(); //swapping @@ -268,14 +268,14 @@ public class PenaltyFunction { } } - */ + log.info("The max Component Deployment Time value is " + maxx); //Close connection to Influx DB - //influxDB.close(); + influxDB.close(); HashMap hm = new HashMap(); @@ -427,9 +427,10 @@ public class PenaltyFunction { } - double avgTime = ((((result + result2) / value1) + avg) / 2) - min; - resultss = avgTime / (maxx - min); - log.info("!!!!!!!!!!!!! result={}, result2={}, value1={}, avg={}, min={}, max={} --> resultss={}", result, result2, value1, avg, min, max, resultss); + double avgTime = ((((result + result2) / value1) + (avg/1000)) / 2) - min; + resultss = avgTime / ((maxx/1000) - min); + log.info("The max Component Deployment Time value is " + maxx/1000); + log.info("!!!!!!!!!!!!! result={}, result2={}, value1={}, avg={}, min={}, max={} --> resultss={}", result, result2, value1, avg/1000, min, maxx/1000, resultss); //return resultss; PenaltyFunctionResult pfResult = new PenaltyFunctionResult(resultss, avgTime); diff --git a/penalty-calculator/src/main/java/eu/melodic/upperware/penaltycalculator/PenaltyTests.java b/penalty-calculator/src/main/java/eu/melodic/upperware/penaltycalculator/PenaltyTests.java index 666f41feb..4831812af 100644 --- a/penalty-calculator/src/main/java/eu/melodic/upperware/penaltycalculator/PenaltyTests.java +++ b/penalty-calculator/src/main/java/eu/melodic/upperware/penaltycalculator/PenaltyTests.java @@ -55,8 +55,8 @@ public class PenaltyTests implements CommandLineRunner { PenaltyFunctionResult penaltyResults = penaltyCalculator.evaluatePenaltyFunction(collection_1, collection_2); //normalized average startup time using max-min normalization - log.info("Average Time of VM Startup Time : {}", penaltyResults.getStartupTime()); - log.info("Normalized Average Time of VM Startup Time : {}", penaltyResults.getPenaltyValue()); + log.info("Average Time of VM and Component Startup Time : {}", penaltyResults.getStartupTime()); + log.info("Normalized Average Time of VM and Component Startup Time : {}", penaltyResults.getPenaltyValue()); } protected Collection readConfigElementsFromFile(String fileName) throws IOException { -- GitLab From 00ae31da4319677dd99791635b71e4efb66217a5 Mon Sep 17 00:00:00 2001 From: tc360950 Date: Mon, 16 Dec 2019 13:52:36 +0100 Subject: [PATCH 040/340] Catch-up with ZPP2019Master --- ZPPSolver/PTSolver/pom.xml | 6 ++++++ .../PTSolver/src/main/java/CPComponents/PTObjective.java | 2 +- .../src/main/java/CPComponents/PTRandomGenerator.java | 2 +- .../main/java/{CPWrapper => PTCPWrapper}/PTCPWrapper.java | 5 +++-- 4 files changed, 11 insertions(+), 4 deletions(-) rename ZPPSolver/PTSolver/src/main/java/{CPWrapper => PTCPWrapper}/PTCPWrapper.java (88%) diff --git a/ZPPSolver/PTSolver/pom.xml b/ZPPSolver/PTSolver/pom.xml index 4cace3f1b..7b938a255 100644 --- a/ZPPSolver/PTSolver/pom.xml +++ b/ZPPSolver/PTSolver/pom.xml @@ -33,6 +33,12 @@ RELEASE test + + org.ow2.paasage + CPParser + 2.5.1-SNAPSHOT + compile + \ No newline at end of file diff --git a/ZPPSolver/PTSolver/src/main/java/CPComponents/PTObjective.java b/ZPPSolver/PTSolver/src/main/java/CPComponents/PTObjective.java index e6be77a20..2470044f4 100644 --- a/ZPPSolver/PTSolver/src/main/java/CPComponents/PTObjective.java +++ b/ZPPSolver/PTSolver/src/main/java/CPComponents/PTObjective.java @@ -1,6 +1,6 @@ package CPComponents; -import CPWrapper.PTCPWrapper; +import PTCPWrapper.PTCPWrapper; import org.jamesframework.core.problems.objectives.Objective; import org.jamesframework.core.problems.objectives.evaluations.Evaluation; diff --git a/ZPPSolver/PTSolver/src/main/java/CPComponents/PTRandomGenerator.java b/ZPPSolver/PTSolver/src/main/java/CPComponents/PTRandomGenerator.java index 56af88483..6a6500fca 100644 --- a/ZPPSolver/PTSolver/src/main/java/CPComponents/PTRandomGenerator.java +++ b/ZPPSolver/PTSolver/src/main/java/CPComponents/PTRandomGenerator.java @@ -1,6 +1,6 @@ package CPComponents; -import CPWrapper.PTCPWrapper; +import PTCPWrapper.PTCPWrapper; import org.jamesframework.core.problems.sol.RandomSolutionGenerator; import java.util.Random; diff --git a/ZPPSolver/PTSolver/src/main/java/CPWrapper/PTCPWrapper.java b/ZPPSolver/PTSolver/src/main/java/PTCPWrapper/PTCPWrapper.java similarity index 88% rename from ZPPSolver/PTSolver/src/main/java/CPWrapper/PTCPWrapper.java rename to ZPPSolver/PTSolver/src/main/java/PTCPWrapper/PTCPWrapper.java index 2f2b6a954..06d61850a 100644 --- a/ZPPSolver/PTSolver/src/main/java/CPWrapper/PTCPWrapper.java +++ b/ZPPSolver/PTSolver/src/main/java/PTCPWrapper/PTCPWrapper.java @@ -1,14 +1,15 @@ -package CPWrapper; +package PTCPWrapper; import CPComponents.PTEvaluation; import CPComponents.PTSolution; +import CPWrapper.CPWrapper; import org.jamesframework.core.problems.objectives.evaluations.Evaluation; import java.util.List; import java.util.Random; public class PTCPWrapper { - + private CPWrapper cpWrapper; public Evaluation evaluate(List assignments) { //TODO Use cpWrapper to check constraint //TODO Use CpWrapper to calc utility -- GitLab From db44e605ce2b45c8f55c3a0fa0689e1d031f298b Mon Sep 17 00:00:00 2001 From: tc360950 Date: Mon, 16 Dec 2019 14:06:04 +0100 Subject: [PATCH 041/340] Added min/max domain value methods to DomainHandler, CpWrapper, PTCPWrapper --- .../src/main/java/CPWrapper/CPWrapper.java | 12 +++++++++ .../java/CPWrapper/Utils/DomainHandler.java | 26 +++++++++++++++++++ .../CPWrapper/Utils/ExpressionEvaluator.java | 7 +++++ .../main/java/PTCPWrapper/PTCPWrapper.java | 15 +++++++---- 4 files changed, 55 insertions(+), 5 deletions(-) diff --git a/ZPPSolver/CPParser/src/main/java/CPWrapper/CPWrapper.java b/ZPPSolver/CPParser/src/main/java/CPWrapper/CPWrapper.java index faa08c6c7..1d8be79b8 100644 --- a/ZPPSolver/CPParser/src/main/java/CPWrapper/CPWrapper.java +++ b/ZPPSolver/CPParser/src/main/java/CPWrapper/CPWrapper.java @@ -86,4 +86,16 @@ public class CPWrapper { List vars = assignmentToVariableValueDTOList(assignments); return this.utilityProvider.evaluate(vars); } + + public int getMaxDomainValue(int variable) { + return DomainHandler.getMaxDomainValue( + cpParsedData.getVariableDomain(variableOrderer.indexToVariableName(variable)) + ); + } + + public int getMinDomainValue(int variable) { + return DomainHandler.getMinDomainValue( + cpParsedData.getVariableDomain(variableOrderer.indexToVariableName(variable)) + ); + } } diff --git a/ZPPSolver/CPParser/src/main/java/CPWrapper/Utils/DomainHandler.java b/ZPPSolver/CPParser/src/main/java/CPWrapper/Utils/DomainHandler.java index 0a43dacac..64ab59136 100644 --- a/ZPPSolver/CPParser/src/main/java/CPWrapper/Utils/DomainHandler.java +++ b/ZPPSolver/CPParser/src/main/java/CPWrapper/Utils/DomainHandler.java @@ -38,4 +38,30 @@ public class DomainHandler { } return ExpressionEvaluator.getValueOfNumericInterface(values.get(valueIndex)); } + + public static int getMaxDomainValue(Domain domain) { + if (domain instanceof NumericListDomain) { + return ((NumericListDomain) domain).getValues().size() - 1; + } else if (domain instanceof RangeDomain) { + return ExpressionEvaluator + .getValueOfIntegerNumericInterface( + (IntegerValueUpperware) ((RangeDomain) domain).getTo() + ); + } + + throw new RuntimeException("Only integer RangeDomains are supported!"); + } + + public static int getMinDomainValue(Domain domain) { + if (domain instanceof NumericListDomain) { + return 0; + } else if (domain instanceof RangeDomain) { + return ExpressionEvaluator + .getValueOfIntegerNumericInterface( + (IntegerValueUpperware) ((RangeDomain) domain).getFrom() + ); + } + + throw new RuntimeException("Only integer RangeDomains are supported!"); + } } diff --git a/ZPPSolver/CPParser/src/main/java/CPWrapper/Utils/ExpressionEvaluator.java b/ZPPSolver/CPParser/src/main/java/CPWrapper/Utils/ExpressionEvaluator.java index a224dcab3..1d79673e2 100644 --- a/ZPPSolver/CPParser/src/main/java/CPWrapper/Utils/ExpressionEvaluator.java +++ b/ZPPSolver/CPParser/src/main/java/CPWrapper/Utils/ExpressionEvaluator.java @@ -32,6 +32,13 @@ public class ExpressionEvaluator { throw new RuntimeException("Unsupported NumericValueUpperware implementation"); } + static int getValueOfIntegerNumericInterface(IntegerValueUpperware value) { + if (value instanceof IntegerValueUpperware) { + return ((IntegerValueUpperware) value).getValue(); + } + throw new RuntimeException("Only integer values are supported"); + } + private static boolean isTwoArgsOperator(OperatorEnum oper) { return (oper == OperatorEnum.MINUS || oper == OperatorEnum.DIV || oper == OperatorEnum.EQ); } diff --git a/ZPPSolver/PTSolver/src/main/java/PTCPWrapper/PTCPWrapper.java b/ZPPSolver/PTSolver/src/main/java/PTCPWrapper/PTCPWrapper.java index 06d61850a..e933d9323 100644 --- a/ZPPSolver/PTSolver/src/main/java/PTCPWrapper/PTCPWrapper.java +++ b/ZPPSolver/PTSolver/src/main/java/PTCPWrapper/PTCPWrapper.java @@ -10,17 +10,22 @@ import java.util.Random; public class PTCPWrapper { private CPWrapper cpWrapper; + public Evaluation evaluate(List assignments) { - //TODO Use cpWrapper to check constraint - //TODO Use CpWrapper to calc utility - return new PTEvaluation(0); + if (cpWrapper.isFeasible(assignments)) { + return new PTEvaluation(cpWrapper.getUtility(assignments)); + } else { + return new PTEvaluation(0); + } } public int getMaxValue(int variable) { - //TODO use CPWrapper - must impement a new method; - return 0; + return cpWrapper.getMaxDomainValue(variable); } + public int getMinValue(int variable) { + return cpWrapper.getMinDomainValue(variable); + } public PTSolution generateRandom(Random random) { //TODO must use CPWrapper return null; -- GitLab From 4f7f8dd59c141210ed7b9cde2adfd8f26fd865b3 Mon Sep 17 00:00:00 2001 From: tc360950 Date: Mon, 16 Dec 2019 14:18:17 +0100 Subject: [PATCH 042/340] Finished implementation of PTCPWrapper --- .../src/main/java/CPWrapper/CPWrapper.java | 4 ++++ .../src/main/java/PTCPWrapper/PTCPWrapper.java | 17 +++++++++++++++-- 2 files changed, 19 insertions(+), 2 deletions(-) diff --git a/ZPPSolver/CPParser/src/main/java/CPWrapper/CPWrapper.java b/ZPPSolver/CPParser/src/main/java/CPWrapper/CPWrapper.java index 1d8be79b8..9e71c4199 100644 --- a/ZPPSolver/CPParser/src/main/java/CPWrapper/CPWrapper.java +++ b/ZPPSolver/CPParser/src/main/java/CPWrapper/CPWrapper.java @@ -98,4 +98,8 @@ public class CPWrapper { cpParsedData.getVariableDomain(variableOrderer.indexToVariableName(variable)) ); } + + public int getVariablesCount() { + return cpParsedData.getVariableNames().size(); + } } diff --git a/ZPPSolver/PTSolver/src/main/java/PTCPWrapper/PTCPWrapper.java b/ZPPSolver/PTSolver/src/main/java/PTCPWrapper/PTCPWrapper.java index e933d9323..155b34646 100644 --- a/ZPPSolver/PTSolver/src/main/java/PTCPWrapper/PTCPWrapper.java +++ b/ZPPSolver/PTSolver/src/main/java/PTCPWrapper/PTCPWrapper.java @@ -4,7 +4,9 @@ import CPComponents.PTEvaluation; import CPComponents.PTSolution; import CPWrapper.CPWrapper; import org.jamesframework.core.problems.objectives.evaluations.Evaluation; +import org.jamesframework.core.problems.sol.RandomSolutionGenerator; +import java.util.ArrayList; import java.util.List; import java.util.Random; @@ -26,8 +28,19 @@ public class PTCPWrapper { public int getMinValue(int variable) { return cpWrapper.getMinDomainValue(variable); } + + private int generateRandomValue(int variable, Random random) { + int domainSize = getMaxValue(variable) - getMinValue(variable) + 1; + int value = random.nextInt(domainSize); + value += getMinValue(variable); + return value; + } + public PTSolution generateRandom(Random random) { - //TODO must use CPWrapper - return null; + List assignment = new ArrayList<>(); + for (int i = 0; i < cpWrapper.getVariablesCount(); i++) { + assignment.add(generateRandomValue(i, random)); + } + return new PTSolution(assignment); } } -- GitLab From 0863c0a5f5035f5af5777a05a0ed684353b77634 Mon Sep 17 00:00:00 2001 From: tc360950 Date: Mon, 16 Dec 2019 18:03:29 +0100 Subject: [PATCH 043/340] Implemented PTCPSolverCoordinator --- .../main/java/PTCPWrapper/PTCPWrapper.java | 11 ++- .../src/main/java/PTSolverCoordinator.java | 78 +++++++++++++------ 2 files changed, 65 insertions(+), 24 deletions(-) diff --git a/ZPPSolver/PTSolver/src/main/java/PTCPWrapper/PTCPWrapper.java b/ZPPSolver/PTSolver/src/main/java/PTCPWrapper/PTCPWrapper.java index 155b34646..66e62a4d2 100644 --- a/ZPPSolver/PTSolver/src/main/java/PTCPWrapper/PTCPWrapper.java +++ b/ZPPSolver/PTSolver/src/main/java/PTCPWrapper/PTCPWrapper.java @@ -1,15 +1,18 @@ package PTCPWrapper; - +/* + Thin layer on top of CPWrapper class from CPParser package. + */ import CPComponents.PTEvaluation; import CPComponents.PTSolution; import CPWrapper.CPWrapper; +import lombok.AllArgsConstructor; import org.jamesframework.core.problems.objectives.evaluations.Evaluation; import org.jamesframework.core.problems.sol.RandomSolutionGenerator; import java.util.ArrayList; import java.util.List; import java.util.Random; - +@AllArgsConstructor public class PTCPWrapper { private CPWrapper cpWrapper; @@ -36,6 +39,10 @@ public class PTCPWrapper { return value; } + public int getVariablesCount() { + return cpWrapper.getVariablesCount(); + } + public PTSolution generateRandom(Random random) { List assignment = new ArrayList<>(); for (int i = 0; i < cpWrapper.getVariablesCount(); i++) { diff --git a/ZPPSolver/PTSolver/src/main/java/PTSolverCoordinator.java b/ZPPSolver/PTSolver/src/main/java/PTSolverCoordinator.java index a4549a925..ef5a2c939 100644 --- a/ZPPSolver/PTSolver/src/main/java/PTSolverCoordinator.java +++ b/ZPPSolver/PTSolver/src/main/java/PTSolverCoordinator.java @@ -1,30 +1,64 @@ +import CPComponents.*; +import CPWrapper.CPWrapper; +import CPWrapper.UtilityProvider; +import PTCPWrapper.PTCPWrapper; +import eu.paasage.upperware.metamodel.cp.ConstraintProblem; +import org.jamesframework.core.problems.GenericProblem; +import org.jamesframework.core.problems.Problem; +import org.jamesframework.core.search.algo.ParallelTempering; +import org.jamesframework.core.search.stopcriteria.StopCriterion; + +import java.util.ArrayList; + public class PTSolverCoordinator { + private PTCPWrapper ptcpWrapper; + private Problem CPProblem; + private double minTemp; + private double maxTemp; + private int numReplicas; + private ParallelTempering parallelTemperingSolver; + + public PTSolverCoordinator(double minTemp, double maxTemp, int numReplicas, ConstraintProblem cp, UtilityProvider utility) { + this.minTemp = minTemp; + this.maxTemp = maxTemp; + this.numReplicas = numReplicas; + CPWrapper cpWrapper = new CPWrapper(); + cpWrapper.parse(cp, utility); + this.ptcpWrapper = new PTCPWrapper(cpWrapper); + preparePTSolver(); + } - public void prepareProblem() { - //TODO must Set PTSolution static data - // create data - //TSPData data = new TSPData(dist); -// create objective - //TSPObjective obj = new TSPObjective(); -// create random solution generator - //RandomSolutionGenerator rsg = ... // see before + public void solve(StopCriterion stopCriterion) { + // np new MaxRuntime(timeLimit, TimeUnit.SECONDS) + parallelTemperingSolver.addStopCriterion(stopCriterion); + parallelTemperingSolver.start(); -// wrap in generic problem - //Problem problem = new GenericProblem<>(data, obj, rsg); + if(parallelTemperingSolver.getBestSolution() != null){ + // TODO + } else { + System.out.println("No valid solution found..."); + } + //TODO should return solution; } - public void preparePTSolver() { - // set temperature range, scaled according to average -// distance between cities and their nearest neighbours - /* double scale = computeAvgNearestNeighbourDistance(data); - double minTemp = scale * 1e-8; - double maxTemp = scale * 0.6; -// create parallel tempering search with TSP neighbourhood - int numReplicas = 10; - ParallelTempering parallelTempering = new ParallelTempering<>( - problem, - new TSP2OptNeighbourhood(), - numReplicas, minTemp, maxTemp*/ + private void setMaxMinDomainValues() { + PTSolution.minVariableValues = new ArrayList<>(); + PTSolution.maxVariableValues = new ArrayList<>(); + for (int i = 0; i < ptcpWrapper.getVariablesCount(); i++) { + PTSolution.minVariableValues.add(ptcpWrapper.getMinValue(i)); + PTSolution.maxVariableValues.add(ptcpWrapper.getMaxValue(i)); + } + } + private void prepareProblem() { + setMaxMinDomainValues(); + CPProblem = new GenericProblem<>(ptcpWrapper, new PTObjective(), new PTRandomGenerator()); + } + private void preparePTSolver() { + prepareProblem(); + parallelTemperingSolver = new ParallelTempering<>( + CPProblem, + new PTNeighbourhood(), + numReplicas, minTemp, maxTemp); } } -- GitLab From 9d1d52258359f4f1c337b3f0803dbb2e9bffa5e1 Mon Sep 17 00:00:00 2001 From: tc360950 Date: Mon, 16 Dec 2019 19:22:58 +0100 Subject: [PATCH 044/340] Implemented missing assignmentToVariableValueDTOList method in CPWrapper --- ZPPSolver/CPParser/pom.xml | 27 ++++- .../src/main/java/CPWrapper/CPWrapper.java | 24 +++- .../java/CPWrapper/Parser/CPParsedData.java | 26 +++-- .../CPWrapper/Utils/VariableNumericType.java | 6 + ZPPSolver/PTSolver/pom.xml | 9 +- .../src/main/java/PTSolverCoordinator.java | 9 +- .../test/java/PTSolverCoordinatorTest.java | 107 ++++++++++++++++++ 7 files changed, 193 insertions(+), 15 deletions(-) create mode 100644 ZPPSolver/CPParser/src/main/java/CPWrapper/Utils/VariableNumericType.java create mode 100644 ZPPSolver/PTSolver/src/test/java/PTSolverCoordinatorTest.java diff --git a/ZPPSolver/CPParser/pom.xml b/ZPPSolver/CPParser/pom.xml index baa890e8a..602b5c886 100644 --- a/ZPPSolver/CPParser/pom.xml +++ b/ZPPSolver/CPParser/pom.xml @@ -47,7 +47,32 @@ javatuples 1.2 + + eu.melodic + cp-solver + 2.5.1-SNAPSHOT + compile + - + + + + + org.apache.maven.plugins + maven-jar-plugin + 2.6 + + + Jar Tests Package + package + + test-jar + + + + + + + \ No newline at end of file diff --git a/ZPPSolver/CPParser/src/main/java/CPWrapper/CPWrapper.java b/ZPPSolver/CPParser/src/main/java/CPWrapper/CPWrapper.java index 9e71c4199..5f74ddfa9 100644 --- a/ZPPSolver/CPParser/src/main/java/CPWrapper/CPWrapper.java +++ b/ZPPSolver/CPParser/src/main/java/CPWrapper/CPWrapper.java @@ -4,10 +4,12 @@ import CPWrapper.Parser.CPParsedData; import CPWrapper.Parser.CPParser; import CPWrapper.Utils.DomainHandler; import CPWrapper.Utils.HeuristicVariableOrderer; +import CPWrapper.Utils.VariableNumericType; import CPWrapper.Utils.VariableOrderer; import eu.melodic.upperware.utilitygenerator.cdo.cp_model.DTO.VariableValueDTO; import eu.melodic.upperware.utilitygenerator.cdo.cp_model.DTO.VariableValueDTOFactory; import eu.paasage.upperware.metamodel.cp.*; +import org.eclipse.ocl.pivot.internal.values.NumberValueImpl; import java.util.ArrayList; import java.util.HashMap; @@ -77,9 +79,25 @@ public class CPWrapper { } private List assignmentToVariableValueDTOList(List assignments) { - //TODO - //VariableValueDTOFactory.createElement() - return new ArrayList<>(); + List result = new ArrayList<>(); + for (int i = 0; i < assignments.size(); i++) { + if (cpParsedData.getVariableType(variableOrderer.indexToVariableName(i)) == VariableNumericType.INT) { + result.add( + VariableValueDTOFactory.createElement( + variableOrderer.indexToVariableName(i), + (int) getVariableValueFromDomainIndex(i, assignments.get(i)) + ) + ); + } else { + result.add( + VariableValueDTOFactory.createElement( + variableOrderer.indexToVariableName(i), + getVariableValueFromDomainIndex(i, assignments.get(i)) + ) + ); + } + } + return result; } public double getUtility(List assignments) { diff --git a/ZPPSolver/CPParser/src/main/java/CPWrapper/Parser/CPParsedData.java b/ZPPSolver/CPParser/src/main/java/CPWrapper/Parser/CPParsedData.java index f30d1cab3..d55cbfee8 100644 --- a/ZPPSolver/CPParser/src/main/java/CPWrapper/Parser/CPParsedData.java +++ b/ZPPSolver/CPParser/src/main/java/CPWrapper/Parser/CPParsedData.java @@ -5,6 +5,8 @@ package CPWrapper.Parser; import CPWrapper.Utils.ArConstraint; import CPWrapper.Utils.ConstraintGraph; +import CPWrapper.Utils.VariableNumericType; +import eu.melodic.upperware.cpsolver.solver.parser.creator.IntVarCreator; import eu.paasage.upperware.metamodel.cp.*; import lombok.Getter; @@ -15,10 +17,11 @@ import java.util.Map; import java.util.stream.Collectors; public class CPParsedData { - private Collection constants; - private Collection metrics; - private Collection constraints; - private Collection variables; + private List constants; + private List metrics; + private List constraints; + private List variables; + private IntVarCreator intVarCreator; @Getter private ConstraintGraph constraintGraph; private Map nameToVariable; @@ -59,6 +62,13 @@ public class CPParsedData { return nameToVariable.get(variable).getDomain(); } + public VariableNumericType getVariableType(String name) { + if (intVarCreator.is(nameToVariable.get(name))) { + return VariableNumericType.INT; + } else { + return VariableNumericType.DOUBLE; + } + } private void initializeNameToVariable() { nameToVariable = new HashMap(); for (CpVariable var : variables) { @@ -74,16 +84,16 @@ public class CPParsedData { constraintGraph = new ConstraintGraph(constraints, variableNames); } - void postConstants(Collection constants) { + void postConstants(List constants) { this.constants = constants; } - void postMetrics(Collection metrics) { + void postMetrics(List metrics) { this.metrics = metrics; } - void postConstraints(Collection constraints) { + void postConstraints(List constraints) { this.constraints = constraints; } - void postVariables(Collection variables) { + void postVariables(List variables) { this.variables = variables; } } diff --git a/ZPPSolver/CPParser/src/main/java/CPWrapper/Utils/VariableNumericType.java b/ZPPSolver/CPParser/src/main/java/CPWrapper/Utils/VariableNumericType.java new file mode 100644 index 000000000..f1d1aa6f4 --- /dev/null +++ b/ZPPSolver/CPParser/src/main/java/CPWrapper/Utils/VariableNumericType.java @@ -0,0 +1,6 @@ +package CPWrapper.Utils; + +public enum VariableNumericType { + INT, + DOUBLE +} diff --git a/ZPPSolver/PTSolver/pom.xml b/ZPPSolver/PTSolver/pom.xml index 7b938a255..7e5ad7205 100644 --- a/ZPPSolver/PTSolver/pom.xml +++ b/ZPPSolver/PTSolver/pom.xml @@ -39,6 +39,13 @@ 2.5.1-SNAPSHOT compile - + + org.ow2.paasage + CPParser + 2.5.1-SNAPSHOT + test-jar + test + + \ No newline at end of file diff --git a/ZPPSolver/PTSolver/src/main/java/PTSolverCoordinator.java b/ZPPSolver/PTSolver/src/main/java/PTSolverCoordinator.java index ef5a2c939..4a6690da1 100644 --- a/ZPPSolver/PTSolver/src/main/java/PTSolverCoordinator.java +++ b/ZPPSolver/PTSolver/src/main/java/PTSolverCoordinator.java @@ -5,6 +5,7 @@ import PTCPWrapper.PTCPWrapper; import eu.paasage.upperware.metamodel.cp.ConstraintProblem; import org.jamesframework.core.problems.GenericProblem; import org.jamesframework.core.problems.Problem; +import org.jamesframework.core.search.Search; import org.jamesframework.core.search.algo.ParallelTempering; import org.jamesframework.core.search.stopcriteria.StopCriterion; @@ -28,16 +29,20 @@ public class PTSolverCoordinator { preparePTSolver(); } - public void solve(StopCriterion stopCriterion) { + /* + This method must return something different - PTSolution is only for tests. + */ + public PTSolution solve(StopCriterion stopCriterion) { // np new MaxRuntime(timeLimit, TimeUnit.SECONDS) parallelTemperingSolver.addStopCriterion(stopCriterion); parallelTemperingSolver.start(); if(parallelTemperingSolver.getBestSolution() != null){ - // TODO + return parallelTemperingSolver.getBestSolution(); } else { System.out.println("No valid solution found..."); } + throw new RuntimeException("Couldn't find a solution"); //TODO should return solution; } diff --git a/ZPPSolver/PTSolver/src/test/java/PTSolverCoordinatorTest.java b/ZPPSolver/PTSolver/src/test/java/PTSolverCoordinatorTest.java new file mode 100644 index 000000000..61dc14830 --- /dev/null +++ b/ZPPSolver/PTSolver/src/test/java/PTSolverCoordinatorTest.java @@ -0,0 +1,107 @@ +import CPComponents.PTSolution; +import CPWrapper.Mockups.*; +import CPWrapper.UtilityProvider; +import eu.melodic.upperware.utilitygenerator.cdo.cp_model.DTO.VariableValueDTO; +import eu.paasage.upperware.metamodel.cp.*; +import eu.paasage.upperware.metamodel.types.BasicTypeEnum; +import org.eclipse.emf.common.util.BasicEList; +import org.eclipse.emf.common.util.EList; +import org.jamesframework.core.search.stopcriteria.MaxRuntime; +import org.junit.jupiter.api.Test; + +import java.util.Arrays; +import java.util.Collections; +import java.util.List; +import java.util.Map; +import java.util.concurrent.TimeUnit; + +import static org.junit.jupiter.api.Assertions.*; + +class PTSolverCoordinatorTest { + + private static Map prepareSimpleConstraintProblem() { + /* + @var1 in {1,2,3,4,5} + @var2 in {0.5, 1.5, 2.5} + @var3 in {0,...,9} + @const1 = 3 + + @constraint1 : @var1 < @var3 + + @constraint2 : @var1 * @var2 * @var3 >= @const1; + + @constraint3: @var1 * @var2 >= @var3 + + @constraint4: @var3 == @var3 + */ + List variables = Arrays.asList("var1", "var2", "var3", "var4", "var5", "var6", "var7", "var8"); + EList vars = new BasicEList<>(); + for (int i= 0; i < 3; i++) vars.add(new CpVariableImplMockup(variables.get(i), VariableType.CARDINALITY)); + RangeDomainImpMockup dom1 = new RangeDomainImpMockup(); + RangeDomainImpMockup dom3 = new RangeDomainImpMockup(); + dom1.setFrom(1);dom3.setFrom(0);dom1.setTo(5);dom3.setTo(9); + NumericListDomainImplMockup dom2 = new NumericListDomainImplMockup(); + dom2.setValues(Arrays.asList(0.5, 1.5, 2.5)); + List domains = Arrays.asList(new Domain[] {dom1, dom2, dom3}); + for (int i = 0; i <3 ; i++ ){ + vars.get(i).setDomain(domains.get(i)); + } + + Constant c = new ConstantImplMockup(BasicTypeEnum.DOUBLE, new NumericValueUpperwareImplMockup(3)); + + EList exprs = new BasicEList<>(); + exprs.add(vars.get(0)); exprs.add(vars.get(1)); + NumericExpression times = new ComposedExpressionImplMockup(exprs, OperatorEnum.TIMES); + ConstraintMockup constraint1 = new ConstraintMockup(); + constraint1.setExp1(vars.get(0));constraint1.setExp2(vars.get(2)); + constraint1.setComparator(ComparatorEnum.LESS_THAN); + + ConstraintMockup constraint3 = new ConstraintMockup(); + constraint3.setExp1(times);constraint3.setExp2(vars.get(2)); + constraint3.setComparator(ComparatorEnum.GREATER_OR_EQUAL_TO); + + exprs.add(vars.get(2)); + ConstraintMockup constraint2 = new ConstraintMockup(); + times = new ComposedExpressionImplMockup(exprs, OperatorEnum.TIMES); + constraint2.setExp1(times);constraint2.setExp2(c); + constraint2.setComparator(ComparatorEnum.GREATER_OR_EQUAL_TO); + + ConstraintMockup constraint4 = new ConstraintMockup(); + constraint4.setExp1(vars.get(2));constraint4.setExp2(vars.get(2)); + constraint4.setComparator(ComparatorEnum.EQUAL_TO); + + EList consts = new BasicEList<>(); + consts.add(c); + + EList varsE = new BasicEList<>(); + for (int i = 0; i < 3; i++) varsE.add(vars.get(i)); + + EList constraints = new BasicEList<>(); + constraints.addAll(Arrays.asList(constraint1, constraint2, constraint3, constraint4)); + + ConstraintProblem cp = new ConstraintProblemMockup(consts,null, varsE, constraints ); + return Collections.singletonMap(cp, new UtilityProvider() { + @Override + public double evaluate(List result) { + return 1; + } + }); + } + + @Test + public void simpleConstraintProblemTest() { + Map problem = prepareSimpleConstraintProblem(); + PTSolverCoordinator solver = new PTSolverCoordinator(1, 10, 4, + problem.keySet().iterator().next(), problem.values().iterator().next()); + PTSolution solution = solver.solve(new MaxRuntime(10, TimeUnit.SECONDS)); + + + List domain1 = Arrays.asList(1.0,2.0,3.0,4.0,5.0); + List domain2 = Arrays.asList(0.5, 1.5, 2.5); + List domain3 = Arrays.asList(0.0, 1.0,2.0,3.0,4.0,5.0, 6.0, 7.0, 8.0, 9.0); + List assignment = solution.getVarAssignments(); + + assertTrue(domain1.get(assignment.get(0)) < domain3.get(assignment.get(2))); + + } +} \ No newline at end of file -- GitLab From c97b613fc77f7f57682f1d0aaf02e90633f32b35 Mon Sep 17 00:00:00 2001 From: tc360950 Date: Mon, 16 Dec 2019 19:54:59 +0100 Subject: [PATCH 045/340] Finished first end-to-end test for Parallel tempering solver --- .../java/CPWrapper/Parser/CPParsedData.java | 1 + .../java/CPWrapper/Utils/DomainHandler.java | 11 ++++----- .../src/main/java/PTSolverCoordinator.java | 2 +- .../test/java/PTSolverCoordinatorTest.java | 23 ++++++++++++++----- 4 files changed, 24 insertions(+), 13 deletions(-) diff --git a/ZPPSolver/CPParser/src/main/java/CPWrapper/Parser/CPParsedData.java b/ZPPSolver/CPParser/src/main/java/CPWrapper/Parser/CPParsedData.java index d55cbfee8..234958460 100644 --- a/ZPPSolver/CPParser/src/main/java/CPWrapper/Parser/CPParsedData.java +++ b/ZPPSolver/CPParser/src/main/java/CPWrapper/Parser/CPParsedData.java @@ -31,6 +31,7 @@ public class CPParsedData { } protected void init() { + intVarCreator = new IntVarCreator(); initializeConstraintGraph(); initializeNameToVariable(); } diff --git a/ZPPSolver/CPParser/src/main/java/CPWrapper/Utils/DomainHandler.java b/ZPPSolver/CPParser/src/main/java/CPWrapper/Utils/DomainHandler.java index 64ab59136..fad2a9fb7 100644 --- a/ZPPSolver/CPParser/src/main/java/CPWrapper/Utils/DomainHandler.java +++ b/ZPPSolver/CPParser/src/main/java/CPWrapper/Utils/DomainHandler.java @@ -46,6 +46,10 @@ public class DomainHandler { return ExpressionEvaluator .getValueOfIntegerNumericInterface( (IntegerValueUpperware) ((RangeDomain) domain).getTo() + ) - + ExpressionEvaluator + .getValueOfIntegerNumericInterface( + (IntegerValueUpperware) ((RangeDomain) domain).getFrom() ); } @@ -53,13 +57,8 @@ public class DomainHandler { } public static int getMinDomainValue(Domain domain) { - if (domain instanceof NumericListDomain) { + if (domain instanceof NumericListDomain || domain instanceof RangeDomain) { return 0; - } else if (domain instanceof RangeDomain) { - return ExpressionEvaluator - .getValueOfIntegerNumericInterface( - (IntegerValueUpperware) ((RangeDomain) domain).getFrom() - ); } throw new RuntimeException("Only integer RangeDomains are supported!"); diff --git a/ZPPSolver/PTSolver/src/main/java/PTSolverCoordinator.java b/ZPPSolver/PTSolver/src/main/java/PTSolverCoordinator.java index 4a6690da1..9aa27b84f 100644 --- a/ZPPSolver/PTSolver/src/main/java/PTSolverCoordinator.java +++ b/ZPPSolver/PTSolver/src/main/java/PTSolverCoordinator.java @@ -5,7 +5,6 @@ import PTCPWrapper.PTCPWrapper; import eu.paasage.upperware.metamodel.cp.ConstraintProblem; import org.jamesframework.core.problems.GenericProblem; import org.jamesframework.core.problems.Problem; -import org.jamesframework.core.search.Search; import org.jamesframework.core.search.algo.ParallelTempering; import org.jamesframework.core.search.stopcriteria.StopCriterion; @@ -50,6 +49,7 @@ public class PTSolverCoordinator { PTSolution.minVariableValues = new ArrayList<>(); PTSolution.maxVariableValues = new ArrayList<>(); for (int i = 0; i < ptcpWrapper.getVariablesCount(); i++) { + System.out.println("Variable " + i + " " + ptcpWrapper.getMinValue(i) + " " + ptcpWrapper.getMaxValue(i)); PTSolution.minVariableValues.add(ptcpWrapper.getMinValue(i)); PTSolution.maxVariableValues.add(ptcpWrapper.getMaxValue(i)); } diff --git a/ZPPSolver/PTSolver/src/test/java/PTSolverCoordinatorTest.java b/ZPPSolver/PTSolver/src/test/java/PTSolverCoordinatorTest.java index 61dc14830..dbaeb8a13 100644 --- a/ZPPSolver/PTSolver/src/test/java/PTSolverCoordinatorTest.java +++ b/ZPPSolver/PTSolver/src/test/java/PTSolverCoordinatorTest.java @@ -80,14 +80,23 @@ class PTSolverCoordinatorTest { constraints.addAll(Arrays.asList(constraint1, constraint2, constraint3, constraint4)); ConstraintProblem cp = new ConstraintProblemMockup(consts,null, varsE, constraints ); - return Collections.singletonMap(cp, new UtilityProvider() { - @Override - public double evaluate(List result) { - return 1; + return Collections.singletonMap(cp, result -> { + double sum = 0; + for (VariableValueDTO v : result) { + if (v.getValue() instanceof Double) { + sum += v.getValue().doubleValue(); + } else { + sum += v.getValue().intValue(); + } } + return sum; }); } + /* + Since the solver is non-deterministic, in theory the test may not pass, + but 10 seconds should be enough for exact optimization. + */ @Test public void simpleConstraintProblemTest() { Map problem = prepareSimpleConstraintProblem(); @@ -100,8 +109,10 @@ class PTSolverCoordinatorTest { List domain2 = Arrays.asList(0.5, 1.5, 2.5); List domain3 = Arrays.asList(0.0, 1.0,2.0,3.0,4.0,5.0, 6.0, 7.0, 8.0, 9.0); List assignment = solution.getVarAssignments(); - - assertTrue(domain1.get(assignment.get(0)) < domain3.get(assignment.get(2))); + System.out.println("values: " + domain1.get(assignment.get(1)) + domain2.get(assignment.get(2))+ " "+ domain3.get(assignment.get(0))); + assertEquals((double) domain1.get(assignment.get(1)), 5.0); + assertEquals((double) domain2.get(assignment.get(2)), 2.5); + assertEquals((double) domain3.get(assignment.get(0)), 9); } } \ No newline at end of file -- GitLab From a5daf917651ad0cf10ba71c001f6a775f657eba3 Mon Sep 17 00:00:00 2001 From: tc360950 Date: Sun, 22 Dec 2019 15:55:44 +0100 Subject: [PATCH 046/340] changed packages names --- .../CPParser => zpp-solver/cp-parser}/pom.xml | 0 .../src/main/java/cp_wrapper}/CPWrapper.java | 39 +++++++++---------- .../java/cp_wrapper}/UtilityProvider.java | 2 +- .../java/cp_wrapper/parser}/CPParsedData.java | 16 ++++---- .../java/cp_wrapper/parser}/CPParser.java | 10 ++--- .../cp_wrapper/utils}/ConstraintGraph.java | 22 ++++++----- .../java/cp_wrapper/utils}/DomainHandler.java | 2 +- .../utils}/ExpressionEvaluator.java | 10 ++--- .../utils}/VariableNumericType.java | 2 +- .../utils/constraint/Constraint.java | 4 +- .../utils/constraint/ConstraintImpl.java | 8 ++-- .../HeuristicVariableOrderer.java | 5 ++- .../variable_orderer}/VariableOrderer.java | 4 +- .../test/java/cp_wrapper}/CPWrapperTest.java | 22 ++++++----- .../mockups/ComparisonExpressionMockup.java | 4 +- .../ComposedExpressionImplMockup.java | 2 +- .../mockups}/ConstantImplMockup.java | 2 +- .../cp_wrapper/mockups/ConstraintMockup.java | 6 +-- .../mockups}/ConstraintProblemMockup.java | 2 +- .../mockups}/CpMetricImplMockup.java | 2 +- .../mockups}/CpVariableImplMockup.java | 2 +- .../mockups}/NumericListDomainImplMockup.java | 2 +- .../NumericValueUpperwareImplMockup.java | 2 +- .../mockups}/RangeDomainImpMockup.java | 2 +- .../mockups}/UtilityProviderMockup.java | 5 +-- .../utils}/ConstraintGraphTest.java | 25 ++++++------ .../cp_wrapper/utils/ConstraintImplTest.java | 18 +++++---- .../utils}/ExpressionEvaluatorTest.java | 4 +- .../utils}/HeuristicVariableOrdererTest.java | 34 ++++++++-------- .../genetic-solver}/pom.xml | 0 .../mcts-solver}/pom.xml | 0 .../PTSolver => zpp-solver/pt-solver}/pom.xml | 0 .../src/main/java/PTSolverCoordinator.java | 8 ++-- .../java/cp_components}/PTEvaluation.java | 6 ++- .../src/main/java/cp_components}/PTMover.java | 2 +- .../java/cp_components}/PTNeighbourhood.java | 2 +- .../main/java/cp_components}/PTObjective.java | 4 +- .../cp_components}/PTRandomGenerator.java | 4 +- .../main/java/cp_components}/PTSolution.java | 2 +- .../main/java/ptcp_wrapper}/PTCPWrapper.java | 23 +++++++---- .../test/java/PTSolverCoordinatorTest.java | 14 +++---- .../test/java/cp_components}/PTMoverTest.java | 2 +- .../cp_components}/PTNeighbourhoodTest.java | 2 +- .../java/cp_components}/PTSolutionTest.java | 2 +- 44 files changed, 174 insertions(+), 155 deletions(-) rename {ZPPSolver/CPParser => zpp-solver/cp-parser}/pom.xml (100%) rename {ZPPSolver/CPParser/src/main/java/CPWrapper => zpp-solver/cp-parser/src/main/java/cp_wrapper}/CPWrapper.java (75%) rename {ZPPSolver/CPParser/src/main/java/CPWrapper => zpp-solver/cp-parser/src/main/java/cp_wrapper}/UtilityProvider.java (90%) rename {ZPPSolver/CPParser/src/main/java/CPWrapper/Parser => zpp-solver/cp-parser/src/main/java/cp_wrapper/parser}/CPParsedData.java (88%) rename {ZPPSolver/CPParser/src/main/java/CPWrapper/Parser => zpp-solver/cp-parser/src/main/java/cp_wrapper/parser}/CPParser.java (82%) rename {ZPPSolver/CPParser/src/main/java/CPWrapper/Utils => zpp-solver/cp-parser/src/main/java/cp_wrapper/utils}/ConstraintGraph.java (89%) rename {ZPPSolver/CPParser/src/main/java/CPWrapper/Utils => zpp-solver/cp-parser/src/main/java/cp_wrapper/utils}/DomainHandler.java (98%) rename {ZPPSolver/CPParser/src/main/java/CPWrapper/Utils => zpp-solver/cp-parser/src/main/java/cp_wrapper/utils}/ExpressionEvaluator.java (94%) rename {ZPPSolver/CPParser/src/main/java/CPWrapper/Utils => zpp-solver/cp-parser/src/main/java/cp_wrapper/utils}/VariableNumericType.java (68%) rename ZPPSolver/CPParser/src/main/java/CPWrapper/Utils/ArConstraint.java => zpp-solver/cp-parser/src/main/java/cp_wrapper/utils/constraint/Constraint.java (69%) rename ZPPSolver/CPParser/src/main/java/CPWrapper/Utils/ArConstraintImpl.java => zpp-solver/cp-parser/src/main/java/cp_wrapper/utils/constraint/ConstraintImpl.java (86%) rename {ZPPSolver/CPParser/src/main/java/CPWrapper/Utils => zpp-solver/cp-parser/src/main/java/cp_wrapper/utils/variable_orderer}/HeuristicVariableOrderer.java (94%) rename {ZPPSolver/CPParser/src/main/java/CPWrapper/Utils => zpp-solver/cp-parser/src/main/java/cp_wrapper/utils/variable_orderer}/VariableOrderer.java (70%) rename {ZPPSolver/CPParser/src/test/java/CPWrapper => zpp-solver/cp-parser/src/test/java/cp_wrapper}/CPWrapperTest.java (84%) rename ZPPSolver/CPParser/src/test/java/CPWrapper/Mockups/ConstraintMockup.java => zpp-solver/cp-parser/src/test/java/cp_wrapper/mockups/ComparisonExpressionMockup.java (97%) rename {ZPPSolver/CPParser/src/test/java/CPWrapper/Mockups => zpp-solver/cp-parser/src/test/java/cp_wrapper/mockups}/ComposedExpressionImplMockup.java (96%) rename {ZPPSolver/CPParser/src/test/java/CPWrapper/Mockups => zpp-solver/cp-parser/src/test/java/cp_wrapper/mockups}/ConstantImplMockup.java (96%) rename ZPPSolver/CPParser/src/test/java/CPWrapper/Mockups/ArConstraintMockup.java => zpp-solver/cp-parser/src/test/java/cp_wrapper/mockups/ConstraintMockup.java (75%) rename {ZPPSolver/CPParser/src/test/java/CPWrapper/Mockups => zpp-solver/cp-parser/src/test/java/cp_wrapper/mockups}/ConstraintProblemMockup.java (99%) rename {ZPPSolver/CPParser/src/test/java/CPWrapper/Mockups => zpp-solver/cp-parser/src/test/java/cp_wrapper/mockups}/CpMetricImplMockup.java (96%) rename {ZPPSolver/CPParser/src/test/java/CPWrapper/Mockups => zpp-solver/cp-parser/src/test/java/cp_wrapper/mockups}/CpVariableImplMockup.java (97%) rename {ZPPSolver/CPParser/src/test/java/CPWrapper/Mockups => zpp-solver/cp-parser/src/test/java/cp_wrapper/mockups}/NumericListDomainImplMockup.java (99%) rename {ZPPSolver/CPParser/src/test/java/CPWrapper/Mockups => zpp-solver/cp-parser/src/test/java/cp_wrapper/mockups}/NumericValueUpperwareImplMockup.java (99%) rename {ZPPSolver/CPParser/src/test/java/CPWrapper/Mockups => zpp-solver/cp-parser/src/test/java/cp_wrapper/mockups}/RangeDomainImpMockup.java (99%) rename {ZPPSolver/CPParser/src/test/java/CPWrapper/Mockups => zpp-solver/cp-parser/src/test/java/cp_wrapper/mockups}/UtilityProviderMockup.java (66%) rename {ZPPSolver/CPParser/src/test/java/CPWrapper/Utils => zpp-solver/cp-parser/src/test/java/cp_wrapper/utils}/ConstraintGraphTest.java (79%) rename ZPPSolver/CPParser/src/test/java/CPWrapper/Utils/ArConstraintImplTest.java => zpp-solver/cp-parser/src/test/java/cp_wrapper/utils/ConstraintImplTest.java (80%) rename {ZPPSolver/CPParser/src/test/java/CPWrapper/Utils => zpp-solver/cp-parser/src/test/java/cp_wrapper/utils}/ExpressionEvaluatorTest.java (98%) rename {ZPPSolver/CPParser/src/test/java/CPWrapper/Utils => zpp-solver/cp-parser/src/test/java/cp_wrapper/utils}/HeuristicVariableOrdererTest.java (61%) rename {ZPPSolver/GeneticSolver => zpp-solver/genetic-solver}/pom.xml (100%) rename {ZPPSolver/MCTSSolver => zpp-solver/mcts-solver}/pom.xml (100%) rename {ZPPSolver/PTSolver => zpp-solver/pt-solver}/pom.xml (100%) rename {ZPPSolver/PTSolver => zpp-solver/pt-solver}/src/main/java/PTSolverCoordinator.java (95%) rename {ZPPSolver/PTSolver/src/main/java/CPComponents => zpp-solver/pt-solver/src/main/java/cp_components}/PTEvaluation.java (76%) rename {ZPPSolver/PTSolver/src/main/java/CPComponents => zpp-solver/pt-solver/src/main/java/cp_components}/PTMover.java (98%) rename {ZPPSolver/PTSolver/src/main/java/CPComponents => zpp-solver/pt-solver/src/main/java/cp_components}/PTNeighbourhood.java (98%) rename {ZPPSolver/PTSolver/src/main/java/CPComponents => zpp-solver/pt-solver/src/main/java/cp_components}/PTObjective.java (90%) rename {ZPPSolver/PTSolver/src/main/java/CPComponents => zpp-solver/pt-solver/src/main/java/cp_components}/PTRandomGenerator.java (85%) rename {ZPPSolver/PTSolver/src/main/java/CPComponents => zpp-solver/pt-solver/src/main/java/cp_components}/PTSolution.java (98%) rename {ZPPSolver/PTSolver/src/main/java/PTCPWrapper => zpp-solver/pt-solver/src/main/java/ptcp_wrapper}/PTCPWrapper.java (75%) rename {ZPPSolver/PTSolver => zpp-solver/pt-solver}/src/test/java/PTSolverCoordinatorTest.java (91%) rename {ZPPSolver/PTSolver/src/test/java/CPComponents => zpp-solver/pt-solver/src/test/java/cp_components}/PTMoverTest.java (97%) rename {ZPPSolver/PTSolver/src/test/java/CPComponents => zpp-solver/pt-solver/src/test/java/cp_components}/PTNeighbourhoodTest.java (97%) rename {ZPPSolver/PTSolver/src/test/java/CPComponents => zpp-solver/pt-solver/src/test/java/cp_components}/PTSolutionTest.java (97%) diff --git a/ZPPSolver/CPParser/pom.xml b/zpp-solver/cp-parser/pom.xml similarity index 100% rename from ZPPSolver/CPParser/pom.xml rename to zpp-solver/cp-parser/pom.xml diff --git a/ZPPSolver/CPParser/src/main/java/CPWrapper/CPWrapper.java b/zpp-solver/cp-parser/src/main/java/cp_wrapper/CPWrapper.java similarity index 75% rename from ZPPSolver/CPParser/src/main/java/CPWrapper/CPWrapper.java rename to zpp-solver/cp-parser/src/main/java/cp_wrapper/CPWrapper.java index 5f74ddfa9..6376a6fc5 100644 --- a/ZPPSolver/CPParser/src/main/java/CPWrapper/CPWrapper.java +++ b/zpp-solver/cp-parser/src/main/java/cp_wrapper/CPWrapper.java @@ -1,15 +1,14 @@ -package CPWrapper; - -import CPWrapper.Parser.CPParsedData; -import CPWrapper.Parser.CPParser; -import CPWrapper.Utils.DomainHandler; -import CPWrapper.Utils.HeuristicVariableOrderer; -import CPWrapper.Utils.VariableNumericType; -import CPWrapper.Utils.VariableOrderer; +package cp_wrapper; + +import cp_wrapper.parser.CPParsedData; +import cp_wrapper.parser.CPParser; +import cp_wrapper.utils.DomainHandler; +import cp_wrapper.utils.variable_orderer.HeuristicVariableOrderer; +import cp_wrapper.utils.VariableNumericType; +import cp_wrapper.utils.variable_orderer.VariableOrderer; import eu.melodic.upperware.utilitygenerator.cdo.cp_model.DTO.VariableValueDTO; import eu.melodic.upperware.utilitygenerator.cdo.cp_model.DTO.VariableValueDTOFactory; import eu.paasage.upperware.metamodel.cp.*; -import org.eclipse.ocl.pivot.internal.values.NumberValueImpl; import java.util.ArrayList; import java.util.HashMap; @@ -33,16 +32,16 @@ public class CPWrapper { this.variableOrderer = vO; } - public boolean isFeasible(List assignment) { - return cpParsedData.isFeasible(getAssignmentFromValueList(assignment)); + public boolean checkIfFeasible(List assignment) { + return cpParsedData.checkIfFeasible(getAssignmentFromValueList(assignment)); } public Domain getVariableDomain(int variableIndex) { - return cpParsedData.getVariableDomain(variableOrderer.indexToVariableName(variableIndex)); + return cpParsedData.getVariableDomain(variableOrderer.getNameFromIndex(variableIndex)); } private double getVariableValueFromDomainIndex(int varIndex, int value) { - String variableName = variableOrderer.indexToVariableName(varIndex); + String variableName = variableOrderer.getNameFromIndex(varIndex); Domain domain = cpParsedData.getVariableDomain(variableName); if (DomainHandler.isRangeDomain(domain)) { return DomainHandler.getRangeValue(value, (RangeDomain) domain); @@ -56,7 +55,7 @@ public class CPWrapper { private Map getAssignmentFromValueList(List assignments) { Map vars = new HashMap<>(); for (int i = 0; i < assignments.size(); i++) { - vars.put(variableOrderer.indexToVariableName(i), getVariableValueFromDomainIndex(i, assignments.get(i))); + vars.put(variableOrderer.getNameFromIndex(i), getVariableValueFromDomainIndex(i, assignments.get(i))); } return vars; } @@ -74,24 +73,24 @@ public class CPWrapper { throw new RuntimeException("Wrong number of variables in assignment"); } - return cpParsedData.getHeuristicEvaluation(variableOrderer.indexToVariableName(variableIndex), + return cpParsedData.getHeuristicEvaluation(variableOrderer.getNameFromIndex(variableIndex), getAssignmentFromValueList(assignments)); } private List assignmentToVariableValueDTOList(List assignments) { List result = new ArrayList<>(); for (int i = 0; i < assignments.size(); i++) { - if (cpParsedData.getVariableType(variableOrderer.indexToVariableName(i)) == VariableNumericType.INT) { + if (cpParsedData.getVariableType(variableOrderer.getNameFromIndex(i)) == VariableNumericType.INT) { result.add( VariableValueDTOFactory.createElement( - variableOrderer.indexToVariableName(i), + variableOrderer.getNameFromIndex(i), (int) getVariableValueFromDomainIndex(i, assignments.get(i)) ) ); } else { result.add( VariableValueDTOFactory.createElement( - variableOrderer.indexToVariableName(i), + variableOrderer.getNameFromIndex(i), getVariableValueFromDomainIndex(i, assignments.get(i)) ) ); @@ -107,13 +106,13 @@ public class CPWrapper { public int getMaxDomainValue(int variable) { return DomainHandler.getMaxDomainValue( - cpParsedData.getVariableDomain(variableOrderer.indexToVariableName(variable)) + cpParsedData.getVariableDomain(variableOrderer.getNameFromIndex(variable)) ); } public int getMinDomainValue(int variable) { return DomainHandler.getMinDomainValue( - cpParsedData.getVariableDomain(variableOrderer.indexToVariableName(variable)) + cpParsedData.getVariableDomain(variableOrderer.getNameFromIndex(variable)) ); } diff --git a/ZPPSolver/CPParser/src/main/java/CPWrapper/UtilityProvider.java b/zpp-solver/cp-parser/src/main/java/cp_wrapper/UtilityProvider.java similarity index 90% rename from ZPPSolver/CPParser/src/main/java/CPWrapper/UtilityProvider.java rename to zpp-solver/cp-parser/src/main/java/cp_wrapper/UtilityProvider.java index ef39757f7..9e0cea9ce 100644 --- a/ZPPSolver/CPParser/src/main/java/CPWrapper/UtilityProvider.java +++ b/zpp-solver/cp-parser/src/main/java/cp_wrapper/UtilityProvider.java @@ -1,4 +1,4 @@ -package CPWrapper; +package cp_wrapper; import eu.melodic.upperware.utilitygenerator.cdo.cp_model.DTO.VariableValueDTO; diff --git a/ZPPSolver/CPParser/src/main/java/CPWrapper/Parser/CPParsedData.java b/zpp-solver/cp-parser/src/main/java/cp_wrapper/parser/CPParsedData.java similarity index 88% rename from ZPPSolver/CPParser/src/main/java/CPWrapper/Parser/CPParsedData.java rename to zpp-solver/cp-parser/src/main/java/cp_wrapper/parser/CPParsedData.java index 234958460..56776a9ed 100644 --- a/ZPPSolver/CPParser/src/main/java/CPWrapper/Parser/CPParsedData.java +++ b/zpp-solver/cp-parser/src/main/java/cp_wrapper/parser/CPParsedData.java @@ -1,11 +1,11 @@ -package CPWrapper.Parser; +package cp_wrapper.parser; /* This class contains all data representing a specific constraint problem. */ -import CPWrapper.Utils.ArConstraint; -import CPWrapper.Utils.ConstraintGraph; -import CPWrapper.Utils.VariableNumericType; +import cp_wrapper.utils.constraint.Constraint; +import cp_wrapper.utils.ConstraintGraph; +import cp_wrapper.utils.VariableNumericType; import eu.melodic.upperware.cpsolver.solver.parser.creator.IntVarCreator; import eu.paasage.upperware.metamodel.cp.*; import lombok.Getter; @@ -19,7 +19,7 @@ import java.util.stream.Collectors; public class CPParsedData { private List constants; private List metrics; - private List constraints; + private List constraints; private List variables; private IntVarCreator intVarCreator; @Getter @@ -36,8 +36,8 @@ public class CPParsedData { initializeNameToVariable(); } - public boolean isFeasible(Map variables) { - for (ArConstraint c : constraints) { + public boolean checkIfFeasible(Map variables) { + for (Constraint c : constraints) { if (!c.evaluate(variables)) { return false; } @@ -91,7 +91,7 @@ public class CPParsedData { void postMetrics(List metrics) { this.metrics = metrics; } - void postConstraints(List constraints) { + void postConstraints(List constraints) { this.constraints = constraints; } void postVariables(List variables) { diff --git a/ZPPSolver/CPParser/src/main/java/CPWrapper/Parser/CPParser.java b/zpp-solver/cp-parser/src/main/java/cp_wrapper/parser/CPParser.java similarity index 82% rename from ZPPSolver/CPParser/src/main/java/CPWrapper/Parser/CPParser.java rename to zpp-solver/cp-parser/src/main/java/cp_wrapper/parser/CPParser.java index e5bcffcc3..9553dc67f 100644 --- a/ZPPSolver/CPParser/src/main/java/CPWrapper/Parser/CPParser.java +++ b/zpp-solver/cp-parser/src/main/java/cp_wrapper/parser/CPParser.java @@ -1,11 +1,11 @@ -package CPWrapper.Parser; +package cp_wrapper.parser; /* This class is responsible for transforming ConstraintProblem interface into CPParser class. The only work that is done here is transforming ComparisonExpression interface into less abstract ArConstraint instance. */ -import CPWrapper.Utils.ArConstraint; -import CPWrapper.Utils.ArConstraintImpl; +import cp_wrapper.utils.constraint.Constraint; +import cp_wrapper.utils.constraint.ConstraintImpl; import eu.paasage.upperware.metamodel.cp.ConstraintProblem; import java.util.List; @@ -40,9 +40,9 @@ public class CPParser { } private void parseConstraints(ConstraintProblem cp) { - List constraints = + List constraints = cp.getConstraints().stream() - .map(compExp -> new ArConstraintImpl(compExp.getComparator(), compExp.getExp1(), compExp.getExp2())) + .map(compExp -> new ConstraintImpl(compExp.getComparator(), compExp.getExp1(), compExp.getExp2())) .collect(Collectors.toList()); cpParsedData.postConstraints(constraints); } diff --git a/ZPPSolver/CPParser/src/main/java/CPWrapper/Utils/ConstraintGraph.java b/zpp-solver/cp-parser/src/main/java/cp_wrapper/utils/ConstraintGraph.java similarity index 89% rename from ZPPSolver/CPParser/src/main/java/CPWrapper/Utils/ConstraintGraph.java rename to zpp-solver/cp-parser/src/main/java/cp_wrapper/utils/ConstraintGraph.java index 7e0ec384c..bb311d786 100644 --- a/ZPPSolver/CPParser/src/main/java/CPWrapper/Utils/ConstraintGraph.java +++ b/zpp-solver/cp-parser/src/main/java/cp_wrapper/utils/ConstraintGraph.java @@ -1,4 +1,4 @@ -package CPWrapper.Utils; +package cp_wrapper.utils; /* This class implements constraint graph. A constraint graph is created from a set of @@ -8,10 +8,12 @@ package CPWrapper.Utils; */ +import cp_wrapper.utils.constraint.Constraint; + import java.util.*; public class ConstraintGraph { - private Collection constraints; + private Collection constraints; private Collection variables; /* For variable var and natural number d @@ -19,9 +21,9 @@ public class ConstraintGraph { */ private Map>> neighbourhoodList; - private Map> variableToConstraint; + private Map> variableToConstraint; - public ConstraintGraph(Collection constraints, Collection vars) { + public ConstraintGraph(Collection constraints, Collection vars) { this.constraints = constraints; this.variables = vars; initializeStructures(); @@ -45,7 +47,7 @@ public class ConstraintGraph { } private void buildVariableToConstraintMap() { - for (ArConstraint c : constraints) { + for (Constraint c : constraints) { for (String var : c.getVariableNames()) { variableToConstraint.get(var).add(c); } @@ -63,13 +65,13 @@ public class ConstraintGraph { variableToConstraint = new HashMap<>(); for (String node : variables) { neighbourhoodList.put(node, new HashMap<>()); - variableToConstraint.put(node, new LinkedList()); + variableToConstraint.put(node, new LinkedList()); } } private void calculateNeighbours(Map> knownDistances) { initializeNeighbourhoodList(1); - for (ArConstraint constraint : constraints) { + for (Constraint constraint : constraints) { Collection variables = constraint.getVariableNames(); for (String var : variables) { knownDistances.get(var).addAll(variables); @@ -130,7 +132,7 @@ public class ConstraintGraph { Counts number of distinct variables which are either involved in constraint @c or are a neighbour of some variable which is involved in @c. */ - private int countConstraintVariablesAndTheirNeighbours(ArConstraint c) { + private int countConstraintVariablesAndTheirNeighbours(Constraint c) { Set vars = new HashSet<>(); for (String var : c.getVariableNames()) { vars.addAll(neighbourhoodList.get(var).get(1)); @@ -150,7 +152,7 @@ public class ConstraintGraph { */ public int getVariableHeuristicEvaluation(String variable, Map variables) { int result = 0; - for (ArConstraint c : variableToConstraint.get(variable)) { + for (Constraint c : variableToConstraint.get(variable)) { if (!c.evaluate(variables)) { result += countConstraintVariablesAndTheirNeighbours(c) - 1; } @@ -158,7 +160,7 @@ public class ConstraintGraph { return result; } - public Collection getConstraints(String variable) { + public Collection getConstraints(String variable) { return variableToConstraint.get(variable); } diff --git a/ZPPSolver/CPParser/src/main/java/CPWrapper/Utils/DomainHandler.java b/zpp-solver/cp-parser/src/main/java/cp_wrapper/utils/DomainHandler.java similarity index 98% rename from ZPPSolver/CPParser/src/main/java/CPWrapper/Utils/DomainHandler.java rename to zpp-solver/cp-parser/src/main/java/cp_wrapper/utils/DomainHandler.java index fad2a9fb7..857cbd087 100644 --- a/ZPPSolver/CPParser/src/main/java/CPWrapper/Utils/DomainHandler.java +++ b/zpp-solver/cp-parser/src/main/java/cp_wrapper/utils/DomainHandler.java @@ -1,4 +1,4 @@ -package CPWrapper.Utils; +package cp_wrapper.utils; /* All variable domains are abstracted as finite sequences of subsequent natural numbers - this class is responsible for turning those "domain indices" diff --git a/ZPPSolver/CPParser/src/main/java/CPWrapper/Utils/ExpressionEvaluator.java b/zpp-solver/cp-parser/src/main/java/cp_wrapper/utils/ExpressionEvaluator.java similarity index 94% rename from ZPPSolver/CPParser/src/main/java/CPWrapper/Utils/ExpressionEvaluator.java rename to zpp-solver/cp-parser/src/main/java/cp_wrapper/utils/ExpressionEvaluator.java index 1d79673e2..86a937c79 100644 --- a/ZPPSolver/CPParser/src/main/java/CPWrapper/Utils/ExpressionEvaluator.java +++ b/zpp-solver/cp-parser/src/main/java/cp_wrapper/utils/ExpressionEvaluator.java @@ -1,4 +1,4 @@ -package CPWrapper.Utils; +package cp_wrapper.utils; /* This class is used to parse and evaluate Expression interfaces from eu.paasage.upperware.metamodel.cp package @@ -115,19 +115,19 @@ public class ExpressionEvaluator { throw new RuntimeException("Unsupported comparator type"); } - static boolean isConstant(Expression expression){ + static public boolean isConstant(Expression expression){ return expression instanceof Constant; } - static boolean isCpVariable(Expression expression){ + static public boolean isCpVariable(Expression expression){ return expression instanceof CpVariable; } - static boolean isCpMetric(Expression expression){ + static public boolean isCpMetric(Expression expression){ return expression instanceof CpMetric; } - static boolean isComposedExpression(Expression expression){ + static public boolean isComposedExpression(Expression expression){ return expression instanceof ComposedExpression; } } diff --git a/ZPPSolver/CPParser/src/main/java/CPWrapper/Utils/VariableNumericType.java b/zpp-solver/cp-parser/src/main/java/cp_wrapper/utils/VariableNumericType.java similarity index 68% rename from ZPPSolver/CPParser/src/main/java/CPWrapper/Utils/VariableNumericType.java rename to zpp-solver/cp-parser/src/main/java/cp_wrapper/utils/VariableNumericType.java index f1d1aa6f4..09c21ca7c 100644 --- a/ZPPSolver/CPParser/src/main/java/CPWrapper/Utils/VariableNumericType.java +++ b/zpp-solver/cp-parser/src/main/java/cp_wrapper/utils/VariableNumericType.java @@ -1,4 +1,4 @@ -package CPWrapper.Utils; +package cp_wrapper.utils; public enum VariableNumericType { INT, diff --git a/ZPPSolver/CPParser/src/main/java/CPWrapper/Utils/ArConstraint.java b/zpp-solver/cp-parser/src/main/java/cp_wrapper/utils/constraint/Constraint.java similarity index 69% rename from ZPPSolver/CPParser/src/main/java/CPWrapper/Utils/ArConstraint.java rename to zpp-solver/cp-parser/src/main/java/cp_wrapper/utils/constraint/Constraint.java index b5c9bd35d..fdd75b9c8 100644 --- a/ZPPSolver/CPParser/src/main/java/CPWrapper/Utils/ArConstraint.java +++ b/zpp-solver/cp-parser/src/main/java/cp_wrapper/utils/constraint/Constraint.java @@ -1,9 +1,9 @@ -package CPWrapper.Utils; +package cp_wrapper.utils.constraint; import java.util.Collection; import java.util.Map; -public interface ArConstraint { +public interface Constraint { Collection getVariableNames(); diff --git a/ZPPSolver/CPParser/src/main/java/CPWrapper/Utils/ArConstraintImpl.java b/zpp-solver/cp-parser/src/main/java/cp_wrapper/utils/constraint/ConstraintImpl.java similarity index 86% rename from ZPPSolver/CPParser/src/main/java/CPWrapper/Utils/ArConstraintImpl.java rename to zpp-solver/cp-parser/src/main/java/cp_wrapper/utils/constraint/ConstraintImpl.java index fe4b6ecb2..b3a7d527d 100644 --- a/ZPPSolver/CPParser/src/main/java/CPWrapper/Utils/ArConstraintImpl.java +++ b/zpp-solver/cp-parser/src/main/java/cp_wrapper/utils/constraint/ConstraintImpl.java @@ -1,12 +1,14 @@ -package CPWrapper.Utils; +package cp_wrapper.utils.constraint; +import cp_wrapper.utils.ExpressionEvaluator; +import cp_wrapper.utils.constraint.Constraint; import eu.paasage.upperware.metamodel.cp.*; import java.util.ArrayList; import java.util.Collection; import java.util.Map; -public class ArConstraintImpl implements ArConstraint { +public class ConstraintImpl implements Constraint { /* Names of variables which are used in the constraint */ @@ -15,7 +17,7 @@ public class ArConstraintImpl implements ArConstraint { private Expression leftExpression; private Expression rightExpression; - public ArConstraintImpl(ComparatorEnum comp, Expression exp1, Expression exp2){ + public ConstraintImpl(ComparatorEnum comp, Expression exp1, Expression exp2){ this.comparator = comp; this.leftExpression = exp1; this.rightExpression = exp2; diff --git a/ZPPSolver/CPParser/src/main/java/CPWrapper/Utils/HeuristicVariableOrderer.java b/zpp-solver/cp-parser/src/main/java/cp_wrapper/utils/variable_orderer/HeuristicVariableOrderer.java similarity index 94% rename from ZPPSolver/CPParser/src/main/java/CPWrapper/Utils/HeuristicVariableOrderer.java rename to zpp-solver/cp-parser/src/main/java/cp_wrapper/utils/variable_orderer/HeuristicVariableOrderer.java index aa422f5a1..f2788243e 100644 --- a/ZPPSolver/CPParser/src/main/java/CPWrapper/Utils/HeuristicVariableOrderer.java +++ b/zpp-solver/cp-parser/src/main/java/cp_wrapper/utils/variable_orderer/HeuristicVariableOrderer.java @@ -1,5 +1,6 @@ -package CPWrapper.Utils; +package cp_wrapper.utils.variable_orderer; +import cp_wrapper.utils.ConstraintGraph; import org.javatuples.Pair; import java.util.Collections; import java.util.HashMap; @@ -15,7 +16,7 @@ public class HeuristicVariableOrderer implements VariableOrderer { } @Override - public String indexToVariableName(int var) { + public String getNameFromIndex(int var) { return indexToVariableName.get(var); } diff --git a/ZPPSolver/CPParser/src/main/java/CPWrapper/Utils/VariableOrderer.java b/zpp-solver/cp-parser/src/main/java/cp_wrapper/utils/variable_orderer/VariableOrderer.java similarity index 70% rename from ZPPSolver/CPParser/src/main/java/CPWrapper/Utils/VariableOrderer.java rename to zpp-solver/cp-parser/src/main/java/cp_wrapper/utils/variable_orderer/VariableOrderer.java index 726577568..1512e61e4 100644 --- a/ZPPSolver/CPParser/src/main/java/CPWrapper/Utils/VariableOrderer.java +++ b/zpp-solver/cp-parser/src/main/java/cp_wrapper/utils/variable_orderer/VariableOrderer.java @@ -1,8 +1,8 @@ -package CPWrapper.Utils; +package cp_wrapper.utils.variable_orderer; /* All variables are referenced through indices. Those indices correspond to some variable ordering - which is maintained by VariableOrderer. */ public interface VariableOrderer { - String indexToVariableName(int var); + String getNameFromIndex(int var); } diff --git a/ZPPSolver/CPParser/src/test/java/CPWrapper/CPWrapperTest.java b/zpp-solver/cp-parser/src/test/java/cp_wrapper/CPWrapperTest.java similarity index 84% rename from ZPPSolver/CPParser/src/test/java/CPWrapper/CPWrapperTest.java rename to zpp-solver/cp-parser/src/test/java/cp_wrapper/CPWrapperTest.java index 52d8335d8..10f829303 100644 --- a/ZPPSolver/CPParser/src/test/java/CPWrapper/CPWrapperTest.java +++ b/zpp-solver/cp-parser/src/test/java/cp_wrapper/CPWrapperTest.java @@ -1,6 +1,6 @@ -package CPWrapper; +package cp_wrapper; -import CPWrapper.Mockups.*; +import cp_wrapper.mockups.*; import eu.paasage.upperware.metamodel.cp.*; import eu.paasage.upperware.metamodel.types.BasicTypeEnum; import org.eclipse.emf.common.util.BasicEList; @@ -11,7 +11,9 @@ import org.junit.jupiter.api.Test; import java.util.Arrays; import java.util.List; -import static org.junit.jupiter.api.Assertions.*; +import static org.junit.Assert.assertEquals; +import static org.junit.Assert.assertTrue; +import static org.junit.jupiter.api.Assertions.assertFalse; class CPWrapperTest { private static CPWrapper cpWrapper; @@ -51,21 +53,21 @@ class CPWrapperTest { EList exprs = new BasicEList<>(); exprs.add(vars.get(0)); exprs.add(vars.get(1)); NumericExpression times = new ComposedExpressionImplMockup(exprs, OperatorEnum.TIMES); - ConstraintMockup constraint1 = new ConstraintMockup(); + ComparisonExpressionMockup constraint1 = new ComparisonExpressionMockup(); constraint1.setExp1(vars.get(0));constraint1.setExp2(vars.get(2)); constraint1.setComparator(ComparatorEnum.LESS_THAN); - ConstraintMockup constraint3 = new ConstraintMockup(); + ComparisonExpressionMockup constraint3 = new ComparisonExpressionMockup(); constraint3.setExp1(times);constraint3.setExp2(vars.get(2)); constraint3.setComparator(ComparatorEnum.GREATER_OR_EQUAL_TO); exprs.add(vars.get(2)); - ConstraintMockup constraint2 = new ConstraintMockup(); + ComparisonExpressionMockup constraint2 = new ComparisonExpressionMockup(); times = new ComposedExpressionImplMockup(exprs, OperatorEnum.TIMES); constraint2.setExp1(times);constraint2.setExp2(c); constraint2.setComparator(ComparatorEnum.GREATER_OR_EQUAL_TO); - ConstraintMockup constraint4 = new ConstraintMockup(); + ComparisonExpressionMockup constraint4 = new ComparisonExpressionMockup(); constraint4.setExp1(vars.get(2));constraint4.setExp2(vars.get(2)); constraint4.setComparator(ComparatorEnum.EQUAL_TO); @@ -102,11 +104,11 @@ class CPWrapperTest { @Test public void isFeasibleTest() { - assertFalse( cpWrapper.isFeasible(Arrays.asList(new Integer[] {0, 0, 0}))); + assertFalse( cpWrapper.checkIfFeasible(Arrays.asList(new Integer[] {0, 0, 0}))); - assertFalse( cpWrapper.isFeasible(Arrays.asList(new Integer[] {0, 0, 2}))); + assertFalse( cpWrapper.checkIfFeasible(Arrays.asList(new Integer[] {0, 0, 2}))); - assertTrue( cpWrapper.isFeasible(Arrays.asList(new Integer[] {2, 0, 2}))); + assertTrue( cpWrapper.checkIfFeasible(Arrays.asList(new Integer[] {2, 0, 2}))); } @Test diff --git a/ZPPSolver/CPParser/src/test/java/CPWrapper/Mockups/ConstraintMockup.java b/zpp-solver/cp-parser/src/test/java/cp_wrapper/mockups/ComparisonExpressionMockup.java similarity index 97% rename from ZPPSolver/CPParser/src/test/java/CPWrapper/Mockups/ConstraintMockup.java rename to zpp-solver/cp-parser/src/test/java/cp_wrapper/mockups/ComparisonExpressionMockup.java index 367ea65f7..d2ffcd7b6 100644 --- a/ZPPSolver/CPParser/src/test/java/CPWrapper/Mockups/ConstraintMockup.java +++ b/zpp-solver/cp-parser/src/test/java/cp_wrapper/mockups/ComparisonExpressionMockup.java @@ -1,4 +1,4 @@ -package CPWrapper.Mockups; +package cp_wrapper.mockups; import eu.paasage.upperware.metamodel.cp.ComparatorEnum; import eu.paasage.upperware.metamodel.cp.ComparisonExpression; @@ -21,7 +21,7 @@ import org.eclipse.emf.ecore.resource.Resource; import java.lang.reflect.InvocationTargetException; -public class ConstraintMockup implements ComparisonExpression { +public class ComparisonExpressionMockup implements ComparisonExpression { Expression exp1; Expression exp2; ComparatorEnum comparator; diff --git a/ZPPSolver/CPParser/src/test/java/CPWrapper/Mockups/ComposedExpressionImplMockup.java b/zpp-solver/cp-parser/src/test/java/cp_wrapper/mockups/ComposedExpressionImplMockup.java similarity index 96% rename from ZPPSolver/CPParser/src/test/java/CPWrapper/Mockups/ComposedExpressionImplMockup.java rename to zpp-solver/cp-parser/src/test/java/cp_wrapper/mockups/ComposedExpressionImplMockup.java index cbc58d695..26270221c 100644 --- a/ZPPSolver/CPParser/src/test/java/CPWrapper/Mockups/ComposedExpressionImplMockup.java +++ b/zpp-solver/cp-parser/src/test/java/cp_wrapper/mockups/ComposedExpressionImplMockup.java @@ -1,4 +1,4 @@ -package CPWrapper.Mockups; +package cp_wrapper.mockups; import eu.paasage.upperware.metamodel.cp.ComposedExpression; import eu.paasage.upperware.metamodel.cp.NumericExpression; diff --git a/ZPPSolver/CPParser/src/test/java/CPWrapper/Mockups/ConstantImplMockup.java b/zpp-solver/cp-parser/src/test/java/cp_wrapper/mockups/ConstantImplMockup.java similarity index 96% rename from ZPPSolver/CPParser/src/test/java/CPWrapper/Mockups/ConstantImplMockup.java rename to zpp-solver/cp-parser/src/test/java/cp_wrapper/mockups/ConstantImplMockup.java index 7f579ea04..eec53147a 100644 --- a/ZPPSolver/CPParser/src/test/java/CPWrapper/Mockups/ConstantImplMockup.java +++ b/zpp-solver/cp-parser/src/test/java/cp_wrapper/mockups/ConstantImplMockup.java @@ -1,4 +1,4 @@ -package CPWrapper.Mockups; +package cp_wrapper.mockups; import eu.paasage.upperware.metamodel.cp.Constant; import eu.paasage.upperware.metamodel.cp.impl.NumericExpressionImpl; diff --git a/ZPPSolver/CPParser/src/test/java/CPWrapper/Mockups/ArConstraintMockup.java b/zpp-solver/cp-parser/src/test/java/cp_wrapper/mockups/ConstraintMockup.java similarity index 75% rename from ZPPSolver/CPParser/src/test/java/CPWrapper/Mockups/ArConstraintMockup.java rename to zpp-solver/cp-parser/src/test/java/cp_wrapper/mockups/ConstraintMockup.java index 6edb75048..6d5b22c9c 100644 --- a/ZPPSolver/CPParser/src/test/java/CPWrapper/Mockups/ArConstraintMockup.java +++ b/zpp-solver/cp-parser/src/test/java/cp_wrapper/mockups/ConstraintMockup.java @@ -1,13 +1,13 @@ -package CPWrapper.Mockups; +package cp_wrapper.mockups; -import CPWrapper.Utils.ArConstraint; +import cp_wrapper.utils.constraint.Constraint; import lombok.AllArgsConstructor; import java.util.Collection; import java.util.Map; @AllArgsConstructor -public class ArConstraintMockup implements ArConstraint { +public class ConstraintMockup implements Constraint { private Collection variables; @Override diff --git a/ZPPSolver/CPParser/src/test/java/CPWrapper/Mockups/ConstraintProblemMockup.java b/zpp-solver/cp-parser/src/test/java/cp_wrapper/mockups/ConstraintProblemMockup.java similarity index 99% rename from ZPPSolver/CPParser/src/test/java/CPWrapper/Mockups/ConstraintProblemMockup.java rename to zpp-solver/cp-parser/src/test/java/cp_wrapper/mockups/ConstraintProblemMockup.java index 51e657996..34b1b9129 100644 --- a/ZPPSolver/CPParser/src/test/java/CPWrapper/Mockups/ConstraintProblemMockup.java +++ b/zpp-solver/cp-parser/src/test/java/cp_wrapper/mockups/ConstraintProblemMockup.java @@ -1,4 +1,4 @@ -package CPWrapper.Mockups; +package cp_wrapper.mockups; import eu.paasage.upperware.metamodel.cp.*; import lombok.AllArgsConstructor; diff --git a/ZPPSolver/CPParser/src/test/java/CPWrapper/Mockups/CpMetricImplMockup.java b/zpp-solver/cp-parser/src/test/java/cp_wrapper/mockups/CpMetricImplMockup.java similarity index 96% rename from ZPPSolver/CPParser/src/test/java/CPWrapper/Mockups/CpMetricImplMockup.java rename to zpp-solver/cp-parser/src/test/java/cp_wrapper/mockups/CpMetricImplMockup.java index 5d60b787f..5c40b8375 100644 --- a/ZPPSolver/CPParser/src/test/java/CPWrapper/Mockups/CpMetricImplMockup.java +++ b/zpp-solver/cp-parser/src/test/java/cp_wrapper/mockups/CpMetricImplMockup.java @@ -1,4 +1,4 @@ -package CPWrapper.Mockups; +package cp_wrapper.mockups; import eu.paasage.upperware.metamodel.cp.CpMetric; import eu.paasage.upperware.metamodel.cp.impl.NumericExpressionImpl; diff --git a/ZPPSolver/CPParser/src/test/java/CPWrapper/Mockups/CpVariableImplMockup.java b/zpp-solver/cp-parser/src/test/java/cp_wrapper/mockups/CpVariableImplMockup.java similarity index 97% rename from ZPPSolver/CPParser/src/test/java/CPWrapper/Mockups/CpVariableImplMockup.java rename to zpp-solver/cp-parser/src/test/java/cp_wrapper/mockups/CpVariableImplMockup.java index 40065b118..df7c16466 100644 --- a/ZPPSolver/CPParser/src/test/java/CPWrapper/Mockups/CpVariableImplMockup.java +++ b/zpp-solver/cp-parser/src/test/java/cp_wrapper/mockups/CpVariableImplMockup.java @@ -1,4 +1,4 @@ -package CPWrapper.Mockups; +package cp_wrapper.mockups; import eu.paasage.upperware.metamodel.cp.CpVariable; import eu.paasage.upperware.metamodel.cp.Domain; diff --git a/ZPPSolver/CPParser/src/test/java/CPWrapper/Mockups/NumericListDomainImplMockup.java b/zpp-solver/cp-parser/src/test/java/cp_wrapper/mockups/NumericListDomainImplMockup.java similarity index 99% rename from ZPPSolver/CPParser/src/test/java/CPWrapper/Mockups/NumericListDomainImplMockup.java rename to zpp-solver/cp-parser/src/test/java/cp_wrapper/mockups/NumericListDomainImplMockup.java index 05d0dc1a6..35c875cf3 100644 --- a/ZPPSolver/CPParser/src/test/java/CPWrapper/Mockups/NumericListDomainImplMockup.java +++ b/zpp-solver/cp-parser/src/test/java/cp_wrapper/mockups/NumericListDomainImplMockup.java @@ -1,4 +1,4 @@ -package CPWrapper.Mockups; +package cp_wrapper.mockups; import eu.paasage.upperware.metamodel.cp.NumericListDomain; import eu.paasage.upperware.metamodel.types.BasicTypeEnum; diff --git a/ZPPSolver/CPParser/src/test/java/CPWrapper/Mockups/NumericValueUpperwareImplMockup.java b/zpp-solver/cp-parser/src/test/java/cp_wrapper/mockups/NumericValueUpperwareImplMockup.java similarity index 99% rename from ZPPSolver/CPParser/src/test/java/CPWrapper/Mockups/NumericValueUpperwareImplMockup.java rename to zpp-solver/cp-parser/src/test/java/cp_wrapper/mockups/NumericValueUpperwareImplMockup.java index 20ecc035f..b1e9ce6df 100644 --- a/ZPPSolver/CPParser/src/test/java/CPWrapper/Mockups/NumericValueUpperwareImplMockup.java +++ b/zpp-solver/cp-parser/src/test/java/cp_wrapper/mockups/NumericValueUpperwareImplMockup.java @@ -1,4 +1,4 @@ -package CPWrapper.Mockups; +package cp_wrapper.mockups; import eu.paasage.upperware.metamodel.types.DoubleValueUpperware; import lombok.AllArgsConstructor; diff --git a/ZPPSolver/CPParser/src/test/java/CPWrapper/Mockups/RangeDomainImpMockup.java b/zpp-solver/cp-parser/src/test/java/cp_wrapper/mockups/RangeDomainImpMockup.java similarity index 99% rename from ZPPSolver/CPParser/src/test/java/CPWrapper/Mockups/RangeDomainImpMockup.java rename to zpp-solver/cp-parser/src/test/java/cp_wrapper/mockups/RangeDomainImpMockup.java index 07716bc8c..018eec869 100644 --- a/ZPPSolver/CPParser/src/test/java/CPWrapper/Mockups/RangeDomainImpMockup.java +++ b/zpp-solver/cp-parser/src/test/java/cp_wrapper/mockups/RangeDomainImpMockup.java @@ -1,4 +1,4 @@ -package CPWrapper.Mockups; +package cp_wrapper.mockups; import eu.paasage.upperware.metamodel.cp.RangeDomain; import eu.paasage.upperware.metamodel.types.BasicTypeEnum; diff --git a/ZPPSolver/CPParser/src/test/java/CPWrapper/Mockups/UtilityProviderMockup.java b/zpp-solver/cp-parser/src/test/java/cp_wrapper/mockups/UtilityProviderMockup.java similarity index 66% rename from ZPPSolver/CPParser/src/test/java/CPWrapper/Mockups/UtilityProviderMockup.java rename to zpp-solver/cp-parser/src/test/java/cp_wrapper/mockups/UtilityProviderMockup.java index 745097a4a..a073e2fe2 100644 --- a/ZPPSolver/CPParser/src/test/java/CPWrapper/Mockups/UtilityProviderMockup.java +++ b/zpp-solver/cp-parser/src/test/java/cp_wrapper/mockups/UtilityProviderMockup.java @@ -1,7 +1,6 @@ -package CPWrapper.Mockups; +package cp_wrapper.mockups; -import CPWrapper.UtilityProvider; -import eu.melodic.upperware.utilitygenerator.UtilityGeneratorApplication; +import cp_wrapper.UtilityProvider; import eu.melodic.upperware.utilitygenerator.cdo.cp_model.DTO.VariableValueDTO; import java.util.List; diff --git a/ZPPSolver/CPParser/src/test/java/CPWrapper/Utils/ConstraintGraphTest.java b/zpp-solver/cp-parser/src/test/java/cp_wrapper/utils/ConstraintGraphTest.java similarity index 79% rename from ZPPSolver/CPParser/src/test/java/CPWrapper/Utils/ConstraintGraphTest.java rename to zpp-solver/cp-parser/src/test/java/cp_wrapper/utils/ConstraintGraphTest.java index 1b2801e19..cf22de1b1 100644 --- a/ZPPSolver/CPParser/src/test/java/CPWrapper/Utils/ConstraintGraphTest.java +++ b/zpp-solver/cp-parser/src/test/java/cp_wrapper/utils/ConstraintGraphTest.java @@ -1,12 +1,13 @@ -package CPWrapper.Utils; +package cp_wrapper.utils; -import CPWrapper.Mockups.ArConstraintMockup; +import cp_wrapper.mockups.ConstraintMockup; +import cp_wrapper.utils.constraint.Constraint; import org.junit.jupiter.api.BeforeAll; import org.junit.jupiter.api.Test; import java.util.*; -import static org.junit.jupiter.api.Assertions.*; +import static org.junit.Assert.assertEquals; class ConstraintGraphTest { private static List variables; @@ -18,7 +19,7 @@ class ConstraintGraphTest { @Test public void noEdgesGraphTest() { - ConstraintGraph graph = new ConstraintGraph(new ArrayList(), variables); + ConstraintGraph graph = new ConstraintGraph(new ArrayList(), variables); for (int distance = 1; distance < 10; distance ++) { for (String v : variables) { assertEquals(graph.getNumberOfNeighbours(v, distance), 0); @@ -28,14 +29,14 @@ class ConstraintGraphTest { @Test public void graphWithCycleTest() { - Collection constraints = new ArrayList<>(); + Collection constraints = new ArrayList<>(); int varsSize = variables.size(); for (int i =1; i <= variables.size(); i++) { List vars = new ArrayList<>(); vars.add(variables.get(i-1)); vars.add(variables.get(i % varsSize)); - constraints.add(new ArConstraintMockup(vars)); + constraints.add(new ConstraintMockup(vars)); } ConstraintGraph graph = new ConstraintGraph(constraints, variables); @@ -50,8 +51,8 @@ class ConstraintGraphTest { @Test public void fullGraphTest() { int varsSize = variables.size(); - Collection constraints = new ArrayList<>(); - ArConstraint constraint = new ArConstraintMockup(variables); + Collection constraints = new ArrayList<>(); + Constraint constraint = new ConstraintMockup(variables); constraints.add(constraint); ConstraintGraph graph = new ConstraintGraph(constraints, variables); for (String var : variables) { @@ -62,10 +63,10 @@ class ConstraintGraphTest { @Test public void hugeFullyConnectedGraphTest() { int varsSize = variables.size(); - Collection constraints = new ArrayList<>(); + Collection constraints = new ArrayList<>(); int noOfConstraints = 10000; for (int i = 0; i < noOfConstraints; i ++ ) { - constraints.add(new ArConstraintMockup(variables)); + constraints.add(new ConstraintMockup(variables)); } ConstraintGraph graph = new ConstraintGraph(constraints, variables); for (String var : variables) { @@ -80,10 +81,10 @@ class ConstraintGraphTest { @Test public void expandingGraphTest() { - Collection constraints = new ArrayList<>(); + Collection constraints = new ArrayList<>(); int varsSize = variables.size(); for(int i = 0; i < varsSize; i++) { - constraints.add(new ArConstraintMockup(variables.subList(0,i+1))); + constraints.add(new ConstraintMockup(variables.subList(0,i+1))); } ConstraintGraph graph = new ConstraintGraph(constraints, variables); for (int i = 0; i < varsSize; i++) { diff --git a/ZPPSolver/CPParser/src/test/java/CPWrapper/Utils/ArConstraintImplTest.java b/zpp-solver/cp-parser/src/test/java/cp_wrapper/utils/ConstraintImplTest.java similarity index 80% rename from ZPPSolver/CPParser/src/test/java/CPWrapper/Utils/ArConstraintImplTest.java rename to zpp-solver/cp-parser/src/test/java/cp_wrapper/utils/ConstraintImplTest.java index 55a3ae48f..a1b60e3a0 100644 --- a/ZPPSolver/CPParser/src/test/java/CPWrapper/Utils/ArConstraintImplTest.java +++ b/zpp-solver/cp-parser/src/test/java/cp_wrapper/utils/ConstraintImplTest.java @@ -1,6 +1,8 @@ -package CPWrapper.Utils; +package cp_wrapper.utils; -import CPWrapper.Mockups.*; +import cp_wrapper.mockups.*; +import cp_wrapper.utils.constraint.Constraint; +import cp_wrapper.utils.constraint.ConstraintImpl; import eu.paasage.upperware.metamodel.cp.*; import eu.paasage.upperware.metamodel.types.BasicTypeEnum; import org.eclipse.emf.common.util.BasicEList; @@ -12,7 +14,7 @@ import java.util.*; import static org.junit.jupiter.api.Assertions.*; -class ArConstraintImplTest { +class ConstraintImplTest { private static List variables; private static final String[] names = new String[]{"Variable", "qwerty", "wewrfdvdfbfdvd"}; @BeforeAll @@ -25,7 +27,7 @@ class ArConstraintImplTest { @Test public void shouldThrowEmptyVariables(){ Map emptyVars = new HashMap<>(); - ArConstraint constraint = new ArConstraintImpl(ComparatorEnum.DIFFERENT, variables.get(0), variables.get(1)); + Constraint constraint = new ConstraintImpl(ComparatorEnum.DIFFERENT, variables.get(0), variables.get(1)); assertThrows(RuntimeException.class, () -> { constraint.evaluate(emptyVars); }); @@ -34,7 +36,7 @@ class ArConstraintImplTest { @Test public void shouldThrowWrongVariables(){ Map emptyVars = new HashMap<>(); - ArConstraint constraint = new ArConstraintImpl(ComparatorEnum.DIFFERENT, variables.get(0), variables.get(1)); + Constraint constraint = new ConstraintImpl(ComparatorEnum.DIFFERENT, variables.get(0), variables.get(1)); Map vars = new HashMap<>(); vars.put(names[1], 0.00123); vars.put(names[2], 123.345); @@ -56,11 +58,11 @@ class ArConstraintImplTest { exprs.addAll(variables); Expression sum = new ComposedExpressionImplMockup(exprs, OperatorEnum.PLUS); - ArConstraint constraint = new ArConstraintImpl(ComparatorEnum.GREATER_OR_EQUAL_TO, sum, c); + Constraint constraint = new ConstraintImpl(ComparatorEnum.GREATER_OR_EQUAL_TO, sum, c); assertTrue(constraint.evaluate(vars)); - constraint = new ArConstraintImpl(ComparatorEnum.GREATER_OR_EQUAL_TO, c, sum); + constraint = new ConstraintImpl(ComparatorEnum.GREATER_OR_EQUAL_TO, c, sum); assertFalse(constraint.evaluate(vars)); } @@ -81,7 +83,7 @@ class ArConstraintImplTest { vars.put(names[0], 2.0); vars.put(names[1], 3.0); vars.put(names[2], 5.0); - ArConstraint constraint = new ArConstraintImpl(ComparatorEnum.GREATER_OR_EQUAL_TO, div, sum); + Constraint constraint = new ConstraintImpl(ComparatorEnum.GREATER_OR_EQUAL_TO, div, sum); assertFalse(constraint.evaluate(vars)); } } \ No newline at end of file diff --git a/ZPPSolver/CPParser/src/test/java/CPWrapper/Utils/ExpressionEvaluatorTest.java b/zpp-solver/cp-parser/src/test/java/cp_wrapper/utils/ExpressionEvaluatorTest.java similarity index 98% rename from ZPPSolver/CPParser/src/test/java/CPWrapper/Utils/ExpressionEvaluatorTest.java rename to zpp-solver/cp-parser/src/test/java/cp_wrapper/utils/ExpressionEvaluatorTest.java index bbfbd4617..3bd68cee4 100644 --- a/ZPPSolver/CPParser/src/test/java/CPWrapper/Utils/ExpressionEvaluatorTest.java +++ b/zpp-solver/cp-parser/src/test/java/cp_wrapper/utils/ExpressionEvaluatorTest.java @@ -1,6 +1,6 @@ -package CPWrapper.Utils; +package cp_wrapper.utils; -import CPWrapper.Mockups.*; +import cp_wrapper.mockups.*; import eu.paasage.upperware.metamodel.cp.*; import eu.paasage.upperware.metamodel.types.BasicTypeEnum; import eu.paasage.upperware.metamodel.types.NumericValueUpperware; diff --git a/ZPPSolver/CPParser/src/test/java/CPWrapper/Utils/HeuristicVariableOrdererTest.java b/zpp-solver/cp-parser/src/test/java/cp_wrapper/utils/HeuristicVariableOrdererTest.java similarity index 61% rename from ZPPSolver/CPParser/src/test/java/CPWrapper/Utils/HeuristicVariableOrdererTest.java rename to zpp-solver/cp-parser/src/test/java/cp_wrapper/utils/HeuristicVariableOrdererTest.java index 3a33bde17..d99edd913 100644 --- a/ZPPSolver/CPParser/src/test/java/CPWrapper/Utils/HeuristicVariableOrdererTest.java +++ b/zpp-solver/cp-parser/src/test/java/cp_wrapper/utils/HeuristicVariableOrdererTest.java @@ -1,5 +1,7 @@ -package CPWrapper.Utils; -import CPWrapper.Mockups.ArConstraintMockup; +package cp_wrapper.utils; +import cp_wrapper.mockups.ConstraintMockup; +import cp_wrapper.utils.constraint.Constraint; +import cp_wrapper.utils.variable_orderer.HeuristicVariableOrderer; import org.junit.jupiter.api.BeforeAll; import org.junit.jupiter.api.Test; @@ -16,21 +18,21 @@ class HeuristicVariableOrdererTest { } private static ConstraintGraph createExpandingGraph() { - Collection constraints = new ArrayList<>(); + Collection constraints = new ArrayList<>(); int varsSize = variables.size(); for(int i = 0; i < varsSize; i++) { - constraints.add(new ArConstraintMockup(variables.subList(0,i+1))); + constraints.add(new ConstraintMockup(variables.subList(0,i+1))); } return new ConstraintGraph(constraints, variables); } private static ConstraintGraph sameNumberOfConstraintsGraph() { - Collection constraints = new ArrayList<>(); + Collection constraints = new ArrayList<>(); int varsSize = variables.size(); for(int i = 0; i < varsSize; i++) { - constraints.add(new ArConstraintMockup(variables.subList(0,i+1))); + constraints.add(new ConstraintMockup(variables.subList(0,i+1))); for (int j = i + 1; j < varsSize; j++) { - constraints.add(new ArConstraintMockup(variables.subList(j, j+1))); + constraints.add(new ConstraintMockup(variables.subList(j, j+1))); } } return new ConstraintGraph(constraints, variables); @@ -41,7 +43,7 @@ class HeuristicVariableOrdererTest { ConstraintGraph graph = createExpandingGraph(); HeuristicVariableOrderer orderer = new HeuristicVariableOrderer(graph); for (int i = 0; i < variables.size(); i++) { - assertTrue( orderer.indexToVariableName(i).equals(variables.get(i))); + assertTrue( orderer.getNameFromIndex(i).equals(variables.get(i))); } } @@ -53,22 +55,22 @@ class HeuristicVariableOrdererTest { HeuristicVariableOrderer orderer = new HeuristicVariableOrderer(graph); Set vars = new HashSet<>(); for (int i = 0; i < variables.size(); i++) { - vars.add(orderer.indexToVariableName(i)); + vars.add(orderer.getNameFromIndex(i)); } assertEquals(vars.size(), variables.size()); } @Test public void simpleGraphTest() { - Collection constraints = new ArrayList<>(); - constraints.add(new ArConstraintMockup(variables.subList(0,1))); - constraints.add(new ArConstraintMockup(variables.subList(1,3))); - constraints.add(new ArConstraintMockup(variables.subList(2,3))); + Collection constraints = new ArrayList<>(); + constraints.add(new ConstraintMockup(variables.subList(0,1))); + constraints.add(new ConstraintMockup(variables.subList(1,3))); + constraints.add(new ConstraintMockup(variables.subList(2,3))); ConstraintGraph graph = new ConstraintGraph(constraints, variables.subList(0,3)); HeuristicVariableOrderer orderer = new HeuristicVariableOrderer(graph); - assertTrue(orderer.indexToVariableName(0).equals(variables.get(2))); - assertTrue(orderer.indexToVariableName(1).equals(variables.get(1))); - assertTrue(orderer.indexToVariableName(2).equals(variables.get(0))); + assertTrue(orderer.getNameFromIndex(0).equals(variables.get(2))); + assertTrue(orderer.getNameFromIndex(1).equals(variables.get(1))); + assertTrue(orderer.getNameFromIndex(2).equals(variables.get(0))); } } \ No newline at end of file diff --git a/ZPPSolver/GeneticSolver/pom.xml b/zpp-solver/genetic-solver/pom.xml similarity index 100% rename from ZPPSolver/GeneticSolver/pom.xml rename to zpp-solver/genetic-solver/pom.xml diff --git a/ZPPSolver/MCTSSolver/pom.xml b/zpp-solver/mcts-solver/pom.xml similarity index 100% rename from ZPPSolver/MCTSSolver/pom.xml rename to zpp-solver/mcts-solver/pom.xml diff --git a/ZPPSolver/PTSolver/pom.xml b/zpp-solver/pt-solver/pom.xml similarity index 100% rename from ZPPSolver/PTSolver/pom.xml rename to zpp-solver/pt-solver/pom.xml diff --git a/ZPPSolver/PTSolver/src/main/java/PTSolverCoordinator.java b/zpp-solver/pt-solver/src/main/java/PTSolverCoordinator.java similarity index 95% rename from ZPPSolver/PTSolver/src/main/java/PTSolverCoordinator.java rename to zpp-solver/pt-solver/src/main/java/PTSolverCoordinator.java index 9aa27b84f..6f1a438c4 100644 --- a/ZPPSolver/PTSolver/src/main/java/PTSolverCoordinator.java +++ b/zpp-solver/pt-solver/src/main/java/PTSolverCoordinator.java @@ -1,7 +1,7 @@ -import CPComponents.*; -import CPWrapper.CPWrapper; -import CPWrapper.UtilityProvider; -import PTCPWrapper.PTCPWrapper; +import cp_components.*; +import cp_wrapper.CPWrapper; +import cp_wrapper.UtilityProvider; +import ptcp_wrapper.PTCPWrapper; import eu.paasage.upperware.metamodel.cp.ConstraintProblem; import org.jamesframework.core.problems.GenericProblem; import org.jamesframework.core.problems.Problem; diff --git a/ZPPSolver/PTSolver/src/main/java/CPComponents/PTEvaluation.java b/zpp-solver/pt-solver/src/main/java/cp_components/PTEvaluation.java similarity index 76% rename from ZPPSolver/PTSolver/src/main/java/CPComponents/PTEvaluation.java rename to zpp-solver/pt-solver/src/main/java/cp_components/PTEvaluation.java index 2cb1e948c..42901c109 100644 --- a/ZPPSolver/PTSolver/src/main/java/CPComponents/PTEvaluation.java +++ b/zpp-solver/pt-solver/src/main/java/cp_components/PTEvaluation.java @@ -1,5 +1,7 @@ -package CPComponents; - +package cp_components; +/* + Wrapper over double type - required by James library + */ import lombok.AllArgsConstructor; import org.jamesframework.core.problems.objectives.evaluations.Evaluation; diff --git a/ZPPSolver/PTSolver/src/main/java/CPComponents/PTMover.java b/zpp-solver/pt-solver/src/main/java/cp_components/PTMover.java similarity index 98% rename from ZPPSolver/PTSolver/src/main/java/CPComponents/PTMover.java rename to zpp-solver/pt-solver/src/main/java/cp_components/PTMover.java index 827cd89fb..e27c35cad 100644 --- a/ZPPSolver/PTSolver/src/main/java/CPComponents/PTMover.java +++ b/zpp-solver/pt-solver/src/main/java/cp_components/PTMover.java @@ -1,4 +1,4 @@ -package CPComponents; +package cp_components; /* Class which abstracts moves in CP search space. There are only two types of moves: diff --git a/ZPPSolver/PTSolver/src/main/java/CPComponents/PTNeighbourhood.java b/zpp-solver/pt-solver/src/main/java/cp_components/PTNeighbourhood.java similarity index 98% rename from ZPPSolver/PTSolver/src/main/java/CPComponents/PTNeighbourhood.java rename to zpp-solver/pt-solver/src/main/java/cp_components/PTNeighbourhood.java index 14ba109d9..84d40fbd6 100644 --- a/ZPPSolver/PTSolver/src/main/java/CPComponents/PTNeighbourhood.java +++ b/zpp-solver/pt-solver/src/main/java/cp_components/PTNeighbourhood.java @@ -1,4 +1,4 @@ -package CPComponents; +package cp_components; /* Neighbourhood of a search space element - V - is defined to be a set of all elements which may be transformed to diff --git a/ZPPSolver/PTSolver/src/main/java/CPComponents/PTObjective.java b/zpp-solver/pt-solver/src/main/java/cp_components/PTObjective.java similarity index 90% rename from ZPPSolver/PTSolver/src/main/java/CPComponents/PTObjective.java rename to zpp-solver/pt-solver/src/main/java/cp_components/PTObjective.java index 2470044f4..ddf2527c1 100644 --- a/ZPPSolver/PTSolver/src/main/java/CPComponents/PTObjective.java +++ b/zpp-solver/pt-solver/src/main/java/cp_components/PTObjective.java @@ -1,6 +1,6 @@ -package CPComponents; +package cp_components; -import PTCPWrapper.PTCPWrapper; +import ptcp_wrapper.PTCPWrapper; import org.jamesframework.core.problems.objectives.Objective; import org.jamesframework.core.problems.objectives.evaluations.Evaluation; diff --git a/ZPPSolver/PTSolver/src/main/java/CPComponents/PTRandomGenerator.java b/zpp-solver/pt-solver/src/main/java/cp_components/PTRandomGenerator.java similarity index 85% rename from ZPPSolver/PTSolver/src/main/java/CPComponents/PTRandomGenerator.java rename to zpp-solver/pt-solver/src/main/java/cp_components/PTRandomGenerator.java index 6a6500fca..0d27241c8 100644 --- a/ZPPSolver/PTSolver/src/main/java/CPComponents/PTRandomGenerator.java +++ b/zpp-solver/pt-solver/src/main/java/cp_components/PTRandomGenerator.java @@ -1,6 +1,6 @@ -package CPComponents; +package cp_components; -import PTCPWrapper.PTCPWrapper; +import ptcp_wrapper.PTCPWrapper; import org.jamesframework.core.problems.sol.RandomSolutionGenerator; import java.util.Random; diff --git a/ZPPSolver/PTSolver/src/main/java/CPComponents/PTSolution.java b/zpp-solver/pt-solver/src/main/java/cp_components/PTSolution.java similarity index 98% rename from ZPPSolver/PTSolver/src/main/java/CPComponents/PTSolution.java rename to zpp-solver/pt-solver/src/main/java/cp_components/PTSolution.java index e41093ce7..2ec7512bd 100644 --- a/ZPPSolver/PTSolver/src/main/java/CPComponents/PTSolution.java +++ b/zpp-solver/pt-solver/src/main/java/cp_components/PTSolution.java @@ -1,4 +1,4 @@ -package CPComponents; +package cp_components; /* Search space element for Parallel Tempering */ diff --git a/ZPPSolver/PTSolver/src/main/java/PTCPWrapper/PTCPWrapper.java b/zpp-solver/pt-solver/src/main/java/ptcp_wrapper/PTCPWrapper.java similarity index 75% rename from ZPPSolver/PTSolver/src/main/java/PTCPWrapper/PTCPWrapper.java rename to zpp-solver/pt-solver/src/main/java/ptcp_wrapper/PTCPWrapper.java index 66e62a4d2..803cb9f24 100644 --- a/ZPPSolver/PTSolver/src/main/java/PTCPWrapper/PTCPWrapper.java +++ b/zpp-solver/pt-solver/src/main/java/ptcp_wrapper/PTCPWrapper.java @@ -1,13 +1,12 @@ -package PTCPWrapper; +package ptcp_wrapper; /* Thin layer on top of CPWrapper class from CPParser package. */ -import CPComponents.PTEvaluation; -import CPComponents.PTSolution; -import CPWrapper.CPWrapper; +import cp_components.PTEvaluation; +import cp_components.PTSolution; +import cp_wrapper.CPWrapper; import lombok.AllArgsConstructor; import org.jamesframework.core.problems.objectives.evaluations.Evaluation; -import org.jamesframework.core.problems.sol.RandomSolutionGenerator; import java.util.ArrayList; import java.util.List; @@ -17,13 +16,15 @@ public class PTCPWrapper { private CPWrapper cpWrapper; public Evaluation evaluate(List assignments) { - if (cpWrapper.isFeasible(assignments)) { + if (cpWrapper.checkIfFeasible(assignments)) { return new PTEvaluation(cpWrapper.getUtility(assignments)); } else { return new PTEvaluation(0); } } - + /* + Returns maximal value of variable @variable + */ public int getMaxValue(int variable) { return cpWrapper.getMaxDomainValue(variable); } @@ -32,6 +33,9 @@ public class PTCPWrapper { return cpWrapper.getMinDomainValue(variable); } + /* + Generates random (uniform) value for variable @variable + */ private int generateRandomValue(int variable, Random random) { int domainSize = getMaxValue(variable) - getMinValue(variable) + 1; int value = random.nextInt(domainSize); @@ -42,7 +46,10 @@ public class PTCPWrapper { public int getVariablesCount() { return cpWrapper.getVariablesCount(); } - + /* + Generates random solution to the constraint problem. + Used to sample starting point for parallel tempering. + */ public PTSolution generateRandom(Random random) { List assignment = new ArrayList<>(); for (int i = 0; i < cpWrapper.getVariablesCount(); i++) { diff --git a/ZPPSolver/PTSolver/src/test/java/PTSolverCoordinatorTest.java b/zpp-solver/pt-solver/src/test/java/PTSolverCoordinatorTest.java similarity index 91% rename from ZPPSolver/PTSolver/src/test/java/PTSolverCoordinatorTest.java rename to zpp-solver/pt-solver/src/test/java/PTSolverCoordinatorTest.java index dbaeb8a13..bdcf540f6 100644 --- a/ZPPSolver/PTSolver/src/test/java/PTSolverCoordinatorTest.java +++ b/zpp-solver/pt-solver/src/test/java/PTSolverCoordinatorTest.java @@ -1,6 +1,6 @@ -import CPComponents.PTSolution; -import CPWrapper.Mockups.*; -import CPWrapper.UtilityProvider; +import cp_components.PTSolution; +import cp_wrapper.mockups.*; +import cp_wrapper.UtilityProvider; import eu.melodic.upperware.utilitygenerator.cdo.cp_model.DTO.VariableValueDTO; import eu.paasage.upperware.metamodel.cp.*; import eu.paasage.upperware.metamodel.types.BasicTypeEnum; @@ -52,21 +52,21 @@ class PTSolverCoordinatorTest { EList exprs = new BasicEList<>(); exprs.add(vars.get(0)); exprs.add(vars.get(1)); NumericExpression times = new ComposedExpressionImplMockup(exprs, OperatorEnum.TIMES); - ConstraintMockup constraint1 = new ConstraintMockup(); + ComparisonExpressionMockup constraint1 = new ComparisonExpressionMockup(); constraint1.setExp1(vars.get(0));constraint1.setExp2(vars.get(2)); constraint1.setComparator(ComparatorEnum.LESS_THAN); - ConstraintMockup constraint3 = new ConstraintMockup(); + ComparisonExpressionMockup constraint3 = new ComparisonExpressionMockup(); constraint3.setExp1(times);constraint3.setExp2(vars.get(2)); constraint3.setComparator(ComparatorEnum.GREATER_OR_EQUAL_TO); exprs.add(vars.get(2)); - ConstraintMockup constraint2 = new ConstraintMockup(); + ComparisonExpressionMockup constraint2 = new ComparisonExpressionMockup(); times = new ComposedExpressionImplMockup(exprs, OperatorEnum.TIMES); constraint2.setExp1(times);constraint2.setExp2(c); constraint2.setComparator(ComparatorEnum.GREATER_OR_EQUAL_TO); - ConstraintMockup constraint4 = new ConstraintMockup(); + ComparisonExpressionMockup constraint4 = new ComparisonExpressionMockup(); constraint4.setExp1(vars.get(2));constraint4.setExp2(vars.get(2)); constraint4.setComparator(ComparatorEnum.EQUAL_TO); diff --git a/ZPPSolver/PTSolver/src/test/java/CPComponents/PTMoverTest.java b/zpp-solver/pt-solver/src/test/java/cp_components/PTMoverTest.java similarity index 97% rename from ZPPSolver/PTSolver/src/test/java/CPComponents/PTMoverTest.java rename to zpp-solver/pt-solver/src/test/java/cp_components/PTMoverTest.java index fb590790e..373a39339 100644 --- a/ZPPSolver/PTSolver/src/test/java/CPComponents/PTMoverTest.java +++ b/zpp-solver/pt-solver/src/test/java/cp_components/PTMoverTest.java @@ -1,4 +1,4 @@ -package CPComponents; +package cp_components; import org.junit.jupiter.api.Test; diff --git a/ZPPSolver/PTSolver/src/test/java/CPComponents/PTNeighbourhoodTest.java b/zpp-solver/pt-solver/src/test/java/cp_components/PTNeighbourhoodTest.java similarity index 97% rename from ZPPSolver/PTSolver/src/test/java/CPComponents/PTNeighbourhoodTest.java rename to zpp-solver/pt-solver/src/test/java/cp_components/PTNeighbourhoodTest.java index cf9cc0486..27e4e443d 100644 --- a/ZPPSolver/PTSolver/src/test/java/CPComponents/PTNeighbourhoodTest.java +++ b/zpp-solver/pt-solver/src/test/java/cp_components/PTNeighbourhoodTest.java @@ -1,4 +1,4 @@ -package CPComponents; +package cp_components; import org.junit.jupiter.api.Test; diff --git a/ZPPSolver/PTSolver/src/test/java/CPComponents/PTSolutionTest.java b/zpp-solver/pt-solver/src/test/java/cp_components/PTSolutionTest.java similarity index 97% rename from ZPPSolver/PTSolver/src/test/java/CPComponents/PTSolutionTest.java rename to zpp-solver/pt-solver/src/test/java/cp_components/PTSolutionTest.java index c3a2c1304..f01207e9d 100644 --- a/ZPPSolver/PTSolver/src/test/java/CPComponents/PTSolutionTest.java +++ b/zpp-solver/pt-solver/src/test/java/cp_components/PTSolutionTest.java @@ -1,4 +1,4 @@ -package CPComponents; +package cp_components; import org.junit.jupiter.api.Test; -- GitLab From d298d698d81a7c3a33ce37143005d07dc8bd26b7 Mon Sep 17 00:00:00 2001 From: tc360950 Date: Sun, 22 Dec 2019 21:50:06 +0100 Subject: [PATCH 047/340] Initial classes structre --- zpp-solver/node_candidates_solver/pom.xml | 41 ++++++++++ .../src/main/java/NCWrapper.java | 8 ++ .../src/main/java/cp_components/PTMover.java | 20 +++++ .../java/cp_components/PTNeighbourhood.java | 21 +++++ .../main/java/cp_components/PTSolution.java | 52 +++++++++++++ .../node_candidate/GeographicCoordinate.java | 6 ++ .../java/node_candidate/NodeCandidate.java | 26 +++++++ .../node_candidate/NodeCandidatesPool.java | 70 +++++++++++++++++ .../ComponentVariableOrderer.java | 76 +++++++++++++++++++ .../src/test/java/NCWrapperTest.java | 5 ++ 10 files changed, 325 insertions(+) create mode 100644 zpp-solver/node_candidates_solver/pom.xml create mode 100644 zpp-solver/node_candidates_solver/src/main/java/NCWrapper.java create mode 100644 zpp-solver/node_candidates_solver/src/main/java/cp_components/PTMover.java create mode 100644 zpp-solver/node_candidates_solver/src/main/java/cp_components/PTNeighbourhood.java create mode 100644 zpp-solver/node_candidates_solver/src/main/java/cp_components/PTSolution.java create mode 100644 zpp-solver/node_candidates_solver/src/main/java/node_candidate/GeographicCoordinate.java create mode 100644 zpp-solver/node_candidates_solver/src/main/java/node_candidate/NodeCandidate.java create mode 100644 zpp-solver/node_candidates_solver/src/main/java/node_candidate/NodeCandidatesPool.java create mode 100644 zpp-solver/node_candidates_solver/src/main/java/variable_orderer/ComponentVariableOrderer.java create mode 100644 zpp-solver/node_candidates_solver/src/test/java/NCWrapperTest.java diff --git a/zpp-solver/node_candidates_solver/pom.xml b/zpp-solver/node_candidates_solver/pom.xml new file mode 100644 index 000000000..100beebf8 --- /dev/null +++ b/zpp-solver/node_candidates_solver/pom.xml @@ -0,0 +1,41 @@ + + + 4.0.0 + + org.ow2.paasage + node_candidates_solver + 1.0-SNAPSHOT + + + + org.apache.maven.plugins + maven-compiler-plugin + + 7 + 7 + + + + + + + org.jamesframework + james-core + 1.2 + + + org.projectlombok + lombok + ${lombok.version} + + + org.ow2.paasage + upperware-metamodel + 3.0.0-SNAPSHOT + compile + + + + \ No newline at end of file diff --git a/zpp-solver/node_candidates_solver/src/main/java/NCWrapper.java b/zpp-solver/node_candidates_solver/src/main/java/NCWrapper.java new file mode 100644 index 000000000..9fe1073df --- /dev/null +++ b/zpp-solver/node_candidates_solver/src/main/java/NCWrapper.java @@ -0,0 +1,8 @@ +import java.util.List; + +public class NCWrapper { + private CpWrapper cpWrapper; + private List components; + private VariableOrderer variableOrderer; + +} diff --git a/zpp-solver/node_candidates_solver/src/main/java/cp_components/PTMover.java b/zpp-solver/node_candidates_solver/src/main/java/cp_components/PTMover.java new file mode 100644 index 000000000..bf9980cd8 --- /dev/null +++ b/zpp-solver/node_candidates_solver/src/main/java/cp_components/PTMover.java @@ -0,0 +1,20 @@ +package cp_components; + +import org.jamesframework.core.search.neigh.Move; + +import java.util.List; +@AllArgsConstructor +public class PTMover implements Move { + private List beforeMoveAssignment; + private List afterMoveAssignment; + + @Override + public void apply(PTSolution ptSolution) { + ptSolution.setVarAssignments(afterMoveAssignment); + } + + @Override + public void undo(PTSolution ptSolution) { + ptSolution.setVarAssignments(beforeMoveAssignment); + } +} diff --git a/zpp-solver/node_candidates_solver/src/main/java/cp_components/PTNeighbourhood.java b/zpp-solver/node_candidates_solver/src/main/java/cp_components/PTNeighbourhood.java new file mode 100644 index 000000000..8cf39edb1 --- /dev/null +++ b/zpp-solver/node_candidates_solver/src/main/java/cp_components/PTNeighbourhood.java @@ -0,0 +1,21 @@ +package cp_components; + +import node_candidate.NodeCandidatesPool; +import org.jamesframework.core.search.neigh.Move; +import org.jamesframework.core.search.neigh.Neighbourhood; + +import java.util.List; +import java.util.Random; + +public class PTNeighbourhood implements Neighbourhood { + private NodeCandidatesPool nodeCandidatesPool; + @Override + public Move getRandomMove(PTSolution ptSolution, Random random) { + return nodeCandidatesPool.getRandomMove(ptSolution.getVarAssignments()); + } + + @Override + public List> getAllMoves(PTSolution ptSolution) { + return null; + } +} diff --git a/zpp-solver/node_candidates_solver/src/main/java/cp_components/PTSolution.java b/zpp-solver/node_candidates_solver/src/main/java/cp_components/PTSolution.java new file mode 100644 index 000000000..667848551 --- /dev/null +++ b/zpp-solver/node_candidates_solver/src/main/java/cp_components/PTSolution.java @@ -0,0 +1,52 @@ +package cp_components; + +import org.jamesframework.core.problems.sol.Solution; + +import java.util.ArrayList; +import java.util.List; +import java.util.Objects; + +public class PTSolution extends Solution +{ + @Getter @Setter + private List varAssignments; + + public PTSolution(List varAssignments) { + this.varAssignments = varAssignments; + } + + @Override + public Solution copy() { + List varsClone = new ArrayList<>(varAssignments); + return new PTSolution(varsClone); + } + + private boolean equals(PTSolution s) { + if (s.varAssignments.size() != varAssignments.size()) { + return false; + } + for (int i = 0; i < varAssignments.size(); i++) { + if (s.varAssignments.get(i) != varAssignments.get(i)) { + return false; + } + } + return true; + } + + @Override + public boolean equals(Object o) { + if (o == null) { + return false; + } + if (getClass() != o.getClass()) { + return false; + } + final PTSolution other = (PTSolution) o; + return equals(other); + } + + @Override + public int hashCode() { + return Objects.hashCode(varAssignments); + } +} diff --git a/zpp-solver/node_candidates_solver/src/main/java/node_candidate/GeographicCoordinate.java b/zpp-solver/node_candidates_solver/src/main/java/node_candidate/GeographicCoordinate.java new file mode 100644 index 000000000..74eb5de07 --- /dev/null +++ b/zpp-solver/node_candidates_solver/src/main/java/node_candidate/GeographicCoordinate.java @@ -0,0 +1,6 @@ +package node_candidate; + +public class GeographicCoordinate { + private int latitude; + private int longitude; +} diff --git a/zpp-solver/node_candidates_solver/src/main/java/node_candidate/NodeCandidate.java b/zpp-solver/node_candidates_solver/src/main/java/node_candidate/NodeCandidate.java new file mode 100644 index 000000000..b6d9b6ad1 --- /dev/null +++ b/zpp-solver/node_candidates_solver/src/main/java/node_candidate/NodeCandidate.java @@ -0,0 +1,26 @@ +package node_candidate; +@AllArgsConstructor +public class NodeCandidate { + @Getter + private int cores; + @Getter + private int ram; + @Getter + private int disk; + + @Override + public boolean equals(Object obj) { + if (this == obj) { + return true; + } else if (obj == null) { + return false; + } else if (obj instanceof NodeCandidate) { + return cores == ((NodeCandidate) obj).cores + && + ram == ((NodeCandidate) obj).ram + && + disk == ((NodeCandidate) obj).disk; + } + return false; + } +} diff --git a/zpp-solver/node_candidates_solver/src/main/java/node_candidate/NodeCandidatesPool.java b/zpp-solver/node_candidates_solver/src/main/java/node_candidate/NodeCandidatesPool.java new file mode 100644 index 000000000..55b78a2cc --- /dev/null +++ b/zpp-solver/node_candidates_solver/src/main/java/node_candidate/NodeCandidatesPool.java @@ -0,0 +1,70 @@ +package node_candidate; + +import cp_components.PTMover; + +import java.util.List; +import java.util.Map; +import java.util.Random; +//TODO musi miec maksymalne wartosci +public class NodeCandidatesPool { + private final int variablesPerComponent = 7; + + private enum MovementType { + CARDINALITY, + VM_SPECIFICATION, + VM_LOCATION, + PROVIDER + }; + + private List components; + /* + Provider -> VM specification + NodeCandidates must be sorted lexicographically in ascending order + */ + private Map> nodeCandidates; + /* + Provider -> VM location. + Coordinates must be sorted lexicographically in ascending order + */ + private Map> vmLocations; + + public void postNodeCandidate() { + + } + + private NodeCandidate extractNodeCandidate(int component, List assignment) { + int index = component * variablesPerComponent; + return new NodeCandidate( + assignment.get(index + 1), assignment.get(index+2), assignment.get(index+3) + ); + } + + private GeographicCoordinate extractVMLocation(int component, List assignment) { + int index = component * variablesPerComponent; + return new GeographicCoordinate( + assignment.get(index + 5), assignment.get(index+6) + ); + } + + private MovementType sampleMovementType(Random random) { + int rand = random.nextInt(variablesPerComponent); + if (rand == 0) return MovementType.CARDINALITY; + else if (rand >= 5) return MovementType.VM_LOCATION; + else if ( rand <= 3) return MovementType.VM_SPECIFICATION; + else return MovementType.PROVIDER; + } + + private int extractProvider(int component, List assignment) { + + } + + private PTMover sampleVMSpecificationMove(int component, List assignment, Random random) { + NodeCandidate node = extractNodeCandidate(component, assignment); + // TODO binsearch node and sample one of the neighbours - if any exists + } + + public PTMover getRandomMove(List assignment, Random random) { + int component = random.nextInt(components.size()); + + } +} diff --git a/zpp-solver/node_candidates_solver/src/main/java/variable_orderer/ComponentVariableOrderer.java b/zpp-solver/node_candidates_solver/src/main/java/variable_orderer/ComponentVariableOrderer.java new file mode 100644 index 000000000..d0737cb9c --- /dev/null +++ b/zpp-solver/node_candidates_solver/src/main/java/variable_orderer/ComponentVariableOrderer.java @@ -0,0 +1,76 @@ +package variable_orderer; + +import eu.paasage.upperware.metamodel.cp.ConstraintProblem; +import eu.paasage.upperware.metamodel.cp.CpVariable; +import eu.paasage.upperware.metamodel.cp.VariableType; + +import java.util.ArrayList; +import java.util.List; +import java.util.Map; + +import static eu.paasage.upperware.metamodel.cp.VariableType.*; + + +public class ComponentVariableOrderer implements VariableOrderer { + private ConstraintProblem constraintProblem; + private List components; + private final int variablesPerComponent = 7; + private Map indexToVariableName; + + public ComponentVariableOrderer(ConstraintProblem cp) { + constraintProblem = cp; + fillIndexToVariable(); + } + + private void fillComponents() { + components = new ArrayList<>(); + for (CpVariable var : constraintProblem.getCpVariables()) { + if (!components.contains(var.getComponentId())) { + components.add(var.getComponentId()); + } + } + } + + @Override + public String getNameFromIndex(int var) { + return indexToVariableName.get(var); + } + + private int getComponentIndex(String name) { + for (int i = 0; i < components.size(); i++) { + if (components.get(i).equals(name)) { + return i; + } + } + throw new RuntimeException(); + } + + private void fillIndexToVariable() { + for (CpVariable var : constraintProblem.getCpVariables()) { + int componentIndex = getComponentIndex(var.getComponentId()); + int index = componentIndex + mapTypeToIndex(var.getVariableType()) - 1; + indexToVariableName.put(index, var.getId()); + } + } + + private int mapTypeToIndex(VariableType type) { + switch(type) { + case CORES: + return 2; + case PROVIDER: + return 1; + case RAM: + return 3; + case STORAGE: + return 4; + case CARDINALITY: + return 5; + case LATITUDE: + return 6; + case LONGITUDE: + return 7; + default: + throw new RuntimeException("Unsupported Variable type !"); + } + } +} diff --git a/zpp-solver/node_candidates_solver/src/test/java/NCWrapperTest.java b/zpp-solver/node_candidates_solver/src/test/java/NCWrapperTest.java new file mode 100644 index 000000000..06588323b --- /dev/null +++ b/zpp-solver/node_candidates_solver/src/test/java/NCWrapperTest.java @@ -0,0 +1,5 @@ +import static org.junit.jupiter.api.Assertions.*; + +class NCWrapperTest { + +} \ No newline at end of file -- GitLab From cd8fa7781c9e4331ba2ef47d2eb152a172e40a9c Mon Sep 17 00:00:00 2001 From: tc360950 Date: Mon, 23 Dec 2019 16:33:05 +0100 Subject: [PATCH 048/340] Changed lists to Collections in CPParsedData --- .../java/cp_wrapper/parser/CPParsedData.java | 16 ++++++++-------- 1 file changed, 8 insertions(+), 8 deletions(-) diff --git a/zpp-solver/cp-parser/src/main/java/cp_wrapper/parser/CPParsedData.java b/zpp-solver/cp-parser/src/main/java/cp_wrapper/parser/CPParsedData.java index 56776a9ed..b57c3fa45 100644 --- a/zpp-solver/cp-parser/src/main/java/cp_wrapper/parser/CPParsedData.java +++ b/zpp-solver/cp-parser/src/main/java/cp_wrapper/parser/CPParsedData.java @@ -17,10 +17,10 @@ import java.util.Map; import java.util.stream.Collectors; public class CPParsedData { - private List constants; - private List metrics; - private List constraints; - private List variables; + private Collection constants; + private Collection metrics; + private Collection constraints; + private Collection variables; private IntVarCreator intVarCreator; @Getter private ConstraintGraph constraintGraph; @@ -85,16 +85,16 @@ public class CPParsedData { constraintGraph = new ConstraintGraph(constraints, variableNames); } - void postConstants(List constants) { + void postConstants(Collection constants) { this.constants = constants; } - void postMetrics(List metrics) { + void postMetrics(Collection metrics) { this.metrics = metrics; } - void postConstraints(List constraints) { + void postConstraints(Collection constraints) { this.constraints = constraints; } - void postVariables(List variables) { + void postVariables(Collection variables) { this.variables = variables; } } -- GitLab From 8e55d7040af0c5bc17535b01cb7ca42ad39e287b Mon Sep 17 00:00:00 2001 From: tc360950 Date: Tue, 24 Dec 2019 11:31:55 +0100 Subject: [PATCH 049/340] Fixed build errors --- pom.xml | 9 +++++---- zpp-solver/cp-parser/pom.xml | 2 +- zpp-solver/genetic-solver/pom.xml | 2 +- zpp-solver/mcts-solver/pom.xml | 2 +- zpp-solver/pt-solver/pom.xml | 6 +++--- 5 files changed, 11 insertions(+), 10 deletions(-) diff --git a/pom.xml b/pom.xml index 2bca1dff0..a31bf7e4f 100644 --- a/pom.xml +++ b/pom.xml @@ -40,10 +40,10 @@ dlms event-management mq-http-adapter - ZPPSolver/CPParser - ZPPSolver/GeneticSolver - ZPPSolver/MCTSSolver - ZPPSolver/PTSolver + zpp-solver/cp-parser + zpp-solver/genetic-solver + zpp-solver/mcts-solver + zpp-solver/pt-solver @@ -75,6 +75,7 @@ false 127.0.0.1:5000/ + melodic-${scmBranch}/ parent ${project.build.finalName}.jar diff --git a/zpp-solver/cp-parser/pom.xml b/zpp-solver/cp-parser/pom.xml index 602b5c886..fb81466ec 100644 --- a/zpp-solver/cp-parser/pom.xml +++ b/zpp-solver/cp-parser/pom.xml @@ -10,7 +10,7 @@ 4.0.0 - CPParser + cp-parser org.ow2.paasage diff --git a/zpp-solver/genetic-solver/pom.xml b/zpp-solver/genetic-solver/pom.xml index 9a597b957..71f83064a 100644 --- a/zpp-solver/genetic-solver/pom.xml +++ b/zpp-solver/genetic-solver/pom.xml @@ -10,7 +10,7 @@ 4.0.0 - GeneticSolver + genetic-solver \ No newline at end of file diff --git a/zpp-solver/mcts-solver/pom.xml b/zpp-solver/mcts-solver/pom.xml index 9f99c4884..ccefffb96 100644 --- a/zpp-solver/mcts-solver/pom.xml +++ b/zpp-solver/mcts-solver/pom.xml @@ -10,7 +10,7 @@ 4.0.0 - MCTSSolver + mcts-solver \ No newline at end of file diff --git a/zpp-solver/pt-solver/pom.xml b/zpp-solver/pt-solver/pom.xml index 7e5ad7205..6aa60d3e1 100644 --- a/zpp-solver/pt-solver/pom.xml +++ b/zpp-solver/pt-solver/pom.xml @@ -10,7 +10,7 @@ 4.0.0 - PTSolver + pt-solver org.jamesframework @@ -35,13 +35,13 @@ org.ow2.paasage - CPParser + cp-parser 2.5.1-SNAPSHOT compile org.ow2.paasage - CPParser + cp-parser 2.5.1-SNAPSHOT test-jar test -- GitLab From c1393e4e9070364bdbb999c31ca17af3c31b2822 Mon Sep 17 00:00:00 2001 From: tc360950 Date: Tue, 24 Dec 2019 12:28:27 +0100 Subject: [PATCH 050/340] Added main pom for all modules --- .../eu/melodic/event/util/PasswordUtil.java | 10 ++--- pom.xml | 5 +-- zpp-solver/cp-parser/pom.xml | 26 ++--------- zpp-solver/pom.xml | 43 +++++++++++++++++++ zpp-solver/pt-solver/pom.xml | 16 +++++-- 5 files changed, 65 insertions(+), 35 deletions(-) create mode 100644 zpp-solver/pom.xml diff --git a/event-management/util/src/main/java/eu/melodic/event/util/PasswordUtil.java b/event-management/util/src/main/java/eu/melodic/event/util/PasswordUtil.java index 7fedf1125..bf8b29ebd 100644 --- a/event-management/util/src/main/java/eu/melodic/event/util/PasswordUtil.java +++ b/event-management/util/src/main/java/eu/melodic/event/util/PasswordUtil.java @@ -1,10 +1,10 @@ /* - * Copyright (C) 2017 Institute of Communication and Computer Systems (imu.iccs.com) + * Copyright (C) 2017-2019 Institute of Communication and Computer Systems (imu.iccs.gr) * - * This Source Code Form is subject to the terms of the - * Mozilla Public License, v. 2.0. If a copy of the MPL - * was not distributed with this file, You can obtain one at - * http://mozilla.org/MPL/2.0/. + * This Source Code Form is subject to the terms of the Mozilla Public License, v2.0, unless + * Esper library is used, in which case it is subject to the terms of General Public License v2.0. + * If a copy of the MPL was not distributed with this file, you can obtain one at + * https://www.mozilla.org/en-US/MPL/2.0/ */ package eu.melodic.event.util; diff --git a/pom.xml b/pom.xml index a31bf7e4f..59d8e6ac8 100644 --- a/pom.xml +++ b/pom.xml @@ -40,10 +40,7 @@ dlms event-management mq-http-adapter - zpp-solver/cp-parser - zpp-solver/genetic-solver - zpp-solver/mcts-solver - zpp-solver/pt-solver + zpp-solver diff --git a/zpp-solver/cp-parser/pom.xml b/zpp-solver/cp-parser/pom.xml index fb81466ec..3cd39ca90 100644 --- a/zpp-solver/cp-parser/pom.xml +++ b/zpp-solver/cp-parser/pom.xml @@ -3,19 +3,15 @@ xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd"> - upperware + zpp-solver org.ow2.paasage 2.5.1-SNAPSHOT - ../../pom.xml + ../pom.xml 4.0.0 cp-parser - - org.ow2.paasage - upperware-metamodel - org.junit.jupiter junit-jupiter @@ -36,23 +32,7 @@ antlr test - - eu.melodic - utility-generator - 2.5.1-SNAPSHOT - compile - - - org.javatuples - javatuples - 1.2 - - - eu.melodic - cp-solver - 2.5.1-SNAPSHOT - compile - + diff --git a/zpp-solver/pom.xml b/zpp-solver/pom.xml new file mode 100644 index 000000000..f6d64c0aa --- /dev/null +++ b/zpp-solver/pom.xml @@ -0,0 +1,43 @@ + + + + upperware + org.ow2.paasage + 2.5.1-SNAPSHOT + + 4.0.0 + + + cp-parser + genetic-solver + mcts-solver + pt-solver + + zpp-solver + + + org.ow2.paasage + upperware-metamodel + + + eu.melodic + utility-generator + 2.5.1-SNAPSHOT + compile + + + org.javatuples + javatuples + 1.2 + + + eu.melodic + cp-solver + 2.5.1-SNAPSHOT + compile + + + + \ No newline at end of file diff --git a/zpp-solver/pt-solver/pom.xml b/zpp-solver/pt-solver/pom.xml index 6aa60d3e1..9ab847c92 100644 --- a/zpp-solver/pt-solver/pom.xml +++ b/zpp-solver/pt-solver/pom.xml @@ -3,10 +3,10 @@ xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd"> - upperware + zpp-solver org.ow2.paasage 2.5.1-SNAPSHOT - ../../pom.xml + ../pom.xml 4.0.0 @@ -33,6 +33,17 @@ RELEASE test + + + org.ow2.paasage + upperware-metamodel + + + eu.melodic + utility-generator + 2.5.1-SNAPSHOT + test + org.ow2.paasage cp-parser @@ -46,6 +57,5 @@ test-jar test - \ No newline at end of file -- GitLab From 5244cb1d5f9871d52fb4c5db34af614fefd1efe8 Mon Sep 17 00:00:00 2001 From: tc360950 Date: Fri, 27 Dec 2019 15:44:02 +0100 Subject: [PATCH 051/340] Removed ZPP modules from pom.xml to resolve merge conflicts --- pom.xml | 3 --- 1 file changed, 3 deletions(-) diff --git a/pom.xml b/pom.xml index d74565b3c..ec686c0cb 100644 --- a/pom.xml +++ b/pom.xml @@ -41,9 +41,6 @@ event-management mq-http-adapter penalty-calculator - ZPPSolver/CPParser - ZPPSolver/GeneticSolver - ZPPSolver/MCTSSolver -- GitLab From 3b8b24628ffea429eb6071e369ba1fb7aeecc460 Mon Sep 17 00:00:00 2001 From: tc360950 Date: Fri, 27 Dec 2019 19:23:38 +0100 Subject: [PATCH 052/340] Fixes in NodesCandidatesPool --- zpp-solver/cp-parser/pom.xml | 2 +- zpp-solver/node_candidates_solver/pom.xml | 16 +- .../src/main/java/NCSolverCoordinator.java | 70 ++++++ .../src/main/java/NCWrapper.java | 8 - .../main/java/cp_components/PTEvaluation.java | 18 ++ .../src/main/java/cp_components/PTMover.java | 1 + .../java/cp_components/PTNeighbourhood.java | 6 +- .../main/java/cp_components/PTObjective.java | 20 ++ .../java/cp_components/PTRandomGenerator.java | 13 ++ .../main/java/cp_components/PTSolution.java | 2 + .../src/main/java/nc_wrapper/NCWrapper.java | 60 ++++++ .../node_candidate/GeographicCoordinate.java | 33 ++- .../java/node_candidate/NodeCandidate.java | 26 --- .../node_candidate/NodeCandidatesPool.java | 204 +++++++++++++++--- .../java/node_candidate/VMConfiguration.java | 45 ++++ .../ComponentVariableOrderer.java | 36 +--- .../variable_orderer/VariableTypeOrderer.java | 27 +++ zpp-solver/pom.xml | 7 +- zpp-solver/pt-solver/pom.xml | 8 +- 19 files changed, 499 insertions(+), 103 deletions(-) create mode 100644 zpp-solver/node_candidates_solver/src/main/java/NCSolverCoordinator.java delete mode 100644 zpp-solver/node_candidates_solver/src/main/java/NCWrapper.java create mode 100644 zpp-solver/node_candidates_solver/src/main/java/cp_components/PTEvaluation.java create mode 100644 zpp-solver/node_candidates_solver/src/main/java/cp_components/PTObjective.java create mode 100644 zpp-solver/node_candidates_solver/src/main/java/cp_components/PTRandomGenerator.java create mode 100644 zpp-solver/node_candidates_solver/src/main/java/nc_wrapper/NCWrapper.java delete mode 100644 zpp-solver/node_candidates_solver/src/main/java/node_candidate/NodeCandidate.java create mode 100644 zpp-solver/node_candidates_solver/src/main/java/node_candidate/VMConfiguration.java create mode 100644 zpp-solver/node_candidates_solver/src/main/java/variable_orderer/VariableTypeOrderer.java diff --git a/zpp-solver/cp-parser/pom.xml b/zpp-solver/cp-parser/pom.xml index 3cd39ca90..dc3c7cd43 100644 --- a/zpp-solver/cp-parser/pom.xml +++ b/zpp-solver/cp-parser/pom.xml @@ -5,7 +5,7 @@ zpp-solver org.ow2.paasage - 2.5.1-SNAPSHOT + 3.0.0-SNAPSHOT ../pom.xml 4.0.0 diff --git a/zpp-solver/node_candidates_solver/pom.xml b/zpp-solver/node_candidates_solver/pom.xml index 100beebf8..ef480d2fc 100644 --- a/zpp-solver/node_candidates_solver/pom.xml +++ b/zpp-solver/node_candidates_solver/pom.xml @@ -2,11 +2,15 @@ + + zpp-solver + org.ow2.paasage + 3.0.0-SNAPSHOT + ../pom.xml + 4.0.0 - org.ow2.paasage - node_candidates_solver - 1.0-SNAPSHOT + node-candidates-solver @@ -36,6 +40,12 @@ 3.0.0-SNAPSHOT compile + + org.ow2.paasage + cp-parser + 3.0.0-SNAPSHOT + compile + \ No newline at end of file diff --git a/zpp-solver/node_candidates_solver/src/main/java/NCSolverCoordinator.java b/zpp-solver/node_candidates_solver/src/main/java/NCSolverCoordinator.java new file mode 100644 index 000000000..8396475c1 --- /dev/null +++ b/zpp-solver/node_candidates_solver/src/main/java/NCSolverCoordinator.java @@ -0,0 +1,70 @@ +import cp_components.*; +import cp_wrapper.CPWrapper; +import cp_wrapper.UtilityProvider; +import nc_wrapper.NCWrapper; +import ptcp_wrapper.PTCPWrapper; +import eu.paasage.upperware.metamodel.cp.ConstraintProblem; +import org.jamesframework.core.problems.GenericProblem; +import org.jamesframework.core.problems.Problem; +import org.jamesframework.core.search.algo.ParallelTempering; +import org.jamesframework.core.search.stopcriteria.StopCriterion; + +import java.util.ArrayList; + +public class NCSolverCoordinator { + private NCWrapper ncWrapper; + private Problem CPProblem; + private double minTemp; + private double maxTemp; + private int numReplicas; + private ParallelTempering parallelTemperingSolver; + + public NCSolverCoordinator(double minTemp, double maxTemp, int numReplicas, ConstraintProblem cp, UtilityProvider utility) { + this.minTemp = minTemp; + this.maxTemp = maxTemp; + this.numReplicas = numReplicas; + CPWrapper cpWrapper = new CPWrapper(); + cpWrapper.parse(cp, utility); + this.ncWrapper = new NCWrapper(cpWrapper); + preparePTSolver(); + } + + /* + This method must return something different - PTSolution is only for tests. + */ + public PTSolution solve(StopCriterion stopCriterion) { + // np new MaxRuntime(timeLimit, TimeUnit.SECONDS) + parallelTemperingSolver.addStopCriterion(stopCriterion); + parallelTemperingSolver.start(); + + if(parallelTemperingSolver.getBestSolution() != null){ + return parallelTemperingSolver.getBestSolution(); + } else { + System.out.println("No valid solution found..."); + } + throw new RuntimeException("Couldn't find a solution"); + //TODO should return solution; + } + + private void setMaxMinDomainValues() { + PTSolution.minVariableValues = new ArrayList<>(); + PTSolution.maxVariableValues = new ArrayList<>(); + for (int i = 0; i < ptcpWrapper.getVariablesCount(); i++) { + System.out.println("Variable " + i + " " + ptcpWrapper.getMinValue(i) + " " + ptcpWrapper.getMaxValue(i)); + PTSolution.minVariableValues.add(ptcpWrapper.getMinValue(i)); + PTSolution.maxVariableValues.add(ptcpWrapper.getMaxValue(i)); + } + } + private void prepareProblem() { + setMaxMinDomainValues(); + CPProblem = new GenericProblem<>(ptcpWrapper, new PTObjective(), new PTRandomGenerator()); + } + + private void preparePTSolver() { + prepareProblem(); + parallelTemperingSolver = new ParallelTempering<>( + CPProblem, + new PTNeighbourhood(), + numReplicas, minTemp, maxTemp); + } +} diff --git a/zpp-solver/node_candidates_solver/src/main/java/NCWrapper.java b/zpp-solver/node_candidates_solver/src/main/java/NCWrapper.java deleted file mode 100644 index 9fe1073df..000000000 --- a/zpp-solver/node_candidates_solver/src/main/java/NCWrapper.java +++ /dev/null @@ -1,8 +0,0 @@ -import java.util.List; - -public class NCWrapper { - private CpWrapper cpWrapper; - private List components; - private VariableOrderer variableOrderer; - -} diff --git a/zpp-solver/node_candidates_solver/src/main/java/cp_components/PTEvaluation.java b/zpp-solver/node_candidates_solver/src/main/java/cp_components/PTEvaluation.java new file mode 100644 index 000000000..be6155c43 --- /dev/null +++ b/zpp-solver/node_candidates_solver/src/main/java/cp_components/PTEvaluation.java @@ -0,0 +1,18 @@ +package cp_components; + +import lombok.AllArgsConstructor; +import org.jamesframework.core.problems.objectives.evaluations.Evaluation; +/* + Wrapper over double type - required by James library + */ + import lombok.AllArgsConstructor; + import org.jamesframework.core.problems.objectives.evaluations.Evaluation; + +@AllArgsConstructor +public class PTEvaluation implements Evaluation { + private double value; + @Override + public double getValue() { + return value; + } +} diff --git a/zpp-solver/node_candidates_solver/src/main/java/cp_components/PTMover.java b/zpp-solver/node_candidates_solver/src/main/java/cp_components/PTMover.java index bf9980cd8..f387ed442 100644 --- a/zpp-solver/node_candidates_solver/src/main/java/cp_components/PTMover.java +++ b/zpp-solver/node_candidates_solver/src/main/java/cp_components/PTMover.java @@ -1,5 +1,6 @@ package cp_components; +import lombok.AllArgsConstructor; import org.jamesframework.core.search.neigh.Move; import java.util.List; diff --git a/zpp-solver/node_candidates_solver/src/main/java/cp_components/PTNeighbourhood.java b/zpp-solver/node_candidates_solver/src/main/java/cp_components/PTNeighbourhood.java index 8cf39edb1..a352ad55d 100644 --- a/zpp-solver/node_candidates_solver/src/main/java/cp_components/PTNeighbourhood.java +++ b/zpp-solver/node_candidates_solver/src/main/java/cp_components/PTNeighbourhood.java @@ -4,6 +4,7 @@ import node_candidate.NodeCandidatesPool; import org.jamesframework.core.search.neigh.Move; import org.jamesframework.core.search.neigh.Neighbourhood; +import java.util.Collection; import java.util.List; import java.util.Random; @@ -11,11 +12,12 @@ public class PTNeighbourhood implements Neighbourhood { private NodeCandidatesPool nodeCandidatesPool; @Override public Move getRandomMove(PTSolution ptSolution, Random random) { - return nodeCandidatesPool.getRandomMove(ptSolution.getVarAssignments()); + List> moves = getAllMoves(ptSolution); + return moves.get(random.nextInt(moves.size())); } @Override public List> getAllMoves(PTSolution ptSolution) { - return null; + return nodeCandidatesPool.getAllMoves(ptSolution.getVarAssignments()); } } diff --git a/zpp-solver/node_candidates_solver/src/main/java/cp_components/PTObjective.java b/zpp-solver/node_candidates_solver/src/main/java/cp_components/PTObjective.java new file mode 100644 index 000000000..0a3a78be1 --- /dev/null +++ b/zpp-solver/node_candidates_solver/src/main/java/cp_components/PTObjective.java @@ -0,0 +1,20 @@ +package cp_components; + + import nc_wrapper.NCWrapper; + import org.jamesframework.core.problems.objectives.Objective; + import org.jamesframework.core.problems.objectives.evaluations.Evaluation; + +public class PTObjective implements Objective { + @Override + public Evaluation evaluate(PTSolution cpSolution, NCWrapper ncWrapper) { + return ncWrapper.evaluate(cpSolution.getVarAssignments()); + } + + /* + True if are goal is to minimize the objective + */ + @Override + public boolean isMinimizing() { + return false; + } +} diff --git a/zpp-solver/node_candidates_solver/src/main/java/cp_components/PTRandomGenerator.java b/zpp-solver/node_candidates_solver/src/main/java/cp_components/PTRandomGenerator.java new file mode 100644 index 000000000..043a407b5 --- /dev/null +++ b/zpp-solver/node_candidates_solver/src/main/java/cp_components/PTRandomGenerator.java @@ -0,0 +1,13 @@ +package cp_components; + +import nc_wrapper.NCWrapper; +import org.jamesframework.core.problems.sol.RandomSolutionGenerator; + +import java.util.Random; + +public class PTRandomGenerator implements RandomSolutionGenerator { + @Override + public PTSolution create(Random random, NCWrapper ncWrapper) { + return ncWrapper.generateRandom(random); + } +} diff --git a/zpp-solver/node_candidates_solver/src/main/java/cp_components/PTSolution.java b/zpp-solver/node_candidates_solver/src/main/java/cp_components/PTSolution.java index 667848551..0ef66e572 100644 --- a/zpp-solver/node_candidates_solver/src/main/java/cp_components/PTSolution.java +++ b/zpp-solver/node_candidates_solver/src/main/java/cp_components/PTSolution.java @@ -1,5 +1,7 @@ package cp_components; +import lombok.Getter; +import lombok.Setter; import org.jamesframework.core.problems.sol.Solution; import java.util.ArrayList; diff --git a/zpp-solver/node_candidates_solver/src/main/java/nc_wrapper/NCWrapper.java b/zpp-solver/node_candidates_solver/src/main/java/nc_wrapper/NCWrapper.java new file mode 100644 index 000000000..6c17e0f12 --- /dev/null +++ b/zpp-solver/node_candidates_solver/src/main/java/nc_wrapper/NCWrapper.java @@ -0,0 +1,60 @@ +package nc_wrapper; + +import cp_components.PTEvaluation; +import cp_components.PTSolution; +import cp_wrapper.CPWrapper; +import cp_wrapper.utils.variable_orderer.VariableOrderer; +import org.jamesframework.core.problems.objectives.evaluations.Evaluation; + +import java.util.ArrayList; +import java.util.List; +import java.util.Random; + +public class NCWrapper { + private CPWrapper cpWrapper; + private List components; + private VariableOrderer variableOrderer; + + public Evaluation evaluate(List assignments) { + if (cpWrapper.checkIfFeasible(assignments)) { + return new PTEvaluation(cpWrapper.getUtility(assignments)); + } else { + return new PTEvaluation(0); + } + } + /* + Returns maximal value of variable @variable + */ + public int getMaxValue(int variable) { + return cpWrapper.getMaxDomainValue(variable); + } + + public int getMinValue(int variable) { + return cpWrapper.getMinDomainValue(variable); + } + + /* + Generates random (uniform) value for variable @variable + */ + private int generateRandomValue(int variable, Random random) { + int domainSize = getMaxValue(variable) - getMinValue(variable) + 1; + int value = random.nextInt(domainSize); + value += getMinValue(variable); + return value; + } + + public int getVariablesCount() { + return cpWrapper.getVariablesCount(); + } + /* + Generates random solution to the constraint problem. + Used to sample starting point for parallel tempering. + */ + public PTSolution generateRandom(Random random) { + List assignment = new ArrayList<>(); + for (int i = 0; i < cpWrapper.getVariablesCount(); i++) { + assignment.add(generateRandomValue(i, random)); + } + return new PTSolution(assignment); + } +} diff --git a/zpp-solver/node_candidates_solver/src/main/java/node_candidate/GeographicCoordinate.java b/zpp-solver/node_candidates_solver/src/main/java/node_candidate/GeographicCoordinate.java index 74eb5de07..037002e70 100644 --- a/zpp-solver/node_candidates_solver/src/main/java/node_candidate/GeographicCoordinate.java +++ b/zpp-solver/node_candidates_solver/src/main/java/node_candidate/GeographicCoordinate.java @@ -1,6 +1,37 @@ package node_candidate; -public class GeographicCoordinate { +import lombok.AllArgsConstructor; +import lombok.Getter; + +@AllArgsConstructor +public class GeographicCoordinate implements Comparable{ + @Getter private int latitude; + @Getter private int longitude; + + @Override + public boolean equals(Object obj) { + if (this == obj) { + return true; + } else if (obj == null) { + return false; + } else if (obj instanceof GeographicCoordinate) { + return latitude == ((GeographicCoordinate) obj).latitude + && + longitude == ((GeographicCoordinate) obj).longitude; + } + return false; + } + + @Override + public int compareTo(GeographicCoordinate o) { + if (this.equals(o)) { + return 0; + } else if (latitude > o.latitude || (latitude == o.latitude && longitude > o.longitude)) { + return 1; + } else { + return -1; + } + } } diff --git a/zpp-solver/node_candidates_solver/src/main/java/node_candidate/NodeCandidate.java b/zpp-solver/node_candidates_solver/src/main/java/node_candidate/NodeCandidate.java deleted file mode 100644 index b6d9b6ad1..000000000 --- a/zpp-solver/node_candidates_solver/src/main/java/node_candidate/NodeCandidate.java +++ /dev/null @@ -1,26 +0,0 @@ -package node_candidate; -@AllArgsConstructor -public class NodeCandidate { - @Getter - private int cores; - @Getter - private int ram; - @Getter - private int disk; - - @Override - public boolean equals(Object obj) { - if (this == obj) { - return true; - } else if (obj == null) { - return false; - } else if (obj instanceof NodeCandidate) { - return cores == ((NodeCandidate) obj).cores - && - ram == ((NodeCandidate) obj).ram - && - disk == ((NodeCandidate) obj).disk; - } - return false; - } -} diff --git a/zpp-solver/node_candidates_solver/src/main/java/node_candidate/NodeCandidatesPool.java b/zpp-solver/node_candidates_solver/src/main/java/node_candidate/NodeCandidatesPool.java index 55b78a2cc..1803f9910 100644 --- a/zpp-solver/node_candidates_solver/src/main/java/node_candidate/NodeCandidatesPool.java +++ b/zpp-solver/node_candidates_solver/src/main/java/node_candidate/NodeCandidatesPool.java @@ -1,14 +1,14 @@ package node_candidate; import cp_components.PTMover; +import eu.paasage.upperware.metamodel.cp.VariableType; +import nc_wrapper.NCWrapper; +import variable_orderer.VariableTypeOrderer; -import java.util.List; -import java.util.Map; -import java.util.Random; -//TODO musi miec maksymalne wartosci -public class NodeCandidatesPool { - private final int variablesPerComponent = 7; +import java.util.*; +public class NodeCandidatesPool { + private NCWrapper ncWrapper; private enum MovementType { CARDINALITY, VM_SPECIFICATION, @@ -21,50 +21,202 @@ public class NodeCandidatesPool { Provider -> VM specification NodeCandidates must be sorted lexicographically in ascending order */ - private Map> nodeCandidates; + private Map> vmConfigurations; /* Provider -> VM location. Coordinates must be sorted lexicographically in ascending order */ private Map> vmLocations; - public void postNodeCandidate() { + public void postVMConfiguration(int provider, VMConfiguration configuration) { + if (!vmConfigurations.containsKey(provider)) { + vmConfigurations.put(provider, new ArrayList()); + } + vmConfigurations.get(provider).add(configuration); + } + + public void postVMLocation(int provider, GeographicCoordinate location) { + if (!vmLocations.containsKey(provider)) { + vmLocations.put(provider, new ArrayList()); + } + vmLocations.get(provider).add(location); + } + + public void initNodeCandidates() { + for ( Integer key : vmConfigurations.keySet()) { + Collections.sort(vmConfigurations.get(key)); + } + for ( Integer key : vmLocations.keySet()) { + Collections.sort(vmLocations.get(key)); + } + } + + private Collection getVMConfigurationNeighbours(int provider, VMConfiguration conf) { + int index = Collections.binarySearch(vmConfigurations.get(provider), conf); + Collection result = new ArrayList<>(); + if(index >= 0) { + if (index > 0) { + result.add(vmConfigurations.get(provider).get(index-1)); + } + if (index + 1 < vmConfigurations.get(provider).size()) { + result.add(vmConfigurations.get(provider).get(index+1)); + } + } else { + index = (-index) - 1; + if (index > 0) { + result.add(vmConfigurations.get(provider).get(index-1)); + } + if (index < vmConfigurations.get(provider).size()) { + result.add(vmConfigurations.get(provider).get(index)); + } + } + return result; + } + private Collection getVMLocationNeighbours(int provider, GeographicCoordinate loc) { + Collection result = new ArrayList<>(); + int index = Collections.binarySearch(vmLocations.get(provider), loc); + if(index >= 0) { + if (index > 0) { + result.add(vmLocations.get(provider).get(index-1)); + } + if (index + 1 < vmLocations.get(provider).size()) { + result.add(vmLocations.get(provider).get(index+1)); + } + } else { + index = (-index) - 1; + if (index > 0) { + result.add(vmLocations.get(provider).get(index-1)); + } + if (index < vmLocations.get(provider).size()) { + result.add(vmLocations.get(provider).get(index)); + } + } + return result; } - private NodeCandidate extractNodeCandidate(int component, List assignment) { - int index = component * variablesPerComponent; - return new NodeCandidate( - assignment.get(index + 1), assignment.get(index+2), assignment.get(index+3) + + private VMConfiguration extractVMConfiguration(int component, List assignment) { + int index = component * VariableTypeOrderer.variablesPerComponent; + return new VMConfiguration( + assignment.get(index + VariableTypeOrderer.mapTypeToIndex(VariableType.CORES)), + assignment.get(index + VariableTypeOrderer.mapTypeToIndex(VariableType.RAM)), + assignment.get(index + VariableTypeOrderer.mapTypeToIndex(VariableType.STORAGE)) ); } private GeographicCoordinate extractVMLocation(int component, List assignment) { - int index = component * variablesPerComponent; + int index = component * VariableTypeOrderer.variablesPerComponent; return new GeographicCoordinate( - assignment.get(index + 5), assignment.get(index+6) + assignment.get(index + VariableTypeOrderer.mapTypeToIndex(VariableType.LATITUDE)), + assignment.get(index + VariableTypeOrderer.mapTypeToIndex(VariableType.LONGITUDE)) ); } - private MovementType sampleMovementType(Random random) { - int rand = random.nextInt(variablesPerComponent); - if (rand == 0) return MovementType.CARDINALITY; - else if (rand >= 5) return MovementType.VM_LOCATION; - else if ( rand <= 3) return MovementType.VM_SPECIFICATION; - else return MovementType.PROVIDER; + private int extractProvider(int component, List assignment) { + return assignment.get(VariableTypeOrderer.variablesPerComponent * component); } - private int extractProvider(int component, List assignment) { + private List updateComponentConfiguration(List assignment, int component, + int provider, VMConfiguration vmConfiguration, + GeographicCoordinate vmLocation) { + int index = component * VariableTypeOrderer.variablesPerComponent; + List newAssignment = new ArrayList<>(assignment); + newAssignment.set(index, provider); + + newAssignment.set(index + VariableTypeOrderer.mapTypeToIndex(VariableType.LATITUDE), + vmLocation.getLatitude()); + newAssignment.set(index + VariableTypeOrderer.mapTypeToIndex(VariableType.LONGITUDE), + vmLocation.getLongitude()); + + newAssignment.set(index + VariableTypeOrderer.mapTypeToIndex(VariableType.CORES), + vmConfiguration.getCores()); + newAssignment.set(index + VariableTypeOrderer.mapTypeToIndex(VariableType.RAM), + vmConfiguration.getRam()); + newAssignment.set(index + VariableTypeOrderer.mapTypeToIndex(VariableType.STORAGE), + vmConfiguration.getDisk()); + return newAssignment; + } + + private Collection getAllVMConfigurationChangeMoves(List assignment, int component) { + Collection result = new ArrayList<>(); + VMConfiguration conf = extractVMConfiguration(component, assignment); + int provider = extractProvider(component, assignment); + Collection neighbours = getVMConfigurationNeighbours(provider, conf); + if (neighbours.isEmpty()) { + return result; + } + for (VMConfiguration n : neighbours) { + result.add(new PTMover( + assignment, + updateComponentConfiguration(assignment, + component, provider, n, extractVMLocation(component, assignment)) + )); + } + return result; + } + + private Collection getAllVMLocationChangeMoves(List assignment, int component) { + Collection result = new ArrayList<>(); + GeographicCoordinate loc = extractVMLocation(component, assignment); + int provider = extractProvider(component, assignment); + Collection neighbours = getVMLocationNeighbours(provider, loc); + if (neighbours.isEmpty()) { + return result; + } + for (GeographicCoordinate n : neighbours) { + result.add(new PTMover( + assignment, + updateComponentConfiguration(assignment, + component, provider, extractVMConfiguration(component, assignment), n) + )); + } + return result; } - private PTMover sampleVMSpecificationMove(int component, List assignment, Random random) { - NodeCandidate node = extractNodeCandidate(component, assignment); - // TODO binsearch node and sample one of the neighbours - if any exists + private Collection getAllCardinalityChangeMoves(List assignment, int component) { + int index = component * VariableTypeOrderer.variablesPerComponent + + VariableTypeOrderer.mapTypeToIndex(VariableType.CARDINALITY); + int maxCardinality = ncWrapper.getMaxValue(index); + int minCardinality = ncWrapper.getMinValue(index); + Collection result = new ArrayList<>(); + if (assignment.get(index) < maxCardinality) { + List newAssignment = new ArrayList<>(assignment); + newAssignment.set(index, assignment.get(index) + 1); + result.add(new PTMover(assignment, newAssignment)); + } + if (assignment.get(index) > minCardinality) { + List newAssignment = new ArrayList<>(assignment); + newAssignment.set(index, assignment.get(index) - 1); + result.add(new PTMover(assignment, newAssignment)); + } + return result; } - public PTMover getRandomMove(List assignment, Random random) { - int component = random.nextInt(components.size()); + private Collection getAllProviderChangeMove(List assignment, int component) { + int provider = extractProvider(component, assignment); + int maxProvider = ncWrapper.getMaxValue(component * VariableTypeOrderer.variablesPerComponent); + int minProvider = ncWrapper.getMinValue(component * VariableTypeOrderer.variablesPerComponent); + return null; } + + public Collection getAllMovesComponent(List assignment, int component) { + Collection result = getAllVMConfigurationChangeMoves(assignment, component); + result.addAll(getAllVMLocationChangeMoves(assignment, component)); + result.addAll(getAllCardinalityChangeMoves(assignment, component)); + result.addAll(getAllProviderChangeMove(assignment, component)); + return result; + } + + public List getAllMoves(List assignment) { + List moves = new ArrayList<>(); + for (int i = 0; i < components.size(); i++) { + moves.addAll(getAllMovesComponent(assignment, i)); + } + return moves; + } + + } diff --git a/zpp-solver/node_candidates_solver/src/main/java/node_candidate/VMConfiguration.java b/zpp-solver/node_candidates_solver/src/main/java/node_candidate/VMConfiguration.java new file mode 100644 index 000000000..81e9a1645 --- /dev/null +++ b/zpp-solver/node_candidates_solver/src/main/java/node_candidate/VMConfiguration.java @@ -0,0 +1,45 @@ +package node_candidate; + +import lombok.AllArgsConstructor; +import lombok.Getter; + +@AllArgsConstructor +public class VMConfiguration implements Comparable { + @Getter + private int cores; + @Getter + private int ram; + @Getter + private int disk; + + @Override + public boolean equals(Object obj) { + if (this == obj) { + return true; + } else if (obj == null) { + return false; + } else if (obj instanceof VMConfiguration) { + return cores == ((VMConfiguration) obj).cores + && + ram == ((VMConfiguration) obj).ram + && + disk == ((VMConfiguration) obj).disk; + } + return false; + } + + @Override + public int compareTo(VMConfiguration o) { + if (this.equals(o)) { + return 0; + } else if ( + (cores > o.cores) + || (cores == o.cores && ram > o.ram) + || (cores == o.cores && ram == o.ram && disk > o.disk) + ) { + return 1; + } else { + return -1; + } + } +} diff --git a/zpp-solver/node_candidates_solver/src/main/java/variable_orderer/ComponentVariableOrderer.java b/zpp-solver/node_candidates_solver/src/main/java/variable_orderer/ComponentVariableOrderer.java index d0737cb9c..e332f8083 100644 --- a/zpp-solver/node_candidates_solver/src/main/java/variable_orderer/ComponentVariableOrderer.java +++ b/zpp-solver/node_candidates_solver/src/main/java/variable_orderer/ComponentVariableOrderer.java @@ -1,5 +1,6 @@ package variable_orderer; +import cp_wrapper.utils.variable_orderer.VariableOrderer; import eu.paasage.upperware.metamodel.cp.ConstraintProblem; import eu.paasage.upperware.metamodel.cp.CpVariable; import eu.paasage.upperware.metamodel.cp.VariableType; @@ -8,8 +9,6 @@ import java.util.ArrayList; import java.util.List; import java.util.Map; -import static eu.paasage.upperware.metamodel.cp.VariableType.*; - public class ComponentVariableOrderer implements VariableOrderer { private ConstraintProblem constraintProblem; @@ -23,7 +22,7 @@ public class ComponentVariableOrderer implements VariableOrderer { } private void fillComponents() { - components = new ArrayList<>(); + components = new ArrayList(); for (CpVariable var : constraintProblem.getCpVariables()) { if (!components.contains(var.getComponentId())) { components.add(var.getComponentId()); @@ -31,15 +30,10 @@ public class ComponentVariableOrderer implements VariableOrderer { } } - @Override - public String getNameFromIndex(int var) { - return indexToVariableName.get(var); - } - private int getComponentIndex(String name) { for (int i = 0; i < components.size(); i++) { if (components.get(i).equals(name)) { - return i; + return variablesPerComponent * i; } } throw new RuntimeException(); @@ -48,29 +42,13 @@ public class ComponentVariableOrderer implements VariableOrderer { private void fillIndexToVariable() { for (CpVariable var : constraintProblem.getCpVariables()) { int componentIndex = getComponentIndex(var.getComponentId()); - int index = componentIndex + mapTypeToIndex(var.getVariableType()) - 1; + int index = componentIndex + VariableTypeOrderer.mapTypeToIndex(var.getVariableType()); indexToVariableName.put(index, var.getId()); } } - private int mapTypeToIndex(VariableType type) { - switch(type) { - case CORES: - return 2; - case PROVIDER: - return 1; - case RAM: - return 3; - case STORAGE: - return 4; - case CARDINALITY: - return 5; - case LATITUDE: - return 6; - case LONGITUDE: - return 7; - default: - throw new RuntimeException("Unsupported Variable type !"); - } + @Override + public String getNameFromIndex(int var) { + return indexToVariableName.get(var); } } diff --git a/zpp-solver/node_candidates_solver/src/main/java/variable_orderer/VariableTypeOrderer.java b/zpp-solver/node_candidates_solver/src/main/java/variable_orderer/VariableTypeOrderer.java new file mode 100644 index 000000000..7cec274ca --- /dev/null +++ b/zpp-solver/node_candidates_solver/src/main/java/variable_orderer/VariableTypeOrderer.java @@ -0,0 +1,27 @@ +package variable_orderer; + +import eu.paasage.upperware.metamodel.cp.VariableType; + +public class VariableTypeOrderer { + public static final int variablesPerComponent = 7; + public static int mapTypeToIndex(VariableType type) { + switch(type) { + case PROVIDER: + return 0; + case CORES: + return 1; + case RAM: + return 2; + case STORAGE: + return 3; + case CARDINALITY: + return 4; + case LATITUDE: + return 5; + case LONGITUDE: + return 6; + default: + throw new RuntimeException("Unsupported Variable type !"); + } + } +} diff --git a/zpp-solver/pom.xml b/zpp-solver/pom.xml index f6d64c0aa..303a8666e 100644 --- a/zpp-solver/pom.xml +++ b/zpp-solver/pom.xml @@ -5,7 +5,7 @@ upperware org.ow2.paasage - 2.5.1-SNAPSHOT + 3.0.0-SNAPSHOT 4.0.0 @@ -14,6 +14,7 @@ genetic-solver mcts-solver pt-solver + node-candidates-solver zpp-solver @@ -24,7 +25,7 @@ eu.melodic utility-generator - 2.5.1-SNAPSHOT + 3.0.0-SNAPSHOT compile @@ -35,7 +36,7 @@ eu.melodic cp-solver - 2.5.1-SNAPSHOT + 3.0.0-SNAPSHOT compile diff --git a/zpp-solver/pt-solver/pom.xml b/zpp-solver/pt-solver/pom.xml index 9ab847c92..597911d53 100644 --- a/zpp-solver/pt-solver/pom.xml +++ b/zpp-solver/pt-solver/pom.xml @@ -5,7 +5,7 @@ zpp-solver org.ow2.paasage - 2.5.1-SNAPSHOT + 3.0.0-SNAPSHOT ../pom.xml 4.0.0 @@ -41,19 +41,19 @@ eu.melodic utility-generator - 2.5.1-SNAPSHOT + 3.0.0-SNAPSHOT test org.ow2.paasage cp-parser - 2.5.1-SNAPSHOT + 3.0.0-SNAPSHOT compile org.ow2.paasage cp-parser - 2.5.1-SNAPSHOT + 3.0.0-SNAPSHOT test-jar test -- GitLab From 7299ec6b40345643e921e3b9f668387981209f64 Mon Sep 17 00:00:00 2001 From: tc360950 Date: Fri, 27 Dec 2019 20:21:17 +0100 Subject: [PATCH 053/340] Finished NCSolverCoordinator implementation --- .../src/main/java/cp_wrapper/CPWrapper.java | 4 +- .../HeuristicVariableOrderer.java | 5 ++ .../variable_orderer/VariableOrderer.java | 5 ++ .../src/main/java/NCSolverCoordinator.java | 25 ++++----- .../java/cp_components/PTNeighbourhood.java | 4 +- .../src/main/java/nc_wrapper/NCWrapper.java | 30 ++++++++--- .../node_candidate/NodeCandidatesPool.java | 53 ++++++++++++++++--- .../ComponentVariableOrderer.java | 11 +++- 8 files changed, 103 insertions(+), 34 deletions(-) diff --git a/zpp-solver/cp-parser/src/main/java/cp_wrapper/CPWrapper.java b/zpp-solver/cp-parser/src/main/java/cp_wrapper/CPWrapper.java index 6376a6fc5..f2a89c22a 100644 --- a/zpp-solver/cp-parser/src/main/java/cp_wrapper/CPWrapper.java +++ b/zpp-solver/cp-parser/src/main/java/cp_wrapper/CPWrapper.java @@ -55,7 +55,9 @@ public class CPWrapper { private Map getAssignmentFromValueList(List assignments) { Map vars = new HashMap<>(); for (int i = 0; i < assignments.size(); i++) { - vars.put(variableOrderer.getNameFromIndex(i), getVariableValueFromDomainIndex(i, assignments.get(i))); + if (variableOrderer.exists(i)) { + vars.put(variableOrderer.getNameFromIndex(i), getVariableValueFromDomainIndex(i, assignments.get(i))); + } } return vars; } diff --git a/zpp-solver/cp-parser/src/main/java/cp_wrapper/utils/variable_orderer/HeuristicVariableOrderer.java b/zpp-solver/cp-parser/src/main/java/cp_wrapper/utils/variable_orderer/HeuristicVariableOrderer.java index f2788243e..a3c6f7708 100644 --- a/zpp-solver/cp-parser/src/main/java/cp_wrapper/utils/variable_orderer/HeuristicVariableOrderer.java +++ b/zpp-solver/cp-parser/src/main/java/cp_wrapper/utils/variable_orderer/HeuristicVariableOrderer.java @@ -20,6 +20,11 @@ public class HeuristicVariableOrderer implements VariableOrderer { return indexToVariableName.get(var); } + @Override + public boolean exists(int index) { + return indexToVariableName.get(index) != null; + } + /* For each variable record its number of constraints and number of other variables which appear in those constraints. diff --git a/zpp-solver/cp-parser/src/main/java/cp_wrapper/utils/variable_orderer/VariableOrderer.java b/zpp-solver/cp-parser/src/main/java/cp_wrapper/utils/variable_orderer/VariableOrderer.java index 1512e61e4..0ed2ab962 100644 --- a/zpp-solver/cp-parser/src/main/java/cp_wrapper/utils/variable_orderer/VariableOrderer.java +++ b/zpp-solver/cp-parser/src/main/java/cp_wrapper/utils/variable_orderer/VariableOrderer.java @@ -5,4 +5,9 @@ package cp_wrapper.utils.variable_orderer; */ public interface VariableOrderer { String getNameFromIndex(int var); + + /* + True if @index represents some variable + */ + boolean exists(int index); } diff --git a/zpp-solver/node_candidates_solver/src/main/java/NCSolverCoordinator.java b/zpp-solver/node_candidates_solver/src/main/java/NCSolverCoordinator.java index 8396475c1..0b5c2236c 100644 --- a/zpp-solver/node_candidates_solver/src/main/java/NCSolverCoordinator.java +++ b/zpp-solver/node_candidates_solver/src/main/java/NCSolverCoordinator.java @@ -2,7 +2,7 @@ import cp_components.*; import cp_wrapper.CPWrapper; import cp_wrapper.UtilityProvider; import nc_wrapper.NCWrapper; -import ptcp_wrapper.PTCPWrapper; +import node_candidate.NodeCandidatesPool; import eu.paasage.upperware.metamodel.cp.ConstraintProblem; import org.jamesframework.core.problems.GenericProblem; import org.jamesframework.core.problems.Problem; @@ -10,7 +10,9 @@ import org.jamesframework.core.search.algo.ParallelTempering; import org.jamesframework.core.search.stopcriteria.StopCriterion; import java.util.ArrayList; - +/* + TODO trzeba dodac dodwanie node candidates do NodeCandidatesPool + */ public class NCSolverCoordinator { private NCWrapper ncWrapper; private Problem CPProblem; @@ -18,6 +20,7 @@ public class NCSolverCoordinator { private double maxTemp; private int numReplicas; private ParallelTempering parallelTemperingSolver; + private NodeCandidatesPool candidatesPool; public NCSolverCoordinator(double minTemp, double maxTemp, int numReplicas, ConstraintProblem cp, UtilityProvider utility) { this.minTemp = minTemp; @@ -25,8 +28,10 @@ public class NCSolverCoordinator { this.numReplicas = numReplicas; CPWrapper cpWrapper = new CPWrapper(); cpWrapper.parse(cp, utility); - this.ncWrapper = new NCWrapper(cpWrapper); + this.ncWrapper = new NCWrapper(cpWrapper, cp); + candidatesPool = new NodeCandidatesPool(ncWrapper); preparePTSolver(); + } /* @@ -46,25 +51,15 @@ public class NCSolverCoordinator { //TODO should return solution; } - private void setMaxMinDomainValues() { - PTSolution.minVariableValues = new ArrayList<>(); - PTSolution.maxVariableValues = new ArrayList<>(); - for (int i = 0; i < ptcpWrapper.getVariablesCount(); i++) { - System.out.println("Variable " + i + " " + ptcpWrapper.getMinValue(i) + " " + ptcpWrapper.getMaxValue(i)); - PTSolution.minVariableValues.add(ptcpWrapper.getMinValue(i)); - PTSolution.maxVariableValues.add(ptcpWrapper.getMaxValue(i)); - } - } private void prepareProblem() { - setMaxMinDomainValues(); - CPProblem = new GenericProblem<>(ptcpWrapper, new PTObjective(), new PTRandomGenerator()); + CPProblem = new GenericProblem<>(ncWrapper, new PTObjective(), new PTRandomGenerator()); } private void preparePTSolver() { prepareProblem(); parallelTemperingSolver = new ParallelTempering<>( CPProblem, - new PTNeighbourhood(), + new PTNeighbourhood(candidatesPool), numReplicas, minTemp, maxTemp); } } diff --git a/zpp-solver/node_candidates_solver/src/main/java/cp_components/PTNeighbourhood.java b/zpp-solver/node_candidates_solver/src/main/java/cp_components/PTNeighbourhood.java index a352ad55d..fba8c1f58 100644 --- a/zpp-solver/node_candidates_solver/src/main/java/cp_components/PTNeighbourhood.java +++ b/zpp-solver/node_candidates_solver/src/main/java/cp_components/PTNeighbourhood.java @@ -1,13 +1,13 @@ package cp_components; +import lombok.AllArgsConstructor; import node_candidate.NodeCandidatesPool; import org.jamesframework.core.search.neigh.Move; import org.jamesframework.core.search.neigh.Neighbourhood; -import java.util.Collection; import java.util.List; import java.util.Random; - +@AllArgsConstructor public class PTNeighbourhood implements Neighbourhood { private NodeCandidatesPool nodeCandidatesPool; @Override diff --git a/zpp-solver/node_candidates_solver/src/main/java/nc_wrapper/NCWrapper.java b/zpp-solver/node_candidates_solver/src/main/java/nc_wrapper/NCWrapper.java index 6c17e0f12..4869aaccd 100644 --- a/zpp-solver/node_candidates_solver/src/main/java/nc_wrapper/NCWrapper.java +++ b/zpp-solver/node_candidates_solver/src/main/java/nc_wrapper/NCWrapper.java @@ -3,8 +3,9 @@ package nc_wrapper; import cp_components.PTEvaluation; import cp_components.PTSolution; import cp_wrapper.CPWrapper; -import cp_wrapper.utils.variable_orderer.VariableOrderer; +import eu.paasage.upperware.metamodel.cp.ConstraintProblem; import org.jamesframework.core.problems.objectives.evaluations.Evaluation; +import variable_orderer.ComponentVariableOrderer; import java.util.ArrayList; import java.util.List; @@ -12,8 +13,17 @@ import java.util.Random; public class NCWrapper { private CPWrapper cpWrapper; - private List components; - private VariableOrderer variableOrderer; + private ComponentVariableOrderer variableOrderer; + + public NCWrapper(CPWrapper cpWrapper, ConstraintProblem cp) { + this.cpWrapper = cpWrapper; + this.variableOrderer = new ComponentVariableOrderer(cp); + cpWrapper.setVariableOrdering(variableOrderer); + } + + public List getComponents() { + return variableOrderer.getComponents(); + } public Evaluation evaluate(List assignments) { if (cpWrapper.checkIfFeasible(assignments)) { @@ -26,10 +36,16 @@ public class NCWrapper { Returns maximal value of variable @variable */ public int getMaxValue(int variable) { + if (!variableOrderer.exists(variable)) { + return 0; + } return cpWrapper.getMaxDomainValue(variable); } public int getMinValue(int variable) { + if (!variableOrderer.exists(variable)) { + return 0; + } return cpWrapper.getMinDomainValue(variable); } @@ -37,22 +53,22 @@ public class NCWrapper { Generates random (uniform) value for variable @variable */ private int generateRandomValue(int variable, Random random) { + if (!variableOrderer.exists(variable)) { + return 0; + } int domainSize = getMaxValue(variable) - getMinValue(variable) + 1; int value = random.nextInt(domainSize); value += getMinValue(variable); return value; } - public int getVariablesCount() { - return cpWrapper.getVariablesCount(); - } /* Generates random solution to the constraint problem. Used to sample starting point for parallel tempering. */ public PTSolution generateRandom(Random random) { List assignment = new ArrayList<>(); - for (int i = 0; i < cpWrapper.getVariablesCount(); i++) { + for (int i = 0; i < variableOrderer.getMaxIndex(); i++) { assignment.add(generateRandomValue(i, random)); } return new PTSolution(assignment); diff --git a/zpp-solver/node_candidates_solver/src/main/java/node_candidate/NodeCandidatesPool.java b/zpp-solver/node_candidates_solver/src/main/java/node_candidate/NodeCandidatesPool.java index 1803f9910..72e40436f 100644 --- a/zpp-solver/node_candidates_solver/src/main/java/node_candidate/NodeCandidatesPool.java +++ b/zpp-solver/node_candidates_solver/src/main/java/node_candidate/NodeCandidatesPool.java @@ -9,12 +9,6 @@ import java.util.*; public class NodeCandidatesPool { private NCWrapper ncWrapper; - private enum MovementType { - CARDINALITY, - VM_SPECIFICATION, - VM_LOCATION, - PROVIDER - }; private List components; /* @@ -28,6 +22,11 @@ public class NodeCandidatesPool { */ private Map> vmLocations; + public NodeCandidatesPool(NCWrapper ncWrapper) { + this.components = ncWrapper.getComponents(); + this.ncWrapper = ncWrapper; + } + public void postVMConfiguration(int provider, VMConfiguration configuration) { if (!vmConfigurations.containsKey(provider)) { vmConfigurations.put(provider, new ArrayList()); @@ -50,6 +49,21 @@ public class NodeCandidatesPool { Collections.sort(vmLocations.get(key)); } } + private Collection getVMConfigurationOrItsNeighbours(int provider, VMConfiguration conf) { + if (Collections.binarySearch(vmConfigurations.get(provider), conf) >= 0) { + return Arrays.asList(conf); + } else { + return getVMConfigurationNeighbours(provider, conf); + } + } + + private Collection getVMLocationOrItsNeighbours(int provider, GeographicCoordinate loc) { + if (Collections.binarySearch(vmLocations.get(provider), loc) >= 0) { + return Arrays.asList(loc); + } else { + return getVMLocationNeighbours(provider, loc); + } + } private Collection getVMConfigurationNeighbours(int provider, VMConfiguration conf) { int index = Collections.binarySearch(vmConfigurations.get(provider), conf); @@ -136,6 +150,7 @@ public class NodeCandidatesPool { vmConfiguration.getRam()); newAssignment.set(index + VariableTypeOrderer.mapTypeToIndex(VariableType.STORAGE), vmConfiguration.getDisk()); + return newAssignment; } @@ -194,7 +209,29 @@ public class NodeCandidatesPool { return result; } - private Collection getAllProviderChangeMove(List assignment, int component) { + private Collection getAllProviderChangeMoves(List assignment, int component, int provider) { + Collection result = new ArrayList<>(); + Collection confs = + getVMConfigurationOrItsNeighbours(provider, extractVMConfiguration(component, assignment)); + for (VMConfiguration conf : confs) { + Collection locs = getVMLocationOrItsNeighbours( provider, extractVMLocation(component, assignment)); + for (GeographicCoordinate loc : locs) { + result.add(new PTMover( + assignment, + updateComponentConfiguration( + assignment, + component, + provider, + conf, + loc + ) + )); + } + } + return result; + } + + private Collection getAllProviderChangeMoves(List assignment, int component) { int provider = extractProvider(component, assignment); int maxProvider = ncWrapper.getMaxValue(component * VariableTypeOrderer.variablesPerComponent); int minProvider = ncWrapper.getMinValue(component * VariableTypeOrderer.variablesPerComponent); @@ -206,7 +243,7 @@ public class NodeCandidatesPool { Collection result = getAllVMConfigurationChangeMoves(assignment, component); result.addAll(getAllVMLocationChangeMoves(assignment, component)); result.addAll(getAllCardinalityChangeMoves(assignment, component)); - result.addAll(getAllProviderChangeMove(assignment, component)); + result.addAll(getAllProviderChangeMoves(assignment, component)); return result; } diff --git a/zpp-solver/node_candidates_solver/src/main/java/variable_orderer/ComponentVariableOrderer.java b/zpp-solver/node_candidates_solver/src/main/java/variable_orderer/ComponentVariableOrderer.java index e332f8083..c85b22239 100644 --- a/zpp-solver/node_candidates_solver/src/main/java/variable_orderer/ComponentVariableOrderer.java +++ b/zpp-solver/node_candidates_solver/src/main/java/variable_orderer/ComponentVariableOrderer.java @@ -3,7 +3,7 @@ package variable_orderer; import cp_wrapper.utils.variable_orderer.VariableOrderer; import eu.paasage.upperware.metamodel.cp.ConstraintProblem; import eu.paasage.upperware.metamodel.cp.CpVariable; -import eu.paasage.upperware.metamodel.cp.VariableType; +import lombok.Getter; import java.util.ArrayList; import java.util.List; @@ -12,15 +12,21 @@ import java.util.Map; public class ComponentVariableOrderer implements VariableOrderer { private ConstraintProblem constraintProblem; + @Getter private List components; private final int variablesPerComponent = 7; private Map indexToVariableName; public ComponentVariableOrderer(ConstraintProblem cp) { constraintProblem = cp; + fillComponents(); fillIndexToVariable(); } + public boolean exists(int index) { + return indexToVariableName.get(index) != null; + } + private void fillComponents() { components = new ArrayList(); for (CpVariable var : constraintProblem.getCpVariables()) { @@ -30,6 +36,9 @@ public class ComponentVariableOrderer implements VariableOrderer { } } + public int getMaxIndex() { + return components.size() * VariableTypeOrderer.variablesPerComponent; + } private int getComponentIndex(String name) { for (int i = 0; i < components.size(); i++) { if (components.get(i).equals(name)) { -- GitLab From f1cce5b24c347672697cc36124308f9b58a5bc0b Mon Sep 17 00:00:00 2001 From: tc360950 Date: Fri, 27 Dec 2019 21:41:23 +0100 Subject: [PATCH 054/340] Added tests for NodeCandidatesPool --- .../cpsolver/CPSolverController.java | 2 +- zpp-solver/node_candidates_solver/pom.xml | 6 + .../src/main/java/NCSolverCoordinator.java | 3 +- .../src/main/java/cp_components/PTMover.java | 14 +++ .../MarginalDomainValuesProvider.java | 7 ++ .../src/main/java/nc_wrapper/NCWrapper.java | 2 +- .../node_candidate/NodeCandidatesPool.java | 46 +++++--- .../variable_orderer/VariableTypeOrderer.java | 6 +- .../src/test/java/NCWrapperTest.java | 1 + .../GeographicCoordinateTest.java | 19 ++++ .../NodeCandidatesPoolTest.java | 105 ++++++++++++++++++ .../node_candidate/VMConfigurationTest.java | 19 ++++ zpp-solver/pom.xml | 2 +- 13 files changed, 210 insertions(+), 22 deletions(-) create mode 100644 zpp-solver/node_candidates_solver/src/main/java/nc_wrapper/MarginalDomainValuesProvider.java create mode 100644 zpp-solver/node_candidates_solver/src/test/java/node_candidate/GeographicCoordinateTest.java create mode 100644 zpp-solver/node_candidates_solver/src/test/java/node_candidate/NodeCandidatesPoolTest.java create mode 100644 zpp-solver/node_candidates_solver/src/test/java/node_candidate/VMConfigurationTest.java diff --git a/cp-solver/src/main/java/eu/melodic/upperware/cpsolver/CPSolverController.java b/cp-solver/src/main/java/eu/melodic/upperware/cpsolver/CPSolverController.java index 1e6e10226..606c67f8f 100644 --- a/cp-solver/src/main/java/eu/melodic/upperware/cpsolver/CPSolverController.java +++ b/cp-solver/src/main/java/eu/melodic/upperware/cpsolver/CPSolverController.java @@ -44,7 +44,7 @@ public class CPSolverController { @RequestMapping(value = "/constraintProblemSolutionFromFile", method = POST) public void constraintProblemSolutionFromFile(@RequestBody ConstraintProblemSolutionFromFileRequestImpl request) throws Exception { String camelModelFilePath = request.getCamelModelFilePath(); - String cpModelPath = request.getCpProblemFilePath(); + String cpModelPath = "sdad";//request.getCpProblemFilePath(); String nodeCandidatesFilePath = request.getNodeCandidatesFilePath(); log.info("Received constraintProblemSolutionFromFile request: \n" + camelModelFilePath + " \n" + cpModelPath); diff --git a/zpp-solver/node_candidates_solver/pom.xml b/zpp-solver/node_candidates_solver/pom.xml index ef480d2fc..de2dd41aa 100644 --- a/zpp-solver/node_candidates_solver/pom.xml +++ b/zpp-solver/node_candidates_solver/pom.xml @@ -46,6 +46,12 @@ 3.0.0-SNAPSHOT compile + + org.junit.jupiter + junit-jupiter-api + 5.3.1 + test + \ No newline at end of file diff --git a/zpp-solver/node_candidates_solver/src/main/java/NCSolverCoordinator.java b/zpp-solver/node_candidates_solver/src/main/java/NCSolverCoordinator.java index 0b5c2236c..898c67aaf 100644 --- a/zpp-solver/node_candidates_solver/src/main/java/NCSolverCoordinator.java +++ b/zpp-solver/node_candidates_solver/src/main/java/NCSolverCoordinator.java @@ -29,9 +29,8 @@ public class NCSolverCoordinator { CPWrapper cpWrapper = new CPWrapper(); cpWrapper.parse(cp, utility); this.ncWrapper = new NCWrapper(cpWrapper, cp); - candidatesPool = new NodeCandidatesPool(ncWrapper); + candidatesPool = new NodeCandidatesPool(ncWrapper, ncWrapper.getComponents()); preparePTSolver(); - } /* diff --git a/zpp-solver/node_candidates_solver/src/main/java/cp_components/PTMover.java b/zpp-solver/node_candidates_solver/src/main/java/cp_components/PTMover.java index f387ed442..1ab88cac5 100644 --- a/zpp-solver/node_candidates_solver/src/main/java/cp_components/PTMover.java +++ b/zpp-solver/node_candidates_solver/src/main/java/cp_components/PTMover.java @@ -18,4 +18,18 @@ public class PTMover implements Move { public void undo(PTSolution ptSolution) { ptSolution.setVarAssignments(beforeMoveAssignment); } + + @Override + public boolean equals(Object o) { + if (o == this) { + return true; + } else if (getClass() != o.getClass()) { + return false; + } else { + PTMover m = (PTMover) o; + return m.afterMoveAssignment.equals(afterMoveAssignment) + && + m.beforeMoveAssignment.equals(beforeMoveAssignment); + } + } } diff --git a/zpp-solver/node_candidates_solver/src/main/java/nc_wrapper/MarginalDomainValuesProvider.java b/zpp-solver/node_candidates_solver/src/main/java/nc_wrapper/MarginalDomainValuesProvider.java new file mode 100644 index 000000000..76fb219e7 --- /dev/null +++ b/zpp-solver/node_candidates_solver/src/main/java/nc_wrapper/MarginalDomainValuesProvider.java @@ -0,0 +1,7 @@ +package nc_wrapper; + +public interface MarginalDomainValuesProvider { + int getMaxValue(int variable); + + int getMinValue(int variable); +} diff --git a/zpp-solver/node_candidates_solver/src/main/java/nc_wrapper/NCWrapper.java b/zpp-solver/node_candidates_solver/src/main/java/nc_wrapper/NCWrapper.java index 4869aaccd..7fff05b52 100644 --- a/zpp-solver/node_candidates_solver/src/main/java/nc_wrapper/NCWrapper.java +++ b/zpp-solver/node_candidates_solver/src/main/java/nc_wrapper/NCWrapper.java @@ -11,7 +11,7 @@ import java.util.ArrayList; import java.util.List; import java.util.Random; -public class NCWrapper { +public class NCWrapper implements MarginalDomainValuesProvider{ private CPWrapper cpWrapper; private ComponentVariableOrderer variableOrderer; diff --git a/zpp-solver/node_candidates_solver/src/main/java/node_candidate/NodeCandidatesPool.java b/zpp-solver/node_candidates_solver/src/main/java/node_candidate/NodeCandidatesPool.java index 72e40436f..3dc68cbed 100644 --- a/zpp-solver/node_candidates_solver/src/main/java/node_candidate/NodeCandidatesPool.java +++ b/zpp-solver/node_candidates_solver/src/main/java/node_candidate/NodeCandidatesPool.java @@ -2,13 +2,13 @@ package node_candidate; import cp_components.PTMover; import eu.paasage.upperware.metamodel.cp.VariableType; -import nc_wrapper.NCWrapper; +import nc_wrapper.MarginalDomainValuesProvider; import variable_orderer.VariableTypeOrderer; import java.util.*; public class NodeCandidatesPool { - private NCWrapper ncWrapper; + private MarginalDomainValuesProvider domainHandler; private List components; /* @@ -22,9 +22,11 @@ public class NodeCandidatesPool { */ private Map> vmLocations; - public NodeCandidatesPool(NCWrapper ncWrapper) { - this.components = ncWrapper.getComponents(); - this.ncWrapper = ncWrapper; + public NodeCandidatesPool(MarginalDomainValuesProvider domainHandler, List components) { + this.components = components; + this.domainHandler = domainHandler; + vmConfigurations = new HashMap<>(); + vmLocations = new HashMap<>(); } public void postVMConfiguration(int provider, VMConfiguration configuration) { @@ -50,6 +52,9 @@ public class NodeCandidatesPool { } } private Collection getVMConfigurationOrItsNeighbours(int provider, VMConfiguration conf) { + if (!vmConfigurations.containsKey(provider)) { + return new ArrayList<>(); + } if (Collections.binarySearch(vmConfigurations.get(provider), conf) >= 0) { return Arrays.asList(conf); } else { @@ -58,6 +63,9 @@ public class NodeCandidatesPool { } private Collection getVMLocationOrItsNeighbours(int provider, GeographicCoordinate loc) { + if (!vmLocations.containsKey(provider)) { + return new ArrayList<>(); + } if (Collections.binarySearch(vmLocations.get(provider), loc) >= 0) { return Arrays.asList(loc); } else { @@ -66,6 +74,9 @@ public class NodeCandidatesPool { } private Collection getVMConfigurationNeighbours(int provider, VMConfiguration conf) { + if (!vmConfigurations.containsKey(provider)) { + return new ArrayList<>(); + } int index = Collections.binarySearch(vmConfigurations.get(provider), conf); Collection result = new ArrayList<>(); if(index >= 0) { @@ -88,6 +99,9 @@ public class NodeCandidatesPool { } private Collection getVMLocationNeighbours(int provider, GeographicCoordinate loc) { + if (!vmLocations.containsKey(provider)) { + return new ArrayList<>(); + } Collection result = new ArrayList<>(); int index = Collections.binarySearch(vmLocations.get(provider), loc); if(index >= 0) { @@ -193,8 +207,8 @@ public class NodeCandidatesPool { private Collection getAllCardinalityChangeMoves(List assignment, int component) { int index = component * VariableTypeOrderer.variablesPerComponent + VariableTypeOrderer.mapTypeToIndex(VariableType.CARDINALITY); - int maxCardinality = ncWrapper.getMaxValue(index); - int minCardinality = ncWrapper.getMinValue(index); + int maxCardinality = domainHandler.getMaxValue(index); + int minCardinality = domainHandler.getMinValue(index); Collection result = new ArrayList<>(); if (assignment.get(index) < maxCardinality) { List newAssignment = new ArrayList<>(assignment); @@ -233,13 +247,19 @@ public class NodeCandidatesPool { private Collection getAllProviderChangeMoves(List assignment, int component) { int provider = extractProvider(component, assignment); - int maxProvider = ncWrapper.getMaxValue(component * VariableTypeOrderer.variablesPerComponent); - int minProvider = ncWrapper.getMinValue(component * VariableTypeOrderer.variablesPerComponent); - - return null; + int maxProvider = domainHandler.getMaxValue(component * VariableTypeOrderer.variablesPerComponent); + int minProvider = domainHandler.getMinValue(component * VariableTypeOrderer.variablesPerComponent); + Collection result = new ArrayList<>(); + if (provider < maxProvider) { + result.addAll(getAllProviderChangeMoves(assignment, component, provider + 1)); + } + if (provider > minProvider) { + result.addAll(getAllProviderChangeMoves(assignment, component, provider - 1)); + } + return result; } - public Collection getAllMovesComponent(List assignment, int component) { + private Collection getAllMovesComponent(List assignment, int component) { Collection result = getAllVMConfigurationChangeMoves(assignment, component); result.addAll(getAllVMLocationChangeMoves(assignment, component)); result.addAll(getAllCardinalityChangeMoves(assignment, component)); @@ -254,6 +274,4 @@ public class NodeCandidatesPool { } return moves; } - - } diff --git a/zpp-solver/node_candidates_solver/src/main/java/variable_orderer/VariableTypeOrderer.java b/zpp-solver/node_candidates_solver/src/main/java/variable_orderer/VariableTypeOrderer.java index 7cec274ca..5f91a4b27 100644 --- a/zpp-solver/node_candidates_solver/src/main/java/variable_orderer/VariableTypeOrderer.java +++ b/zpp-solver/node_candidates_solver/src/main/java/variable_orderer/VariableTypeOrderer.java @@ -14,11 +14,11 @@ public class VariableTypeOrderer { return 2; case STORAGE: return 3; - case CARDINALITY: - return 4; case LATITUDE: - return 5; + return 4; case LONGITUDE: + return 5; + case CARDINALITY: return 6; default: throw new RuntimeException("Unsupported Variable type !"); diff --git a/zpp-solver/node_candidates_solver/src/test/java/NCWrapperTest.java b/zpp-solver/node_candidates_solver/src/test/java/NCWrapperTest.java index 06588323b..8b3967415 100644 --- a/zpp-solver/node_candidates_solver/src/test/java/NCWrapperTest.java +++ b/zpp-solver/node_candidates_solver/src/test/java/NCWrapperTest.java @@ -1,4 +1,5 @@ import static org.junit.jupiter.api.Assertions.*; +import org.junit.jupiter.api.Test; class NCWrapperTest { diff --git a/zpp-solver/node_candidates_solver/src/test/java/node_candidate/GeographicCoordinateTest.java b/zpp-solver/node_candidates_solver/src/test/java/node_candidate/GeographicCoordinateTest.java new file mode 100644 index 000000000..2263aad15 --- /dev/null +++ b/zpp-solver/node_candidates_solver/src/test/java/node_candidate/GeographicCoordinateTest.java @@ -0,0 +1,19 @@ +package node_candidate; + +import org.junit.jupiter.api.Test; + +import static org.junit.jupiter.api.Assertions.*; + +class GeographicCoordinateTest { + + @Test + public void comparatorTest() { + GeographicCoordinate t = new GeographicCoordinate(100, 150); + assertEquals(t.compareTo(new GeographicCoordinate(100, 151)), -1); + assertEquals(t.compareTo(new GeographicCoordinate(100, 150)), 0); + assertEquals(t.compareTo(new GeographicCoordinate(101, 1)), -1); + assertEquals(t.compareTo(new GeographicCoordinate(100, 1)), 1); + assertEquals(t.compareTo(new GeographicCoordinate(99, 151)), 1); + } + +} \ No newline at end of file diff --git a/zpp-solver/node_candidates_solver/src/test/java/node_candidate/NodeCandidatesPoolTest.java b/zpp-solver/node_candidates_solver/src/test/java/node_candidate/NodeCandidatesPoolTest.java new file mode 100644 index 000000000..2753fa9a3 --- /dev/null +++ b/zpp-solver/node_candidates_solver/src/test/java/node_candidate/NodeCandidatesPoolTest.java @@ -0,0 +1,105 @@ +package node_candidate; + +import cp_components.PTMover; +import nc_wrapper.MarginalDomainValuesProvider; +import org.junit.jupiter.api.Test; + +import java.util.Arrays; +import java.util.List; + +import static org.junit.jupiter.api.Assertions.*; + +class NodeCandidatesPoolTest { + + public NodeCandidatesPool createPool() { + return new NodeCandidatesPool(new MarginalDomainValuesProvider() { + @Override + public int getMaxValue(int variable) { + return 2; + } + + @Override + public int getMinValue(int variable) { + return 0; + } + }, + Arrays.asList("comp1", "comp2", "comp3")); + } + + @Test + public void firstGetAllMovesTest() { + NodeCandidatesPool pool = createPool(); + pool.postVMConfiguration(0, new VMConfiguration(0, 0, 0)); + pool.postVMConfiguration(0, new VMConfiguration(1, 0, 0)); + pool.postVMConfiguration(0, new VMConfiguration(2, 0, 0)); + pool.postVMConfiguration(0, new VMConfiguration(0, 2, 0)); + pool.postVMLocation(0, new GeographicCoordinate(100, 100)); + + pool.initNodeCandidates(); + List moves = pool.getAllMoves(Arrays.asList(0, 0, 0, 0, 100, 100, 1, 0, 0, 0, 0, 100, 100, 1, 0, 0, 0, 0, 100, 100, 1)); + assertEquals(moves.size(), 3*3); + + PTMover m = new PTMover( + Arrays.asList(0, 0, 0, 0, 100, 100, 1, 0, 0, 0, 0, 100, 100, 1, 0, 0, 0, 0, 100, 100, 1), + Arrays.asList(0, 0, 0, 0, 100, 100, 2, 0, 0, 0, 0, 100, 100, 1, 0, 0, 0, 0, 100, 100, 1) + ); + + assertEquals(moves.contains(m), true); + + m = new PTMover( + Arrays.asList(0, 0, 0, 0, 100, 100, 1, 0, 0, 0, 0, 100, 100, 1, 0, 0, 0, 0, 100, 100, 1), + Arrays.asList(0, 0, 0, 0, 100, 100, 1, 0, 0, 0, 0, 100, 100, 1, 0, 0 , 2, 0, 100, 100, 1) + ); + + assertEquals(moves.contains(m), true); + + m = new PTMover( + Arrays.asList(0, 0, 0, 0, 100, 100, 1, 0, 0, 0, 0, 100, 100, 1, 0, 0, 0, 0, 100, 100, 1), + Arrays.asList(0, 0, 0, 0, 100, 100, 0, 0, 0, 0, 0, 100, 100, 1, 0, 0, 0, 0, 100, 100, 1) + ); + + assertEquals(moves.contains(m), true); + + } + + @Test + public void secondGetAllMovesTest() { + NodeCandidatesPool pool = createPool(); + pool.postVMConfiguration(0, new VMConfiguration(0, 0, 0)); + pool.postVMConfiguration(0, new VMConfiguration(1, 0, 0)); + pool.postVMConfiguration(0, new VMConfiguration(2, 0, 0)); + pool.postVMLocation(0, new GeographicCoordinate(100, 100)); + pool.postVMLocation(0, new GeographicCoordinate(100, 150)); + + pool.postVMConfiguration(1, new VMConfiguration(0, 0, 1)); + pool.postVMConfiguration(1, new VMConfiguration(1, 0, 1)); + pool.postVMConfiguration(1, new VMConfiguration(2, 0, 1)); + pool.postVMLocation(1, new GeographicCoordinate(100, 100)); + pool.postVMLocation(1, new GeographicCoordinate(100, 150)); + + pool.initNodeCandidates(); + List moves = pool.getAllMoves(Arrays.asList(0, 1, 0, 0, 100, 100, 1, 0, 1, 0, 0, 100, 100, 1, 0, 1, 0, 0, 100, 100, 1)); + assertEquals(moves.size(), 3*7); + + PTMover m = new PTMover( + Arrays.asList(0, 1, 0, 0, 100, 100, 1, 0, 1, 0, 0, 100, 100, 1, 0, 1, 0, 0, 100, 100, 1), + Arrays.asList(0, 1, 0, 0, 100, 100, 1, 1, 0, 0, 1, 100, 100, 1, 0, 1, 0, 0, 100, 100, 1) + ); + + assertEquals(moves.contains(m), true); + + m = new PTMover( + Arrays.asList(0, 1, 0, 0, 100, 100, 1, 0, 1, 0, 0, 100, 100, 1, 0, 1, 0, 0, 100, 100, 1), + Arrays.asList(0, 1, 0, 0, 100, 100, 1, 1, 1, 0, 1, 100, 100, 1, 0, 1, 0, 0, 100, 100, 1) + ); + + assertEquals(moves.contains(m), true); + + m = new PTMover( + Arrays.asList(0, 1, 0, 0, 100, 100, 1, 0, 1, 0, 0, 100, 100, 1, 0, 1, 0, 0, 100, 100, 1), + Arrays.asList(0, 1, 0, 0, 100, 100, 1, 0, 1, 0, 0, 100, 100, 1, 0, 1, 0, 0, 100, 150, 1) + ); + + assertEquals(moves.contains(m), true); + } +} \ No newline at end of file diff --git a/zpp-solver/node_candidates_solver/src/test/java/node_candidate/VMConfigurationTest.java b/zpp-solver/node_candidates_solver/src/test/java/node_candidate/VMConfigurationTest.java new file mode 100644 index 000000000..15468d71d --- /dev/null +++ b/zpp-solver/node_candidates_solver/src/test/java/node_candidate/VMConfigurationTest.java @@ -0,0 +1,19 @@ +package node_candidate; + +import org.junit.jupiter.api.Test; + +import static org.junit.jupiter.api.Assertions.*; + +class VMConfigurationTest { + + @Test + public void comparatorTest() { + VMConfiguration t = new VMConfiguration(100, 200, 300); + assertEquals(t.compareTo(new VMConfiguration(100, 200, 300)), 0); + assertEquals(t.compareTo(new VMConfiguration(50, 201, 301)), 1); + assertEquals(t.compareTo(new VMConfiguration(100, 200, 200)), 1); + assertEquals(t.compareTo(new VMConfiguration(100, 200, 400)), -1); + assertEquals(t.compareTo(new VMConfiguration(100, 400, 10)), -1); + } + +} \ No newline at end of file diff --git a/zpp-solver/pom.xml b/zpp-solver/pom.xml index 303a8666e..5c135bf80 100644 --- a/zpp-solver/pom.xml +++ b/zpp-solver/pom.xml @@ -14,7 +14,7 @@ genetic-solver mcts-solver pt-solver - node-candidates-solver + node_candidates_solver zpp-solver -- GitLab From 827290c4fba1043ba9934385394122ff01944074 Mon Sep 17 00:00:00 2001 From: Michal Jankowski Date: Sun, 29 Dec 2019 19:26:27 +0100 Subject: [PATCH 055/340] Updated Snapshot versions from 2.5.1 to 3.0.0 --- zpp-solver/cp-parser/pom.xml | 2 +- zpp-solver/genetic-solver/pom.xml | 15 +++++++++++---- zpp-solver/pom.xml | 6 +++--- zpp-solver/pt-solver/pom.xml | 8 ++++---- 4 files changed, 19 insertions(+), 12 deletions(-) diff --git a/zpp-solver/cp-parser/pom.xml b/zpp-solver/cp-parser/pom.xml index 3cd39ca90..dc3c7cd43 100644 --- a/zpp-solver/cp-parser/pom.xml +++ b/zpp-solver/cp-parser/pom.xml @@ -5,7 +5,7 @@ zpp-solver org.ow2.paasage - 2.5.1-SNAPSHOT + 3.0.0-SNAPSHOT ../pom.xml 4.0.0 diff --git a/zpp-solver/genetic-solver/pom.xml b/zpp-solver/genetic-solver/pom.xml index 71f83064a..f456524c7 100644 --- a/zpp-solver/genetic-solver/pom.xml +++ b/zpp-solver/genetic-solver/pom.xml @@ -3,14 +3,21 @@ xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd"> - upperware + zpp-solver org.ow2.paasage - 2.5.1-SNAPSHOT - ../../pom.xml + 3.0.0-SNAPSHOT + ../pom.xml 4.0.0 genetic-solver - + + + org.ow2.paasage + cp-parser + 3.0.0-SNAPSHOT + compile + + \ No newline at end of file diff --git a/zpp-solver/pom.xml b/zpp-solver/pom.xml index f6d64c0aa..bd8e19189 100644 --- a/zpp-solver/pom.xml +++ b/zpp-solver/pom.xml @@ -5,7 +5,7 @@ upperware org.ow2.paasage - 2.5.1-SNAPSHOT + 3.0.0-SNAPSHOT 4.0.0 @@ -24,7 +24,7 @@ eu.melodic utility-generator - 2.5.1-SNAPSHOT + 3.0.0-SNAPSHOT compile @@ -35,7 +35,7 @@ eu.melodic cp-solver - 2.5.1-SNAPSHOT + 3.0.0-SNAPSHOT compile diff --git a/zpp-solver/pt-solver/pom.xml b/zpp-solver/pt-solver/pom.xml index 9ab847c92..597911d53 100644 --- a/zpp-solver/pt-solver/pom.xml +++ b/zpp-solver/pt-solver/pom.xml @@ -5,7 +5,7 @@ zpp-solver org.ow2.paasage - 2.5.1-SNAPSHOT + 3.0.0-SNAPSHOT ../pom.xml 4.0.0 @@ -41,19 +41,19 @@ eu.melodic utility-generator - 2.5.1-SNAPSHOT + 3.0.0-SNAPSHOT test org.ow2.paasage cp-parser - 2.5.1-SNAPSHOT + 3.0.0-SNAPSHOT compile org.ow2.paasage cp-parser - 2.5.1-SNAPSHOT + 3.0.0-SNAPSHOT test-jar test -- GitLab From 1897d2abe23a028a4c9203acd5fded731e19125c Mon Sep 17 00:00:00 2001 From: Michal Jankowski Date: Sun, 29 Dec 2019 19:27:28 +0100 Subject: [PATCH 056/340] Part of genetic-solver code - high chance much of it changes very soon --- .../src/main/java/OurEngine.java | 30 ++++++ .../cPGeneticWrapper/CPGeneticWrapper.java | 69 +++++++++++++ .../main/java/implementation/OurAlterer.java | 12 +++ .../java/implementation/OurChromosome.java | 98 +++++++++++++++++++ .../src/main/java/implementation/OurGene.java | 52 ++++++++++ .../main/java/implementation/OurSelector.java | 23 +++++ .../StochasticRankingComparator.java | 43 ++++++++ 7 files changed, 327 insertions(+) create mode 100644 zpp-solver/genetic-solver/src/main/java/OurEngine.java create mode 100644 zpp-solver/genetic-solver/src/main/java/cPGeneticWrapper/CPGeneticWrapper.java create mode 100644 zpp-solver/genetic-solver/src/main/java/implementation/OurAlterer.java create mode 100644 zpp-solver/genetic-solver/src/main/java/implementation/OurChromosome.java create mode 100644 zpp-solver/genetic-solver/src/main/java/implementation/OurGene.java create mode 100644 zpp-solver/genetic-solver/src/main/java/implementation/OurSelector.java create mode 100644 zpp-solver/genetic-solver/src/main/java/implementation/StochasticRankingComparator.java diff --git a/zpp-solver/genetic-solver/src/main/java/OurEngine.java b/zpp-solver/genetic-solver/src/main/java/OurEngine.java new file mode 100644 index 000000000..c7e256a57 --- /dev/null +++ b/zpp-solver/genetic-solver/src/main/java/OurEngine.java @@ -0,0 +1,30 @@ +import cPGeneticWrapper.CPGeneticWrapper; +import cp_wrapper.CPWrapper; +import implementation.OurChromosome; +import implementation.OurGene; +import io.jenetics.Genotype; +import io.jenetics.engine.Engine; +import io.jenetics.engine.EvolutionResult; +import io.jenetics.util.Factory; + +import java.util.function.Function; + +public class OurEngine { + + private Integer dummy = 10; + + + public void main(String[] args) { + CPWrapper cpWrapper = new CPWrapper(); + CPGeneticWrapper cpGeneticWrapper = new CPGeneticWrapper(cpWrapper); + + Factory> gtf = + Genotype.of(OurChromosome.of(dummy, dummy, cpGeneticWrapper)); + + Function, Double> fun = chromosomes -> 0.5; + + final Engine engine = Engine.builder(fun, gtf).build(); + + System.out.println(engine.stream().limit(100).collect(EvolutionResult.toBestGenotype())); + } +} diff --git a/zpp-solver/genetic-solver/src/main/java/cPGeneticWrapper/CPGeneticWrapper.java b/zpp-solver/genetic-solver/src/main/java/cPGeneticWrapper/CPGeneticWrapper.java new file mode 100644 index 000000000..fa40d0d19 --- /dev/null +++ b/zpp-solver/genetic-solver/src/main/java/cPGeneticWrapper/CPGeneticWrapper.java @@ -0,0 +1,69 @@ +package cPGeneticWrapper; + +import cp_wrapper.CPWrapper; +import implementation.OurGene; +import io.jenetics.util.ISeq; +import io.jenetics.util.RandomRegistry; + +import java.util.ArrayList; +import java.util.List; +import java.util.Random; + + +// TODO need to implement method getRanges and getList in cpParser +public class CPGeneticWrapper { + private final static Random random = RandomRegistry.getRandom(); + private CPWrapper cpWrapper; + + public CPGeneticWrapper(CPWrapper cpWrapper) { + this.cpWrapper = cpWrapper; + } + + // Calculates which variable has highest heuristic value. Returns its index. + // TODO probably need to calculate it in other way - to get faster exec time + public int calculateHeuristicBest(List values) { + int bestIndex = -1, bestValue = 0, tmp; + + assert values.size() > 0; + + for (int i = 0; i < values.size(); i++) + if ((tmp = cpWrapper.getHeuristicEvaluation(values, i)) > bestValue) { + bestIndex = i; + bestValue = tmp; + } + + return bestIndex; + } + + // Generates random value for variable indexed with index. + public int generateRandomValue(int index) { + return 0; + // TODO random NEEDS to be used here + } + + public double calculateUtility(ISeq genes) { + return cpWrapper.getUtility(genesToIntegerList(genes)); + } + + public int countViolatedConstraints(ISeq genes) { + return cpWrapper.countViolatedConstraints(genesToIntegerList(genes)); + } + + public boolean isValid(int value, int index) { + // TODO + return cpWrapper.getMinDomainValue(index) <= value && value <= cpWrapper.getMaxDomainValue(index); + } + + public boolean getIsFeasible(ISeq genes) { + return cpWrapper.checkIfFeasible(genesToIntegerList(genes)); + } + + private List genesToIntegerList(ISeq genes) { + List list = new ArrayList<>(); + + for (OurGene gene : genes) + list.add(gene.getAllele()); + + return list; + } +} diff --git a/zpp-solver/genetic-solver/src/main/java/implementation/OurAlterer.java b/zpp-solver/genetic-solver/src/main/java/implementation/OurAlterer.java new file mode 100644 index 000000000..51579b1b6 --- /dev/null +++ b/zpp-solver/genetic-solver/src/main/java/implementation/OurAlterer.java @@ -0,0 +1,12 @@ +import implementation.OurGene; +import io.jenetics.Alterer; +import io.jenetics.AltererResult; +import io.jenetics.Phenotype; +import io.jenetics.util.Seq; + +public class OurAlterer implements Alterer { + @Override + public AltererResult alter(Seq> seq, long l) { + return null; + } +} diff --git a/zpp-solver/genetic-solver/src/main/java/implementation/OurChromosome.java b/zpp-solver/genetic-solver/src/main/java/implementation/OurChromosome.java new file mode 100644 index 000000000..4194ff3c4 --- /dev/null +++ b/zpp-solver/genetic-solver/src/main/java/implementation/OurChromosome.java @@ -0,0 +1,98 @@ +package implementation; + +import cPGeneticWrapper.CPGeneticWrapper; +import io.jenetics.Chromosome; +import io.jenetics.util.ISeq; +import io.jenetics.util.MSeq; + + +public class OurChromosome implements Chromosome { + private ISeq genes; + private Integer length; + private boolean isFeasible; + private double utility; + private int brokenConstraints; + private Boolean valid; + private CPGeneticWrapper cpGeneticWrapper; + + public OurChromosome(ISeq genes, Integer length, CPGeneticWrapper cpGeneticWrapper) { + this.genes = genes; + this.length = length; + this.cpGeneticWrapper = cpGeneticWrapper; + this.isFeasible = cpGeneticWrapper.getIsFeasible(genes); + this.utility = cpGeneticWrapper.calculateUtility(genes); + this.brokenConstraints = cpGeneticWrapper.countViolatedConstraints(genes); + this.valid = checkIfValid(genes); + } + + @Override + public Chromosome newInstance(ISeq iSeq) { + return new OurChromosome(iSeq, iSeq.length(), cpGeneticWrapper); + } + + @Override + public OurGene getGene(int i) { + return genes.get(i); + } + + @Override + public int length() { + return genes.length(); + } + + @Override + public ISeq toSeq() { + return genes; + } + + @Override + public Chromosome newInstance() { + return of(length); + } + + @Override + public boolean isValid() { + return valid; + } + + private boolean checkIfValid(ISeq genes) { + for (OurGene gene : genes) + if (!gene.isValid()) + return false; + return true; + } + + // Creates randomly generated Chromosome. + public OurChromosome of(Integer length) { + return of(length, cpGeneticWrapper); + } + + // Creates randomly generated Chromosome. Static version of above method + public static OurChromosome of(Integer length, CPGeneticWrapper cpGeneticWrapper) { + ISeq genes = OurGene.seq(length, cpGeneticWrapper); + return new OurChromosome(genes, length, cpGeneticWrapper); + } + + // Creates randomly generated sequence of Chromosomes. + public ISeq of(Integer length, Integer size) { + return of(length, size, cpGeneticWrapper); + } + + public static ISeq of(Integer length, Integer size, CPGeneticWrapper cpGeneticWrapper) { + return MSeq.ofLength(size) + .fill(() -> of(length, cpGeneticWrapper)) + .toISeq(); + } + + public double getUtility() { + return utility; + } + + public int getBrokenConstraints() { + return brokenConstraints; + } + + public boolean getIsFeasible() { + return isFeasible; + } +} diff --git a/zpp-solver/genetic-solver/src/main/java/implementation/OurGene.java b/zpp-solver/genetic-solver/src/main/java/implementation/OurGene.java new file mode 100644 index 000000000..e36859682 --- /dev/null +++ b/zpp-solver/genetic-solver/src/main/java/implementation/OurGene.java @@ -0,0 +1,52 @@ +package implementation; + +import cPGeneticWrapper.CPGeneticWrapper; +import io.jenetics.Gene; +import io.jenetics.util.ISeq; +import lombok.AllArgsConstructor; + +import java.util.ArrayList; +import java.util.List; + +@AllArgsConstructor +public class OurGene implements Gene { + private Integer value; + private Integer index; + private CPGeneticWrapper cpGeneticWrapper; + + @Override + public Integer getAllele() { + return value; + } + + @Override + public OurGene newInstance() { + return of(index); + } + + @Override + public OurGene newInstance(Integer k) { + return new OurGene(k, index, cpGeneticWrapper); + } + + @Override + public boolean isValid() { + return cpGeneticWrapper.isValid(value, index); + } + + private OurGene of(Integer index) { + return new OurGene(cpGeneticWrapper.generateRandomValue(index), index, cpGeneticWrapper); + } + + public ISeq seq(Integer length) { + return seq(length, cpGeneticWrapper); + } + + static ISeq seq(Integer length, CPGeneticWrapper cpGeneticWrapper) { + List list = new ArrayList<>(); + + for (int i = 0; i < length; i++) + list.add(new OurGene(cpGeneticWrapper.generateRandomValue(i), i, cpGeneticWrapper)); + return ISeq.of(list); + } +} \ No newline at end of file diff --git a/zpp-solver/genetic-solver/src/main/java/implementation/OurSelector.java b/zpp-solver/genetic-solver/src/main/java/implementation/OurSelector.java new file mode 100644 index 000000000..687db36c9 --- /dev/null +++ b/zpp-solver/genetic-solver/src/main/java/implementation/OurSelector.java @@ -0,0 +1,23 @@ +package implementation; + +import io.jenetics.Optimize; +import io.jenetics.Phenotype; +import io.jenetics.Selector; +import io.jenetics.util.ISeq; +import io.jenetics.util.MSeq; +import io.jenetics.util.Seq; + +import java.util.Comparator; + +import static java.util.Collections.reverseOrder; + +public class OurSelector implements Selector { + @Override + public ISeq> select(Seq> seq, int size, Optimize optimize) { + MSeq> mseq = seq.asMSeq(); + Comparator> comparator = new StochasticRankingComparator(0); + mseq.sort(reverseOrder(comparator)); + + return mseq.subSeq(size).toISeq(); + } +} diff --git a/zpp-solver/genetic-solver/src/main/java/implementation/StochasticRankingComparator.java b/zpp-solver/genetic-solver/src/main/java/implementation/StochasticRankingComparator.java new file mode 100644 index 000000000..27bd3af07 --- /dev/null +++ b/zpp-solver/genetic-solver/src/main/java/implementation/StochasticRankingComparator.java @@ -0,0 +1,43 @@ +package implementation; + +import io.jenetics.Phenotype; +import io.jenetics.util.RandomRegistry; + +import java.util.Comparator; +import java.util.Random; + +public class StochasticRankingComparator implements Comparator> { + static final Random random = RandomRegistry.getRandom(); + private double probability; + + public StochasticRankingComparator(double probability) { + assert probability >= 0 && probability <= 1; + this.probability = probability; + } + + @Override + public int compare(Phenotype left, Phenotype right) { + double leftUtility, rightUtility; + int leftBroken, rightBroken; + + + // TODO Maybe such a casting isn't going to work. + OurChromosome l = (OurChromosome) left.getGenotype().getChromosome(); + OurChromosome r = (OurChromosome) right.getGenotype().getChromosome(); + + leftUtility = l.getUtility(); + rightUtility = r.getUtility(); + leftBroken = l.getBrokenConstraints(); + rightBroken = r.getBrokenConstraints(); + + if (leftUtility == rightUtility && leftBroken == rightBroken) + return 0; + + if (leftBroken == rightBroken) + return Double.compare(leftUtility, rightUtility); + else if ((l.getIsFeasible() || r.getIsFeasible()) && random.nextDouble() < probability) + return Double.compare(leftUtility, rightUtility); + else + return Integer.compare(rightBroken, leftBroken); + } +} -- GitLab From b67061f527b1c8a137a59b4304f39b5ec857eb45 Mon Sep 17 00:00:00 2001 From: tc360950 Date: Wed, 8 Jan 2020 18:50:37 +0100 Subject: [PATCH 057/340] Minor fixes & comments --- .../cpsolver/CPSolverController.java | 2 +- .../src/main/java/cp_wrapper/CPWrapper.java | 19 +- .../java/cp_wrapper/parser/CPParsedData.java | 7 +- .../cp_wrapper/utils/ConstraintGraph.java | 4 +- .../java/cp_wrapper/utils/DomainHandler.java | 55 ++- .../cp_wrapper/utils/ExpressionEvaluator.java | 42 +- .../utils/constraint/Constraint.java | 4 +- .../utils/constraint/ConstraintImpl.java | 3 +- .../utils/numeric_value_impl/DoubleValue.java | 23 ++ .../numeric_value_impl/IntValueInterface.java | 5 + .../numeric_value_impl/IntegerValue.java | 26 ++ .../utils/numeric_value_impl/LongValue.java | 45 +++ .../numeric_value_impl/NumericValue.java | 5 + .../cp_wrapper/mockups/ConstraintMockup.java | 3 +- .../mockups/CpVariableImplMockup.java | 13 +- .../mockups/NumericListDomainImplMockup.java | 6 +- .../mockups/RangeDomainImpMockup.java | 5 +- .../cp_wrapper/utils/ConstraintImplTest.java | 26 +- .../utils/ExpressionEvaluatorTest.java | 18 +- .../pom.xml | 11 +- .../src/main/java/NCSolverCoordinator.java | 35 +- .../main/java/cp_components/PTEvaluation.java | 3 - .../src/main/java/cp_components/PTMover.java | 14 +- .../java/cp_components/PTNeighbourhood.java | 8 +- .../main/java/cp_components/PTObjective.java | 6 +- .../java/cp_components/PTRandomGenerator.java | 0 .../main/java/cp_components/PTSolution.java | 82 ++++ .../main/java/nc_wrapper/DomainProvider.java | 11 + .../src/main/java/nc_wrapper/NCWrapper.java | 161 ++++++++ .../node_candidate/GeographicCoordinate.java | 4 +- .../node_candidate/NodeCandidatesPool.java | 360 ++++++++++++++++++ .../java/node_candidate/VMConfiguration.java | 6 +- .../ComponentVariableOrderer.java | 37 +- .../variable_orderer/VariableTypeOrderer.java | 0 .../test/java/NCSolverCoordinatorTest.java | 284 ++++++++++++++ .../java/cp_components/PTSolutionTest.java | 24 ++ .../GeographicCoordinateTest.java | 0 .../NodeCandidatesPoolTest.java | 129 +++++++ .../node_candidate/VMConfigurationTest.java | 0 .../main/java/cp_components/PTSolution.java | 54 --- .../MarginalDomainValuesProvider.java | 7 - .../src/main/java/nc_wrapper/NCWrapper.java | 76 ---- .../node_candidate/NodeCandidatesPool.java | 277 -------------- .../src/test/java/NCWrapperTest.java | 6 - .../NodeCandidatesPoolTest.java | 105 ----- .../test/java/PTSolverCoordinatorTest.java | 3 +- 46 files changed, 1393 insertions(+), 621 deletions(-) create mode 100644 zpp-solver/cp-parser/src/main/java/cp_wrapper/utils/numeric_value_impl/DoubleValue.java create mode 100644 zpp-solver/cp-parser/src/main/java/cp_wrapper/utils/numeric_value_impl/IntValueInterface.java create mode 100644 zpp-solver/cp-parser/src/main/java/cp_wrapper/utils/numeric_value_impl/IntegerValue.java create mode 100644 zpp-solver/cp-parser/src/main/java/cp_wrapper/utils/numeric_value_impl/LongValue.java create mode 100644 zpp-solver/cp-parser/src/main/java/cp_wrapper/utils/numeric_value_impl/NumericValue.java rename zpp-solver/{node_candidates_solver => node-candidates-solver}/pom.xml (85%) rename zpp-solver/{node_candidates_solver => node-candidates-solver}/src/main/java/NCSolverCoordinator.java (60%) rename zpp-solver/{node_candidates_solver => node-candidates-solver}/src/main/java/cp_components/PTEvaluation.java (74%) rename zpp-solver/{node_candidates_solver => node-candidates-solver}/src/main/java/cp_components/PTMover.java (63%) rename zpp-solver/{node_candidates_solver => node-candidates-solver}/src/main/java/cp_components/PTNeighbourhood.java (78%) rename zpp-solver/{node_candidates_solver => node-candidates-solver}/src/main/java/cp_components/PTObjective.java (68%) rename zpp-solver/{node_candidates_solver => node-candidates-solver}/src/main/java/cp_components/PTRandomGenerator.java (100%) create mode 100644 zpp-solver/node-candidates-solver/src/main/java/cp_components/PTSolution.java create mode 100644 zpp-solver/node-candidates-solver/src/main/java/nc_wrapper/DomainProvider.java create mode 100644 zpp-solver/node-candidates-solver/src/main/java/nc_wrapper/NCWrapper.java rename zpp-solver/{node_candidates_solver => node-candidates-solver}/src/main/java/node_candidate/GeographicCoordinate.java (94%) create mode 100644 zpp-solver/node-candidates-solver/src/main/java/node_candidate/NodeCandidatesPool.java rename zpp-solver/{node_candidates_solver => node-candidates-solver}/src/main/java/node_candidate/VMConfiguration.java (93%) rename zpp-solver/{node_candidates_solver => node-candidates-solver}/src/main/java/variable_orderer/ComponentVariableOrderer.java (59%) rename zpp-solver/{node_candidates_solver => node-candidates-solver}/src/main/java/variable_orderer/VariableTypeOrderer.java (100%) create mode 100644 zpp-solver/node-candidates-solver/src/test/java/NCSolverCoordinatorTest.java create mode 100644 zpp-solver/node-candidates-solver/src/test/java/cp_components/PTSolutionTest.java rename zpp-solver/{node_candidates_solver => node-candidates-solver}/src/test/java/node_candidate/GeographicCoordinateTest.java (100%) create mode 100644 zpp-solver/node-candidates-solver/src/test/java/node_candidate/NodeCandidatesPoolTest.java rename zpp-solver/{node_candidates_solver => node-candidates-solver}/src/test/java/node_candidate/VMConfigurationTest.java (100%) delete mode 100644 zpp-solver/node_candidates_solver/src/main/java/cp_components/PTSolution.java delete mode 100644 zpp-solver/node_candidates_solver/src/main/java/nc_wrapper/MarginalDomainValuesProvider.java delete mode 100644 zpp-solver/node_candidates_solver/src/main/java/nc_wrapper/NCWrapper.java delete mode 100644 zpp-solver/node_candidates_solver/src/main/java/node_candidate/NodeCandidatesPool.java delete mode 100644 zpp-solver/node_candidates_solver/src/test/java/NCWrapperTest.java delete mode 100644 zpp-solver/node_candidates_solver/src/test/java/node_candidate/NodeCandidatesPoolTest.java diff --git a/cp-solver/src/main/java/eu/melodic/upperware/cpsolver/CPSolverController.java b/cp-solver/src/main/java/eu/melodic/upperware/cpsolver/CPSolverController.java index 606c67f8f..1e6e10226 100644 --- a/cp-solver/src/main/java/eu/melodic/upperware/cpsolver/CPSolverController.java +++ b/cp-solver/src/main/java/eu/melodic/upperware/cpsolver/CPSolverController.java @@ -44,7 +44,7 @@ public class CPSolverController { @RequestMapping(value = "/constraintProblemSolutionFromFile", method = POST) public void constraintProblemSolutionFromFile(@RequestBody ConstraintProblemSolutionFromFileRequestImpl request) throws Exception { String camelModelFilePath = request.getCamelModelFilePath(); - String cpModelPath = "sdad";//request.getCpProblemFilePath(); + String cpModelPath = request.getCpProblemFilePath(); String nodeCandidatesFilePath = request.getNodeCandidatesFilePath(); log.info("Received constraintProblemSolutionFromFile request: \n" + camelModelFilePath + " \n" + cpModelPath); diff --git a/zpp-solver/cp-parser/src/main/java/cp_wrapper/CPWrapper.java b/zpp-solver/cp-parser/src/main/java/cp_wrapper/CPWrapper.java index f2a89c22a..f26d6aca2 100644 --- a/zpp-solver/cp-parser/src/main/java/cp_wrapper/CPWrapper.java +++ b/zpp-solver/cp-parser/src/main/java/cp_wrapper/CPWrapper.java @@ -3,12 +3,14 @@ package cp_wrapper; import cp_wrapper.parser.CPParsedData; import cp_wrapper.parser.CPParser; import cp_wrapper.utils.DomainHandler; +import cp_wrapper.utils.numeric_value_impl.*; import cp_wrapper.utils.variable_orderer.HeuristicVariableOrderer; import cp_wrapper.utils.VariableNumericType; import cp_wrapper.utils.variable_orderer.VariableOrderer; import eu.melodic.upperware.utilitygenerator.cdo.cp_model.DTO.VariableValueDTO; import eu.melodic.upperware.utilitygenerator.cdo.cp_model.DTO.VariableValueDTOFactory; import eu.paasage.upperware.metamodel.cp.*; +import io.github.cloudiator.rest.model.Runtime; import java.util.ArrayList; import java.util.HashMap; @@ -40,7 +42,7 @@ public class CPWrapper { return cpParsedData.getVariableDomain(variableOrderer.getNameFromIndex(variableIndex)); } - private double getVariableValueFromDomainIndex(int varIndex, int value) { + private NumericValue getVariableValueFromDomainIndex(int varIndex, int value) { String variableName = variableOrderer.getNameFromIndex(varIndex); Domain domain = cpParsedData.getVariableDomain(variableName); if (DomainHandler.isRangeDomain(domain)) { @@ -52,8 +54,8 @@ public class CPWrapper { throw new RuntimeException("Only domaind of types RangeDomain, NumericListDomain are supported!"); } - private Map getAssignmentFromValueList(List assignments) { - Map vars = new HashMap<>(); + private Map getAssignmentFromValueList(List assignments) { + Map vars = new HashMap<>(); for (int i = 0; i < assignments.size(); i++) { if (variableOrderer.exists(i)) { vars.put(variableOrderer.getNameFromIndex(i), getVariableValueFromDomainIndex(i, assignments.get(i))); @@ -82,18 +84,25 @@ public class CPWrapper { private List assignmentToVariableValueDTOList(List assignments) { List result = new ArrayList<>(); for (int i = 0; i < assignments.size(); i++) { + NumericValue val = getVariableValueFromDomainIndex(i, assignments.get(i)); if (cpParsedData.getVariableType(variableOrderer.getNameFromIndex(i)) == VariableNumericType.INT) { + if (!(val instanceof IntValueInterface)) { + throw new RuntimeException(""); + } result.add( VariableValueDTOFactory.createElement( variableOrderer.getNameFromIndex(i), - (int) getVariableValueFromDomainIndex(i, assignments.get(i)) + ((IntValueInterface) val).getIntValue() ) ); } else { + if (!(val instanceof DoubleValue)) { + throw new RuntimeException("Variable " + variableOrderer.getNameFromIndex(i) +" is not of double type!"); + } result.add( VariableValueDTOFactory.createElement( variableOrderer.getNameFromIndex(i), - getVariableValueFromDomainIndex(i, assignments.get(i)) + ((DoubleValue) val).getValue() ) ); } diff --git a/zpp-solver/cp-parser/src/main/java/cp_wrapper/parser/CPParsedData.java b/zpp-solver/cp-parser/src/main/java/cp_wrapper/parser/CPParsedData.java index b57c3fa45..5997f7d2d 100644 --- a/zpp-solver/cp-parser/src/main/java/cp_wrapper/parser/CPParsedData.java +++ b/zpp-solver/cp-parser/src/main/java/cp_wrapper/parser/CPParsedData.java @@ -6,6 +6,7 @@ package cp_wrapper.parser; import cp_wrapper.utils.constraint.Constraint; import cp_wrapper.utils.ConstraintGraph; import cp_wrapper.utils.VariableNumericType; +import cp_wrapper.utils.numeric_value_impl.NumericValue; import eu.melodic.upperware.cpsolver.solver.parser.creator.IntVarCreator; import eu.paasage.upperware.metamodel.cp.*; import lombok.Getter; @@ -36,7 +37,7 @@ public class CPParsedData { initializeNameToVariable(); } - public boolean checkIfFeasible(Map variables) { + public boolean checkIfFeasible(Map variables) { for (Constraint c : constraints) { if (!c.evaluate(variables)) { return false; @@ -45,13 +46,13 @@ public class CPParsedData { return true; } - public int countViolatedConstraints(Map variables) { + public int countViolatedConstraints(Map variables) { return constraints.stream() .map(c -> c.evaluate(variables) ? 0 : 1) .reduce( 0, Integer::sum); } - public int getHeuristicEvaluation(String variable, Map variables) { + public int getHeuristicEvaluation(String variable, Map variables) { return constraintGraph.getVariableHeuristicEvaluation(variable, variables); } diff --git a/zpp-solver/cp-parser/src/main/java/cp_wrapper/utils/ConstraintGraph.java b/zpp-solver/cp-parser/src/main/java/cp_wrapper/utils/ConstraintGraph.java index bb311d786..32e42b92d 100644 --- a/zpp-solver/cp-parser/src/main/java/cp_wrapper/utils/ConstraintGraph.java +++ b/zpp-solver/cp-parser/src/main/java/cp_wrapper/utils/ConstraintGraph.java @@ -9,6 +9,7 @@ package cp_wrapper.utils; import cp_wrapper.utils.constraint.Constraint; +import cp_wrapper.utils.numeric_value_impl.NumericValue; import java.util.*; @@ -74,6 +75,7 @@ public class ConstraintGraph { for (Constraint constraint : constraints) { Collection variables = constraint.getVariableNames(); for (String var : variables) { + System.out.println(var); knownDistances.get(var).addAll(variables); neighbourhoodList.get(var).get(1).addAll(variables); neighbourhoodList.get(var).get(1).remove(var); @@ -150,7 +152,7 @@ public class ConstraintGraph { Heuristic evaluation of a variable is defined to be a sum of violated constrains which involve the variable. */ - public int getVariableHeuristicEvaluation(String variable, Map variables) { + public int getVariableHeuristicEvaluation(String variable, Map variables) { int result = 0; for (Constraint c : variableToConstraint.get(variable)) { if (!c.evaluate(variables)) { diff --git a/zpp-solver/cp-parser/src/main/java/cp_wrapper/utils/DomainHandler.java b/zpp-solver/cp-parser/src/main/java/cp_wrapper/utils/DomainHandler.java index 857cbd087..54a75554d 100644 --- a/zpp-solver/cp-parser/src/main/java/cp_wrapper/utils/DomainHandler.java +++ b/zpp-solver/cp-parser/src/main/java/cp_wrapper/utils/DomainHandler.java @@ -5,6 +5,9 @@ package cp_wrapper.utils; into corresponding values. Currently only RangeDomain and NumericListDomain domains are supported. */ +import cp_wrapper.utils.numeric_value_impl.IntValueInterface; +import cp_wrapper.utils.numeric_value_impl.IntegerValue; +import cp_wrapper.utils.numeric_value_impl.NumericValue; import eu.paasage.upperware.metamodel.cp.Domain; import eu.paasage.upperware.metamodel.cp.NumericListDomain; import eu.paasage.upperware.metamodel.cp.RangeDomain; @@ -22,21 +25,21 @@ public class DomainHandler { return domain instanceof NumericListDomain; } - public static double getRangeValue(int valueIndex, RangeDomain domain) { + public static NumericValue getRangeValue(int valueIndex, RangeDomain domain) { NumericValueUpperware min = domain.getFrom(); if (min instanceof IntegerValueUpperware) { - return (((IntegerValueUpperware) min).getValue() + valueIndex); + return new IntegerValue(((IntegerValueUpperware) min).getValue() + valueIndex); } else { throw new RuntimeException("Only integer RangeDomains are supported!"); } } - public static double getNumericListValue(int valueIndex, NumericListDomain domain) { + public static NumericValue getNumericListValue(int valueIndex, NumericListDomain domain) { List values = domain.getValues(); if (values.size() <= valueIndex) { throw new RuntimeException(); } - return ExpressionEvaluator.getValueOfNumericInterface(values.get(valueIndex)); + return ExpressionEvaluator.convertNumericInterfaceToNumericValue(values.get(valueIndex)); } public static int getMaxDomainValue(Domain domain) { @@ -63,4 +66,48 @@ public class DomainHandler { throw new RuntimeException("Only integer RangeDomains are supported!"); } + + public static NumericValue getMaxValue(Domain domain) { + if (isRangeDomain(domain)) { + return ExpressionEvaluator.convertNumericInterfaceToNumericValue(((RangeDomain) domain).getTo()); + } else if (isNumericListDomain(domain)) { + List values = ((NumericListDomain) domain).getValues(); + return ExpressionEvaluator.convertNumericInterfaceToNumericValue(values.get(values.size() - 1)); + } + throw new RuntimeException("Unsupported dmain type"); + } + + public static NumericValue getMinValue(Domain domain) { + if (isRangeDomain(domain)) { + return ExpressionEvaluator.convertNumericInterfaceToNumericValue(((RangeDomain) domain).getFrom()); + } else if (isNumericListDomain(domain)) { + List values = ((NumericListDomain) domain).getValues(); + return ExpressionEvaluator.convertNumericInterfaceToNumericValue(values.get(0)); + } + throw new RuntimeException("Unsupported dmain type"); + } + + private static boolean isInList(NumericValue value, List list) { + for (NumericValueUpperware v : list) { + if (value.equals(ExpressionEvaluator.convertNumericInterfaceToNumericValue(v))) { + return true; + } + } + return false; + } + + public static boolean isInDomain(NumericValue value, Domain domain) { + if (isRangeDomain(domain)) { + if (!(value instanceof IntValueInterface)) { + return false; + } + int val = ((IntValueInterface) value).getIntValue(); + return val >= ExpressionEvaluator.getValueOfNumericInterface(((RangeDomain) domain).getFrom()) + && + val <= ExpressionEvaluator.getValueOfNumericInterface(((RangeDomain) domain).getTo()); + } else if (isNumericListDomain(domain)) { + return isInList(value, ((NumericListDomain) domain).getValues()); + } + throw new RuntimeException(""); + } } diff --git a/zpp-solver/cp-parser/src/main/java/cp_wrapper/utils/ExpressionEvaluator.java b/zpp-solver/cp-parser/src/main/java/cp_wrapper/utils/ExpressionEvaluator.java index 86a937c79..aa80291c4 100644 --- a/zpp-solver/cp-parser/src/main/java/cp_wrapper/utils/ExpressionEvaluator.java +++ b/zpp-solver/cp-parser/src/main/java/cp_wrapper/utils/ExpressionEvaluator.java @@ -4,6 +4,10 @@ package cp_wrapper.utils; interfaces from eu.paasage.upperware.metamodel.cp package */ +import cp_wrapper.utils.numeric_value_impl.DoubleValue; +import cp_wrapper.utils.numeric_value_impl.IntegerValue; +import cp_wrapper.utils.numeric_value_impl.LongValue; +import cp_wrapper.utils.numeric_value_impl.NumericValue; import eu.paasage.upperware.metamodel.types.*; import eu.paasage.upperware.metamodel.cp.*; @@ -19,15 +23,28 @@ public class ExpressionEvaluator { */ public static final double PRECISION = 0.1; + public static NumericValue convertNumericInterfaceToNumericValue(NumericValueUpperware value) { + if (value instanceof IntegerValueUpperware) { + return new IntegerValue(((IntegerValueUpperware) value).getValue()); + } else if (value instanceof LongValueUpperware) { + return new LongValue(((LongValueUpperware) value).getValue()); + } else if (value instanceof DoubleValueUpperware) { + return new DoubleValue(((DoubleValueUpperware) value).getValue()); + } else if (value instanceof FloatValueUpperware) { + return new DoubleValue(((FloatValueUpperware) value).getValue()); + } + throw new RuntimeException("Unsupported NumericValueUpperware implementation"); + } + static double getValueOfNumericInterface(NumericValueUpperware value) { if (value instanceof IntegerValueUpperware) { - return (double)((IntegerValueUpperware) value).getValue(); + return ((IntegerValueUpperware) value).getValue(); } else if (value instanceof LongValueUpperware) { - return (double)(int)((LongValueUpperware) value).getValue(); + return (int)((LongValueUpperware) value).getValue(); } else if (value instanceof DoubleValueUpperware) { return ((DoubleValueUpperware) value).getValue(); } else if (value instanceof FloatValueUpperware) { - return (double)((FloatValueUpperware) value).getValue(); + return ((FloatValueUpperware) value).getValue(); } throw new RuntimeException("Unsupported NumericValueUpperware implementation"); } @@ -70,7 +87,7 @@ public class ExpressionEvaluator { throw new RuntimeException("Unsupported operation type"); } - private static double evaluateComposedExpression(ComposedExpression exp, Map variables) { + private static double evaluateComposedExpression(ComposedExpression exp, Map variables) { List expressionsValues = exp.getExpressions() .stream() .map(e -> evaluateExpression(e, variables)) @@ -78,20 +95,31 @@ public class ExpressionEvaluator { return evaluateOnOperator(exp.getOperator(), expressionsValues); } - static double evaluateExpression(Expression exp, Map variables) { + private static double castNumericValueToDouble(NumericValue val) { + if (val instanceof DoubleValue) { + return ((DoubleValue) val).getValue(); + } else if (val instanceof IntegerValue) { + return ((IntegerValue) val).getValue(); + } else if (val instanceof LongValue) { + return ((LongValue) val).getValue(); + } + throw new RuntimeException("Unsupported NumericValue type!"); + } + + static double evaluateExpression(Expression exp, Map variables) { if (isConstant(exp)) { return getValueOfNumericInterface(((Constant) exp).getValue()); } else if (isCpMetric(exp)) { return getValueOfNumericInterface(((CpMetric) exp).getValue()); } else if (isCpVariable(exp)) { - return variables.get(exp.getId()); + return castNumericValueToDouble(variables.get(exp.getId())); } else if (isComposedExpression(exp)) { return evaluateComposedExpression((ComposedExpression) exp, variables); } throw new RuntimeException("Unsupported Expression type"); } - public static boolean evaluateComparator(ComparatorEnum comparator, Expression leftExp, Expression rightExp, Map variables) { + public static boolean evaluateComparator(ComparatorEnum comparator, Expression leftExp, Expression rightExp, Map variables) { double leftExpValue = evaluateExpression(leftExp, variables); double rightExpValue = evaluateExpression(rightExp, variables); return evaluateComparator(comparator, leftExpValue, rightExpValue); diff --git a/zpp-solver/cp-parser/src/main/java/cp_wrapper/utils/constraint/Constraint.java b/zpp-solver/cp-parser/src/main/java/cp_wrapper/utils/constraint/Constraint.java index fdd75b9c8..e18ec8aa0 100644 --- a/zpp-solver/cp-parser/src/main/java/cp_wrapper/utils/constraint/Constraint.java +++ b/zpp-solver/cp-parser/src/main/java/cp_wrapper/utils/constraint/Constraint.java @@ -1,5 +1,7 @@ package cp_wrapper.utils.constraint; +import cp_wrapper.utils.numeric_value_impl.NumericValue; + import java.util.Collection; import java.util.Map; @@ -7,5 +9,5 @@ public interface Constraint { Collection getVariableNames(); - boolean evaluate(Map variables); + boolean evaluate(Map variables); } diff --git a/zpp-solver/cp-parser/src/main/java/cp_wrapper/utils/constraint/ConstraintImpl.java b/zpp-solver/cp-parser/src/main/java/cp_wrapper/utils/constraint/ConstraintImpl.java index b3a7d527d..0b954c3eb 100644 --- a/zpp-solver/cp-parser/src/main/java/cp_wrapper/utils/constraint/ConstraintImpl.java +++ b/zpp-solver/cp-parser/src/main/java/cp_wrapper/utils/constraint/ConstraintImpl.java @@ -2,6 +2,7 @@ package cp_wrapper.utils.constraint; import cp_wrapper.utils.ExpressionEvaluator; import cp_wrapper.utils.constraint.Constraint; +import cp_wrapper.utils.numeric_value_impl.NumericValue; import eu.paasage.upperware.metamodel.cp.*; import java.util.ArrayList; @@ -46,7 +47,7 @@ public class ConstraintImpl implements Constraint { } @Override - public boolean evaluate(Map variables){ + public boolean evaluate(Map variables){ if (!checkVariables(variables.keySet())) { throw new RuntimeException("Can't evaluate - some variables are missing"); } diff --git a/zpp-solver/cp-parser/src/main/java/cp_wrapper/utils/numeric_value_impl/DoubleValue.java b/zpp-solver/cp-parser/src/main/java/cp_wrapper/utils/numeric_value_impl/DoubleValue.java new file mode 100644 index 000000000..6b202064d --- /dev/null +++ b/zpp-solver/cp-parser/src/main/java/cp_wrapper/utils/numeric_value_impl/DoubleValue.java @@ -0,0 +1,23 @@ +package cp_wrapper.utils.numeric_value_impl; + +import eu.paasage.upperware.metamodel.types.DoubleValueUpperware; +import lombok.AllArgsConstructor; + +@AllArgsConstructor +public class DoubleValue implements NumericValue { + double value; + + public double getValue() { return value;} + + public void setValue(double value) { + this.value = value; + } + + @Override + public boolean equals(NumericValue value) { + if (value instanceof DoubleValue) { + return this.value == ((DoubleValue) value).getValue(); + } + return false; + } +} diff --git a/zpp-solver/cp-parser/src/main/java/cp_wrapper/utils/numeric_value_impl/IntValueInterface.java b/zpp-solver/cp-parser/src/main/java/cp_wrapper/utils/numeric_value_impl/IntValueInterface.java new file mode 100644 index 000000000..2fff1d878 --- /dev/null +++ b/zpp-solver/cp-parser/src/main/java/cp_wrapper/utils/numeric_value_impl/IntValueInterface.java @@ -0,0 +1,5 @@ +package cp_wrapper.utils.numeric_value_impl; + +public interface IntValueInterface { + int getIntValue(); +} diff --git a/zpp-solver/cp-parser/src/main/java/cp_wrapper/utils/numeric_value_impl/IntegerValue.java b/zpp-solver/cp-parser/src/main/java/cp_wrapper/utils/numeric_value_impl/IntegerValue.java new file mode 100644 index 000000000..b42297657 --- /dev/null +++ b/zpp-solver/cp-parser/src/main/java/cp_wrapper/utils/numeric_value_impl/IntegerValue.java @@ -0,0 +1,26 @@ +package cp_wrapper.utils.numeric_value_impl; + +import lombok.AllArgsConstructor; + +@AllArgsConstructor +public class IntegerValue implements NumericValue, IntValueInterface { + private int value; + + public int getValue() { + return value; + } + + public int getIntValue() { return getValue();} + + public void setValue(int value) { + this.value = value; + } + + @Override + public boolean equals(NumericValue value) { + if (value instanceof IntValueInterface) { + return this.value == ((IntValueInterface) value).getIntValue(); + } + return false; + } +} diff --git a/zpp-solver/cp-parser/src/main/java/cp_wrapper/utils/numeric_value_impl/LongValue.java b/zpp-solver/cp-parser/src/main/java/cp_wrapper/utils/numeric_value_impl/LongValue.java new file mode 100644 index 000000000..57f44a6c0 --- /dev/null +++ b/zpp-solver/cp-parser/src/main/java/cp_wrapper/utils/numeric_value_impl/LongValue.java @@ -0,0 +1,45 @@ +package cp_wrapper.utils.numeric_value_impl; + +import eu.paasage.upperware.metamodel.types.LongValueUpperware; +import lombok.AllArgsConstructor; +import org.eclipse.emf.cdo.CDOLock; +import org.eclipse.emf.cdo.CDOObjectHistory; +import org.eclipse.emf.cdo.CDOState; +import org.eclipse.emf.cdo.common.id.CDOID; +import org.eclipse.emf.cdo.common.lock.CDOLockState; +import org.eclipse.emf.cdo.common.revision.CDORevision; +import org.eclipse.emf.cdo.common.security.CDOPermission; +import org.eclipse.emf.cdo.eresource.CDOResource; +import org.eclipse.emf.cdo.view.CDOView; +import org.eclipse.emf.common.notify.Adapter; +import org.eclipse.emf.common.notify.Notification; +import org.eclipse.emf.common.util.EList; +import org.eclipse.emf.common.util.TreeIterator; +import org.eclipse.emf.ecore.*; +import org.eclipse.emf.ecore.resource.Resource; + +import java.lang.reflect.InvocationTargetException; +@AllArgsConstructor +public class LongValue implements NumericValue, IntValueInterface{ + long value; + + public long getValue() { + return value; + } + + public int getIntValue() { return (int) value;} + + public void setValue(long value) { + this.value = value; + } + + @Override + public boolean equals(NumericValue value) { + if (value instanceof LongValue) { + return this.value == ((LongValue) value).getValue(); + } else if (value instanceof IntegerValue) { + return this.value == (long) ((IntegerValue) value).getValue(); + } + return false; + } +} diff --git a/zpp-solver/cp-parser/src/main/java/cp_wrapper/utils/numeric_value_impl/NumericValue.java b/zpp-solver/cp-parser/src/main/java/cp_wrapper/utils/numeric_value_impl/NumericValue.java new file mode 100644 index 000000000..4502bc18a --- /dev/null +++ b/zpp-solver/cp-parser/src/main/java/cp_wrapper/utils/numeric_value_impl/NumericValue.java @@ -0,0 +1,5 @@ +package cp_wrapper.utils.numeric_value_impl; + +public interface NumericValue { + boolean equals(NumericValue value); +} diff --git a/zpp-solver/cp-parser/src/test/java/cp_wrapper/mockups/ConstraintMockup.java b/zpp-solver/cp-parser/src/test/java/cp_wrapper/mockups/ConstraintMockup.java index 6d5b22c9c..026954b00 100644 --- a/zpp-solver/cp-parser/src/test/java/cp_wrapper/mockups/ConstraintMockup.java +++ b/zpp-solver/cp-parser/src/test/java/cp_wrapper/mockups/ConstraintMockup.java @@ -1,6 +1,7 @@ package cp_wrapper.mockups; import cp_wrapper.utils.constraint.Constraint; +import cp_wrapper.utils.numeric_value_impl.NumericValue; import lombok.AllArgsConstructor; import java.util.Collection; @@ -16,7 +17,7 @@ public class ConstraintMockup implements Constraint { } @Override - public boolean evaluate(Map variables) { + public boolean evaluate(Map variables) { return false; } } diff --git a/zpp-solver/cp-parser/src/test/java/cp_wrapper/mockups/CpVariableImplMockup.java b/zpp-solver/cp-parser/src/test/java/cp_wrapper/mockups/CpVariableImplMockup.java index df7c16466..ef000d5ba 100644 --- a/zpp-solver/cp-parser/src/test/java/cp_wrapper/mockups/CpVariableImplMockup.java +++ b/zpp-solver/cp-parser/src/test/java/cp_wrapper/mockups/CpVariableImplMockup.java @@ -9,10 +9,17 @@ public class CpVariableImplMockup extends NumericExpressionImpl implements CpVar private String id; private VariableType type; private Domain domain; + private String componentId; public CpVariableImplMockup(String id, VariableType type) { this.id = id; this.type = type; } + public CpVariableImplMockup(String id, VariableType type, Domain domain, String componentId) { + this.id = id; + this.type = type; + this.domain = domain; + this.componentId= componentId; + } @Override public String getId() { return this.id; @@ -34,16 +41,16 @@ public class CpVariableImplMockup extends NumericExpressionImpl implements CpVar @Override public void setVariableType(VariableType value) { - this.type = type; + this.type = value; } @Override public String getComponentId() { - return id; + return componentId; } @Override public void setComponentId(String value) { - this.id = id; + this.componentId = componentId; } } diff --git a/zpp-solver/cp-parser/src/test/java/cp_wrapper/mockups/NumericListDomainImplMockup.java b/zpp-solver/cp-parser/src/test/java/cp_wrapper/mockups/NumericListDomainImplMockup.java index 35c875cf3..d89980fdb 100644 --- a/zpp-solver/cp-parser/src/test/java/cp_wrapper/mockups/NumericListDomainImplMockup.java +++ b/zpp-solver/cp-parser/src/test/java/cp_wrapper/mockups/NumericListDomainImplMockup.java @@ -25,7 +25,7 @@ import java.util.List; public class NumericListDomainImplMockup implements NumericListDomain { private EList values = new BasicEList<>(); - + private BasicTypeEnum type; @Override public EList getValues() { return values; @@ -39,12 +39,12 @@ public class NumericListDomainImplMockup implements NumericListDomain { @Override public BasicTypeEnum getType() { - return null; + return type; } @Override public void setType(BasicTypeEnum value) { - + this.type = value; } @Override diff --git a/zpp-solver/cp-parser/src/test/java/cp_wrapper/mockups/RangeDomainImpMockup.java b/zpp-solver/cp-parser/src/test/java/cp_wrapper/mockups/RangeDomainImpMockup.java index 018eec869..2f0b1fd00 100644 --- a/zpp-solver/cp-parser/src/test/java/cp_wrapper/mockups/RangeDomainImpMockup.java +++ b/zpp-solver/cp-parser/src/test/java/cp_wrapper/mockups/RangeDomainImpMockup.java @@ -25,6 +25,7 @@ import java.lang.reflect.InvocationTargetException; public class RangeDomainImpMockup implements RangeDomain { private int min; private int max; + BasicTypeEnum type; private class IntegerValueUpperwareImplMockup implements IntegerValueUpperware { private int value; @@ -247,12 +248,12 @@ public class RangeDomainImpMockup implements RangeDomain { @Override public BasicTypeEnum getType() { - return null; + return type; } @Override public void setType(BasicTypeEnum value) { - + this.type = value; } @Override diff --git a/zpp-solver/cp-parser/src/test/java/cp_wrapper/utils/ConstraintImplTest.java b/zpp-solver/cp-parser/src/test/java/cp_wrapper/utils/ConstraintImplTest.java index a1b60e3a0..18622ce20 100644 --- a/zpp-solver/cp-parser/src/test/java/cp_wrapper/utils/ConstraintImplTest.java +++ b/zpp-solver/cp-parser/src/test/java/cp_wrapper/utils/ConstraintImplTest.java @@ -3,6 +3,8 @@ package cp_wrapper.utils; import cp_wrapper.mockups.*; import cp_wrapper.utils.constraint.Constraint; import cp_wrapper.utils.constraint.ConstraintImpl; +import cp_wrapper.utils.numeric_value_impl.DoubleValue; +import cp_wrapper.utils.numeric_value_impl.NumericValue; import eu.paasage.upperware.metamodel.cp.*; import eu.paasage.upperware.metamodel.types.BasicTypeEnum; import org.eclipse.emf.common.util.BasicEList; @@ -26,7 +28,7 @@ class ConstraintImplTest { } @Test public void shouldThrowEmptyVariables(){ - Map emptyVars = new HashMap<>(); + Map emptyVars = new HashMap<>(); Constraint constraint = new ConstraintImpl(ComparatorEnum.DIFFERENT, variables.get(0), variables.get(1)); assertThrows(RuntimeException.class, () -> { constraint.evaluate(emptyVars); @@ -37,9 +39,9 @@ class ConstraintImplTest { public void shouldThrowWrongVariables(){ Map emptyVars = new HashMap<>(); Constraint constraint = new ConstraintImpl(ComparatorEnum.DIFFERENT, variables.get(0), variables.get(1)); - Map vars = new HashMap<>(); - vars.put(names[1], 0.00123); - vars.put(names[2], 123.345); + Map vars = new HashMap<>(); + vars.put(names[1], new DoubleValue(0.00123)); + vars.put(names[2], new DoubleValue(123.345)); assertThrows(RuntimeException.class, () -> { constraint.evaluate(vars); }); @@ -49,10 +51,10 @@ class ConstraintImplTest { public void linearConstraintEvaluationTest(){ Constant c = new ConstantImplMockup(BasicTypeEnum.DOUBLE, new NumericValueUpperwareImplMockup(1.0)); - Map vars = new HashMap<>(); - vars.put(names[0], 2.0); - vars.put(names[1], 0.00123); - vars.put(names[2], 123.345); + Map vars = new HashMap<>(); + vars.put(names[0], new DoubleValue(2.0)); + vars.put(names[1], new DoubleValue(0.00123)); + vars.put(names[2], new DoubleValue(123.345)); EList exprs = new BasicEList<>(); exprs.addAll(variables); @@ -79,10 +81,10 @@ class ConstraintImplTest { exprs = new BasicEList<>(); exprs.addAll(variables); NumericExpression sum = new ComposedExpressionImplMockup(exprs, OperatorEnum.PLUS); - Map vars = new HashMap<>(); - vars.put(names[0], 2.0); - vars.put(names[1], 3.0); - vars.put(names[2], 5.0); + Map vars = new HashMap<>(); + vars.put(names[0], new DoubleValue(2.0)); + vars.put(names[1], new DoubleValue(3.0)); + vars.put(names[2], new DoubleValue(5.0)); Constraint constraint = new ConstraintImpl(ComparatorEnum.GREATER_OR_EQUAL_TO, div, sum); assertFalse(constraint.evaluate(vars)); } diff --git a/zpp-solver/cp-parser/src/test/java/cp_wrapper/utils/ExpressionEvaluatorTest.java b/zpp-solver/cp-parser/src/test/java/cp_wrapper/utils/ExpressionEvaluatorTest.java index 3bd68cee4..f1cb6a27c 100644 --- a/zpp-solver/cp-parser/src/test/java/cp_wrapper/utils/ExpressionEvaluatorTest.java +++ b/zpp-solver/cp-parser/src/test/java/cp_wrapper/utils/ExpressionEvaluatorTest.java @@ -1,6 +1,8 @@ package cp_wrapper.utils; import cp_wrapper.mockups.*; +import cp_wrapper.utils.numeric_value_impl.DoubleValue; +import cp_wrapper.utils.numeric_value_impl.NumericValue; import eu.paasage.upperware.metamodel.cp.*; import eu.paasage.upperware.metamodel.types.BasicTypeEnum; import eu.paasage.upperware.metamodel.types.NumericValueUpperware; @@ -65,10 +67,10 @@ class ExpressionEvaluatorTest { double a = Math.random(); NumericValueUpperware val = new NumericValueUpperwareImplMockup(a); Constant c = new ConstantImplMockup(BasicTypeEnum.DOUBLE, val); - assertEquals(ExpressionEvaluator.evaluateExpression(c, new HashMap()), a); + assertEquals(ExpressionEvaluator.evaluateExpression(c, new HashMap()), a); CpMetric m = new CpMetricImplMockup(BasicTypeEnum.DOUBLE, val); - assertEquals(ExpressionEvaluator.evaluateExpression(m, new HashMap()), a); + assertEquals(ExpressionEvaluator.evaluateExpression(m, new HashMap()), a); } @Test @@ -76,8 +78,8 @@ class ExpressionEvaluatorTest { double a = Math.random(); String name = "Variable11"; CpVariable var = new CpVariableImplMockup(name, VariableType.CPU); - Map vars = new HashMap<>(); - vars.put(name, a); + Map vars = new HashMap<>(); + vars.put(name, new DoubleValue(a)); assertEquals(ExpressionEvaluator.evaluateExpression(var, vars) , a); } @@ -109,10 +111,10 @@ class ExpressionEvaluatorTest { exprs.add(minus); exprs.add(var3); NumericExpression composed = new ComposedExpressionImplMockup(exprs, OperatorEnum.DIV); - Map vars = new HashMap<>(); - vars.put(names[0], vals[2]); - vars.put(names[1], vals[3]); - vars.put(names[2], vals[4]); + Map vars = new HashMap<>(); + vars.put(names[0], new DoubleValue(vals[2])); + vars.put(names[1],new DoubleValue( vals[3])); + vars.put(names[2], new DoubleValue(vals[4])); assertEquals(ExpressionEvaluator.evaluateExpression(composed, vars) , realValue); } } \ No newline at end of file diff --git a/zpp-solver/node_candidates_solver/pom.xml b/zpp-solver/node-candidates-solver/pom.xml similarity index 85% rename from zpp-solver/node_candidates_solver/pom.xml rename to zpp-solver/node-candidates-solver/pom.xml index de2dd41aa..b98e693f3 100644 --- a/zpp-solver/node_candidates_solver/pom.xml +++ b/zpp-solver/node-candidates-solver/pom.xml @@ -17,8 +17,8 @@ org.apache.maven.plugins maven-compiler-plugin - 7 - 7 + 8 + 8 @@ -46,6 +46,13 @@ 3.0.0-SNAPSHOT compile + + org.ow2.paasage + cp-parser + 3.0.0-SNAPSHOT + test-jar + test + org.junit.jupiter junit-jupiter-api diff --git a/zpp-solver/node_candidates_solver/src/main/java/NCSolverCoordinator.java b/zpp-solver/node-candidates-solver/src/main/java/NCSolverCoordinator.java similarity index 60% rename from zpp-solver/node_candidates_solver/src/main/java/NCSolverCoordinator.java rename to zpp-solver/node-candidates-solver/src/main/java/NCSolverCoordinator.java index 898c67aaf..fcaf963de 100644 --- a/zpp-solver/node_candidates_solver/src/main/java/NCSolverCoordinator.java +++ b/zpp-solver/node-candidates-solver/src/main/java/NCSolverCoordinator.java @@ -1,18 +1,23 @@ import cp_components.*; import cp_wrapper.CPWrapper; import cp_wrapper.UtilityProvider; +import cp_wrapper.parser.CPParsedData; +import eu.melodic.cache.NodeCandidates; +import io.github.cloudiator.rest.model.NodeCandidate; import nc_wrapper.NCWrapper; +import node_candidate.GeographicCoordinate; import node_candidate.NodeCandidatesPool; import eu.paasage.upperware.metamodel.cp.ConstraintProblem; +import node_candidate.VMConfiguration; import org.jamesframework.core.problems.GenericProblem; import org.jamesframework.core.problems.Problem; import org.jamesframework.core.search.algo.ParallelTempering; import org.jamesframework.core.search.stopcriteria.StopCriterion; import java.util.ArrayList; -/* - TODO trzeba dodac dodwanie node candidates do NodeCandidatesPool - */ +import java.util.List; +import java.util.Map; + public class NCSolverCoordinator { private NCWrapper ncWrapper; private Problem CPProblem; @@ -22,22 +27,36 @@ public class NCSolverCoordinator { private ParallelTempering parallelTemperingSolver; private NodeCandidatesPool candidatesPool; - public NCSolverCoordinator(double minTemp, double maxTemp, int numReplicas, ConstraintProblem cp, UtilityProvider utility) { + public NCSolverCoordinator(double minTemp, double maxTemp, int numReplicas, ConstraintProblem cp, UtilityProvider utility, NodeCandidates nodeCandidates) { this.minTemp = minTemp; this.maxTemp = maxTemp; this.numReplicas = numReplicas; - CPWrapper cpWrapper = new CPWrapper(); - cpWrapper.parse(cp, utility); - this.ncWrapper = new NCWrapper(cpWrapper, cp); + this.ncWrapper = new NCWrapper(cp, utility); candidatesPool = new NodeCandidatesPool(ncWrapper, ncWrapper.getComponents()); + ncWrapper.setNodeCandidatesPool(candidatesPool); preparePTSolver(); + postNodeCandidates(nodeCandidates); + } + + private void postNodeCandidates(NodeCandidates nodeCandidates) { + Map>> nodes = nodeCandidates.get(); + for (Map> n : nodes.values()) { + for (Integer prov : n.keySet()) { + n.get(prov).stream().forEach((el) -> { + candidatesPool.postVMLocation(prov, + new GeographicCoordinate(el.getLocation().getGeoLocation().getLatitude(), el.getLocation().getGeoLocation().getLongitude())); + candidatesPool.postVMConfiguration(prov, + new VMConfiguration(el.getHardware().getCores(), el.getHardware().getRam(), el.getHardware().getDisk())); + }); + } + } + candidatesPool.initNodeCandidates(); } /* This method must return something different - PTSolution is only for tests. */ public PTSolution solve(StopCriterion stopCriterion) { - // np new MaxRuntime(timeLimit, TimeUnit.SECONDS) parallelTemperingSolver.addStopCriterion(stopCriterion); parallelTemperingSolver.start(); diff --git a/zpp-solver/node_candidates_solver/src/main/java/cp_components/PTEvaluation.java b/zpp-solver/node-candidates-solver/src/main/java/cp_components/PTEvaluation.java similarity index 74% rename from zpp-solver/node_candidates_solver/src/main/java/cp_components/PTEvaluation.java rename to zpp-solver/node-candidates-solver/src/main/java/cp_components/PTEvaluation.java index be6155c43..f9b4af663 100644 --- a/zpp-solver/node_candidates_solver/src/main/java/cp_components/PTEvaluation.java +++ b/zpp-solver/node-candidates-solver/src/main/java/cp_components/PTEvaluation.java @@ -5,9 +5,6 @@ import org.jamesframework.core.problems.objectives.evaluations.Evaluation; /* Wrapper over double type - required by James library */ - import lombok.AllArgsConstructor; - import org.jamesframework.core.problems.objectives.evaluations.Evaluation; - @AllArgsConstructor public class PTEvaluation implements Evaluation { private double value; diff --git a/zpp-solver/node_candidates_solver/src/main/java/cp_components/PTMover.java b/zpp-solver/node-candidates-solver/src/main/java/cp_components/PTMover.java similarity index 63% rename from zpp-solver/node_candidates_solver/src/main/java/cp_components/PTMover.java rename to zpp-solver/node-candidates-solver/src/main/java/cp_components/PTMover.java index 1ab88cac5..85f636199 100644 --- a/zpp-solver/node_candidates_solver/src/main/java/cp_components/PTMover.java +++ b/zpp-solver/node-candidates-solver/src/main/java/cp_components/PTMover.java @@ -2,21 +2,25 @@ package cp_components; import lombok.AllArgsConstructor; import org.jamesframework.core.search.neigh.Move; +/* + Class which abstracts moves in CP search space. + Here the move means changing full variable assignment from + @beforeMoveAssignment to @asterMoveAssignment + */ -import java.util.List; @AllArgsConstructor public class PTMover implements Move { - private List beforeMoveAssignment; - private List afterMoveAssignment; + private PTSolution beforeMoveAssignment; + private PTSolution afterMoveAssignment; @Override public void apply(PTSolution ptSolution) { - ptSolution.setVarAssignments(afterMoveAssignment); + ptSolution.setVarAssignments(afterMoveAssignment.getVarAssignments()); } @Override public void undo(PTSolution ptSolution) { - ptSolution.setVarAssignments(beforeMoveAssignment); + ptSolution.setVarAssignments(beforeMoveAssignment.getVarAssignments()); } @Override diff --git a/zpp-solver/node_candidates_solver/src/main/java/cp_components/PTNeighbourhood.java b/zpp-solver/node-candidates-solver/src/main/java/cp_components/PTNeighbourhood.java similarity index 78% rename from zpp-solver/node_candidates_solver/src/main/java/cp_components/PTNeighbourhood.java rename to zpp-solver/node-candidates-solver/src/main/java/cp_components/PTNeighbourhood.java index fba8c1f58..9dad372ac 100644 --- a/zpp-solver/node_candidates_solver/src/main/java/cp_components/PTNeighbourhood.java +++ b/zpp-solver/node-candidates-solver/src/main/java/cp_components/PTNeighbourhood.java @@ -1,5 +1,9 @@ package cp_components; - +/* + Neighbourhood of a search space element - V - + is defined to be a set of all elements which may be transformed to + V with one move. + */ import lombok.AllArgsConstructor; import node_candidate.NodeCandidatesPool; import org.jamesframework.core.search.neigh.Move; @@ -18,6 +22,6 @@ public class PTNeighbourhood implements Neighbourhood { @Override public List> getAllMoves(PTSolution ptSolution) { - return nodeCandidatesPool.getAllMoves(ptSolution.getVarAssignments()); + return nodeCandidatesPool.getAllMoves(ptSolution); } } diff --git a/zpp-solver/node_candidates_solver/src/main/java/cp_components/PTObjective.java b/zpp-solver/node-candidates-solver/src/main/java/cp_components/PTObjective.java similarity index 68% rename from zpp-solver/node_candidates_solver/src/main/java/cp_components/PTObjective.java rename to zpp-solver/node-candidates-solver/src/main/java/cp_components/PTObjective.java index 0a3a78be1..90f8e47bf 100644 --- a/zpp-solver/node_candidates_solver/src/main/java/cp_components/PTObjective.java +++ b/zpp-solver/node-candidates-solver/src/main/java/cp_components/PTObjective.java @@ -1,8 +1,8 @@ package cp_components; - import nc_wrapper.NCWrapper; - import org.jamesframework.core.problems.objectives.Objective; - import org.jamesframework.core.problems.objectives.evaluations.Evaluation; +import nc_wrapper.NCWrapper; +import org.jamesframework.core.problems.objectives.Objective; +import org.jamesframework.core.problems.objectives.evaluations.Evaluation; public class PTObjective implements Objective { @Override diff --git a/zpp-solver/node_candidates_solver/src/main/java/cp_components/PTRandomGenerator.java b/zpp-solver/node-candidates-solver/src/main/java/cp_components/PTRandomGenerator.java similarity index 100% rename from zpp-solver/node_candidates_solver/src/main/java/cp_components/PTRandomGenerator.java rename to zpp-solver/node-candidates-solver/src/main/java/cp_components/PTRandomGenerator.java diff --git a/zpp-solver/node-candidates-solver/src/main/java/cp_components/PTSolution.java b/zpp-solver/node-candidates-solver/src/main/java/cp_components/PTSolution.java new file mode 100644 index 000000000..724fe99eb --- /dev/null +++ b/zpp-solver/node-candidates-solver/src/main/java/cp_components/PTSolution.java @@ -0,0 +1,82 @@ +package cp_components; +/* + Search space element for Parallel Tempering - + a full assignment of values to variables + */ +import lombok.AllArgsConstructor; +import lombok.Getter; +import lombok.Setter; +import node_candidate.GeographicCoordinate; +import node_candidate.VMConfiguration; +import org.jamesframework.core.problems.sol.Solution; +import org.javatuples.Quartet; + +import java.util.*; +@AllArgsConstructor +public class PTSolution extends Solution +{ + @Getter @Setter + /* + component -> (provider, Cores, Ram, Disk, latitude, longitude, cardinality) + */ + private Map> varAssignments; + + public int extractProvider(int component) { + return varAssignments.get(component).getValue0(); + } + + public VMConfiguration extractVMConfiguration(int component) { + return (VMConfiguration) varAssignments.get(component).getValue(1); + } + + public GeographicCoordinate extractVMLocation(int component) { + return (GeographicCoordinate) varAssignments.get(component).getValue(2); + } + + public int extractCardinality(int component) { + return (Integer) varAssignments.get(component).getValue(3); + } + + public PTSolution updateComponentConfiguration(int component, int provider, VMConfiguration n, + GeographicCoordinate l, int card) { + PTSolution sol = (PTSolution) this.copy(); + sol.varAssignments.put(component, new Quartet<>(provider, n, l, card)); + return sol; + } + + @Override + public Solution copy() { + Map> varsClone = new HashMap<>(varAssignments); + return new PTSolution(varsClone); + } + + private boolean equals(PTSolution s) { + if (s.varAssignments.size() != varAssignments.size()) { + return false; + } + for (Integer key : varAssignments.keySet()) { + if (!s.varAssignments.containsKey(key) + || !varAssignments.get(key).equals(s.varAssignments.get(key))) { + return false; + } + } + return true; + } + + @Override + public boolean equals(Object o) { + if (o == null) { + return false; + } + if (getClass() != o.getClass()) { + return false; + } + final PTSolution other = (PTSolution) o; + return equals(other); + } + + @Override + public int hashCode() { + return Objects.hashCode(varAssignments); + } +} diff --git a/zpp-solver/node-candidates-solver/src/main/java/nc_wrapper/DomainProvider.java b/zpp-solver/node-candidates-solver/src/main/java/nc_wrapper/DomainProvider.java new file mode 100644 index 000000000..022ddef01 --- /dev/null +++ b/zpp-solver/node-candidates-solver/src/main/java/nc_wrapper/DomainProvider.java @@ -0,0 +1,11 @@ +package nc_wrapper; + +import cp_wrapper.utils.numeric_value_impl.NumericValue; + +public interface DomainProvider { + NumericValue getMaxValue(int variable); + + NumericValue getMinValue(int variable); + + boolean isInDomain(NumericValue value, int index); +} diff --git a/zpp-solver/node-candidates-solver/src/main/java/nc_wrapper/NCWrapper.java b/zpp-solver/node-candidates-solver/src/main/java/nc_wrapper/NCWrapper.java new file mode 100644 index 000000000..cbd7aa2ba --- /dev/null +++ b/zpp-solver/node-candidates-solver/src/main/java/nc_wrapper/NCWrapper.java @@ -0,0 +1,161 @@ +package nc_wrapper; + +import cp_components.PTEvaluation; +import cp_components.PTSolution; +import cp_wrapper.UtilityProvider; +import cp_wrapper.parser.CPParsedData; +import cp_wrapper.parser.CPParser; +import cp_wrapper.utils.DomainHandler; +import cp_wrapper.utils.VariableNumericType; +import cp_wrapper.utils.numeric_value_impl.*; +import eu.melodic.upperware.utilitygenerator.cdo.cp_model.DTO.VariableValueDTO; +import eu.melodic.upperware.utilitygenerator.cdo.cp_model.DTO.VariableValueDTOFactory; +import eu.paasage.upperware.metamodel.cp.ConstraintProblem; +import eu.paasage.upperware.metamodel.cp.CpVariable; +import eu.paasage.upperware.metamodel.cp.VariableType; +import node_candidate.GeographicCoordinate; +import node_candidate.NodeCandidatesPool; +import node_candidate.VMConfiguration; +import org.jamesframework.core.problems.objectives.evaluations.Evaluation; +import org.javatuples.Pair; +import org.javatuples.Quartet; +import variable_orderer.ComponentVariableOrderer; + +import java.util.*; +/* + This class provides necessary services related to constraint problem structure: + - checking feasibility + - generating random solutions + - calculating utility + Unlike pt-solver.ptcp_wrapper.PTCPWrapper, it does not use CPWrapper class but + directly interacts with CPParsedData. The main task of CPWrapper - abstracting values of variables to + ranges of subsequent integers- is of no use here since we are dealing directly with node candidates. + */ +public class NCWrapper implements DomainProvider { + private CPParsedData cpParsedData; + private ComponentVariableOrderer variableOrderer; + private NodeCandidatesPool candidatesPool; + UtilityProvider utilityProvider; + + /* + component, variable type -----> variable name + */ + private Map, String> componentTypeToName; + + public NCWrapper(ConstraintProblem cp, UtilityProvider utilityProvider) { + CPParser cpParser = new CPParser(); + this.cpParsedData = cpParser.parse(cp); + this.variableOrderer = new ComponentVariableOrderer(cp); + this.utilityProvider = utilityProvider; + fillComponentTypeToName(cp); + } + + public void setNodeCandidatesPool(NodeCandidatesPool candidatesPool) { + this.candidatesPool = candidatesPool; + } + + private void fillComponentTypeToName(ConstraintProblem cp) { + componentTypeToName = new HashMap<>(); + List components = variableOrderer.getComponents(); + for (int i = 0; i getComponents() { + return variableOrderer.getComponents(); + } + + private Map convertAssignment(Map> assignment) { + Map res = new HashMap<>(); + for (Integer comp : assignment.keySet()) { + res.put(componentTypeToName.get(new Pair(comp, VariableType.PROVIDER)), + new IntegerValue((Integer) assignment.get(comp).getValue(0))); + res.put(componentTypeToName.get(new Pair(comp, VariableType.CORES)), + new LongValue(((VMConfiguration) assignment.get(comp).getValue(1)).getCores())); + res.put(componentTypeToName.get(new Pair(comp, VariableType.RAM)), + new LongValue(((VMConfiguration) assignment.get(comp).getValue(1)).getRam())); + res.put(componentTypeToName.get(new Pair(comp, VariableType.STORAGE)), + new DoubleValue(((VMConfiguration) assignment.get(comp).getValue(1)).getDisk())); + res.put(componentTypeToName.get(new Pair(comp, VariableType.LATITUDE)), + new DoubleValue(((GeographicCoordinate) assignment.get(comp).getValue(2)).getLatitude())); + res.put(componentTypeToName.get(new Pair(comp, VariableType.LONGITUDE)), + new DoubleValue(((GeographicCoordinate) assignment.get(comp).getValue(2)).getLongitude())); + res.put(componentTypeToName.get(new Pair(comp, VariableType.CARDINALITY)), + new IntegerValue(((Integer) assignment.get(comp).getValue(3)))); + } + return res; + } + + private List assignmentToVariableValueDTOList(Map assignments) { + List result = new ArrayList<>(); + for (Map.Entry a : assignments.entrySet()) { + if (a.getKey() == null) continue; + NumericValue val = a.getValue(); + if (cpParsedData.getVariableType(a.getKey()) == VariableNumericType.INT) { + if (!(val instanceof IntValueInterface)) { + throw new RuntimeException("Variable " + a.getKey() + " is not of integer type!"); + } + result.add(VariableValueDTOFactory.createElement(a.getKey(), ((IntValueInterface) val).getIntValue())); + } else { + if (!(val instanceof DoubleValue)) { + throw new RuntimeException("Variable " + a.getKey() +" is not of double type!"); + } + result.add(VariableValueDTOFactory.createElement(a.getKey(), ((DoubleValue) val).getValue())); + } + } + return result; + } + + private double getUtility(Map assignments) { + List vars = assignmentToVariableValueDTOList(assignments); + return utilityProvider.evaluate(vars); + } + + public Evaluation evaluate(Map> assignments) { + Map a = convertAssignment(assignments); + if (cpParsedData.checkIfFeasible(a)) { + return new PTEvaluation(getUtility(a)); + } else { + return new PTEvaluation(0); + } + } + /* + Returns maximal value of variable @variable + */ + @Override + public NumericValue getMaxValue(int variable) { + if (!variableOrderer.exists(variable)) { + return new IntegerValue(0); + } + return DomainHandler.getMaxValue(cpParsedData.getVariableDomain(variableOrderer.getNameFromIndex(variable))); + } + + @Override + public NumericValue getMinValue(int variable) { + if (!variableOrderer.exists(variable)) { + return new IntegerValue(0); + } + return DomainHandler.getMinValue(cpParsedData.getVariableDomain(variableOrderer.getNameFromIndex(variable))); + } + + @Override + public boolean isInDomain(NumericValue value, int index) { + if (!variableOrderer.exists(index)) { + return true; + } else { + return DomainHandler.isInDomain(value, cpParsedData.getVariableDomain(variableOrderer.getNameFromIndex(index))); + } + } + + /* + Generates random solution to the constraint problem. + Used to sample starting point for parallel tempering. + */ + public PTSolution generateRandom(Random random) { + return candidatesPool.generateRandom(random); + } +} diff --git a/zpp-solver/node_candidates_solver/src/main/java/node_candidate/GeographicCoordinate.java b/zpp-solver/node-candidates-solver/src/main/java/node_candidate/GeographicCoordinate.java similarity index 94% rename from zpp-solver/node_candidates_solver/src/main/java/node_candidate/GeographicCoordinate.java rename to zpp-solver/node-candidates-solver/src/main/java/node_candidate/GeographicCoordinate.java index 037002e70..52fe61ebb 100644 --- a/zpp-solver/node_candidates_solver/src/main/java/node_candidate/GeographicCoordinate.java +++ b/zpp-solver/node-candidates-solver/src/main/java/node_candidate/GeographicCoordinate.java @@ -6,9 +6,9 @@ import lombok.Getter; @AllArgsConstructor public class GeographicCoordinate implements Comparable{ @Getter - private int latitude; + private double latitude; @Getter - private int longitude; + private double longitude; @Override public boolean equals(Object obj) { diff --git a/zpp-solver/node-candidates-solver/src/main/java/node_candidate/NodeCandidatesPool.java b/zpp-solver/node-candidates-solver/src/main/java/node_candidate/NodeCandidatesPool.java new file mode 100644 index 000000000..7f24b54b7 --- /dev/null +++ b/zpp-solver/node-candidates-solver/src/main/java/node_candidate/NodeCandidatesPool.java @@ -0,0 +1,360 @@ +package node_candidate; +/* + This class uses node candidates to provide moves in the search space. + (Move is defined by cp_components.PTMover class). + Variables corresponding to one component are split into 4 independent parts: + - cardinality + - GeographicLocation + - VMConfiguration (triple cores, ram, storage) + - provider + + As a result some combinations may not be actually available in the nodes candidates (because + longitude and latitude are treated as independent from VMConfiguration). + Our motivation for the preceding is the ease of implementation. + There are 4 types of moves: + - cardinality - decrease / increase one component cardinality by one (if permitted by domain) + - VMConfiguration change - change VMConfiguration of one component to one of its neighbours - + a neighbour of a configuration is a direct predecessor or successor of the configuration in + lexicographical order (by triple (cores, ram, storage)). + - GeographicLocation change - analogously as in VMConfiguration + - Provider change - change of provider, if either GeographicLocation or VMConfiguration is not + available for the new provider, change it to its neighbour. + + Posting node candidates: + Configurations and locations are posted separately using postVMConfiguration, postVMLocation methods. + We assume that if provider has at least one VMConfiguration then it also has at least one location and vice-versa. + Once all node candidates have been posted, initNodeCandidates method must be called. + + Masks: + Some of the VMConfigurations may not belong to a given component's domain. For each component we + iterate through available configurations and remember whether given configuration is feasible. + This information is stored in vmConfigurationMasks. Masks are applied to configuration lists (i.e. + infeasible configuration are ignored) whenever search for + neighbours is to be conducted. + Analogous masks are kept for GeographicCoordinates. + */ +import cp_components.PTMover; +import cp_components.PTSolution; +import cp_wrapper.utils.numeric_value_impl.DoubleValue; +import cp_wrapper.utils.numeric_value_impl.IntegerValue; +import cp_wrapper.utils.numeric_value_impl.LongValue; +import eu.paasage.upperware.metamodel.cp.VariableType; +import nc_wrapper.DomainProvider; +import variable_orderer.VariableTypeOrderer; + +import java.util.*; + +public class NodeCandidatesPool { + private DomainProvider domainHandler; + private List components; + /* + Provider -> VM specification + Must be sorted lexicographically + */ + private Map> vmConfigurations; + /* + Provider -> VM location. + Must be sorted lexicographically + */ + private Map> vmLocations; + /* + component -> provider -> True if configuration is in domain + */ + private Map>> vmConfigurationMasks; + /* + component -> provider -> True if location is in domain + */ + private Map>> vmLocationMasks; + + public NodeCandidatesPool(DomainProvider domainHandler, List components) { + this.components = components; + this.domainHandler = domainHandler; + vmConfigurations = new HashMap<>(); + vmLocations = new HashMap<>(); + } + + public void postVMConfiguration(int provider, VMConfiguration configuration) { + if (!vmConfigurations.containsKey(provider)) { + vmConfigurations.put(provider, new ArrayList<>()); + } + vmConfigurations.get(provider).add(configuration); + } + + public void postVMLocation(int provider, GeographicCoordinate location) { + if (!vmLocations.containsKey(provider)) { + vmLocations.put(provider, new ArrayList<>()); + } + vmLocations.get(provider).add(location); + } + + public void initNodeCandidates() { + for ( Integer key : vmConfigurations.keySet()) { + Collections.sort(vmConfigurations.get(key)); + } + for ( Integer key : vmLocations.keySet()) { + Collections.sort(vmLocations.get(key)); + } + fillMasks(); + } + + private Collection getVMConfigurationOrItsNeighbours(int provider, VMConfiguration conf, int component) { + if (!vmConfigurations.containsKey(provider)) { + return new ArrayList<>(); + } + if (Collections.binarySearch(vmConfigurations.get(provider), conf) >= 0) { + return Arrays.asList(conf); + } else { + return getVMConfigurationNeighbours(provider, conf, component); + } + } + + private Collection getVMLocationOrItsNeighbours(int provider, GeographicCoordinate loc, int component) { + if (!vmLocations.containsKey(provider)) { + return new ArrayList<>(); + } + if (Collections.binarySearch(vmLocations.get(provider), loc) >= 0) { + return Arrays.asList(loc); + } else { + return getVMLocationNeighbours(provider, loc, component); + } + } + + private > Collection getNeighbours(List list, T element, List mask) { + if (mask.size() !=list.size()) { + throw new RuntimeException("Mask and list must be of equal length"); + } + int index = Collections.binarySearch(list, element); + Collection result = new ArrayList<>(); + if(index >= 0) { + if (index > 0) { + int i = index - 1; + while(i >= 0 && !mask.get(i)) i--; + if (i >= 0) { + result.add(list.get(i)); + } + } + if (index + 1 < list.size()) { + int i = index + 1; + while (i < list.size() && !mask.get(i)) i++; + if (i < list.size()) { + result.add(list.get(i)); + } + } + } else { + index = (-index) - 1; + if (index > 0) { + int i = index - 1; + while(i >= 0 && !mask.get(i)) i--; + if (i >= 0) { + result.add(list.get(i)); + } + } + if (index < list.size()) { + int i = index; + while (i < list.size() && !mask.get(i)) i++; + if (i < list.size()) { + result.add(list.get(i)); + } + } + } + return result; + } + + private Collection getVMConfigurationNeighbours(int provider, VMConfiguration conf, int component) { + if (!vmConfigurations.containsKey(provider)) { + return new ArrayList<>(); + } + return getNeighbours(vmConfigurations.get(provider), conf, vmConfigurationMasks.get(component).get(provider)); + } + + private Collection getVMLocationNeighbours(int provider, GeographicCoordinate loc, int component) { + if (!vmLocations.containsKey(provider)) { + return new ArrayList<>(); + } + return getNeighbours(vmLocations.get(provider), loc, vmLocationMasks.get(component).get(provider)); + } + + private Collection getAllVMConfigurationChangeMoves(PTSolution assignment, int component) { + Collection result = new ArrayList<>(); + VMConfiguration conf = assignment.extractVMConfiguration(component); + int provider = assignment.extractProvider(component); + Collection neighbours = getVMConfigurationNeighbours(provider, conf, component); + for (VMConfiguration n : neighbours) { + result.add(new PTMover( + assignment, + assignment.updateComponentConfiguration( + component, provider, n, assignment.extractVMLocation(component), + assignment.extractCardinality(component)) + )); + } + return result; + } + + private Collection getAllVMLocationChangeMoves(PTSolution assignment, int component) { + Collection result = new ArrayList<>(); + GeographicCoordinate loc = assignment.extractVMLocation(component); + int provider = assignment.extractProvider(component); + Collection neighbours = getVMLocationNeighbours(provider, loc, component); + for (GeographicCoordinate n : neighbours) { + result.add(new PTMover( + assignment, + assignment.updateComponentConfiguration( + component, provider, assignment.extractVMConfiguration(component), n, + assignment.extractCardinality(component)) + )); + } + return result; + } + + private Collection getAllCardinalityChangeMoves(PTSolution assignment, int component) { + int index = component * VariableTypeOrderer.variablesPerComponent + + VariableTypeOrderer.mapTypeToIndex(VariableType.CARDINALITY); + Collection result = new ArrayList<>(); + if (assignment.extractCardinality(component) < ((IntegerValue) domainHandler.getMaxValue(index)).getValue()) { + result.add(new PTMover(assignment, assignment.updateComponentConfiguration( + component, assignment.extractProvider(component), assignment.extractVMConfiguration(component), + assignment.extractVMLocation(component), assignment.extractCardinality(component) + 1)) + ); + } + if (assignment.extractCardinality(component) > ((IntegerValue) domainHandler.getMinValue(index)).getValue()) { + result.add(new PTMover(assignment, assignment.updateComponentConfiguration( + component, assignment.extractProvider(component), assignment.extractVMConfiguration(component), + assignment.extractVMLocation(component), assignment.extractCardinality(component) - 1)) + ); + } + return result; + } + + private Collection getAllProviderChangeMoves(PTSolution assignment, int component, int provider) { + Collection result = new ArrayList<>(); + Collection confs = + getVMConfigurationOrItsNeighbours(provider, assignment.extractVMConfiguration(component), component); + for (VMConfiguration conf : confs) { + Collection locs = + getVMLocationOrItsNeighbours( provider, assignment.extractVMLocation(component), component); + for (GeographicCoordinate loc : locs) { + result.add(new PTMover( + assignment, + assignment.updateComponentConfiguration( + component, + provider, + conf, + loc, + assignment.extractCardinality(component) + ) + )); + } + } + return result; + } + + private Collection getAllProviderChangeMoves(PTSolution assignment, int component) { + int provider = assignment.extractProvider(component); + int maxProvider = ((IntegerValue) domainHandler.getMaxValue(component * VariableTypeOrderer.variablesPerComponent)).getValue(); + int minProvider = ((IntegerValue) domainHandler.getMinValue(component * VariableTypeOrderer.variablesPerComponent)).getValue(); + Collection result = new ArrayList<>(); + if (provider < maxProvider) { + result.addAll(getAllProviderChangeMoves(assignment, component, provider + 1)); + } + if (provider > minProvider) { + result.addAll(getAllProviderChangeMoves(assignment, component, provider - 1)); + } + return result; + } + + private Collection getAllMovesComponent(PTSolution assignment, int component) { + Collection result = getAllVMConfigurationChangeMoves(assignment, component); + result.addAll(getAllVMLocationChangeMoves(assignment, component)); + result.addAll(getAllCardinalityChangeMoves(assignment, component)); + result.addAll(getAllProviderChangeMoves(assignment, component)); + return result; + } + + public List getAllMoves(PTSolution assignment) { + List moves = new ArrayList<>(); + for (int i = 0; i < components.size(); i++) { + moves.addAll(getAllMovesComponent(assignment, i)); + } + return moves; + } + + private int getRandomProvider(Random random) { + Set provs = vmConfigurations.keySet(); + return provs.stream().skip(random.nextInt(provs.size())).findFirst().orElse(null); + } + + private int getRandomCardinality(Random random, int component) { + int index = component * VariableTypeOrderer.variablesPerComponent + + VariableTypeOrderer.mapTypeToIndex(VariableType.CARDINALITY); + int max = ((IntegerValue) domainHandler.getMaxValue(index)).getValue(); + int min = ((IntegerValue) domainHandler.getMinValue(index)).getValue(); + if (max == min) return min; + return min + random.nextInt(max-min); + } + + public PTSolution generateRandom(Random random) { + PTSolution sol = new PTSolution(new HashMap<>()); + for (int i = 0; i < components.size(); i++) { + int prov = getRandomProvider(random); + sol = sol.updateComponentConfiguration( + i, + prov, + vmConfigurations.get(prov).get(random.nextInt(vmConfigurations.get(prov).size())), + vmLocations.get(prov).get(random.nextInt(vmLocations.get(prov).size())), + getRandomCardinality(random, i) + ); + } + return sol; + } + + private boolean isInDomain(VMConfiguration conf, int component) { + return domainHandler.isInDomain( new LongValue(conf.getCores()), + component * VariableTypeOrderer.variablesPerComponent + VariableTypeOrderer.mapTypeToIndex(VariableType.CORES)) + && domainHandler.isInDomain( new LongValue(conf.getRam()), + component * VariableTypeOrderer.variablesPerComponent + VariableTypeOrderer.mapTypeToIndex(VariableType.RAM)) + && domainHandler.isInDomain( new DoubleValue(conf.getDisk()), + component * VariableTypeOrderer.variablesPerComponent + VariableTypeOrderer.mapTypeToIndex(VariableType.STORAGE)); + } + + private boolean isInDomain(GeographicCoordinate loc, int component) { + return domainHandler.isInDomain( new DoubleValue(loc.getLatitude()), + component * VariableTypeOrderer.variablesPerComponent + VariableTypeOrderer.mapTypeToIndex(VariableType.LATITUDE)) + && domainHandler.isInDomain( new DoubleValue(loc.getLongitude()), + component * VariableTypeOrderer.variablesPerComponent + VariableTypeOrderer.mapTypeToIndex(VariableType.LONGITUDE)); + } + + private Map> getConfigurationMask(int component) { + Map> result = new HashMap<>(); + for (Integer key : vmConfigurations.keySet()) { + result.put(key, new ArrayList<>()); + List confs = vmConfigurations.get(key); + for (int i = 0; i < confs.size(); i++) { + boolean mask = isInDomain(confs.get(i), component); + result.get(key).add(mask); + } + } + return result; + } + + private Map> getLocationMask(int component) { + Map> result = new HashMap<>(); + for (Integer key : vmLocations.keySet()) { + result.put(key, new ArrayList<>()); + List locs = vmLocations.get(key); + for (int i = 0; i < locs.size(); i++) { + boolean mask = isInDomain(locs.get(i), component); + result.get(key).add(mask); + } + } + return result; + } + + private void fillMasks() { + vmConfigurationMasks = new HashMap<>(); + vmLocationMasks = new HashMap<>(); + for (int i = 0; i < components.size(); i++) { + vmConfigurationMasks.put(i, getConfigurationMask(i)); + vmLocationMasks.put(i, getLocationMask(i)); + } + } +} diff --git a/zpp-solver/node_candidates_solver/src/main/java/node_candidate/VMConfiguration.java b/zpp-solver/node-candidates-solver/src/main/java/node_candidate/VMConfiguration.java similarity index 93% rename from zpp-solver/node_candidates_solver/src/main/java/node_candidate/VMConfiguration.java rename to zpp-solver/node-candidates-solver/src/main/java/node_candidate/VMConfiguration.java index 81e9a1645..0677b7b5c 100644 --- a/zpp-solver/node_candidates_solver/src/main/java/node_candidate/VMConfiguration.java +++ b/zpp-solver/node-candidates-solver/src/main/java/node_candidate/VMConfiguration.java @@ -6,11 +6,11 @@ import lombok.Getter; @AllArgsConstructor public class VMConfiguration implements Comparable { @Getter - private int cores; + private long cores; @Getter - private int ram; + private long ram; @Getter - private int disk; + private double disk; @Override public boolean equals(Object obj) { diff --git a/zpp-solver/node_candidates_solver/src/main/java/variable_orderer/ComponentVariableOrderer.java b/zpp-solver/node-candidates-solver/src/main/java/variable_orderer/ComponentVariableOrderer.java similarity index 59% rename from zpp-solver/node_candidates_solver/src/main/java/variable_orderer/ComponentVariableOrderer.java rename to zpp-solver/node-candidates-solver/src/main/java/variable_orderer/ComponentVariableOrderer.java index c85b22239..c8fcd4815 100644 --- a/zpp-solver/node_candidates_solver/src/main/java/variable_orderer/ComponentVariableOrderer.java +++ b/zpp-solver/node-candidates-solver/src/main/java/variable_orderer/ComponentVariableOrderer.java @@ -6,39 +6,45 @@ import eu.paasage.upperware.metamodel.cp.CpVariable; import lombok.Getter; import java.util.ArrayList; +import java.util.HashMap; import java.util.List; import java.util.Map; - - +/* + Components are ordered non-deterministically. + Variables are ordered according to pairs + (componentIndex, VariableTypeOrder). Where VariableTypeOrder is defined in + VariableTypeOrderer class. + A word of caution - even if given variable type (for a certain component) does not exist + in the model, it still affects orders of other variables. For instance + if we have only one component - A - with variables A_provider, A_cores, A_storage, then + A_storage will get index 3, even though A_Ram is not present. + */ public class ComponentVariableOrderer implements VariableOrderer { - private ConstraintProblem constraintProblem; @Getter private List components; private final int variablesPerComponent = 7; private Map indexToVariableName; public ComponentVariableOrderer(ConstraintProblem cp) { - constraintProblem = cp; - fillComponents(); - fillIndexToVariable(); + fillComponents(cp); + fillIndexToVariable(cp); } - + /* + True if variable with a given index exists in the model + */ public boolean exists(int index) { return indexToVariableName.get(index) != null; } - private void fillComponents() { - components = new ArrayList(); - for (CpVariable var : constraintProblem.getCpVariables()) { + private void fillComponents(ConstraintProblem cp) { + components = new ArrayList<>(); + for (CpVariable var : cp.getCpVariables()) { if (!components.contains(var.getComponentId())) { components.add(var.getComponentId()); } } } - public int getMaxIndex() { - return components.size() * VariableTypeOrderer.variablesPerComponent; - } private int getComponentIndex(String name) { for (int i = 0; i < components.size(); i++) { if (components.get(i).equals(name)) { @@ -48,8 +54,9 @@ public class ComponentVariableOrderer implements VariableOrderer { throw new RuntimeException(); } - private void fillIndexToVariable() { - for (CpVariable var : constraintProblem.getCpVariables()) { + private void fillIndexToVariable(ConstraintProblem cp) { + indexToVariableName = new HashMap<>(); + for (CpVariable var : cp.getCpVariables()) { int componentIndex = getComponentIndex(var.getComponentId()); int index = componentIndex + VariableTypeOrderer.mapTypeToIndex(var.getVariableType()); indexToVariableName.put(index, var.getId()); diff --git a/zpp-solver/node_candidates_solver/src/main/java/variable_orderer/VariableTypeOrderer.java b/zpp-solver/node-candidates-solver/src/main/java/variable_orderer/VariableTypeOrderer.java similarity index 100% rename from zpp-solver/node_candidates_solver/src/main/java/variable_orderer/VariableTypeOrderer.java rename to zpp-solver/node-candidates-solver/src/main/java/variable_orderer/VariableTypeOrderer.java diff --git a/zpp-solver/node-candidates-solver/src/test/java/NCSolverCoordinatorTest.java b/zpp-solver/node-candidates-solver/src/test/java/NCSolverCoordinatorTest.java new file mode 100644 index 000000000..74d5f9f3a --- /dev/null +++ b/zpp-solver/node-candidates-solver/src/test/java/NCSolverCoordinatorTest.java @@ -0,0 +1,284 @@ +import cp_components.PTSolution; +import cp_wrapper.UtilityProvider; +import cp_wrapper.mockups.*; +import eu.melodic.cache.NodeCandidates; +import eu.melodic.upperware.utilitygenerator.cdo.cp_model.DTO.VariableValueDTO; +import eu.paasage.upperware.metamodel.cp.*; +import eu.paasage.upperware.metamodel.cp.impl.CpVariableImpl; +import eu.paasage.upperware.metamodel.types.BasicTypeEnum; +import io.github.cloudiator.rest.model.GeoLocation; +import io.github.cloudiator.rest.model.Hardware; +import io.github.cloudiator.rest.model.Location; +import io.github.cloudiator.rest.model.NodeCandidate; +import node_candidate.VMConfiguration; +import org.eclipse.emf.common.util.BasicEList; +import org.eclipse.emf.common.util.EList; +import org.jamesframework.core.search.stopcriteria.MaxRuntime; +import org.junit.jupiter.api.Test; + +import java.util.*; +import java.util.concurrent.TimeUnit; + +import static org.junit.jupiter.api.Assertions.*; + +class NCSolverCoordinatorTest { + private static Map prepareSimpleOneComponentConstraintProblem() { + /* + @var1 in {1,2,3,4,5} + @var3 in {0.5, 1.5, 2.5} + @var2 in {0,...,9} + @const1 = 3 + + @constraint1 : @var1 < @var3 + + @constraint2 : @var1 * @var2 * @var3 >= @const1; + @constraint3: @var1 * @var2 >= @var3 + + @constraint4: @var3 == @var3 + */ + List variables = Arrays.asList("var1", "var2", "var3"); + EList vars = new BasicEList<>(); + //Domains: + RangeDomainImpMockup dom1 = new RangeDomainImpMockup(); + RangeDomainImpMockup dom3 = new RangeDomainImpMockup(); + dom3.setType(BasicTypeEnum.INTEGER); dom1.setType(BasicTypeEnum.INTEGER); + dom1.setFrom(1);dom3.setFrom(0);dom1.setTo(5);dom3.setTo(9); + NumericListDomainImplMockup dom2 = new NumericListDomainImplMockup(); + dom2.setValues(Arrays.asList(0.5, 1.5, 2.5)); + dom2.setType(BasicTypeEnum.DOUBLE); + + vars.add(new CpVariableImplMockup(variables.get(0), VariableType.CORES , dom1, "Component1")); + vars.add(new CpVariableImplMockup(variables.get(1), VariableType.RAM , dom3, "Component1")); + vars.add(new CpVariableImplMockup(variables.get(2), VariableType.STORAGE , dom2, "Component1")); + + Constant c = new ConstantImplMockup(BasicTypeEnum.DOUBLE, new NumericValueUpperwareImplMockup(3)); + + EList exprs = new BasicEList<>(); + exprs.add(vars.get(0)); exprs.add(vars.get(1)); + NumericExpression times = new ComposedExpressionImplMockup(exprs, OperatorEnum.TIMES); + ComparisonExpressionMockup constraint1 = new ComparisonExpressionMockup(); + constraint1.setExp1(vars.get(0));constraint1.setExp2(vars.get(2)); + constraint1.setComparator(ComparatorEnum.LESS_THAN); + + ComparisonExpressionMockup constraint3 = new ComparisonExpressionMockup(); + constraint3.setExp1(times);constraint3.setExp2(vars.get(2)); + constraint3.setComparator(ComparatorEnum.GREATER_OR_EQUAL_TO); + + exprs.add(vars.get(2)); + ComparisonExpressionMockup constraint2 = new ComparisonExpressionMockup(); + times = new ComposedExpressionImplMockup(exprs, OperatorEnum.TIMES); + constraint2.setExp1(times);constraint2.setExp2(c); + constraint2.setComparator(ComparatorEnum.GREATER_OR_EQUAL_TO); + + ComparisonExpressionMockup constraint4 = new ComparisonExpressionMockup(); + constraint4.setExp1(vars.get(2));constraint4.setExp2(vars.get(2)); + constraint4.setComparator(ComparatorEnum.EQUAL_TO); + + EList consts = new BasicEList<>(); + consts.add(c); + + EList varsE = new BasicEList<>(); + for (int i = 0; i < 3; i++) varsE.add(vars.get(i)); + + EList constraints = new BasicEList<>(); + constraints.addAll(Arrays.asList(constraint1, constraint2, constraint3, constraint4)); + + ConstraintProblem cp = new ConstraintProblemMockup(consts,null, varsE, constraints ); + return Collections.singletonMap(cp, result -> { + double sum = 0; + for (VariableValueDTO v : result) { + if (v.getValue() instanceof Double) { + sum += v.getValue().doubleValue(); + } else { + sum += v.getValue().intValue(); + } + } + return sum; + }); + } + + private static NodeCandidates getNodesForSimpleProblem() { + Map>> candidates = new HashMap<>(); + Location loc = new Location(); GeoLocation gl = new GeoLocation(); gl.setLatitude(100.0);gl.setLongitude(100.0); + loc.setGeoLocation(gl); + List ar1 = Arrays.asList(1,2,3,4,5, 5,5,5,5,2); + List ar3 = Arrays.asList(0.5, 1.5, 2.5, 2.5, 2.5, 2.5, 2.5, 2.5, 2.5, 2.5); + List ar2 = Arrays.asList(0,1,2,3,4,5,6,7,8,9); + List names = Arrays.asList("q", "w", "e", "r", "t", "y", "u", "i", "o", "p"); + for (int i = 0; i < ar3.size(); i++) { + Hardware hd = new Hardware(); + hd.setCores(ar1.get(i)); + hd.setRam((long) ar2.get(i)); + hd.setDisk(ar3.get(i)); + NodeCandidate nc = new NodeCandidate(); + nc.setLocation(loc); + nc.setHardware(hd); + Map> t = new HashMap<>(); + t.put(0, new ArrayList<>()); + t.get(0).add(nc); + candidates.put(names.get(i), t); + } + return NodeCandidates.of(candidates); + } + + @Test + public void simpleOneComponentTest() { + Map data = prepareSimpleOneComponentConstraintProblem(); + NodeCandidates nc = getNodesForSimpleProblem(); + NCSolverCoordinator ncSolverCoordinator = new NCSolverCoordinator(1, 10, 10, data.keySet().iterator().next(), + data.values().iterator().next(), nc); + PTSolution solution = ncSolverCoordinator.solve(new MaxRuntime(10, TimeUnit.SECONDS)); + assertTrue(solution.extractVMConfiguration(0).equals(new VMConfiguration(2,9,2.5))); + } + + private static Map prepareSimpleTwoComponentConstraintProblem() { + /* + @var0 in {0, 1} - provider + @var1 in {1,2,3,4,5} + @var3 in {0.5, 1.5, 2.5} + @var2 in {0,...,9} + + @var4 in {0, 1} + @var5 in {1,2,3,4,5} + @var7 in {0.5, 1.5, 2.5} + @var6 in {0,...,9} + + @const1 = 3 + + @constraint1 : @var1 < @var3 + + @constraint2 : @var1 * @var2 * @var3 >= @const1; + @constraint3: @var1 * @var2 >= @var3 + + @constraint4: @var3 == @var3 + + @constraint 5: + @var4 == 1 + */ + List variables = Arrays.asList("var0", "var1", "var2", "var3", "var4", "var5", "var6", "var7"); + EList vars = new BasicEList<>(); + //Domains: + RangeDomainImpMockup dom1 = new RangeDomainImpMockup(); + RangeDomainImpMockup dom3 = new RangeDomainImpMockup(); + dom3.setType(BasicTypeEnum.INTEGER); dom1.setType(BasicTypeEnum.INTEGER); + dom1.setFrom(1);dom3.setFrom(0);dom1.setTo(5);dom3.setTo(9); + NumericListDomainImplMockup dom2 = new NumericListDomainImplMockup(); + dom2.setValues(Arrays.asList(0.5, 1.5, 2.5)); + dom2.setType(BasicTypeEnum.DOUBLE); + RangeDomainImpMockup dom0 = new RangeDomainImpMockup(); dom0.setFrom(0);dom0.setTo(1); + dom0.setType(BasicTypeEnum.INTEGER); + + vars.add(new CpVariableImplMockup(variables.get(0), VariableType.PROVIDER, dom0, "Component1")); + vars.add(new CpVariableImplMockup(variables.get(1), VariableType.CORES , dom1, "Component1")); + vars.add(new CpVariableImplMockup(variables.get(2), VariableType.RAM , dom3, "Component1")); + vars.add(new CpVariableImplMockup(variables.get(3), VariableType.STORAGE , dom2, "Component1")); + vars.add(new CpVariableImplMockup(variables.get(4), VariableType.PROVIDER, dom0, "Component2")); + vars.add(new CpVariableImplMockup(variables.get(5), VariableType.CORES , dom1, "Component2")); + vars.add(new CpVariableImplMockup(variables.get(6), VariableType.RAM , dom3, "Component2")); + vars.add(new CpVariableImplMockup(variables.get(7), VariableType.STORAGE , dom2, "Component2")); + Constant c = new ConstantImplMockup(BasicTypeEnum.DOUBLE, new NumericValueUpperwareImplMockup(3)); + Constant c2 = new ConstantImplMockup(BasicTypeEnum.INTEGER, new NumericValueUpperwareImplMockup(0)); + + EList exprs = new BasicEList<>(); + exprs.add(vars.get(1)); exprs.add(vars.get(2)); + NumericExpression times = new ComposedExpressionImplMockup(exprs, OperatorEnum.TIMES); + ComparisonExpressionMockup constraint1 = new ComparisonExpressionMockup(); + constraint1.setExp1(vars.get(1));constraint1.setExp2(vars.get(3)); + constraint1.setComparator(ComparatorEnum.LESS_THAN); + + ComparisonExpressionMockup constraint3 = new ComparisonExpressionMockup(); + constraint3.setExp1(times);constraint3.setExp2(vars.get(3)); + constraint3.setComparator(ComparatorEnum.GREATER_OR_EQUAL_TO); + + exprs.add(vars.get(2)); + ComparisonExpressionMockup constraint2 = new ComparisonExpressionMockup(); + times = new ComposedExpressionImplMockup(exprs, OperatorEnum.TIMES); + constraint2.setExp1(times);constraint2.setExp2(c); + constraint2.setComparator(ComparatorEnum.GREATER_OR_EQUAL_TO); + + ComparisonExpressionMockup constraint4 = new ComparisonExpressionMockup(); + constraint4.setExp1(vars.get(3));constraint4.setExp2(vars.get(3)); + constraint4.setComparator(ComparatorEnum.EQUAL_TO); + + ComparisonExpressionMockup constraint5 = new ComparisonExpressionMockup(); + constraint5.setExp1(vars.get(4));constraint5.setExp2(c2); + constraint5.setComparator(ComparatorEnum.EQUAL_TO); + + EList consts = new BasicEList<>(); + consts.add(c); consts.add(c2); + + EList varsE = new BasicEList<>(); + for (int i = 0; i < 8; i++) varsE.add(vars.get(i)); + + EList constraints = new BasicEList<>(); + constraints.addAll(Arrays.asList(constraint1, constraint2, constraint3, constraint4)); + + ConstraintProblem cp = new ConstraintProblemMockup(consts,null, varsE, constraints ); + return Collections.singletonMap(cp, result -> { + double sum = 0; + int i = 0; + for (VariableValueDTO v : result) { + i++; + if (v.getValue() instanceof Double) { + sum += v.getValue().doubleValue(); + } else { + sum += v.getValue().intValue(); + } + } + return sum; + }); + } + + private static NodeCandidates getNodesForTwoComponentSimpleProblem() { + Map>> candidates = new HashMap<>(); + Location loc = new Location(); GeoLocation gl = new GeoLocation(); gl.setLatitude(100.0);gl.setLongitude(100.0); + loc.setGeoLocation(gl); + List ar1 = Arrays.asList(1,2,3,4,5, 5,5,5,5,2); + List ar3 = Arrays.asList(0.5, 1.5, 2.5, 2.5, 2.5, 2.5, 2.5, 2.5, 2.5, 2.5); + List ar2 = Arrays.asList(0,1,2,3,4,5,6,7,8,9); + List names = Arrays.asList("q", "w", "e", "r", "t", "y", "u", "i", "o", "p"); + for (int i = 0; i < ar3.size(); i++) { + Hardware hd = new Hardware(); + hd.setCores(ar1.get(i)); + hd.setRam((long) ar2.get(i)); + hd.setDisk(ar3.get(i)); + NodeCandidate nc = new NodeCandidate(); + nc.setLocation(loc); + nc.setHardware(hd); + Map> t = new HashMap<>(); + t.put(0, new ArrayList<>()); + t.get(0).add(nc); + candidates.put(names.get(i), t); + } + + List names2 = Arrays.asList("q2", "w2", "e2", "r2", "t2", "y2", "u2", "i2", "o2", "p2"); + for (int i = 0; i < 4; i++) { + Hardware hd = new Hardware(); + hd.setCores(ar1.get(i)); + hd.setRam((long) ar2.get(i)); + hd.setDisk(ar3.get(i)); + NodeCandidate nc = new NodeCandidate(); + nc.setLocation(loc); + nc.setHardware(hd); + Map> t = new HashMap<>(); + t.put(1, new ArrayList<>()); + t.get(1).add(nc); + candidates.put(names2.get(i), t); + } + + return NodeCandidates.of(candidates); + } + + @Test + public void simpleTwoComponentTest() { + Map data = prepareSimpleTwoComponentConstraintProblem(); + NodeCandidates nc = getNodesForTwoComponentSimpleProblem(); + NCSolverCoordinator ncSolverCoordinator = new NCSolverCoordinator(1, 10, 10, data.keySet().iterator().next(), + data.values().iterator().next(), nc); + PTSolution solution = ncSolverCoordinator.solve(new MaxRuntime(10, TimeUnit.SECONDS)); + + assertTrue(solution.extractVMConfiguration(0).equals(new VMConfiguration(2,9,2.5))); + assertTrue(solution.extractVMConfiguration(1).equals(new VMConfiguration(5,8,2.5))); + } + +} diff --git a/zpp-solver/node-candidates-solver/src/test/java/cp_components/PTSolutionTest.java b/zpp-solver/node-candidates-solver/src/test/java/cp_components/PTSolutionTest.java new file mode 100644 index 000000000..89b9ac904 --- /dev/null +++ b/zpp-solver/node-candidates-solver/src/test/java/cp_components/PTSolutionTest.java @@ -0,0 +1,24 @@ +package cp_components; +import node_candidate.GeographicCoordinate; +import node_candidate.VMConfiguration; +import org.javatuples.Quartet; +import org.junit.jupiter.api.Test; + +import java.util.HashMap; +import java.util.Map; + +import static org.junit.jupiter.api.Assertions.*; + +class PTSolutionTest { + + @Test + public void equalsTest() { + Map> map1 = new HashMap(); + map1.put(1, new Quartet<>(0, new VMConfiguration(0,1,1), new GeographicCoordinate(100, 150), 1)); + Map> map2 = new HashMap(); + map2.put(1, new Quartet<>(0, new VMConfiguration(0,1,1), new GeographicCoordinate(100, 150), 1)); + PTSolution sol1 = new PTSolution(map1); + PTSolution sol2 = new PTSolution(map2); + assertTrue(sol1.equals(sol2)); + } +} \ No newline at end of file diff --git a/zpp-solver/node_candidates_solver/src/test/java/node_candidate/GeographicCoordinateTest.java b/zpp-solver/node-candidates-solver/src/test/java/node_candidate/GeographicCoordinateTest.java similarity index 100% rename from zpp-solver/node_candidates_solver/src/test/java/node_candidate/GeographicCoordinateTest.java rename to zpp-solver/node-candidates-solver/src/test/java/node_candidate/GeographicCoordinateTest.java diff --git a/zpp-solver/node-candidates-solver/src/test/java/node_candidate/NodeCandidatesPoolTest.java b/zpp-solver/node-candidates-solver/src/test/java/node_candidate/NodeCandidatesPoolTest.java new file mode 100644 index 000000000..3ab5409f0 --- /dev/null +++ b/zpp-solver/node-candidates-solver/src/test/java/node_candidate/NodeCandidatesPoolTest.java @@ -0,0 +1,129 @@ +package node_candidate; + +import cp_components.PTMover; +import cp_components.PTSolution; +import cp_wrapper.utils.numeric_value_impl.IntegerValue; +import cp_wrapper.utils.numeric_value_impl.NumericValue; +import nc_wrapper.DomainProvider; +import org.javatuples.Quartet; +import org.junit.jupiter.api.Test; + +import java.util.Arrays; +import java.util.HashMap; +import java.util.List; +import java.util.Map; + +import static org.junit.jupiter.api.Assertions.*; + +class NodeCandidatesPoolTest { + + public NodeCandidatesPool createPool() { + return new NodeCandidatesPool(new DomainProvider() { + + @Override + public NumericValue getMaxValue(int variable) { + return new IntegerValue(2); + } + + @Override + public NumericValue getMinValue(int variable) { + return new IntegerValue(0); + } + + @Override + public boolean isInDomain(NumericValue value, int index) { + return true; + } + }, + Arrays.asList("comp1", "comp2", "comp3")); + } + + private PTSolution arrayToAssignment(List arr) { + Map> a = new HashMap<>(); + for (int i = 0; i < 3; i++) { + int cardinality = arr.get(7*i + 6); + int provider = arr.get(7*i); + VMConfiguration conf = new VMConfiguration(arr.get(i*7 + 1), arr.get(i*7 +2), arr.get(i*7 +3)); + GeographicCoordinate loc = new GeographicCoordinate(arr.get(i*7+4), arr.get(i*7 + 5)); + a.put(i, new Quartet<>(provider ,conf, loc, cardinality)); + } + return new PTSolution(a); + } + + @Test + public void firstGetAllMovesTest() { + NodeCandidatesPool pool = createPool(); + pool.postVMConfiguration(0, new VMConfiguration(0, 0, 0)); + pool.postVMConfiguration(0, new VMConfiguration(1, 0, 0)); + pool.postVMConfiguration(0, new VMConfiguration(2, 0, 0)); + pool.postVMConfiguration(0, new VMConfiguration(0, 2, 0)); + pool.postVMLocation(0, new GeographicCoordinate(100, 100)); + + pool.initNodeCandidates(); + List moves = pool.getAllMoves(arrayToAssignment(Arrays.asList(0, 0, 0, 0, 100, 100, 1, 0, 0, 0, 0, 100, 100, 1, 0, 0, 0, 0, 100, 100, 1))); + assertEquals(moves.size(), 3*3); + + PTMover m = new PTMover( + arrayToAssignment(Arrays.asList(0, 0, 0, 0, 100, 100, 1, 0, 0, 0, 0, 100, 100, 1, 0, 0, 0, 0, 100, 100, 1)), + arrayToAssignment(Arrays.asList(0, 0, 0, 0, 100, 100, 2, 0, 0, 0, 0, 100, 100, 1, 0, 0, 0, 0, 100, 100, 1)) + ); + + assertEquals(moves.contains(m), true); + + m = new PTMover( + arrayToAssignment(Arrays.asList(0, 0, 0, 0, 100, 100, 1, 0, 0, 0, 0, 100, 100, 1, 0, 0, 0, 0, 100, 100, 1)), + arrayToAssignment(Arrays.asList(0, 0, 0, 0, 100, 100, 1, 0, 0, 0, 0, 100, 100, 1, 0, 0 , 2, 0, 100, 100, 1)) + ); + + assertEquals(moves.contains(m), true); + + m = new PTMover( + arrayToAssignment(Arrays.asList(0, 0, 0, 0, 100, 100, 1, 0, 0, 0, 0, 100, 100, 1, 0, 0, 0, 0, 100, 100, 1)), + arrayToAssignment(Arrays.asList(0, 0, 0, 0, 100, 100, 0, 0, 0, 0, 0, 100, 100, 1, 0, 0, 0, 0, 100, 100, 1)) + ); + + assertEquals(moves.contains(m), true); + + } + + @Test + public void secondGetAllMovesTest() { + NodeCandidatesPool pool = createPool(); + pool.postVMConfiguration(0, new VMConfiguration(0, 0, 0)); + pool.postVMConfiguration(0, new VMConfiguration(1, 0, 0)); + pool.postVMConfiguration(0, new VMConfiguration(2, 0, 0)); + pool.postVMLocation(0, new GeographicCoordinate(100, 100)); + pool.postVMLocation(0, new GeographicCoordinate(100, 150)); + + pool.postVMConfiguration(1, new VMConfiguration(0, 0, 1)); + pool.postVMConfiguration(1, new VMConfiguration(1, 0, 1)); + pool.postVMConfiguration(1, new VMConfiguration(2, 0, 1)); + pool.postVMLocation(1, new GeographicCoordinate(100, 100)); + pool.postVMLocation(1, new GeographicCoordinate(100, 150)); + + pool.initNodeCandidates(); + List moves = pool.getAllMoves(arrayToAssignment(Arrays.asList(0, 1, 0, 0, 100, 100, 1, 0, 1, 0, 0, 100, 100, 1, 0, 1, 0, 0, 100, 100, 1))); + assertEquals(moves.size(), 3*7); + + PTMover m = new PTMover( + arrayToAssignment(Arrays.asList(0, 1, 0, 0, 100, 100, 1, 0, 1, 0, 0, 100, 100, 1, 0, 1, 0, 0, 100, 100, 1)), + arrayToAssignment(Arrays.asList(0, 1, 0, 0, 100, 100, 1, 1, 0, 0, 1, 100, 100, 1, 0, 1, 0, 0, 100, 100, 1)) + ); + + assertEquals(moves.contains(m), true); + + m = new PTMover( + arrayToAssignment(Arrays.asList(0, 1, 0, 0, 100, 100, 1, 0, 1, 0, 0, 100, 100, 1, 0, 1, 0, 0, 100, 100, 1)), + arrayToAssignment(Arrays.asList(0, 1, 0, 0, 100, 100, 1, 1, 1, 0, 1, 100, 100, 1, 0, 1, 0, 0, 100, 100, 1)) + ); + + assertEquals(moves.contains(m), true); + + m = new PTMover( + arrayToAssignment(Arrays.asList(0, 1, 0, 0, 100, 100, 1, 0, 1, 0, 0, 100, 100, 1, 0, 1, 0, 0, 100, 100, 1)), + arrayToAssignment(Arrays.asList(0, 1, 0, 0, 100, 100, 1, 0, 1, 0, 0, 100, 100, 1, 0, 1, 0, 0, 100, 150, 1)) + ); + + assertEquals(moves.contains(m), true); + } +} \ No newline at end of file diff --git a/zpp-solver/node_candidates_solver/src/test/java/node_candidate/VMConfigurationTest.java b/zpp-solver/node-candidates-solver/src/test/java/node_candidate/VMConfigurationTest.java similarity index 100% rename from zpp-solver/node_candidates_solver/src/test/java/node_candidate/VMConfigurationTest.java rename to zpp-solver/node-candidates-solver/src/test/java/node_candidate/VMConfigurationTest.java diff --git a/zpp-solver/node_candidates_solver/src/main/java/cp_components/PTSolution.java b/zpp-solver/node_candidates_solver/src/main/java/cp_components/PTSolution.java deleted file mode 100644 index 0ef66e572..000000000 --- a/zpp-solver/node_candidates_solver/src/main/java/cp_components/PTSolution.java +++ /dev/null @@ -1,54 +0,0 @@ -package cp_components; - -import lombok.Getter; -import lombok.Setter; -import org.jamesframework.core.problems.sol.Solution; - -import java.util.ArrayList; -import java.util.List; -import java.util.Objects; - -public class PTSolution extends Solution -{ - @Getter @Setter - private List varAssignments; - - public PTSolution(List varAssignments) { - this.varAssignments = varAssignments; - } - - @Override - public Solution copy() { - List varsClone = new ArrayList<>(varAssignments); - return new PTSolution(varsClone); - } - - private boolean equals(PTSolution s) { - if (s.varAssignments.size() != varAssignments.size()) { - return false; - } - for (int i = 0; i < varAssignments.size(); i++) { - if (s.varAssignments.get(i) != varAssignments.get(i)) { - return false; - } - } - return true; - } - - @Override - public boolean equals(Object o) { - if (o == null) { - return false; - } - if (getClass() != o.getClass()) { - return false; - } - final PTSolution other = (PTSolution) o; - return equals(other); - } - - @Override - public int hashCode() { - return Objects.hashCode(varAssignments); - } -} diff --git a/zpp-solver/node_candidates_solver/src/main/java/nc_wrapper/MarginalDomainValuesProvider.java b/zpp-solver/node_candidates_solver/src/main/java/nc_wrapper/MarginalDomainValuesProvider.java deleted file mode 100644 index 76fb219e7..000000000 --- a/zpp-solver/node_candidates_solver/src/main/java/nc_wrapper/MarginalDomainValuesProvider.java +++ /dev/null @@ -1,7 +0,0 @@ -package nc_wrapper; - -public interface MarginalDomainValuesProvider { - int getMaxValue(int variable); - - int getMinValue(int variable); -} diff --git a/zpp-solver/node_candidates_solver/src/main/java/nc_wrapper/NCWrapper.java b/zpp-solver/node_candidates_solver/src/main/java/nc_wrapper/NCWrapper.java deleted file mode 100644 index 7fff05b52..000000000 --- a/zpp-solver/node_candidates_solver/src/main/java/nc_wrapper/NCWrapper.java +++ /dev/null @@ -1,76 +0,0 @@ -package nc_wrapper; - -import cp_components.PTEvaluation; -import cp_components.PTSolution; -import cp_wrapper.CPWrapper; -import eu.paasage.upperware.metamodel.cp.ConstraintProblem; -import org.jamesframework.core.problems.objectives.evaluations.Evaluation; -import variable_orderer.ComponentVariableOrderer; - -import java.util.ArrayList; -import java.util.List; -import java.util.Random; - -public class NCWrapper implements MarginalDomainValuesProvider{ - private CPWrapper cpWrapper; - private ComponentVariableOrderer variableOrderer; - - public NCWrapper(CPWrapper cpWrapper, ConstraintProblem cp) { - this.cpWrapper = cpWrapper; - this.variableOrderer = new ComponentVariableOrderer(cp); - cpWrapper.setVariableOrdering(variableOrderer); - } - - public List getComponents() { - return variableOrderer.getComponents(); - } - - public Evaluation evaluate(List assignments) { - if (cpWrapper.checkIfFeasible(assignments)) { - return new PTEvaluation(cpWrapper.getUtility(assignments)); - } else { - return new PTEvaluation(0); - } - } - /* - Returns maximal value of variable @variable - */ - public int getMaxValue(int variable) { - if (!variableOrderer.exists(variable)) { - return 0; - } - return cpWrapper.getMaxDomainValue(variable); - } - - public int getMinValue(int variable) { - if (!variableOrderer.exists(variable)) { - return 0; - } - return cpWrapper.getMinDomainValue(variable); - } - - /* - Generates random (uniform) value for variable @variable - */ - private int generateRandomValue(int variable, Random random) { - if (!variableOrderer.exists(variable)) { - return 0; - } - int domainSize = getMaxValue(variable) - getMinValue(variable) + 1; - int value = random.nextInt(domainSize); - value += getMinValue(variable); - return value; - } - - /* - Generates random solution to the constraint problem. - Used to sample starting point for parallel tempering. - */ - public PTSolution generateRandom(Random random) { - List assignment = new ArrayList<>(); - for (int i = 0; i < variableOrderer.getMaxIndex(); i++) { - assignment.add(generateRandomValue(i, random)); - } - return new PTSolution(assignment); - } -} diff --git a/zpp-solver/node_candidates_solver/src/main/java/node_candidate/NodeCandidatesPool.java b/zpp-solver/node_candidates_solver/src/main/java/node_candidate/NodeCandidatesPool.java deleted file mode 100644 index 3dc68cbed..000000000 --- a/zpp-solver/node_candidates_solver/src/main/java/node_candidate/NodeCandidatesPool.java +++ /dev/null @@ -1,277 +0,0 @@ -package node_candidate; - -import cp_components.PTMover; -import eu.paasage.upperware.metamodel.cp.VariableType; -import nc_wrapper.MarginalDomainValuesProvider; -import variable_orderer.VariableTypeOrderer; - -import java.util.*; - -public class NodeCandidatesPool { - private MarginalDomainValuesProvider domainHandler; - - private List components; - /* - Provider -> VM specification - NodeCandidates must be sorted lexicographically in ascending order - */ - private Map> vmConfigurations; - /* - Provider -> VM location. - Coordinates must be sorted lexicographically in ascending order - */ - private Map> vmLocations; - - public NodeCandidatesPool(MarginalDomainValuesProvider domainHandler, List components) { - this.components = components; - this.domainHandler = domainHandler; - vmConfigurations = new HashMap<>(); - vmLocations = new HashMap<>(); - } - - public void postVMConfiguration(int provider, VMConfiguration configuration) { - if (!vmConfigurations.containsKey(provider)) { - vmConfigurations.put(provider, new ArrayList()); - } - vmConfigurations.get(provider).add(configuration); - } - - public void postVMLocation(int provider, GeographicCoordinate location) { - if (!vmLocations.containsKey(provider)) { - vmLocations.put(provider, new ArrayList()); - } - vmLocations.get(provider).add(location); - } - - public void initNodeCandidates() { - for ( Integer key : vmConfigurations.keySet()) { - Collections.sort(vmConfigurations.get(key)); - } - for ( Integer key : vmLocations.keySet()) { - Collections.sort(vmLocations.get(key)); - } - } - private Collection getVMConfigurationOrItsNeighbours(int provider, VMConfiguration conf) { - if (!vmConfigurations.containsKey(provider)) { - return new ArrayList<>(); - } - if (Collections.binarySearch(vmConfigurations.get(provider), conf) >= 0) { - return Arrays.asList(conf); - } else { - return getVMConfigurationNeighbours(provider, conf); - } - } - - private Collection getVMLocationOrItsNeighbours(int provider, GeographicCoordinate loc) { - if (!vmLocations.containsKey(provider)) { - return new ArrayList<>(); - } - if (Collections.binarySearch(vmLocations.get(provider), loc) >= 0) { - return Arrays.asList(loc); - } else { - return getVMLocationNeighbours(provider, loc); - } - } - - private Collection getVMConfigurationNeighbours(int provider, VMConfiguration conf) { - if (!vmConfigurations.containsKey(provider)) { - return new ArrayList<>(); - } - int index = Collections.binarySearch(vmConfigurations.get(provider), conf); - Collection result = new ArrayList<>(); - if(index >= 0) { - if (index > 0) { - result.add(vmConfigurations.get(provider).get(index-1)); - } - if (index + 1 < vmConfigurations.get(provider).size()) { - result.add(vmConfigurations.get(provider).get(index+1)); - } - } else { - index = (-index) - 1; - if (index > 0) { - result.add(vmConfigurations.get(provider).get(index-1)); - } - if (index < vmConfigurations.get(provider).size()) { - result.add(vmConfigurations.get(provider).get(index)); - } - } - return result; - } - - private Collection getVMLocationNeighbours(int provider, GeographicCoordinate loc) { - if (!vmLocations.containsKey(provider)) { - return new ArrayList<>(); - } - Collection result = new ArrayList<>(); - int index = Collections.binarySearch(vmLocations.get(provider), loc); - if(index >= 0) { - if (index > 0) { - result.add(vmLocations.get(provider).get(index-1)); - } - if (index + 1 < vmLocations.get(provider).size()) { - result.add(vmLocations.get(provider).get(index+1)); - } - } else { - index = (-index) - 1; - if (index > 0) { - result.add(vmLocations.get(provider).get(index-1)); - } - if (index < vmLocations.get(provider).size()) { - result.add(vmLocations.get(provider).get(index)); - } - } - return result; - } - - - private VMConfiguration extractVMConfiguration(int component, List assignment) { - int index = component * VariableTypeOrderer.variablesPerComponent; - return new VMConfiguration( - assignment.get(index + VariableTypeOrderer.mapTypeToIndex(VariableType.CORES)), - assignment.get(index + VariableTypeOrderer.mapTypeToIndex(VariableType.RAM)), - assignment.get(index + VariableTypeOrderer.mapTypeToIndex(VariableType.STORAGE)) - ); - } - - private GeographicCoordinate extractVMLocation(int component, List assignment) { - int index = component * VariableTypeOrderer.variablesPerComponent; - return new GeographicCoordinate( - assignment.get(index + VariableTypeOrderer.mapTypeToIndex(VariableType.LATITUDE)), - assignment.get(index + VariableTypeOrderer.mapTypeToIndex(VariableType.LONGITUDE)) - ); - } - - private int extractProvider(int component, List assignment) { - return assignment.get(VariableTypeOrderer.variablesPerComponent * component); - } - - private List updateComponentConfiguration(List assignment, int component, - int provider, VMConfiguration vmConfiguration, - GeographicCoordinate vmLocation) { - int index = component * VariableTypeOrderer.variablesPerComponent; - List newAssignment = new ArrayList<>(assignment); - - newAssignment.set(index, provider); - - newAssignment.set(index + VariableTypeOrderer.mapTypeToIndex(VariableType.LATITUDE), - vmLocation.getLatitude()); - newAssignment.set(index + VariableTypeOrderer.mapTypeToIndex(VariableType.LONGITUDE), - vmLocation.getLongitude()); - - newAssignment.set(index + VariableTypeOrderer.mapTypeToIndex(VariableType.CORES), - vmConfiguration.getCores()); - newAssignment.set(index + VariableTypeOrderer.mapTypeToIndex(VariableType.RAM), - vmConfiguration.getRam()); - newAssignment.set(index + VariableTypeOrderer.mapTypeToIndex(VariableType.STORAGE), - vmConfiguration.getDisk()); - - return newAssignment; - } - - private Collection getAllVMConfigurationChangeMoves(List assignment, int component) { - Collection result = new ArrayList<>(); - VMConfiguration conf = extractVMConfiguration(component, assignment); - int provider = extractProvider(component, assignment); - Collection neighbours = getVMConfigurationNeighbours(provider, conf); - if (neighbours.isEmpty()) { - return result; - } - for (VMConfiguration n : neighbours) { - result.add(new PTMover( - assignment, - updateComponentConfiguration(assignment, - component, provider, n, extractVMLocation(component, assignment)) - )); - } - return result; - } - - private Collection getAllVMLocationChangeMoves(List assignment, int component) { - Collection result = new ArrayList<>(); - GeographicCoordinate loc = extractVMLocation(component, assignment); - int provider = extractProvider(component, assignment); - Collection neighbours = getVMLocationNeighbours(provider, loc); - if (neighbours.isEmpty()) { - return result; - } - for (GeographicCoordinate n : neighbours) { - result.add(new PTMover( - assignment, - updateComponentConfiguration(assignment, - component, provider, extractVMConfiguration(component, assignment), n) - )); - } - return result; - } - - private Collection getAllCardinalityChangeMoves(List assignment, int component) { - int index = component * VariableTypeOrderer.variablesPerComponent - + VariableTypeOrderer.mapTypeToIndex(VariableType.CARDINALITY); - int maxCardinality = domainHandler.getMaxValue(index); - int minCardinality = domainHandler.getMinValue(index); - Collection result = new ArrayList<>(); - if (assignment.get(index) < maxCardinality) { - List newAssignment = new ArrayList<>(assignment); - newAssignment.set(index, assignment.get(index) + 1); - result.add(new PTMover(assignment, newAssignment)); - } - if (assignment.get(index) > minCardinality) { - List newAssignment = new ArrayList<>(assignment); - newAssignment.set(index, assignment.get(index) - 1); - result.add(new PTMover(assignment, newAssignment)); - } - return result; - } - - private Collection getAllProviderChangeMoves(List assignment, int component, int provider) { - Collection result = new ArrayList<>(); - Collection confs = - getVMConfigurationOrItsNeighbours(provider, extractVMConfiguration(component, assignment)); - for (VMConfiguration conf : confs) { - Collection locs = getVMLocationOrItsNeighbours( provider, extractVMLocation(component, assignment)); - for (GeographicCoordinate loc : locs) { - result.add(new PTMover( - assignment, - updateComponentConfiguration( - assignment, - component, - provider, - conf, - loc - ) - )); - } - } - return result; - } - - private Collection getAllProviderChangeMoves(List assignment, int component) { - int provider = extractProvider(component, assignment); - int maxProvider = domainHandler.getMaxValue(component * VariableTypeOrderer.variablesPerComponent); - int minProvider = domainHandler.getMinValue(component * VariableTypeOrderer.variablesPerComponent); - Collection result = new ArrayList<>(); - if (provider < maxProvider) { - result.addAll(getAllProviderChangeMoves(assignment, component, provider + 1)); - } - if (provider > minProvider) { - result.addAll(getAllProviderChangeMoves(assignment, component, provider - 1)); - } - return result; - } - - private Collection getAllMovesComponent(List assignment, int component) { - Collection result = getAllVMConfigurationChangeMoves(assignment, component); - result.addAll(getAllVMLocationChangeMoves(assignment, component)); - result.addAll(getAllCardinalityChangeMoves(assignment, component)); - result.addAll(getAllProviderChangeMoves(assignment, component)); - return result; - } - - public List getAllMoves(List assignment) { - List moves = new ArrayList<>(); - for (int i = 0; i < components.size(); i++) { - moves.addAll(getAllMovesComponent(assignment, i)); - } - return moves; - } -} diff --git a/zpp-solver/node_candidates_solver/src/test/java/NCWrapperTest.java b/zpp-solver/node_candidates_solver/src/test/java/NCWrapperTest.java deleted file mode 100644 index 8b3967415..000000000 --- a/zpp-solver/node_candidates_solver/src/test/java/NCWrapperTest.java +++ /dev/null @@ -1,6 +0,0 @@ -import static org.junit.jupiter.api.Assertions.*; -import org.junit.jupiter.api.Test; - -class NCWrapperTest { - -} \ No newline at end of file diff --git a/zpp-solver/node_candidates_solver/src/test/java/node_candidate/NodeCandidatesPoolTest.java b/zpp-solver/node_candidates_solver/src/test/java/node_candidate/NodeCandidatesPoolTest.java deleted file mode 100644 index 2753fa9a3..000000000 --- a/zpp-solver/node_candidates_solver/src/test/java/node_candidate/NodeCandidatesPoolTest.java +++ /dev/null @@ -1,105 +0,0 @@ -package node_candidate; - -import cp_components.PTMover; -import nc_wrapper.MarginalDomainValuesProvider; -import org.junit.jupiter.api.Test; - -import java.util.Arrays; -import java.util.List; - -import static org.junit.jupiter.api.Assertions.*; - -class NodeCandidatesPoolTest { - - public NodeCandidatesPool createPool() { - return new NodeCandidatesPool(new MarginalDomainValuesProvider() { - @Override - public int getMaxValue(int variable) { - return 2; - } - - @Override - public int getMinValue(int variable) { - return 0; - } - }, - Arrays.asList("comp1", "comp2", "comp3")); - } - - @Test - public void firstGetAllMovesTest() { - NodeCandidatesPool pool = createPool(); - pool.postVMConfiguration(0, new VMConfiguration(0, 0, 0)); - pool.postVMConfiguration(0, new VMConfiguration(1, 0, 0)); - pool.postVMConfiguration(0, new VMConfiguration(2, 0, 0)); - pool.postVMConfiguration(0, new VMConfiguration(0, 2, 0)); - pool.postVMLocation(0, new GeographicCoordinate(100, 100)); - - pool.initNodeCandidates(); - List moves = pool.getAllMoves(Arrays.asList(0, 0, 0, 0, 100, 100, 1, 0, 0, 0, 0, 100, 100, 1, 0, 0, 0, 0, 100, 100, 1)); - assertEquals(moves.size(), 3*3); - - PTMover m = new PTMover( - Arrays.asList(0, 0, 0, 0, 100, 100, 1, 0, 0, 0, 0, 100, 100, 1, 0, 0, 0, 0, 100, 100, 1), - Arrays.asList(0, 0, 0, 0, 100, 100, 2, 0, 0, 0, 0, 100, 100, 1, 0, 0, 0, 0, 100, 100, 1) - ); - - assertEquals(moves.contains(m), true); - - m = new PTMover( - Arrays.asList(0, 0, 0, 0, 100, 100, 1, 0, 0, 0, 0, 100, 100, 1, 0, 0, 0, 0, 100, 100, 1), - Arrays.asList(0, 0, 0, 0, 100, 100, 1, 0, 0, 0, 0, 100, 100, 1, 0, 0 , 2, 0, 100, 100, 1) - ); - - assertEquals(moves.contains(m), true); - - m = new PTMover( - Arrays.asList(0, 0, 0, 0, 100, 100, 1, 0, 0, 0, 0, 100, 100, 1, 0, 0, 0, 0, 100, 100, 1), - Arrays.asList(0, 0, 0, 0, 100, 100, 0, 0, 0, 0, 0, 100, 100, 1, 0, 0, 0, 0, 100, 100, 1) - ); - - assertEquals(moves.contains(m), true); - - } - - @Test - public void secondGetAllMovesTest() { - NodeCandidatesPool pool = createPool(); - pool.postVMConfiguration(0, new VMConfiguration(0, 0, 0)); - pool.postVMConfiguration(0, new VMConfiguration(1, 0, 0)); - pool.postVMConfiguration(0, new VMConfiguration(2, 0, 0)); - pool.postVMLocation(0, new GeographicCoordinate(100, 100)); - pool.postVMLocation(0, new GeographicCoordinate(100, 150)); - - pool.postVMConfiguration(1, new VMConfiguration(0, 0, 1)); - pool.postVMConfiguration(1, new VMConfiguration(1, 0, 1)); - pool.postVMConfiguration(1, new VMConfiguration(2, 0, 1)); - pool.postVMLocation(1, new GeographicCoordinate(100, 100)); - pool.postVMLocation(1, new GeographicCoordinate(100, 150)); - - pool.initNodeCandidates(); - List moves = pool.getAllMoves(Arrays.asList(0, 1, 0, 0, 100, 100, 1, 0, 1, 0, 0, 100, 100, 1, 0, 1, 0, 0, 100, 100, 1)); - assertEquals(moves.size(), 3*7); - - PTMover m = new PTMover( - Arrays.asList(0, 1, 0, 0, 100, 100, 1, 0, 1, 0, 0, 100, 100, 1, 0, 1, 0, 0, 100, 100, 1), - Arrays.asList(0, 1, 0, 0, 100, 100, 1, 1, 0, 0, 1, 100, 100, 1, 0, 1, 0, 0, 100, 100, 1) - ); - - assertEquals(moves.contains(m), true); - - m = new PTMover( - Arrays.asList(0, 1, 0, 0, 100, 100, 1, 0, 1, 0, 0, 100, 100, 1, 0, 1, 0, 0, 100, 100, 1), - Arrays.asList(0, 1, 0, 0, 100, 100, 1, 1, 1, 0, 1, 100, 100, 1, 0, 1, 0, 0, 100, 100, 1) - ); - - assertEquals(moves.contains(m), true); - - m = new PTMover( - Arrays.asList(0, 1, 0, 0, 100, 100, 1, 0, 1, 0, 0, 100, 100, 1, 0, 1, 0, 0, 100, 100, 1), - Arrays.asList(0, 1, 0, 0, 100, 100, 1, 0, 1, 0, 0, 100, 100, 1, 0, 1, 0, 0, 100, 150, 1) - ); - - assertEquals(moves.contains(m), true); - } -} \ No newline at end of file diff --git a/zpp-solver/pt-solver/src/test/java/PTSolverCoordinatorTest.java b/zpp-solver/pt-solver/src/test/java/PTSolverCoordinatorTest.java index bdcf540f6..2d1fcc8ee 100644 --- a/zpp-solver/pt-solver/src/test/java/PTSolverCoordinatorTest.java +++ b/zpp-solver/pt-solver/src/test/java/PTSolverCoordinatorTest.java @@ -39,9 +39,11 @@ class PTSolverCoordinatorTest { for (int i= 0; i < 3; i++) vars.add(new CpVariableImplMockup(variables.get(i), VariableType.CARDINALITY)); RangeDomainImpMockup dom1 = new RangeDomainImpMockup(); RangeDomainImpMockup dom3 = new RangeDomainImpMockup(); + dom3.setType(BasicTypeEnum.INTEGER); dom1.setType(BasicTypeEnum.INTEGER); dom1.setFrom(1);dom3.setFrom(0);dom1.setTo(5);dom3.setTo(9); NumericListDomainImplMockup dom2 = new NumericListDomainImplMockup(); dom2.setValues(Arrays.asList(0.5, 1.5, 2.5)); + dom2.setType(BasicTypeEnum.DOUBLE); List domains = Arrays.asList(new Domain[] {dom1, dom2, dom3}); for (int i = 0; i <3 ; i++ ){ vars.get(i).setDomain(domains.get(i)); @@ -109,7 +111,6 @@ class PTSolverCoordinatorTest { List domain2 = Arrays.asList(0.5, 1.5, 2.5); List domain3 = Arrays.asList(0.0, 1.0,2.0,3.0,4.0,5.0, 6.0, 7.0, 8.0, 9.0); List assignment = solution.getVarAssignments(); - System.out.println("values: " + domain1.get(assignment.get(1)) + domain2.get(assignment.get(2))+ " "+ domain3.get(assignment.get(0))); assertEquals((double) domain1.get(assignment.get(1)), 5.0); assertEquals((double) domain2.get(assignment.get(2)), 2.5); assertEquals((double) domain3.get(assignment.get(0)), 9); -- GitLab From 1f5e9ad29e02ad7ad7cc0cd6638c6783e7b45dee Mon Sep 17 00:00:00 2001 From: Michal Jankowski Date: Wed, 8 Jan 2020 20:04:45 +0100 Subject: [PATCH 058/340] Copied work progress from private repository. --- zpp-solver/genetic-solver/pom.xml | 31 +++- .../src/main/java/OurEngine.java | 30 ---- .../genetic-solver/src/main/java/Runner.java | 53 +++++++ .../cPGeneticWrapper/ACPGeneticWrapper.java | 58 +++++++ .../cPGeneticWrapper/CPGeneticWrapper.java | 38 ++--- .../java/implementation/EvalFunction.java | 12 ++ .../main/java/implementation/OurAlterer.java | 12 -- .../java/implementation/OurChromosome.java | 18 ++- .../java/implementation/OurCrossover.java | 44 ++++++ .../src/main/java/implementation/OurGene.java | 8 +- .../main/java/implementation/OurMutator.java | 59 +++++++ .../main/java/implementation/OurSelector.java | 5 +- .../OurSinglePointCrossover.java | 33 ++++ .../implementation/OurUniformCrossover.java | 34 ++++ .../StochasticRankingComparator.java | 6 +- .../src/test/java/CPGeneticWrapperA.java | 51 ++++++ .../src/test/java/GeneticWrapperTest.java | 107 +++++++++++++ .../src/test/java/OurGeneTest.java | 48 ++++++ .../src/test/java/RunnerTest.java | 51 ++++++ .../java/StochasticRankingComparatorTest.java | 149 ++++++++++++++++++ 20 files changed, 766 insertions(+), 81 deletions(-) delete mode 100644 zpp-solver/genetic-solver/src/main/java/OurEngine.java create mode 100644 zpp-solver/genetic-solver/src/main/java/Runner.java create mode 100644 zpp-solver/genetic-solver/src/main/java/cPGeneticWrapper/ACPGeneticWrapper.java create mode 100644 zpp-solver/genetic-solver/src/main/java/implementation/EvalFunction.java delete mode 100644 zpp-solver/genetic-solver/src/main/java/implementation/OurAlterer.java create mode 100644 zpp-solver/genetic-solver/src/main/java/implementation/OurCrossover.java create mode 100644 zpp-solver/genetic-solver/src/main/java/implementation/OurMutator.java create mode 100644 zpp-solver/genetic-solver/src/main/java/implementation/OurSinglePointCrossover.java create mode 100644 zpp-solver/genetic-solver/src/main/java/implementation/OurUniformCrossover.java create mode 100644 zpp-solver/genetic-solver/src/test/java/CPGeneticWrapperA.java create mode 100644 zpp-solver/genetic-solver/src/test/java/GeneticWrapperTest.java create mode 100644 zpp-solver/genetic-solver/src/test/java/OurGeneTest.java create mode 100644 zpp-solver/genetic-solver/src/test/java/RunnerTest.java create mode 100644 zpp-solver/genetic-solver/src/test/java/StochasticRankingComparatorTest.java diff --git a/zpp-solver/genetic-solver/pom.xml b/zpp-solver/genetic-solver/pom.xml index f456524c7..59e97f7aa 100644 --- a/zpp-solver/genetic-solver/pom.xml +++ b/zpp-solver/genetic-solver/pom.xml @@ -12,12 +12,41 @@ genetic-solver + + io.jenetics + jenetics + 5.1.0 + test + + + io.jenetics + jenetics + 5.1.0 + compile + + + org.ow2.paasage + upperware-metamodel + + + eu.melodic + utility-generator + 3.0.0-SNAPSHOT + test + org.ow2.paasage cp-parser 3.0.0-SNAPSHOT compile - + + org.ow2.paasage + cp-parser + 3.0.0-SNAPSHOT + test-jar + test + + \ No newline at end of file diff --git a/zpp-solver/genetic-solver/src/main/java/OurEngine.java b/zpp-solver/genetic-solver/src/main/java/OurEngine.java deleted file mode 100644 index c7e256a57..000000000 --- a/zpp-solver/genetic-solver/src/main/java/OurEngine.java +++ /dev/null @@ -1,30 +0,0 @@ -import cPGeneticWrapper.CPGeneticWrapper; -import cp_wrapper.CPWrapper; -import implementation.OurChromosome; -import implementation.OurGene; -import io.jenetics.Genotype; -import io.jenetics.engine.Engine; -import io.jenetics.engine.EvolutionResult; -import io.jenetics.util.Factory; - -import java.util.function.Function; - -public class OurEngine { - - private Integer dummy = 10; - - - public void main(String[] args) { - CPWrapper cpWrapper = new CPWrapper(); - CPGeneticWrapper cpGeneticWrapper = new CPGeneticWrapper(cpWrapper); - - Factory> gtf = - Genotype.of(OurChromosome.of(dummy, dummy, cpGeneticWrapper)); - - Function, Double> fun = chromosomes -> 0.5; - - final Engine engine = Engine.builder(fun, gtf).build(); - - System.out.println(engine.stream().limit(100).collect(EvolutionResult.toBestGenotype())); - } -} diff --git a/zpp-solver/genetic-solver/src/main/java/Runner.java b/zpp-solver/genetic-solver/src/main/java/Runner.java new file mode 100644 index 000000000..ecaaa9b80 --- /dev/null +++ b/zpp-solver/genetic-solver/src/main/java/Runner.java @@ -0,0 +1,53 @@ +import cPGeneticWrapper.ACPGeneticWrapper; +import cPGeneticWrapper.CPGeneticWrapper; +import cp_wrapper.CPWrapper; +import implementation.*; +import io.jenetics.*; +import io.jenetics.engine.Engine; +import io.jenetics.engine.EvolutionResult; +import io.jenetics.util.Factory; +import lombok.Setter; + +import java.util.List; +import java.util.function.Function; + +public class Runner { + @Setter + private Integer populationSize = 100; + @Setter + private Integer iterations = 100; + @Setter + private double crossoverProbability = 0.2; + @Setter + private double mutatorProbability = 0.05; + @Setter + private double comparatorProbability = 0.4; + @Setter + private int guesses = 10; + + + private final Function, Double> fitnessFunction = new EvalFunction(); + + public List run(ACPGeneticWrapper geneticWrapper) { + Alterer crossoverAlterer = new SinglePointCrossover<>(crossoverProbability); + Mutator mutator = new OurMutator(mutatorProbability, guesses, geneticWrapper); + Selector selector = new OurSelector(new StochasticRankingComparator(comparatorProbability)); + + Factory> gtf = + Genotype.of(OurChromosome.of(populationSize, geneticWrapper.getSize(), geneticWrapper)); + + final Engine engine = + Engine.builder(fitnessFunction, gtf) + .alterers(crossoverAlterer, mutator) + .selector(selector) + .build(); + + return ACPGeneticWrapper.genotypeToIntegerList(engine.stream().limit(iterations).collect(EvolutionResult.toBestGenotype())); + } + + public List run(CPWrapper cpWrapper) { + ACPGeneticWrapper cpGeneticWrapper = new CPGeneticWrapper(cpWrapper); + + return run(cpGeneticWrapper); + } +} diff --git a/zpp-solver/genetic-solver/src/main/java/cPGeneticWrapper/ACPGeneticWrapper.java b/zpp-solver/genetic-solver/src/main/java/cPGeneticWrapper/ACPGeneticWrapper.java new file mode 100644 index 000000000..6320583df --- /dev/null +++ b/zpp-solver/genetic-solver/src/main/java/cPGeneticWrapper/ACPGeneticWrapper.java @@ -0,0 +1,58 @@ +package cPGeneticWrapper; + +import cp_wrapper.CPWrapper; +import implementation.OurChromosome; +import implementation.OurGene; +import io.jenetics.Genotype; +import io.jenetics.Phenotype; +import io.jenetics.util.ISeq; +import io.jenetics.util.RandomRegistry; +import lombok.AllArgsConstructor; + +import java.util.ArrayList; +import java.util.List; +import java.util.Random; + +@AllArgsConstructor +public abstract class ACPGeneticWrapper { + protected final static Random random = RandomRegistry.getRandom(); + protected CPWrapper cpWrapper; + + // Calculates which variable has highest heuristic value. Returns its index. + public abstract int calculateHeuristicBest(ISeq values); + + // Generates random value for variable indexed with index. + public abstract int generateRandomValue(int index); + + public abstract double calculateUtility(ISeq genes); + + public abstract int countViolatedConstraints(ISeq genes); + + public abstract boolean isValid(int value, int index); + + public abstract boolean getIsFeasible(ISeq genes); + + public abstract int getSize(); + + + public static List phenotypeToIntegerList(Phenotype phenotype) { + return genotypeToIntegerList(phenotype.getGenotype()); + } + + public static List genotypeToIntegerList(Genotype genotype) { + return chromosomeToIntegerList((OurChromosome) genotype.getChromosome()); + } + + private static List chromosomeToIntegerList(OurChromosome chromosome) { + return genesToIntegerList(chromosome.toSeq()); + } + + protected static List genesToIntegerList(ISeq genes) { + List list = new ArrayList<>(); + + for (OurGene gene : genes) + list.add(gene.getAllele()); + + return list; + } +} diff --git a/zpp-solver/genetic-solver/src/main/java/cPGeneticWrapper/CPGeneticWrapper.java b/zpp-solver/genetic-solver/src/main/java/cPGeneticWrapper/CPGeneticWrapper.java index fa40d0d19..0ff24a2b2 100644 --- a/zpp-solver/genetic-solver/src/main/java/cPGeneticWrapper/CPGeneticWrapper.java +++ b/zpp-solver/genetic-solver/src/main/java/cPGeneticWrapper/CPGeneticWrapper.java @@ -3,27 +3,23 @@ package cPGeneticWrapper; import cp_wrapper.CPWrapper; import implementation.OurGene; import io.jenetics.util.ISeq; -import io.jenetics.util.RandomRegistry; -import java.util.ArrayList; import java.util.List; -import java.util.Random; - -// TODO need to implement method getRanges and getList in cpParser -public class CPGeneticWrapper { - private final static Random random = RandomRegistry.getRandom(); - private CPWrapper cpWrapper; +public class CPGeneticWrapper extends ACPGeneticWrapper { public CPGeneticWrapper(CPWrapper cpWrapper) { - this.cpWrapper = cpWrapper; + super(cpWrapper); } // Calculates which variable has highest heuristic value. Returns its index. - // TODO probably need to calculate it in other way - to get faster exec time - public int calculateHeuristicBest(List values) { + // TODO probably need to calculate it in other way - to get faster exec time (or maybe getHeuristicEvaluation is fast enough) + @Override + public int calculateHeuristicBest(ISeq genes) { int bestIndex = -1, bestValue = 0, tmp; + List values = genesToIntegerList(genes); + assert values.size() > 0; for (int i = 0; i < values.size(); i++) @@ -36,34 +32,34 @@ public class CPGeneticWrapper { } // Generates random value for variable indexed with index. + @Override public int generateRandomValue(int index) { - return 0; - // TODO random NEEDS to be used here + return random.nextInt(cpWrapper.getMaxDomainValue(index) - cpWrapper.getMinDomainValue(index) + 1) + + cpWrapper.getMinDomainValue(index); } + @Override public double calculateUtility(ISeq genes) { return cpWrapper.getUtility(genesToIntegerList(genes)); } + @Override public int countViolatedConstraints(ISeq genes) { return cpWrapper.countViolatedConstraints(genesToIntegerList(genes)); } + @Override public boolean isValid(int value, int index) { - // TODO return cpWrapper.getMinDomainValue(index) <= value && value <= cpWrapper.getMaxDomainValue(index); } + @Override public boolean getIsFeasible(ISeq genes) { return cpWrapper.checkIfFeasible(genesToIntegerList(genes)); } - private List genesToIntegerList(ISeq genes) { - List list = new ArrayList<>(); - - for (OurGene gene : genes) - list.add(gene.getAllele()); - - return list; + @Override + public int getSize() { + return cpWrapper.getVariablesCount(); } } diff --git a/zpp-solver/genetic-solver/src/main/java/implementation/EvalFunction.java b/zpp-solver/genetic-solver/src/main/java/implementation/EvalFunction.java new file mode 100644 index 000000000..617fb5b61 --- /dev/null +++ b/zpp-solver/genetic-solver/src/main/java/implementation/EvalFunction.java @@ -0,0 +1,12 @@ +package implementation; + +import io.jenetics.Genotype; + +import java.util.function.Function; + +public class EvalFunction implements Function, Double> { + @Override + public Double apply(Genotype chromosomes) { + return ((OurChromosome) chromosomes.getChromosome()).getUtility(); + } +} diff --git a/zpp-solver/genetic-solver/src/main/java/implementation/OurAlterer.java b/zpp-solver/genetic-solver/src/main/java/implementation/OurAlterer.java deleted file mode 100644 index 51579b1b6..000000000 --- a/zpp-solver/genetic-solver/src/main/java/implementation/OurAlterer.java +++ /dev/null @@ -1,12 +0,0 @@ -import implementation.OurGene; -import io.jenetics.Alterer; -import io.jenetics.AltererResult; -import io.jenetics.Phenotype; -import io.jenetics.util.Seq; - -public class OurAlterer implements Alterer { - @Override - public AltererResult alter(Seq> seq, long l) { - return null; - } -} diff --git a/zpp-solver/genetic-solver/src/main/java/implementation/OurChromosome.java b/zpp-solver/genetic-solver/src/main/java/implementation/OurChromosome.java index 4194ff3c4..c0e9f2ea8 100644 --- a/zpp-solver/genetic-solver/src/main/java/implementation/OurChromosome.java +++ b/zpp-solver/genetic-solver/src/main/java/implementation/OurChromosome.java @@ -1,21 +1,23 @@ package implementation; -import cPGeneticWrapper.CPGeneticWrapper; +import cPGeneticWrapper.ACPGeneticWrapper; import io.jenetics.Chromosome; import io.jenetics.util.ISeq; import io.jenetics.util.MSeq; +import lombok.Getter; public class OurChromosome implements Chromosome { + @Getter private ISeq genes; private Integer length; private boolean isFeasible; private double utility; private int brokenConstraints; private Boolean valid; - private CPGeneticWrapper cpGeneticWrapper; + private ACPGeneticWrapper cpGeneticWrapper; - public OurChromosome(ISeq genes, Integer length, CPGeneticWrapper cpGeneticWrapper) { + public OurChromosome(ISeq genes, Integer length, ACPGeneticWrapper cpGeneticWrapper) { this.genes = genes; this.length = length; this.cpGeneticWrapper = cpGeneticWrapper; @@ -67,8 +69,8 @@ public class OurChromosome implements Chromosome { return of(length, cpGeneticWrapper); } - // Creates randomly generated Chromosome. Static version of above method - public static OurChromosome of(Integer length, CPGeneticWrapper cpGeneticWrapper) { + // Creates randomly generated Chromosome. Static version of above method. + public static OurChromosome of(Integer length, ACPGeneticWrapper cpGeneticWrapper) { ISeq genes = OurGene.seq(length, cpGeneticWrapper); return new OurChromosome(genes, length, cpGeneticWrapper); } @@ -78,9 +80,9 @@ public class OurChromosome implements Chromosome { return of(length, size, cpGeneticWrapper); } - public static ISeq of(Integer length, Integer size, CPGeneticWrapper cpGeneticWrapper) { - return MSeq.ofLength(size) - .fill(() -> of(length, cpGeneticWrapper)) + public static ISeq of(Integer length, Integer size, ACPGeneticWrapper cpGeneticWrapper) { + return MSeq.ofLength(length) + .fill(() -> of(size, cpGeneticWrapper)) .toISeq(); } diff --git a/zpp-solver/genetic-solver/src/main/java/implementation/OurCrossover.java b/zpp-solver/genetic-solver/src/main/java/implementation/OurCrossover.java new file mode 100644 index 000000000..d1abceb43 --- /dev/null +++ b/zpp-solver/genetic-solver/src/main/java/implementation/OurCrossover.java @@ -0,0 +1,44 @@ +package implementation; + +import io.jenetics.*; + +import io.jenetics.util.RandomRegistry; +import io.jenetics.util.Seq; +import java.util.ArrayList; +import java.util.List; +import java.util.Random; + +public abstract class OurCrossover implements Alterer { + + private int alterations; + private Random random = RandomRegistry.getRandom(); + + OurCrossover(int alterations) { + this.alterations = alterations; + } + + @Override + public AltererResult alter(Seq> population, long generation) { + + int i1; + int i2; + List> results = new ArrayList<>(); + + for (int i = 0; i < alterations; i++) { + + i1 = random.nextInt(population.length()); + i2 = random.nextInt(population.length()); + + Genotype gt1 = population.get(i1).getGenotype(); + Genotype gt2 = population.get(i2).getGenotype(); + + Genotype newGenotype = crossover(gt1, gt2, random); + + results.add(Phenotype.of(newGenotype, generation + 1)); + } + + return AltererResult.of(population.append(results).asISeq()); + } + + abstract protected Genotype crossover(Genotype gt1, Genotype gt2, Random random); +} diff --git a/zpp-solver/genetic-solver/src/main/java/implementation/OurGene.java b/zpp-solver/genetic-solver/src/main/java/implementation/OurGene.java index e36859682..dac0623d8 100644 --- a/zpp-solver/genetic-solver/src/main/java/implementation/OurGene.java +++ b/zpp-solver/genetic-solver/src/main/java/implementation/OurGene.java @@ -1,6 +1,6 @@ package implementation; -import cPGeneticWrapper.CPGeneticWrapper; +import cPGeneticWrapper.ACPGeneticWrapper; import io.jenetics.Gene; import io.jenetics.util.ISeq; import lombok.AllArgsConstructor; @@ -12,7 +12,7 @@ import java.util.List; public class OurGene implements Gene { private Integer value; private Integer index; - private CPGeneticWrapper cpGeneticWrapper; + private ACPGeneticWrapper cpGeneticWrapper; @Override public Integer getAllele() { @@ -42,11 +42,11 @@ public class OurGene implements Gene { return seq(length, cpGeneticWrapper); } - static ISeq seq(Integer length, CPGeneticWrapper cpGeneticWrapper) { + public static ISeq seq(Integer length, ACPGeneticWrapper cpGeneticWrapper) { List list = new ArrayList<>(); for (int i = 0; i < length; i++) list.add(new OurGene(cpGeneticWrapper.generateRandomValue(i), i, cpGeneticWrapper)); - return ISeq.of(list); + return ISeq.of(list); } } \ No newline at end of file diff --git a/zpp-solver/genetic-solver/src/main/java/implementation/OurMutator.java b/zpp-solver/genetic-solver/src/main/java/implementation/OurMutator.java new file mode 100644 index 000000000..331d7cde5 --- /dev/null +++ b/zpp-solver/genetic-solver/src/main/java/implementation/OurMutator.java @@ -0,0 +1,59 @@ +package implementation; + +import cPGeneticWrapper.ACPGeneticWrapper; +import io.jenetics.Chromosome; +import io.jenetics.Mutator; +import io.jenetics.MutatorResult; +import io.jenetics.util.ISeq; +import lombok.Getter; +import java.util.Random; + +public class OurMutator extends Mutator { + @Getter + private int guesses; + private ACPGeneticWrapper geneticWrapper; + + public OurMutator(int guesses, ACPGeneticWrapper geneticWrapper) { + super(); + this.guesses = guesses; + this.geneticWrapper = geneticWrapper; + } + + public OurMutator(double probability, int guesses, ACPGeneticWrapper geneticWrapper) { + super(probability); + this.guesses = guesses; + this.geneticWrapper = geneticWrapper; + + } + + @Override + protected MutatorResult> mutate( + final Chromosome chromosome, + final double p, + final Random random) { + if (((OurChromosome) chromosome).getBrokenConstraints() == 0) + return super.mutate(chromosome, p, random); + + ISeq genes = chromosome.toSeq(); + int index = geneticWrapper.calculateHeuristicBest(genes); + + + /* This is probably dumb but we're gonna generate random values for this variable some number of times + and see which value is the best. + */ + int best = genes.get(index).getAllele(); + double bestUtility = ((OurChromosome) chromosome).getUtility(); + for (int i = 0; i < guesses; i++) { + genes.asMSeq().set(index, genes.get(index).newInstance()); + double tmp = geneticWrapper.calculateUtility(genes); + if (tmp > bestUtility) { + best = genes.get(index).getAllele(); + bestUtility = tmp; + } + } + + genes.asMSeq().set(index, genes.get(index).newInstance(best)); + + return MutatorResult.of(new OurChromosome(genes, genes.length(), geneticWrapper)); + } +} diff --git a/zpp-solver/genetic-solver/src/main/java/implementation/OurSelector.java b/zpp-solver/genetic-solver/src/main/java/implementation/OurSelector.java index 687db36c9..b2d3cdbe7 100644 --- a/zpp-solver/genetic-solver/src/main/java/implementation/OurSelector.java +++ b/zpp-solver/genetic-solver/src/main/java/implementation/OurSelector.java @@ -6,16 +6,19 @@ import io.jenetics.Selector; import io.jenetics.util.ISeq; import io.jenetics.util.MSeq; import io.jenetics.util.Seq; +import lombok.AllArgsConstructor; import java.util.Comparator; import static java.util.Collections.reverseOrder; +@AllArgsConstructor public class OurSelector implements Selector { + private Comparator> comparator; + @Override public ISeq> select(Seq> seq, int size, Optimize optimize) { MSeq> mseq = seq.asMSeq(); - Comparator> comparator = new StochasticRankingComparator(0); mseq.sort(reverseOrder(comparator)); return mseq.subSeq(size).toISeq(); diff --git a/zpp-solver/genetic-solver/src/main/java/implementation/OurSinglePointCrossover.java b/zpp-solver/genetic-solver/src/main/java/implementation/OurSinglePointCrossover.java new file mode 100644 index 000000000..b0bf1f79a --- /dev/null +++ b/zpp-solver/genetic-solver/src/main/java/implementation/OurSinglePointCrossover.java @@ -0,0 +1,33 @@ +package implementation; + +import io.jenetics.*; +import io.jenetics.Chromosome; + +import java.util.ArrayList; +import java.util.List; +import java.util.Random; + +public class OurSinglePointCrossover extends OurCrossover{ + + public OurSinglePointCrossover(int alterations) { + super(alterations); + } + + @Override + protected Genotype crossover(Genotype gt1, Genotype gt2, Random random) { + + assert gt1.length() == gt2.length(); + int crossIndex = random.nextInt(gt1.length()); + + List> chromosomes = new ArrayList<>(); + + for (Chromosome chromosome : gt1.toSeq().subSeq(0, crossIndex)) + chromosomes.add(chromosome); + + for (Chromosome chromosome : gt2.toSeq().subSeq(crossIndex + 1)) + chromosomes.add(chromosome); + + return Genotype.of(chromosomes); + } + +} diff --git a/zpp-solver/genetic-solver/src/main/java/implementation/OurUniformCrossover.java b/zpp-solver/genetic-solver/src/main/java/implementation/OurUniformCrossover.java new file mode 100644 index 000000000..d330e7b46 --- /dev/null +++ b/zpp-solver/genetic-solver/src/main/java/implementation/OurUniformCrossover.java @@ -0,0 +1,34 @@ +package implementation; + +import io.jenetics.Chromosome; +import io.jenetics.Genotype; + +import java.util.ArrayList; +import java.util.List; +import java.util.Random; + +public class OurUniformCrossover extends OurCrossover { + + public OurUniformCrossover(int alterations) { + super(alterations); + } + + @Override + protected Genotype crossover(Genotype gt1, Genotype gt2, Random random) { + + assert gt1.length() == gt2.length(); + + int len = gt1.length(); + List> chromosomes = new ArrayList<>(); + + for (int i = 0; i < len; i++) { + if (random.nextBoolean()) { + chromosomes.add(gt1.get(i)); + } else { + chromosomes.add(gt2.get(i)); + } + } + + return Genotype.of(chromosomes); + } +} diff --git a/zpp-solver/genetic-solver/src/main/java/implementation/StochasticRankingComparator.java b/zpp-solver/genetic-solver/src/main/java/implementation/StochasticRankingComparator.java index 27bd3af07..57323b026 100644 --- a/zpp-solver/genetic-solver/src/main/java/implementation/StochasticRankingComparator.java +++ b/zpp-solver/genetic-solver/src/main/java/implementation/StochasticRankingComparator.java @@ -20,13 +20,11 @@ public class StochasticRankingComparator implements Comparator values) { + return 0; + } + + @Override + public int generateRandomValue(int index) { + return random.nextInt(1001); + } + + @Override + public double calculateUtility(ISeq genes) { + double res = 0.; + List list = genesToIntegerList(genes); + for (int i = 0; i < list.size() - 1; i+=2) + res += list.get(i) - list.get(i + 1); + return res; + } + + @Override + public int countViolatedConstraints(ISeq genes) { + return 0; + } + + @Override + public boolean isValid(int value, int index) { + return value <= 1000 && value >= 0; + } + + @Override + public boolean getIsFeasible(ISeq genes) { + return true; + } + + @Override + public int getSize() { + return 10; + } +} diff --git a/zpp-solver/genetic-solver/src/test/java/GeneticWrapperTest.java b/zpp-solver/genetic-solver/src/test/java/GeneticWrapperTest.java new file mode 100644 index 000000000..790f0dfdc --- /dev/null +++ b/zpp-solver/genetic-solver/src/test/java/GeneticWrapperTest.java @@ -0,0 +1,107 @@ +import cPGeneticWrapper.ACPGeneticWrapper; +import cPGeneticWrapper.CPGeneticWrapper; +import cp_wrapper.CPWrapper; +import cp_wrapper.UtilityProvider; +import cp_wrapper.mockups.*; +import eu.melodic.upperware.utilitygenerator.cdo.cp_model.DTO.VariableValueDTO; +import eu.paasage.upperware.metamodel.cp.*; +import eu.paasage.upperware.metamodel.types.BasicTypeEnum; +import org.eclipse.emf.common.util.BasicEList; +import org.eclipse.emf.common.util.EList; +import org.junit.Test; + +import java.util.Arrays; +import java.util.Collections; +import java.util.List; +import java.util.Map; + +public class GeneticWrapperTest { + + // Copied problem from PTSolver. + public static Map prepareSimpleConstraintProblem() { + /* + @var1 in {1,2,3,4,5} + @var2 in {0.5, 1.5, 2.5} + @var3 in {0,...,9} + @const1 = 3 + + @constraint1 : @var1 < @var3 + + @constraint2 : @var1 * @var2 * @var3 >= @const1; + + @constraint3: @var1 * @var2 >= @var3 + + @constraint4: @var3 == @var3 + */ + + List variables = Arrays.asList("var1", "var2", "var3", "var4", "var5", "var6", "var7", "var8"); + EList vars = new BasicEList<>(); + for (int i= 0; i < 3; i++) vars.add(new CpVariableImplMockup(variables.get(i), VariableType.CARDINALITY)); + RangeDomainImpMockup dom1 = new RangeDomainImpMockup(); + RangeDomainImpMockup dom3 = new RangeDomainImpMockup(); + dom1.setFrom(1);dom3.setFrom(0);dom1.setTo(5);dom3.setTo(9); + NumericListDomainImplMockup dom2 = new NumericListDomainImplMockup(); + dom2.setValues(Arrays.asList(0.5, 1.5, 2.5)); + List domains = Arrays.asList(new Domain[] {dom1, dom2, dom3}); + for (int i = 0; i <3 ; i++ ){ + vars.get(i).setDomain(domains.get(i)); + } + + Constant c = new ConstantImplMockup(BasicTypeEnum.DOUBLE, new NumericValueUpperwareImplMockup(3)); + + EList exprs = new BasicEList<>(); + exprs.add(vars.get(0)); exprs.add(vars.get(1)); + NumericExpression times = new ComposedExpressionImplMockup(exprs, OperatorEnum.TIMES); + ComparisonExpressionMockup constraint1 = new ComparisonExpressionMockup(); + constraint1.setExp1(vars.get(0));constraint1.setExp2(vars.get(2)); + constraint1.setComparator(ComparatorEnum.LESS_THAN); + + ComparisonExpressionMockup constraint3 = new ComparisonExpressionMockup(); + constraint3.setExp1(times);constraint3.setExp2(vars.get(2)); + constraint3.setComparator(ComparatorEnum.GREATER_OR_EQUAL_TO); + + exprs.add(vars.get(2)); + ComparisonExpressionMockup constraint2 = new ComparisonExpressionMockup(); + times = new ComposedExpressionImplMockup(exprs, OperatorEnum.TIMES); + constraint2.setExp1(times);constraint2.setExp2(c); + constraint2.setComparator(ComparatorEnum.GREATER_OR_EQUAL_TO); + + ComparisonExpressionMockup constraint4 = new ComparisonExpressionMockup(); + constraint4.setExp1(vars.get(2));constraint4.setExp2(vars.get(2)); + constraint4.setComparator(ComparatorEnum.EQUAL_TO); + + EList consts = new BasicEList<>(); + consts.add(c); + + EList varsE = new BasicEList<>(); + for (int i = 0; i < 3; i++) varsE.add(vars.get(i)); + + EList constraints = new BasicEList<>(); + constraints.addAll(Arrays.asList(constraint1, constraint2, constraint3, constraint4)); + + ConstraintProblem cp = new ConstraintProblemMockup(consts,null, varsE, constraints ); + return Collections.singletonMap(cp, result -> { + double sum = 0; + for (VariableValueDTO v : result) { + if (v.getValue() instanceof Double) { + sum += v.getValue().doubleValue(); + } else { + sum += v.getValue().intValue(); + } + } + return sum; + }); + } + + @Test + public void testConstructorAndGetters() { + // TODO + Map problem = GeneticWrapperTest.prepareSimpleConstraintProblem(); + CPWrapper cpWrapper = new CPWrapper(); + cpWrapper.parse(problem.keySet().iterator().next(), problem.values().iterator().next()); + + ACPGeneticWrapper geneticWrapper = new CPGeneticWrapper(cpWrapper); + System.out.println(geneticWrapper.getSize()); + System.out.println(geneticWrapper.generateRandomValue(2)); + } +} diff --git a/zpp-solver/genetic-solver/src/test/java/OurGeneTest.java b/zpp-solver/genetic-solver/src/test/java/OurGeneTest.java new file mode 100644 index 000000000..282c0e936 --- /dev/null +++ b/zpp-solver/genetic-solver/src/test/java/OurGeneTest.java @@ -0,0 +1,48 @@ + +import implementation.OurGene; +import io.jenetics.Gene; +import io.jenetics.util.Seq; +import org.junit.Test; +import static org.junit.Assert.*; + +public class OurGeneTest { + + + + @Test + public void constructorAndGettersTest() { + OurGene gene = new OurGene(1, 0, null); + assertEquals(gene.getAllele(), (Integer) 1); + + OurGene gen = new OurGene(2333, 13, null); + assertEquals(gen.getAllele(), (Integer) 2333); + } + + @Test + public void newInstanceGeneTest() { + OurGene gene = new OurGene(1, 0, new CPGeneticWrapperA(null)); + + System.out.println("What follows should be a list of randomly generated genes with value in <0, 1000>"); + + for (int i = 0; i < 10; i++) + System.out.print(gene.newInstance().getAllele() + " "); + System.out.println(); + } + + @Test + public void newInstanceFromValueTest() { + OurGene gene = new OurGene(1, 0, new CPGeneticWrapperA(null)); + + OurGene newGeneFromValue = gene.newInstance(5); + assertEquals(newGeneFromValue.getAllele(), (Integer) 5); + } + + @Test + public void checkSeqMethodWithGivenWrapperTest() { + System.out.println("What follows should be a list of 10 randomly generated genes with values in <0, 1000>"); + Seq s = OurGene.seq(10, new CPGeneticWrapperA(null)); + for (OurGene gene : s) + System.out.print(gene.getAllele() + " "); + System.out.println(); + } +} diff --git a/zpp-solver/genetic-solver/src/test/java/RunnerTest.java b/zpp-solver/genetic-solver/src/test/java/RunnerTest.java new file mode 100644 index 000000000..9ed2310a4 --- /dev/null +++ b/zpp-solver/genetic-solver/src/test/java/RunnerTest.java @@ -0,0 +1,51 @@ +import cPGeneticWrapper.ACPGeneticWrapper; +import cp_wrapper.CPWrapper; +import cp_wrapper.UtilityProvider; +import eu.paasage.upperware.metamodel.cp.*; +import org.junit.Test; + +import java.util.Arrays; +import java.util.List; +import java.util.Map; + +import static org.junit.Assert.assertEquals; + +public class RunnerTest { + + @Test + public void SimpleRunnerWithGeneticWrapperA() { + ACPGeneticWrapper geneticWrapper = new CPGeneticWrapperA(null); + + Runner runner = new Runner(); + runner.setGuesses(10); + runner.setMutatorProbability(0.05); + runner.setPopulationSize(10); + runner.setIterations(10000); + + System.out.println(runner.run(geneticWrapper)); + } + + @Test + public void SimpleTestGeneratedByTomek() { + Map problem = GeneticWrapperTest.prepareSimpleConstraintProblem(); + CPWrapper cpWrapper = new CPWrapper(); + cpWrapper.parse(problem.keySet().iterator().next(), problem.values().iterator().next()); + + Runner runner = new Runner(); + runner.setGuesses(10); + runner.setMutatorProbability(0.2); + runner.setPopulationSize(10); + runner.setIterations(1000); + + List assignment = runner.run(cpWrapper); + + + List domain1 = Arrays.asList(1.0,2.0,3.0,4.0,5.0); + List domain2 = Arrays.asList(0.5, 1.5, 2.5); + List domain3 = Arrays.asList(0.0, 1.0,2.0,3.0,4.0,5.0, 6.0, 7.0, 8.0, 9.0); + System.out.println("values: " + domain1.get(assignment.get(1)) + domain2.get(assignment.get(2))+ " "+ domain3.get(assignment.get(0))); + assertEquals((double) domain1.get(assignment.get(1)), 5.0, 0.01); + assertEquals((double) domain2.get(assignment.get(2)), 2.5, 0.01); + assertEquals((double) domain3.get(assignment.get(0)), 9, 0.01); + } +} diff --git a/zpp-solver/genetic-solver/src/test/java/StochasticRankingComparatorTest.java b/zpp-solver/genetic-solver/src/test/java/StochasticRankingComparatorTest.java new file mode 100644 index 000000000..24a2f7af3 --- /dev/null +++ b/zpp-solver/genetic-solver/src/test/java/StochasticRankingComparatorTest.java @@ -0,0 +1,149 @@ +import cPGeneticWrapper.ACPGeneticWrapper; +import implementation.EvalFunction; +import implementation.OurChromosome; +import implementation.OurGene; +import implementation.StochasticRankingComparator; +import io.jenetics.Genotype; +import io.jenetics.Phenotype; +import io.jenetics.util.ISeq; +import io.jenetics.util.MSeq; +import io.jenetics.util.Seq; +import org.junit.Test; + +import java.util.ArrayList; +import java.util.Arrays; +import java.util.Comparator; +import java.util.List; +import java.util.function.Function; + +import static java.util.Collections.reverseOrder; +import static org.junit.Assert.assertEquals; + +public class StochasticRankingComparatorTest { + //TODO ITS A MESS + @Test + public void checkComparatorWithoutRandomnessAndBrokenConstraints() { + Comparator> comparator = new StochasticRankingComparator(0); + ACPGeneticWrapper geneticWrapper = new CPGeneticWrapperA(null); + + OurGene[] g = new OurGene[8]; + + g[0] = new OurGene(0, 0, geneticWrapper); + g[1] = new OurGene(0, 1, geneticWrapper); + g[2] = new OurGene(0, 2, geneticWrapper); + g[3] = new OurGene(0, 3, geneticWrapper); + g[4] = new OurGene(1, 0, geneticWrapper); + g[5] = new OurGene(1, 1, geneticWrapper); + g[6] = new OurGene(1, 2, geneticWrapper); + g[7] = new OurGene(1, 3, geneticWrapper); + + + List l1 = new ArrayList<>(Arrays.asList(g).subList(0, 4)); + List l2 = new ArrayList<>(Arrays.asList(g).subList(0, 3)); + List l3 = new ArrayList<>(Arrays.asList(g).subList(0, 2)); + List l4 = new ArrayList<>(Arrays.asList(g).subList(0, 1)); + List l5 = new ArrayList<>(Arrays.asList(g).subList(4, 8)); + List l6 = new ArrayList<>(Arrays.asList(g).subList(4, 7)); + List l7 = new ArrayList<>(Arrays.asList(g).subList(4, 6)); + List l8 = new ArrayList<>(Arrays.asList(g).subList(4, 5)); + + List lq1 = new ArrayList<>(); + List lq2 = new ArrayList<>(); + List lq3 = new ArrayList<>(); + List lq4 = new ArrayList<>(); + List lq5 = new ArrayList<>(); + + + // Best list with fitness 2. + lq1.add(g[4]); lq1.add(g[1]); lq1.add(g[6]); lq1.add(g[3]); + // Second best list with fitness 1. + lq2.add(g[4]); lq2.add(g[1]); lq2.add(g[6]); lq2.add(g[7]); + // Mid list with fitness 0. + lq3.add(g[0]); lq3.add(g[1]); lq3.add(g[2]); lq3.add(g[3]); + // Second worst list with fitness -1. + lq4.add(g[0]); lq4.add(g[5]); lq4.add(g[2]); lq4.add(g[3]); + // Worst list with fitness -2. + lq5.add(g[0]); lq5.add(g[5]); lq5.add(g[2]); lq5.add(g[7]); + + + l2.add(g[7]); + l3.add(g[6]); + l3.add(g[7]); + l4.add(g[5]); + l4.add(g[6]); + l4.add(g[7]); + l6.add(g[3]); + l7.add(g[2]); + l7.add(g[3]); + l8.add(g[1]); + l8.add(g[2]); + l8.add(g[3]); + + Phenotype p1 = Phenotype.of(Genotype.of(new OurChromosome(MSeq.of(l1).toISeq(), 4, geneticWrapper)), 0); + Phenotype p2 = Phenotype.of(Genotype.of(new OurChromosome(MSeq.of(l2).toISeq(), 4, geneticWrapper)), 0); + Phenotype p3 = Phenotype.of(Genotype.of(new OurChromosome(MSeq.of(l3).toISeq(), 4, geneticWrapper)), 0); + Phenotype p4 = Phenotype.of(Genotype.of(new OurChromosome(MSeq.of(l4).toISeq(), 4, geneticWrapper)), 0); + Phenotype p5 = Phenotype.of(Genotype.of(new OurChromosome(MSeq.of(l5).toISeq(), 4, geneticWrapper)), 0); + Phenotype p6 = Phenotype.of(Genotype.of(new OurChromosome(MSeq.of(l6).toISeq(), 4, geneticWrapper)), 0); + Phenotype p7 = Phenotype.of(Genotype.of(new OurChromosome(MSeq.of(l7).toISeq(), 4, geneticWrapper)), 0); + Phenotype p8 = Phenotype.of(Genotype.of(new OurChromosome(MSeq.of(l8).toISeq(), 4, geneticWrapper)), 0); + + Phenotype pq1 = Phenotype.of(Genotype.of(new OurChromosome(MSeq.of(lq1).toISeq(), 4, geneticWrapper)), 0); + Phenotype pq2 = Phenotype.of(Genotype.of(new OurChromosome(MSeq.of(lq2).toISeq(), 4, geneticWrapper)), 0); + Phenotype pq3 = Phenotype.of(Genotype.of(new OurChromosome(MSeq.of(lq3).toISeq(), 4, geneticWrapper)), 0); + Phenotype pq4 = Phenotype.of(Genotype.of(new OurChromosome(MSeq.of(lq4).toISeq(), 4, geneticWrapper)), 0); + Phenotype pq5 = Phenotype.of(Genotype.of(new OurChromosome(MSeq.of(lq5).toISeq(), 4, geneticWrapper)), 0); + + Function, Double> fun = new EvalFunction(); + p1 = p1.eval(fun); + p2 = p2.eval(fun); + p3 = p3.eval(fun); + p4 = p4.eval(fun); + p5 = p5.eval(fun); + p6 = p6.eval(fun); + p7 = p7.eval(fun); + p8 = p8.eval(fun); + + pq1 = pq1.eval(fun); + pq2 = pq2.eval(fun); + pq3 = pq3.eval(fun); + pq4 = pq4.eval(fun); + pq5 = pq5.eval(fun); + + List> pop = new ArrayList<>(); + pop.add(p1); + pop.add(p2); + pop.add(p3); + pop.add(p4); + pop.add(p5); + pop.add(p6); + pop.add(p7); + pop.add(p8); + + List> popq = new ArrayList<>(); + popq.add(pq4); + popq.add(pq2); + popq.add(pq3); + popq.add(pq1); + popq.add(pq5); + + + MSeq> population = MSeq.of(pop); + MSeq> populationq = MSeq.of(popq); + + population.sort(reverseOrder(comparator)); + populationq.sort(reverseOrder(comparator)); + + for (Phenotype phen : population) { + for (OurGene gene : phen.getGenotype().getChromosome().toSeq()) + System.out.print(gene.getAllele() + " "); + System.out.println(); + } + + assertEquals(populationq.asList().get(0), pq1); + assertEquals(populationq.asList().get(1), pq2); + assertEquals(populationq.asList().get(2), pq3); + assertEquals(populationq.asList().get(3), pq4); + assertEquals(populationq.asList().get(4), pq5); + } +} \ No newline at end of file -- GitLab From 3ce9bb4a932bf088e0bdbb65bce073db04a6c321 Mon Sep 17 00:00:00 2001 From: Michal Jankowski Date: Wed, 8 Jan 2020 21:02:21 +0100 Subject: [PATCH 059/340] Removed unnecessary classes. --- .../java/implementation/OurCrossover.java | 44 ------------------- .../OurSinglePointCrossover.java | 33 -------------- .../implementation/OurUniformCrossover.java | 34 -------------- 3 files changed, 111 deletions(-) delete mode 100644 zpp-solver/genetic-solver/src/main/java/implementation/OurCrossover.java delete mode 100644 zpp-solver/genetic-solver/src/main/java/implementation/OurSinglePointCrossover.java delete mode 100644 zpp-solver/genetic-solver/src/main/java/implementation/OurUniformCrossover.java diff --git a/zpp-solver/genetic-solver/src/main/java/implementation/OurCrossover.java b/zpp-solver/genetic-solver/src/main/java/implementation/OurCrossover.java deleted file mode 100644 index d1abceb43..000000000 --- a/zpp-solver/genetic-solver/src/main/java/implementation/OurCrossover.java +++ /dev/null @@ -1,44 +0,0 @@ -package implementation; - -import io.jenetics.*; - -import io.jenetics.util.RandomRegistry; -import io.jenetics.util.Seq; -import java.util.ArrayList; -import java.util.List; -import java.util.Random; - -public abstract class OurCrossover implements Alterer { - - private int alterations; - private Random random = RandomRegistry.getRandom(); - - OurCrossover(int alterations) { - this.alterations = alterations; - } - - @Override - public AltererResult alter(Seq> population, long generation) { - - int i1; - int i2; - List> results = new ArrayList<>(); - - for (int i = 0; i < alterations; i++) { - - i1 = random.nextInt(population.length()); - i2 = random.nextInt(population.length()); - - Genotype gt1 = population.get(i1).getGenotype(); - Genotype gt2 = population.get(i2).getGenotype(); - - Genotype newGenotype = crossover(gt1, gt2, random); - - results.add(Phenotype.of(newGenotype, generation + 1)); - } - - return AltererResult.of(population.append(results).asISeq()); - } - - abstract protected Genotype crossover(Genotype gt1, Genotype gt2, Random random); -} diff --git a/zpp-solver/genetic-solver/src/main/java/implementation/OurSinglePointCrossover.java b/zpp-solver/genetic-solver/src/main/java/implementation/OurSinglePointCrossover.java deleted file mode 100644 index b0bf1f79a..000000000 --- a/zpp-solver/genetic-solver/src/main/java/implementation/OurSinglePointCrossover.java +++ /dev/null @@ -1,33 +0,0 @@ -package implementation; - -import io.jenetics.*; -import io.jenetics.Chromosome; - -import java.util.ArrayList; -import java.util.List; -import java.util.Random; - -public class OurSinglePointCrossover extends OurCrossover{ - - public OurSinglePointCrossover(int alterations) { - super(alterations); - } - - @Override - protected Genotype crossover(Genotype gt1, Genotype gt2, Random random) { - - assert gt1.length() == gt2.length(); - int crossIndex = random.nextInt(gt1.length()); - - List> chromosomes = new ArrayList<>(); - - for (Chromosome chromosome : gt1.toSeq().subSeq(0, crossIndex)) - chromosomes.add(chromosome); - - for (Chromosome chromosome : gt2.toSeq().subSeq(crossIndex + 1)) - chromosomes.add(chromosome); - - return Genotype.of(chromosomes); - } - -} diff --git a/zpp-solver/genetic-solver/src/main/java/implementation/OurUniformCrossover.java b/zpp-solver/genetic-solver/src/main/java/implementation/OurUniformCrossover.java deleted file mode 100644 index d330e7b46..000000000 --- a/zpp-solver/genetic-solver/src/main/java/implementation/OurUniformCrossover.java +++ /dev/null @@ -1,34 +0,0 @@ -package implementation; - -import io.jenetics.Chromosome; -import io.jenetics.Genotype; - -import java.util.ArrayList; -import java.util.List; -import java.util.Random; - -public class OurUniformCrossover extends OurCrossover { - - public OurUniformCrossover(int alterations) { - super(alterations); - } - - @Override - protected Genotype crossover(Genotype gt1, Genotype gt2, Random random) { - - assert gt1.length() == gt2.length(); - - int len = gt1.length(); - List> chromosomes = new ArrayList<>(); - - for (int i = 0; i < len; i++) { - if (random.nextBoolean()) { - chromosomes.add(gt1.get(i)); - } else { - chromosomes.add(gt2.get(i)); - } - } - - return Genotype.of(chromosomes); - } -} -- GitLab From cb18325e08350dc747b3904ccc08f814d22374b0 Mon Sep 17 00:00:00 2001 From: Michal Jankowski Date: Thu, 9 Jan 2020 01:21:01 +0100 Subject: [PATCH 060/340] Renamed and restructured some parts of code. --- ...ner.java => GeneticSolverCoordinator.java} | 19 +++++++++---------- .../StochasticRankingComparator.java | 17 +++++++---------- ...OurChromosome.java => ImplChromosome.java} | 15 +++------------ .../{OurGene.java => ImplGene.java} | 0 .../{OurMutator.java => ImplMutator.java} | 0 .../{OurSelector.java => ImplSelector.java} | 10 +++++----- ...java => GeneticSolverCoordinatorTest.java} | 19 +++---------------- .../{OurGeneTest.java => ImplGeneTest.java} | 0 .../java/{ => utility}/CPGeneticWrapperA.java | 10 +++++----- 9 files changed, 32 insertions(+), 58 deletions(-) rename zpp-solver/genetic-solver/src/main/java/{Runner.java => GeneticSolverCoordinator.java} (62%) rename zpp-solver/genetic-solver/src/main/java/{implementation => comparators}/StochasticRankingComparator.java (63%) rename zpp-solver/genetic-solver/src/main/java/implementation/{OurChromosome.java => ImplChromosome.java} (92%) rename zpp-solver/genetic-solver/src/main/java/implementation/{OurGene.java => ImplGene.java} (100%) rename zpp-solver/genetic-solver/src/main/java/implementation/{OurMutator.java => ImplMutator.java} (100%) rename zpp-solver/genetic-solver/src/main/java/implementation/{OurSelector.java => ImplSelector.java} (53%) rename zpp-solver/genetic-solver/src/test/java/{RunnerTest.java => GeneticSolverCoordinatorTest.java} (69%) rename zpp-solver/genetic-solver/src/test/java/{OurGeneTest.java => ImplGeneTest.java} (100%) rename zpp-solver/genetic-solver/src/test/java/{ => utility}/CPGeneticWrapperA.java (76%) diff --git a/zpp-solver/genetic-solver/src/main/java/Runner.java b/zpp-solver/genetic-solver/src/main/java/GeneticSolverCoordinator.java similarity index 62% rename from zpp-solver/genetic-solver/src/main/java/Runner.java rename to zpp-solver/genetic-solver/src/main/java/GeneticSolverCoordinator.java index ecaaa9b80..c4ad44821 100644 --- a/zpp-solver/genetic-solver/src/main/java/Runner.java +++ b/zpp-solver/genetic-solver/src/main/java/GeneticSolverCoordinator.java @@ -1,3 +1,4 @@ +import comparators.StochasticRankingComparator; import cPGeneticWrapper.ACPGeneticWrapper; import cPGeneticWrapper.CPGeneticWrapper; import cp_wrapper.CPWrapper; @@ -21,22 +22,20 @@ public class Runner { @Setter private double mutatorProbability = 0.05; @Setter - private double comparatorProbability = 0.4; - @Setter - private int guesses = 10; + private double comparatorProbability = 0.1; - private final Function, Double> fitnessFunction = new EvalFunction(); + private final Function, Double> fitnessFunction = new EvalFunction(); public List run(ACPGeneticWrapper geneticWrapper) { - Alterer crossoverAlterer = new SinglePointCrossover<>(crossoverProbability); - Mutator mutator = new OurMutator(mutatorProbability, guesses, geneticWrapper); - Selector selector = new OurSelector(new StochasticRankingComparator(comparatorProbability)); + Alterer crossoverAlterer = new SinglePointCrossover<>(crossoverProbability); + Mutator mutator = new ImplMutator(mutatorProbability, geneticWrapper); + Selector selector = new ImplSelector(new StochasticRankingComparator(comparatorProbability)); - Factory> gtf = - Genotype.of(OurChromosome.of(populationSize, geneticWrapper.getSize(), geneticWrapper)); + Factory> gtf = + Genotype.of(ImplChromosome.of(populationSize, geneticWrapper.getSize(), geneticWrapper)); - final Engine engine = + final Engine engine = Engine.builder(fitnessFunction, gtf) .alterers(crossoverAlterer, mutator) .selector(selector) diff --git a/zpp-solver/genetic-solver/src/main/java/implementation/StochasticRankingComparator.java b/zpp-solver/genetic-solver/src/main/java/comparators/StochasticRankingComparator.java similarity index 63% rename from zpp-solver/genetic-solver/src/main/java/implementation/StochasticRankingComparator.java rename to zpp-solver/genetic-solver/src/main/java/comparators/StochasticRankingComparator.java index 57323b026..40d51bd72 100644 --- a/zpp-solver/genetic-solver/src/main/java/implementation/StochasticRankingComparator.java +++ b/zpp-solver/genetic-solver/src/main/java/comparators/StochasticRankingComparator.java @@ -2,26 +2,23 @@ package implementation; import io.jenetics.Phenotype; import io.jenetics.util.RandomRegistry; +import lombok.AllArgsConstructor; import java.util.Comparator; import java.util.Random; -public class StochasticRankingComparator implements Comparator> { +@AllArgsConstructor +public class StochasticRankingComparator implements Comparator> { static final Random random = RandomRegistry.getRandom(); private double probability; - public StochasticRankingComparator(double probability) { - assert probability >= 0 && probability <= 1; - this.probability = probability; - } - @Override - public int compare(Phenotype left, Phenotype right) { + public int compare(Phenotype left, Phenotype right) { double leftUtility, rightUtility; int leftBroken, rightBroken; - OurChromosome l = (OurChromosome) left.getGenotype().getChromosome(); - OurChromosome r = (OurChromosome) right.getGenotype().getChromosome(); + ImplChromosome l = (ImplChromosome) left.getGenotype().getChromosome(); + ImplChromosome r = (ImplChromosome) right.getGenotype().getChromosome(); leftUtility = left.getFitness(); rightUtility = right.getFitness(); @@ -33,7 +30,7 @@ public class StochasticRankingComparator implements Comparator { @Getter private ISeq genes; private Integer length; + @Getter private boolean isFeasible; + @Getter private double utility; + @Getter private int brokenConstraints; private Boolean valid; private ACPGeneticWrapper cpGeneticWrapper; @@ -85,16 +88,4 @@ public class OurChromosome implements Chromosome { .fill(() -> of(size, cpGeneticWrapper)) .toISeq(); } - - public double getUtility() { - return utility; - } - - public int getBrokenConstraints() { - return brokenConstraints; - } - - public boolean getIsFeasible() { - return isFeasible; - } } diff --git a/zpp-solver/genetic-solver/src/main/java/implementation/OurGene.java b/zpp-solver/genetic-solver/src/main/java/implementation/ImplGene.java similarity index 100% rename from zpp-solver/genetic-solver/src/main/java/implementation/OurGene.java rename to zpp-solver/genetic-solver/src/main/java/implementation/ImplGene.java diff --git a/zpp-solver/genetic-solver/src/main/java/implementation/OurMutator.java b/zpp-solver/genetic-solver/src/main/java/implementation/ImplMutator.java similarity index 100% rename from zpp-solver/genetic-solver/src/main/java/implementation/OurMutator.java rename to zpp-solver/genetic-solver/src/main/java/implementation/ImplMutator.java diff --git a/zpp-solver/genetic-solver/src/main/java/implementation/OurSelector.java b/zpp-solver/genetic-solver/src/main/java/implementation/ImplSelector.java similarity index 53% rename from zpp-solver/genetic-solver/src/main/java/implementation/OurSelector.java rename to zpp-solver/genetic-solver/src/main/java/implementation/ImplSelector.java index b2d3cdbe7..5619156f6 100644 --- a/zpp-solver/genetic-solver/src/main/java/implementation/OurSelector.java +++ b/zpp-solver/genetic-solver/src/main/java/implementation/ImplSelector.java @@ -13,13 +13,13 @@ import java.util.Comparator; import static java.util.Collections.reverseOrder; @AllArgsConstructor -public class OurSelector implements Selector { - private Comparator> comparator; +public class OurSelector implements Selector { + private Comparator> comparator; @Override - public ISeq> select(Seq> seq, int size, Optimize optimize) { - MSeq> mseq = seq.asMSeq(); - mseq.sort(reverseOrder(comparator)); + public ISeq> select(Seq> seq, int size, Optimize optimize) { + MSeq> mseq = seq.asMSeq().copy(); + mseq.sort(comparator); return mseq.subSeq(size).toISeq(); } diff --git a/zpp-solver/genetic-solver/src/test/java/RunnerTest.java b/zpp-solver/genetic-solver/src/test/java/GeneticSolverCoordinatorTest.java similarity index 69% rename from zpp-solver/genetic-solver/src/test/java/RunnerTest.java rename to zpp-solver/genetic-solver/src/test/java/GeneticSolverCoordinatorTest.java index 9ed2310a4..1790f48e9 100644 --- a/zpp-solver/genetic-solver/src/test/java/RunnerTest.java +++ b/zpp-solver/genetic-solver/src/test/java/GeneticSolverCoordinatorTest.java @@ -1,8 +1,8 @@ -import cPGeneticWrapper.ACPGeneticWrapper; import cp_wrapper.CPWrapper; import cp_wrapper.UtilityProvider; import eu.paasage.upperware.metamodel.cp.*; import org.junit.Test; +import utility.Methods; import java.util.Arrays; import java.util.List; @@ -12,30 +12,17 @@ import static org.junit.Assert.assertEquals; public class RunnerTest { - @Test - public void SimpleRunnerWithGeneticWrapperA() { - ACPGeneticWrapper geneticWrapper = new CPGeneticWrapperA(null); - - Runner runner = new Runner(); - runner.setGuesses(10); - runner.setMutatorProbability(0.05); - runner.setPopulationSize(10); - runner.setIterations(10000); - - System.out.println(runner.run(geneticWrapper)); - } - @Test public void SimpleTestGeneratedByTomek() { - Map problem = GeneticWrapperTest.prepareSimpleConstraintProblem(); + Map problem = Methods.prepareSimpleConstraintProblem(); CPWrapper cpWrapper = new CPWrapper(); cpWrapper.parse(problem.keySet().iterator().next(), problem.values().iterator().next()); Runner runner = new Runner(); - runner.setGuesses(10); runner.setMutatorProbability(0.2); runner.setPopulationSize(10); runner.setIterations(1000); + runner.setComparatorProbability(0.1); List assignment = runner.run(cpWrapper); diff --git a/zpp-solver/genetic-solver/src/test/java/OurGeneTest.java b/zpp-solver/genetic-solver/src/test/java/ImplGeneTest.java similarity index 100% rename from zpp-solver/genetic-solver/src/test/java/OurGeneTest.java rename to zpp-solver/genetic-solver/src/test/java/ImplGeneTest.java diff --git a/zpp-solver/genetic-solver/src/test/java/CPGeneticWrapperA.java b/zpp-solver/genetic-solver/src/test/java/utility/CPGeneticWrapperA.java similarity index 76% rename from zpp-solver/genetic-solver/src/test/java/CPGeneticWrapperA.java rename to zpp-solver/genetic-solver/src/test/java/utility/CPGeneticWrapperA.java index 8d7b7bc0e..369435261 100644 --- a/zpp-solver/genetic-solver/src/test/java/CPGeneticWrapperA.java +++ b/zpp-solver/genetic-solver/src/test/java/utility/CPGeneticWrapperA.java @@ -1,6 +1,6 @@ import cPGeneticWrapper.ACPGeneticWrapper; import cp_wrapper.CPWrapper; -import implementation.OurGene; +import implementation.ImplGene; import io.jenetics.util.ISeq; import java.util.List; @@ -11,7 +11,7 @@ public class CPGeneticWrapperA extends ACPGeneticWrapper { } @Override - public int calculateHeuristicBest(ISeq values) { + public int calculateHeuristicBest(ISeq values) { return 0; } @@ -21,7 +21,7 @@ public class CPGeneticWrapperA extends ACPGeneticWrapper { } @Override - public double calculateUtility(ISeq genes) { + public double calculateUtility(ISeq genes) { double res = 0.; List list = genesToIntegerList(genes); for (int i = 0; i < list.size() - 1; i+=2) @@ -30,7 +30,7 @@ public class CPGeneticWrapperA extends ACPGeneticWrapper { } @Override - public int countViolatedConstraints(ISeq genes) { + public int countViolatedConstraints(ISeq genes) { return 0; } @@ -40,7 +40,7 @@ public class CPGeneticWrapperA extends ACPGeneticWrapper { } @Override - public boolean getIsFeasible(ISeq genes) { + public boolean getIsFeasible(ISeq genes) { return true; } -- GitLab From a07a16f787436e47e45000224440a5b11c349ad5 Mon Sep 17 00:00:00 2001 From: Michal Jankowski Date: Thu, 9 Jan 2020 01:24:46 +0100 Subject: [PATCH 061/340] Small fixes in many classes (deleting unused imports etc.). Fixed Selector so that it is now used. Changed the way heuristic mutator mutates chromosome - it now does it deterministically. Tests should be verified and fixed as some of them don't do much. --- zpp-solver/genetic-solver/pom.xml | 13 +- .../main/java/GeneticSolverCoordinator.java | 22 +++- .../cPGeneticWrapper/ACPGeneticWrapper.java | 24 ++-- .../cPGeneticWrapper/CPGeneticWrapper.java | 10 +- .../StochasticRankingComparator.java | 8 +- .../java/implementation/EvalFunction.java | 6 +- .../java/implementation/ImplChromosome.java | 48 +++---- .../main/java/implementation/ImplGene.java | 26 ++-- .../main/java/implementation/ImplMutator.java | 87 ++++++++----- .../java/implementation/ImplSelector.java | 5 +- .../java/GeneticSolverCoordinatorTest.java | 14 +-- .../src/test/java/GeneticWrapperTest.java | 89 +------------ .../src/test/java/ImplGeneTest.java | 21 ++-- .../java/StochasticRankingComparatorTest.java | 117 +++++------------- .../test/java/utility/CPGeneticWrapperA.java | 2 + .../src/test/java/utility/Methods.java | 93 ++++++++++++++ 16 files changed, 284 insertions(+), 301 deletions(-) create mode 100644 zpp-solver/genetic-solver/src/test/java/utility/Methods.java diff --git a/zpp-solver/genetic-solver/pom.xml b/zpp-solver/genetic-solver/pom.xml index 59e97f7aa..db4d996e7 100644 --- a/zpp-solver/genetic-solver/pom.xml +++ b/zpp-solver/genetic-solver/pom.xml @@ -16,17 +16,6 @@ io.jenetics jenetics 5.1.0 - test - - - io.jenetics - jenetics - 5.1.0 - compile - - - org.ow2.paasage - upperware-metamodel eu.melodic @@ -46,7 +35,7 @@ 3.0.0-SNAPSHOT test-jar test - + \ No newline at end of file diff --git a/zpp-solver/genetic-solver/src/main/java/GeneticSolverCoordinator.java b/zpp-solver/genetic-solver/src/main/java/GeneticSolverCoordinator.java index c4ad44821..0656e622a 100644 --- a/zpp-solver/genetic-solver/src/main/java/GeneticSolverCoordinator.java +++ b/zpp-solver/genetic-solver/src/main/java/GeneticSolverCoordinator.java @@ -2,6 +2,8 @@ import comparators.StochasticRankingComparator; import cPGeneticWrapper.ACPGeneticWrapper; import cPGeneticWrapper.CPGeneticWrapper; import cp_wrapper.CPWrapper; +import cp_wrapper.UtilityProvider; +import eu.paasage.upperware.metamodel.cp.ConstraintProblem; import implementation.*; import io.jenetics.*; import io.jenetics.engine.Engine; @@ -12,7 +14,7 @@ import lombok.Setter; import java.util.List; import java.util.function.Function; -public class Runner { +public class GeneticSolverCoordinator { @Setter private Integer populationSize = 100; @Setter @@ -27,6 +29,19 @@ public class Runner { private final Function, Double> fitnessFunction = new EvalFunction(); + public List run(ConstraintProblem cp, UtilityProvider utility) { + CPWrapper cpWrapper = new CPWrapper(); + cpWrapper.parse(cp, utility); + + return run(cpWrapper); + } + + public List run(CPWrapper cpWrapper) { + ACPGeneticWrapper cpGeneticWrapper = new CPGeneticWrapper(cpWrapper); + + return run(cpGeneticWrapper); + } + public List run(ACPGeneticWrapper geneticWrapper) { Alterer crossoverAlterer = new SinglePointCrossover<>(crossoverProbability); Mutator mutator = new ImplMutator(mutatorProbability, geneticWrapper); @@ -44,9 +59,4 @@ public class Runner { return ACPGeneticWrapper.genotypeToIntegerList(engine.stream().limit(iterations).collect(EvolutionResult.toBestGenotype())); } - public List run(CPWrapper cpWrapper) { - ACPGeneticWrapper cpGeneticWrapper = new CPGeneticWrapper(cpWrapper); - - return run(cpGeneticWrapper); - } } diff --git a/zpp-solver/genetic-solver/src/main/java/cPGeneticWrapper/ACPGeneticWrapper.java b/zpp-solver/genetic-solver/src/main/java/cPGeneticWrapper/ACPGeneticWrapper.java index 6320583df..33ab43a36 100644 --- a/zpp-solver/genetic-solver/src/main/java/cPGeneticWrapper/ACPGeneticWrapper.java +++ b/zpp-solver/genetic-solver/src/main/java/cPGeneticWrapper/ACPGeneticWrapper.java @@ -1,8 +1,8 @@ package cPGeneticWrapper; import cp_wrapper.CPWrapper; -import implementation.OurChromosome; -import implementation.OurGene; +import implementation.ImplChromosome; +import implementation.ImplGene; import io.jenetics.Genotype; import io.jenetics.Phenotype; import io.jenetics.util.ISeq; @@ -19,38 +19,38 @@ public abstract class ACPGeneticWrapper { protected CPWrapper cpWrapper; // Calculates which variable has highest heuristic value. Returns its index. - public abstract int calculateHeuristicBest(ISeq values); + public abstract int calculateHeuristicBest(ISeq values); // Generates random value for variable indexed with index. public abstract int generateRandomValue(int index); - public abstract double calculateUtility(ISeq genes); + public abstract double calculateUtility(ISeq genes); - public abstract int countViolatedConstraints(ISeq genes); + public abstract int countViolatedConstraints(ISeq genes); public abstract boolean isValid(int value, int index); - public abstract boolean getIsFeasible(ISeq genes); + public abstract boolean getIsFeasible(ISeq genes); public abstract int getSize(); - public static List phenotypeToIntegerList(Phenotype phenotype) { + public static List phenotypeToIntegerList(Phenotype phenotype) { return genotypeToIntegerList(phenotype.getGenotype()); } - public static List genotypeToIntegerList(Genotype genotype) { - return chromosomeToIntegerList((OurChromosome) genotype.getChromosome()); + public static List genotypeToIntegerList(Genotype genotype) { + return chromosomeToIntegerList((ImplChromosome) genotype.getChromosome()); } - private static List chromosomeToIntegerList(OurChromosome chromosome) { + private static List chromosomeToIntegerList(ImplChromosome chromosome) { return genesToIntegerList(chromosome.toSeq()); } - protected static List genesToIntegerList(ISeq genes) { + protected static List genesToIntegerList(ISeq genes) { List list = new ArrayList<>(); - for (OurGene gene : genes) + for (ImplGene gene : genes) list.add(gene.getAllele()); return list; diff --git a/zpp-solver/genetic-solver/src/main/java/cPGeneticWrapper/CPGeneticWrapper.java b/zpp-solver/genetic-solver/src/main/java/cPGeneticWrapper/CPGeneticWrapper.java index 0ff24a2b2..c25ff4a7f 100644 --- a/zpp-solver/genetic-solver/src/main/java/cPGeneticWrapper/CPGeneticWrapper.java +++ b/zpp-solver/genetic-solver/src/main/java/cPGeneticWrapper/CPGeneticWrapper.java @@ -1,7 +1,7 @@ package cPGeneticWrapper; import cp_wrapper.CPWrapper; -import implementation.OurGene; +import implementation.ImplGene; import io.jenetics.util.ISeq; import java.util.List; @@ -15,7 +15,7 @@ public class CPGeneticWrapper extends ACPGeneticWrapper { // Calculates which variable has highest heuristic value. Returns its index. // TODO probably need to calculate it in other way - to get faster exec time (or maybe getHeuristicEvaluation is fast enough) @Override - public int calculateHeuristicBest(ISeq genes) { + public int calculateHeuristicBest(ISeq genes) { int bestIndex = -1, bestValue = 0, tmp; List values = genesToIntegerList(genes); @@ -39,12 +39,12 @@ public class CPGeneticWrapper extends ACPGeneticWrapper { } @Override - public double calculateUtility(ISeq genes) { + public double calculateUtility(ISeq genes) { return cpWrapper.getUtility(genesToIntegerList(genes)); } @Override - public int countViolatedConstraints(ISeq genes) { + public int countViolatedConstraints(ISeq genes) { return cpWrapper.countViolatedConstraints(genesToIntegerList(genes)); } @@ -54,7 +54,7 @@ public class CPGeneticWrapper extends ACPGeneticWrapper { } @Override - public boolean getIsFeasible(ISeq genes) { + public boolean getIsFeasible(ISeq genes) { return cpWrapper.checkIfFeasible(genesToIntegerList(genes)); } diff --git a/zpp-solver/genetic-solver/src/main/java/comparators/StochasticRankingComparator.java b/zpp-solver/genetic-solver/src/main/java/comparators/StochasticRankingComparator.java index 40d51bd72..8ac19f933 100644 --- a/zpp-solver/genetic-solver/src/main/java/comparators/StochasticRankingComparator.java +++ b/zpp-solver/genetic-solver/src/main/java/comparators/StochasticRankingComparator.java @@ -1,5 +1,7 @@ -package implementation; +package comparators; +import implementation.ImplChromosome; +import implementation.ImplGene; import io.jenetics.Phenotype; import io.jenetics.util.RandomRegistry; import lombok.AllArgsConstructor; @@ -14,8 +16,8 @@ public class StochasticRankingComparator implements Comparator left, Phenotype right) { - double leftUtility, rightUtility; - int leftBroken, rightBroken; + double leftUtility, rightUtility; // Utility value. + int leftBroken, rightBroken; // Number of broken constraints. ImplChromosome l = (ImplChromosome) left.getGenotype().getChromosome(); ImplChromosome r = (ImplChromosome) right.getGenotype().getChromosome(); diff --git a/zpp-solver/genetic-solver/src/main/java/implementation/EvalFunction.java b/zpp-solver/genetic-solver/src/main/java/implementation/EvalFunction.java index 617fb5b61..9fb2c0854 100644 --- a/zpp-solver/genetic-solver/src/main/java/implementation/EvalFunction.java +++ b/zpp-solver/genetic-solver/src/main/java/implementation/EvalFunction.java @@ -4,9 +4,9 @@ import io.jenetics.Genotype; import java.util.function.Function; -public class EvalFunction implements Function, Double> { +public class EvalFunction implements Function, Double> { @Override - public Double apply(Genotype chromosomes) { - return ((OurChromosome) chromosomes.getChromosome()).getUtility(); + public Double apply(Genotype chromosomes) { + return ((ImplChromosome) chromosomes.getChromosome()).getUtility(); } } diff --git a/zpp-solver/genetic-solver/src/main/java/implementation/ImplChromosome.java b/zpp-solver/genetic-solver/src/main/java/implementation/ImplChromosome.java index 3107dca3a..4948f6fa9 100644 --- a/zpp-solver/genetic-solver/src/main/java/implementation/ImplChromosome.java +++ b/zpp-solver/genetic-solver/src/main/java/implementation/ImplChromosome.java @@ -6,10 +6,13 @@ import io.jenetics.util.ISeq; import io.jenetics.util.MSeq; import lombok.Getter; - -public class OurChromosome implements Chromosome { +/* + Chromosome is a population's individual. Phenotype and Genotype are just it's wrappers. + Chromosome consists of sequence of genes. + */ +public class ImplChromosome implements Chromosome { @Getter - private ISeq genes; + private ISeq genes; private Integer length; @Getter private boolean isFeasible; @@ -17,26 +20,24 @@ public class OurChromosome implements Chromosome { private double utility; @Getter private int brokenConstraints; - private Boolean valid; private ACPGeneticWrapper cpGeneticWrapper; - public OurChromosome(ISeq genes, Integer length, ACPGeneticWrapper cpGeneticWrapper) { + public ImplChromosome(ISeq genes, Integer length, ACPGeneticWrapper cpGeneticWrapper) { this.genes = genes; this.length = length; this.cpGeneticWrapper = cpGeneticWrapper; - this.isFeasible = cpGeneticWrapper.getIsFeasible(genes); this.utility = cpGeneticWrapper.calculateUtility(genes); this.brokenConstraints = cpGeneticWrapper.countViolatedConstraints(genes); - this.valid = checkIfValid(genes); + this.isFeasible = (brokenConstraints == 0); } @Override - public Chromosome newInstance(ISeq iSeq) { - return new OurChromosome(iSeq, iSeq.length(), cpGeneticWrapper); + public Chromosome newInstance(ISeq iSeq) { + return new ImplChromosome(iSeq, iSeq.length(), cpGeneticWrapper); } @Override - public OurGene getGene(int i) { + public ImplGene getGene(int i) { return genes.get(i); } @@ -46,45 +47,34 @@ public class OurChromosome implements Chromosome { } @Override - public ISeq toSeq() { + public ISeq toSeq() { return genes; } @Override - public Chromosome newInstance() { + public Chromosome newInstance() { return of(length); } @Override public boolean isValid() { - return valid; - } - - private boolean checkIfValid(ISeq genes) { - for (OurGene gene : genes) - if (!gene.isValid()) - return false; return true; } // Creates randomly generated Chromosome. - public OurChromosome of(Integer length) { + public ImplChromosome of(Integer length) { return of(length, cpGeneticWrapper); } // Creates randomly generated Chromosome. Static version of above method. - public static OurChromosome of(Integer length, ACPGeneticWrapper cpGeneticWrapper) { - ISeq genes = OurGene.seq(length, cpGeneticWrapper); - return new OurChromosome(genes, length, cpGeneticWrapper); + public static ImplChromosome of(Integer length, ACPGeneticWrapper cpGeneticWrapper) { + ISeq genes = ImplGene.seq(length, cpGeneticWrapper); + return new ImplChromosome(genes, length, cpGeneticWrapper); } // Creates randomly generated sequence of Chromosomes. - public ISeq of(Integer length, Integer size) { - return of(length, size, cpGeneticWrapper); - } - - public static ISeq of(Integer length, Integer size, ACPGeneticWrapper cpGeneticWrapper) { - return MSeq.ofLength(length) + public static ISeq of(Integer length, Integer size, ACPGeneticWrapper cpGeneticWrapper) { + return MSeq.ofLength(length) .fill(() -> of(size, cpGeneticWrapper)) .toISeq(); } diff --git a/zpp-solver/genetic-solver/src/main/java/implementation/ImplGene.java b/zpp-solver/genetic-solver/src/main/java/implementation/ImplGene.java index dac0623d8..78a88740a 100644 --- a/zpp-solver/genetic-solver/src/main/java/implementation/ImplGene.java +++ b/zpp-solver/genetic-solver/src/main/java/implementation/ImplGene.java @@ -8,8 +8,12 @@ import lombok.AllArgsConstructor; import java.util.ArrayList; import java.util.List; +/* + ImplGene is a representation of variable assignment. It contains either index (for list defined variables) or + value (for range defined variables). It can produce other genes. + */ @AllArgsConstructor -public class OurGene implements Gene { +public class ImplGene implements Gene { private Integer value; private Integer index; private ACPGeneticWrapper cpGeneticWrapper; @@ -20,33 +24,33 @@ public class OurGene implements Gene { } @Override - public OurGene newInstance() { + public ImplGene newInstance() { return of(index); } @Override - public OurGene newInstance(Integer k) { - return new OurGene(k, index, cpGeneticWrapper); + public ImplGene newInstance(Integer k) { + return new ImplGene(k, index, cpGeneticWrapper); } @Override public boolean isValid() { - return cpGeneticWrapper.isValid(value, index); + return true; } - private OurGene of(Integer index) { - return new OurGene(cpGeneticWrapper.generateRandomValue(index), index, cpGeneticWrapper); + private ImplGene of(Integer index) { + return new ImplGene(cpGeneticWrapper.generateRandomValue(index), index, cpGeneticWrapper); } - public ISeq seq(Integer length) { + public ISeq seq(Integer length) { return seq(length, cpGeneticWrapper); } - public static ISeq seq(Integer length, ACPGeneticWrapper cpGeneticWrapper) { - List list = new ArrayList<>(); + public static ISeq seq(Integer length, ACPGeneticWrapper cpGeneticWrapper) { + List list = new ArrayList<>(); for (int i = 0; i < length; i++) - list.add(new OurGene(cpGeneticWrapper.generateRandomValue(i), i, cpGeneticWrapper)); + list.add(new ImplGene(cpGeneticWrapper.generateRandomValue(i), i, cpGeneticWrapper)); return ISeq.of(list); } } \ No newline at end of file diff --git a/zpp-solver/genetic-solver/src/main/java/implementation/ImplMutator.java b/zpp-solver/genetic-solver/src/main/java/implementation/ImplMutator.java index 331d7cde5..4b4241ad2 100644 --- a/zpp-solver/genetic-solver/src/main/java/implementation/ImplMutator.java +++ b/zpp-solver/genetic-solver/src/main/java/implementation/ImplMutator.java @@ -5,55 +5,84 @@ import io.jenetics.Chromosome; import io.jenetics.Mutator; import io.jenetics.MutatorResult; import io.jenetics.util.ISeq; -import lombok.Getter; import java.util.Random; -public class OurMutator extends Mutator { - @Getter - private int guesses; +/* + Mutator mutates chromosome by changing it's genes values. + When chromosome breaks some constraint heuristic approach is used. + */ +public class ImplMutator extends Mutator { private ACPGeneticWrapper geneticWrapper; - public OurMutator(int guesses, ACPGeneticWrapper geneticWrapper) { - super(); - this.guesses = guesses; - this.geneticWrapper = geneticWrapper; - } - - public OurMutator(double probability, int guesses, ACPGeneticWrapper geneticWrapper) { + public ImplMutator(double probability, ACPGeneticWrapper geneticWrapper) { super(probability); - this.guesses = guesses; this.geneticWrapper = geneticWrapper; } @Override - protected MutatorResult> mutate( - final Chromosome chromosome, + protected MutatorResult> mutate( + final Chromosome chromosome, final double p, final Random random) { - if (((OurChromosome) chromosome).getBrokenConstraints() == 0) + // No broken constraints -> mutate normally. + if (((ImplChromosome) chromosome).getBrokenConstraints() == 0) return super.mutate(chromosome, p, random); - ISeq genes = chromosome.toSeq(); + // There are broken constraints mutate variable that breaks most constraints. + ISeq genes = chromosome.toSeq(); int index = geneticWrapper.calculateHeuristicBest(genes); + int currentValue, initValue, bestValue = genes.get(index).getAllele(); + double currentUtility, bestUtility = ((ImplChromosome) chromosome).getUtility(); + + + initValue = bestValue; + currentValue = initValue; + + /* We're going to check whether we should be decreasing or increasing value in order to get better result. */ + double increasedUtility = -1, decreasedUtility = -1; + int direction = 0; + currentValue--; + if (geneticWrapper.isValid(currentValue, index)) { + genes.asMSeq().set(index, genes.get(index).newInstance(currentValue)); + decreasedUtility = geneticWrapper.calculateUtility(genes); + } + currentValue += 2; + if (geneticWrapper.isValid(currentValue, index)) { + genes.asMSeq().set(index, genes.get(index).newInstance(currentValue)); + increasedUtility = geneticWrapper.calculateUtility(genes); + } + + if (increasedUtility > bestUtility && increasedUtility > decreasedUtility) + direction = 1; + else if (decreasedUtility > bestUtility) + direction = -1; + + /* Increase gene's values as long as utility increases. */ + while (direction != 0) { + currentValue += direction; + + if (geneticWrapper.isValid(currentValue, index)) { + genes.asMSeq().set(index, genes.get(index).newInstance(currentValue)); + currentUtility = geneticWrapper.calculateUtility(genes); + if (currentUtility > bestUtility) { + bestValue = currentValue; + bestUtility = currentUtility; + } + else + // Utility no longer increases -> break from while. + direction = 0; - /* This is probably dumb but we're gonna generate random values for this variable some number of times - and see which value is the best. - */ - int best = genes.get(index).getAllele(); - double bestUtility = ((OurChromosome) chromosome).getUtility(); - for (int i = 0; i < guesses; i++) { - genes.asMSeq().set(index, genes.get(index).newInstance()); - double tmp = geneticWrapper.calculateUtility(genes); - if (tmp > bestUtility) { - best = genes.get(index).getAllele(); - bestUtility = tmp; } + else + // Value no longer valid -> break from while. + direction = 0; } - genes.asMSeq().set(index, genes.get(index).newInstance(best)); + // Modify chromosome using best value. + genes.asMSeq().set(index, genes.get(index).newInstance(bestValue)); - return MutatorResult.of(new OurChromosome(genes, genes.length(), geneticWrapper)); + return MutatorResult.of(new ImplChromosome(genes, genes.length(), geneticWrapper)); } } diff --git a/zpp-solver/genetic-solver/src/main/java/implementation/ImplSelector.java b/zpp-solver/genetic-solver/src/main/java/implementation/ImplSelector.java index 5619156f6..d893bf0e9 100644 --- a/zpp-solver/genetic-solver/src/main/java/implementation/ImplSelector.java +++ b/zpp-solver/genetic-solver/src/main/java/implementation/ImplSelector.java @@ -12,8 +12,11 @@ import java.util.Comparator; import static java.util.Collections.reverseOrder; +/* + Important part of this selector is that it can use custom comparators. + */ @AllArgsConstructor -public class OurSelector implements Selector { +public class ImplSelector implements Selector { private Comparator> comparator; @Override diff --git a/zpp-solver/genetic-solver/src/test/java/GeneticSolverCoordinatorTest.java b/zpp-solver/genetic-solver/src/test/java/GeneticSolverCoordinatorTest.java index 1790f48e9..f63819857 100644 --- a/zpp-solver/genetic-solver/src/test/java/GeneticSolverCoordinatorTest.java +++ b/zpp-solver/genetic-solver/src/test/java/GeneticSolverCoordinatorTest.java @@ -10,7 +10,7 @@ import java.util.Map; import static org.junit.Assert.assertEquals; -public class RunnerTest { +public class GeneticSolverCoordinatorTest { @Test public void SimpleTestGeneratedByTomek() { @@ -18,13 +18,13 @@ public class RunnerTest { CPWrapper cpWrapper = new CPWrapper(); cpWrapper.parse(problem.keySet().iterator().next(), problem.values().iterator().next()); - Runner runner = new Runner(); - runner.setMutatorProbability(0.2); - runner.setPopulationSize(10); - runner.setIterations(1000); - runner.setComparatorProbability(0.1); + GeneticSolverCoordinator geneticSolverCoordinator = new GeneticSolverCoordinator(); + geneticSolverCoordinator.setMutatorProbability(0.2); + geneticSolverCoordinator.setPopulationSize(10); + geneticSolverCoordinator.setIterations(1000); + geneticSolverCoordinator.setComparatorProbability(0.1); - List assignment = runner.run(cpWrapper); + List assignment = geneticSolverCoordinator.run(cpWrapper); List domain1 = Arrays.asList(1.0,2.0,3.0,4.0,5.0); diff --git a/zpp-solver/genetic-solver/src/test/java/GeneticWrapperTest.java b/zpp-solver/genetic-solver/src/test/java/GeneticWrapperTest.java index 790f0dfdc..e5290e6d3 100644 --- a/zpp-solver/genetic-solver/src/test/java/GeneticWrapperTest.java +++ b/zpp-solver/genetic-solver/src/test/java/GeneticWrapperTest.java @@ -2,101 +2,20 @@ import cPGeneticWrapper.ACPGeneticWrapper; import cPGeneticWrapper.CPGeneticWrapper; import cp_wrapper.CPWrapper; import cp_wrapper.UtilityProvider; -import cp_wrapper.mockups.*; -import eu.melodic.upperware.utilitygenerator.cdo.cp_model.DTO.VariableValueDTO; import eu.paasage.upperware.metamodel.cp.*; -import eu.paasage.upperware.metamodel.types.BasicTypeEnum; -import org.eclipse.emf.common.util.BasicEList; -import org.eclipse.emf.common.util.EList; + import org.junit.Test; +import utility.Methods; + -import java.util.Arrays; -import java.util.Collections; -import java.util.List; import java.util.Map; public class GeneticWrapperTest { - // Copied problem from PTSolver. - public static Map prepareSimpleConstraintProblem() { - /* - @var1 in {1,2,3,4,5} - @var2 in {0.5, 1.5, 2.5} - @var3 in {0,...,9} - @const1 = 3 - - @constraint1 : @var1 < @var3 - - @constraint2 : @var1 * @var2 * @var3 >= @const1; - - @constraint3: @var1 * @var2 >= @var3 - - @constraint4: @var3 == @var3 - */ - - List variables = Arrays.asList("var1", "var2", "var3", "var4", "var5", "var6", "var7", "var8"); - EList vars = new BasicEList<>(); - for (int i= 0; i < 3; i++) vars.add(new CpVariableImplMockup(variables.get(i), VariableType.CARDINALITY)); - RangeDomainImpMockup dom1 = new RangeDomainImpMockup(); - RangeDomainImpMockup dom3 = new RangeDomainImpMockup(); - dom1.setFrom(1);dom3.setFrom(0);dom1.setTo(5);dom3.setTo(9); - NumericListDomainImplMockup dom2 = new NumericListDomainImplMockup(); - dom2.setValues(Arrays.asList(0.5, 1.5, 2.5)); - List domains = Arrays.asList(new Domain[] {dom1, dom2, dom3}); - for (int i = 0; i <3 ; i++ ){ - vars.get(i).setDomain(domains.get(i)); - } - - Constant c = new ConstantImplMockup(BasicTypeEnum.DOUBLE, new NumericValueUpperwareImplMockup(3)); - - EList exprs = new BasicEList<>(); - exprs.add(vars.get(0)); exprs.add(vars.get(1)); - NumericExpression times = new ComposedExpressionImplMockup(exprs, OperatorEnum.TIMES); - ComparisonExpressionMockup constraint1 = new ComparisonExpressionMockup(); - constraint1.setExp1(vars.get(0));constraint1.setExp2(vars.get(2)); - constraint1.setComparator(ComparatorEnum.LESS_THAN); - - ComparisonExpressionMockup constraint3 = new ComparisonExpressionMockup(); - constraint3.setExp1(times);constraint3.setExp2(vars.get(2)); - constraint3.setComparator(ComparatorEnum.GREATER_OR_EQUAL_TO); - - exprs.add(vars.get(2)); - ComparisonExpressionMockup constraint2 = new ComparisonExpressionMockup(); - times = new ComposedExpressionImplMockup(exprs, OperatorEnum.TIMES); - constraint2.setExp1(times);constraint2.setExp2(c); - constraint2.setComparator(ComparatorEnum.GREATER_OR_EQUAL_TO); - - ComparisonExpressionMockup constraint4 = new ComparisonExpressionMockup(); - constraint4.setExp1(vars.get(2));constraint4.setExp2(vars.get(2)); - constraint4.setComparator(ComparatorEnum.EQUAL_TO); - - EList consts = new BasicEList<>(); - consts.add(c); - - EList varsE = new BasicEList<>(); - for (int i = 0; i < 3; i++) varsE.add(vars.get(i)); - - EList constraints = new BasicEList<>(); - constraints.addAll(Arrays.asList(constraint1, constraint2, constraint3, constraint4)); - - ConstraintProblem cp = new ConstraintProblemMockup(consts,null, varsE, constraints ); - return Collections.singletonMap(cp, result -> { - double sum = 0; - for (VariableValueDTO v : result) { - if (v.getValue() instanceof Double) { - sum += v.getValue().doubleValue(); - } else { - sum += v.getValue().intValue(); - } - } - return sum; - }); - } - @Test public void testConstructorAndGetters() { // TODO - Map problem = GeneticWrapperTest.prepareSimpleConstraintProblem(); + Map problem = Methods.prepareSimpleConstraintProblem(); CPWrapper cpWrapper = new CPWrapper(); cpWrapper.parse(problem.keySet().iterator().next(), problem.values().iterator().next()); diff --git a/zpp-solver/genetic-solver/src/test/java/ImplGeneTest.java b/zpp-solver/genetic-solver/src/test/java/ImplGeneTest.java index 282c0e936..8528e8f79 100644 --- a/zpp-solver/genetic-solver/src/test/java/ImplGeneTest.java +++ b/zpp-solver/genetic-solver/src/test/java/ImplGeneTest.java @@ -1,26 +1,27 @@ -import implementation.OurGene; -import io.jenetics.Gene; +import implementation.ImplGene; import io.jenetics.util.Seq; import org.junit.Test; +import utility.CPGeneticWrapperA; + import static org.junit.Assert.*; -public class OurGeneTest { +public class ImplGeneTest { @Test public void constructorAndGettersTest() { - OurGene gene = new OurGene(1, 0, null); + ImplGene gene = new ImplGene(1, 0, null); assertEquals(gene.getAllele(), (Integer) 1); - OurGene gen = new OurGene(2333, 13, null); + ImplGene gen = new ImplGene(2333, 13, null); assertEquals(gen.getAllele(), (Integer) 2333); } @Test public void newInstanceGeneTest() { - OurGene gene = new OurGene(1, 0, new CPGeneticWrapperA(null)); + ImplGene gene = new ImplGene(1, 0, new CPGeneticWrapperA(null)); System.out.println("What follows should be a list of randomly generated genes with value in <0, 1000>"); @@ -31,17 +32,17 @@ public class OurGeneTest { @Test public void newInstanceFromValueTest() { - OurGene gene = new OurGene(1, 0, new CPGeneticWrapperA(null)); + ImplGene gene = new ImplGene(1, 0, new CPGeneticWrapperA(null)); - OurGene newGeneFromValue = gene.newInstance(5); + ImplGene newGeneFromValue = gene.newInstance(5); assertEquals(newGeneFromValue.getAllele(), (Integer) 5); } @Test public void checkSeqMethodWithGivenWrapperTest() { System.out.println("What follows should be a list of 10 randomly generated genes with values in <0, 1000>"); - Seq s = OurGene.seq(10, new CPGeneticWrapperA(null)); - for (OurGene gene : s) + Seq s = ImplGene.seq(10, new CPGeneticWrapperA(null)); + for (ImplGene gene : s) System.out.print(gene.getAllele() + " "); System.out.println(); } diff --git a/zpp-solver/genetic-solver/src/test/java/StochasticRankingComparatorTest.java b/zpp-solver/genetic-solver/src/test/java/StochasticRankingComparatorTest.java index 24a2f7af3..98f100cd1 100644 --- a/zpp-solver/genetic-solver/src/test/java/StochasticRankingComparatorTest.java +++ b/zpp-solver/genetic-solver/src/test/java/StochasticRankingComparatorTest.java @@ -1,17 +1,15 @@ import cPGeneticWrapper.ACPGeneticWrapper; import implementation.EvalFunction; -import implementation.OurChromosome; -import implementation.OurGene; -import implementation.StochasticRankingComparator; +import implementation.ImplChromosome; +import implementation.ImplGene; +import comparators.StochasticRankingComparator; import io.jenetics.Genotype; import io.jenetics.Phenotype; -import io.jenetics.util.ISeq; import io.jenetics.util.MSeq; -import io.jenetics.util.Seq; import org.junit.Test; +import utility.CPGeneticWrapperA; import java.util.ArrayList; -import java.util.Arrays; import java.util.Comparator; import java.util.List; import java.util.function.Function; @@ -20,38 +18,27 @@ import static java.util.Collections.reverseOrder; import static org.junit.Assert.assertEquals; public class StochasticRankingComparatorTest { - //TODO ITS A MESS @Test public void checkComparatorWithoutRandomnessAndBrokenConstraints() { - Comparator> comparator = new StochasticRankingComparator(0); + Comparator> comparator = new StochasticRankingComparator(0); ACPGeneticWrapper geneticWrapper = new CPGeneticWrapperA(null); - OurGene[] g = new OurGene[8]; + ImplGene[] g = new ImplGene[8]; - g[0] = new OurGene(0, 0, geneticWrapper); - g[1] = new OurGene(0, 1, geneticWrapper); - g[2] = new OurGene(0, 2, geneticWrapper); - g[3] = new OurGene(0, 3, geneticWrapper); - g[4] = new OurGene(1, 0, geneticWrapper); - g[5] = new OurGene(1, 1, geneticWrapper); - g[6] = new OurGene(1, 2, geneticWrapper); - g[7] = new OurGene(1, 3, geneticWrapper); + g[0] = new ImplGene(0, 0, geneticWrapper); + g[1] = new ImplGene(0, 1, geneticWrapper); + g[2] = new ImplGene(0, 2, geneticWrapper); + g[3] = new ImplGene(0, 3, geneticWrapper); + g[4] = new ImplGene(1, 0, geneticWrapper); + g[5] = new ImplGene(1, 1, geneticWrapper); + g[6] = new ImplGene(1, 2, geneticWrapper); + g[7] = new ImplGene(1, 3, geneticWrapper); - - List l1 = new ArrayList<>(Arrays.asList(g).subList(0, 4)); - List l2 = new ArrayList<>(Arrays.asList(g).subList(0, 3)); - List l3 = new ArrayList<>(Arrays.asList(g).subList(0, 2)); - List l4 = new ArrayList<>(Arrays.asList(g).subList(0, 1)); - List l5 = new ArrayList<>(Arrays.asList(g).subList(4, 8)); - List l6 = new ArrayList<>(Arrays.asList(g).subList(4, 7)); - List l7 = new ArrayList<>(Arrays.asList(g).subList(4, 6)); - List l8 = new ArrayList<>(Arrays.asList(g).subList(4, 5)); - - List lq1 = new ArrayList<>(); - List lq2 = new ArrayList<>(); - List lq3 = new ArrayList<>(); - List lq4 = new ArrayList<>(); - List lq5 = new ArrayList<>(); + List lq1 = new ArrayList<>(); + List lq2 = new ArrayList<>(); + List lq3 = new ArrayList<>(); + List lq4 = new ArrayList<>(); + List lq5 = new ArrayList<>(); // Best list with fitness 2. @@ -66,43 +53,13 @@ public class StochasticRankingComparatorTest { lq5.add(g[0]); lq5.add(g[5]); lq5.add(g[2]); lq5.add(g[7]); - l2.add(g[7]); - l3.add(g[6]); - l3.add(g[7]); - l4.add(g[5]); - l4.add(g[6]); - l4.add(g[7]); - l6.add(g[3]); - l7.add(g[2]); - l7.add(g[3]); - l8.add(g[1]); - l8.add(g[2]); - l8.add(g[3]); - - Phenotype p1 = Phenotype.of(Genotype.of(new OurChromosome(MSeq.of(l1).toISeq(), 4, geneticWrapper)), 0); - Phenotype p2 = Phenotype.of(Genotype.of(new OurChromosome(MSeq.of(l2).toISeq(), 4, geneticWrapper)), 0); - Phenotype p3 = Phenotype.of(Genotype.of(new OurChromosome(MSeq.of(l3).toISeq(), 4, geneticWrapper)), 0); - Phenotype p4 = Phenotype.of(Genotype.of(new OurChromosome(MSeq.of(l4).toISeq(), 4, geneticWrapper)), 0); - Phenotype p5 = Phenotype.of(Genotype.of(new OurChromosome(MSeq.of(l5).toISeq(), 4, geneticWrapper)), 0); - Phenotype p6 = Phenotype.of(Genotype.of(new OurChromosome(MSeq.of(l6).toISeq(), 4, geneticWrapper)), 0); - Phenotype p7 = Phenotype.of(Genotype.of(new OurChromosome(MSeq.of(l7).toISeq(), 4, geneticWrapper)), 0); - Phenotype p8 = Phenotype.of(Genotype.of(new OurChromosome(MSeq.of(l8).toISeq(), 4, geneticWrapper)), 0); - - Phenotype pq1 = Phenotype.of(Genotype.of(new OurChromosome(MSeq.of(lq1).toISeq(), 4, geneticWrapper)), 0); - Phenotype pq2 = Phenotype.of(Genotype.of(new OurChromosome(MSeq.of(lq2).toISeq(), 4, geneticWrapper)), 0); - Phenotype pq3 = Phenotype.of(Genotype.of(new OurChromosome(MSeq.of(lq3).toISeq(), 4, geneticWrapper)), 0); - Phenotype pq4 = Phenotype.of(Genotype.of(new OurChromosome(MSeq.of(lq4).toISeq(), 4, geneticWrapper)), 0); - Phenotype pq5 = Phenotype.of(Genotype.of(new OurChromosome(MSeq.of(lq5).toISeq(), 4, geneticWrapper)), 0); - - Function, Double> fun = new EvalFunction(); - p1 = p1.eval(fun); - p2 = p2.eval(fun); - p3 = p3.eval(fun); - p4 = p4.eval(fun); - p5 = p5.eval(fun); - p6 = p6.eval(fun); - p7 = p7.eval(fun); - p8 = p8.eval(fun); + Phenotype pq1 = Phenotype.of(Genotype.of(new ImplChromosome(MSeq.of(lq1).toISeq(), 4, geneticWrapper)), 0); + Phenotype pq2 = Phenotype.of(Genotype.of(new ImplChromosome(MSeq.of(lq2).toISeq(), 4, geneticWrapper)), 0); + Phenotype pq3 = Phenotype.of(Genotype.of(new ImplChromosome(MSeq.of(lq3).toISeq(), 4, geneticWrapper)), 0); + Phenotype pq4 = Phenotype.of(Genotype.of(new ImplChromosome(MSeq.of(lq4).toISeq(), 4, geneticWrapper)), 0); + Phenotype pq5 = Phenotype.of(Genotype.of(new ImplChromosome(MSeq.of(lq5).toISeq(), 4, geneticWrapper)), 0); + + Function, Double> fun = new EvalFunction(); pq1 = pq1.eval(fun); pq2 = pq2.eval(fun); @@ -110,17 +67,8 @@ public class StochasticRankingComparatorTest { pq4 = pq4.eval(fun); pq5 = pq5.eval(fun); - List> pop = new ArrayList<>(); - pop.add(p1); - pop.add(p2); - pop.add(p3); - pop.add(p4); - pop.add(p5); - pop.add(p6); - pop.add(p7); - pop.add(p8); - - List> popq = new ArrayList<>(); + + List> popq = new ArrayList<>(); popq.add(pq4); popq.add(pq2); popq.add(pq3); @@ -128,17 +76,10 @@ public class StochasticRankingComparatorTest { popq.add(pq5); - MSeq> population = MSeq.of(pop); - MSeq> populationq = MSeq.of(popq); + MSeq> populationq = MSeq.of(popq); - population.sort(reverseOrder(comparator)); populationq.sort(reverseOrder(comparator)); - for (Phenotype phen : population) { - for (OurGene gene : phen.getGenotype().getChromosome().toSeq()) - System.out.print(gene.getAllele() + " "); - System.out.println(); - } assertEquals(populationq.asList().get(0), pq1); assertEquals(populationq.asList().get(1), pq2); diff --git a/zpp-solver/genetic-solver/src/test/java/utility/CPGeneticWrapperA.java b/zpp-solver/genetic-solver/src/test/java/utility/CPGeneticWrapperA.java index 369435261..bbc670a85 100644 --- a/zpp-solver/genetic-solver/src/test/java/utility/CPGeneticWrapperA.java +++ b/zpp-solver/genetic-solver/src/test/java/utility/CPGeneticWrapperA.java @@ -1,3 +1,5 @@ +package utility; + import cPGeneticWrapper.ACPGeneticWrapper; import cp_wrapper.CPWrapper; import implementation.ImplGene; diff --git a/zpp-solver/genetic-solver/src/test/java/utility/Methods.java b/zpp-solver/genetic-solver/src/test/java/utility/Methods.java new file mode 100644 index 000000000..9cc460488 --- /dev/null +++ b/zpp-solver/genetic-solver/src/test/java/utility/Methods.java @@ -0,0 +1,93 @@ +package utility; + +import cp_wrapper.UtilityProvider; +import cp_wrapper.mockups.*; +import eu.melodic.upperware.utilitygenerator.cdo.cp_model.DTO.VariableValueDTO; +import eu.paasage.upperware.metamodel.cp.*; +import eu.paasage.upperware.metamodel.types.BasicTypeEnum; +import org.eclipse.emf.common.util.BasicEList; +import org.eclipse.emf.common.util.EList; + +import java.util.Arrays; +import java.util.Collections; +import java.util.List; +import java.util.Map; + +public class Methods { + // Copied problem from PTSolver. + public static Map prepareSimpleConstraintProblem() { + /* + @var1 in {1,2,3,4,5} + @var2 in {0.5, 1.5, 2.5} + @var3 in {0,...,9} + @const1 = 3 + + @constraint1 : @var1 < @var3 + + @constraint2 : @var1 * @var2 * @var3 >= @const1; + + @constraint3: @var1 * @var2 >= @var3 + + @constraint4: @var3 == @var3 + */ + + List variables = Arrays.asList("var1", "var2", "var3", "var4", "var5", "var6", "var7", "var8"); + EList vars = new BasicEList<>(); + for (int i= 0; i < 3; i++) vars.add(new CpVariableImplMockup(variables.get(i), VariableType.CARDINALITY)); + RangeDomainImpMockup dom1 = new RangeDomainImpMockup(); + RangeDomainImpMockup dom3 = new RangeDomainImpMockup(); + dom1.setFrom(1);dom3.setFrom(0);dom1.setTo(5);dom3.setTo(9); + NumericListDomainImplMockup dom2 = new NumericListDomainImplMockup(); + dom2.setValues(Arrays.asList(0.5, 1.5, 2.5)); + List domains = Arrays.asList(new Domain[] {dom1, dom2, dom3}); + for (int i = 0; i <3 ; i++ ){ + vars.get(i).setDomain(domains.get(i)); + } + + Constant c = new ConstantImplMockup(BasicTypeEnum.DOUBLE, new NumericValueUpperwareImplMockup(3)); + + EList exprs = new BasicEList<>(); + exprs.add(vars.get(0)); exprs.add(vars.get(1)); + NumericExpression times = new ComposedExpressionImplMockup(exprs, OperatorEnum.TIMES); + ComparisonExpressionMockup constraint1 = new ComparisonExpressionMockup(); + constraint1.setExp1(vars.get(0));constraint1.setExp2(vars.get(2)); + constraint1.setComparator(ComparatorEnum.LESS_THAN); + + ComparisonExpressionMockup constraint3 = new ComparisonExpressionMockup(); + constraint3.setExp1(times);constraint3.setExp2(vars.get(2)); + constraint3.setComparator(ComparatorEnum.GREATER_OR_EQUAL_TO); + + exprs.add(vars.get(2)); + ComparisonExpressionMockup constraint2 = new ComparisonExpressionMockup(); + times = new ComposedExpressionImplMockup(exprs, OperatorEnum.TIMES); + constraint2.setExp1(times);constraint2.setExp2(c); + constraint2.setComparator(ComparatorEnum.GREATER_OR_EQUAL_TO); + + ComparisonExpressionMockup constraint4 = new ComparisonExpressionMockup(); + constraint4.setExp1(vars.get(2));constraint4.setExp2(vars.get(2)); + constraint4.setComparator(ComparatorEnum.EQUAL_TO); + + EList consts = new BasicEList<>(); + consts.add(c); + + EList varsE = new BasicEList<>(); + for (int i = 0; i < 3; i++) varsE.add(vars.get(i)); + + EList constraints = new BasicEList<>(); + constraints.addAll(Arrays.asList(constraint1, constraint2, constraint3, constraint4)); + + ConstraintProblem cp = new ConstraintProblemMockup(consts,null, varsE, constraints ); + return Collections.singletonMap(cp, result -> { + double sum = 0; + for (VariableValueDTO v : result) { + if (v.getValue() instanceof Double) { + sum += v.getValue().doubleValue(); + } else { + sum += v.getValue().intValue(); + } + } + return sum; + }); + } + +} -- GitLab From d89647d97ab03ee7fd639fd1ee63903e90d8e149 Mon Sep 17 00:00:00 2001 From: Michal Jankowski Date: Thu, 9 Jan 2020 06:18:47 +0100 Subject: [PATCH 062/340] Added custom sorting algorithm. ImplSelector is based on a TruncationSelector. --- .../java/implementation/ImplSelector.java | 42 +++++++- .../java/sortingAlgortihms/MergeSort.java | 58 +++++++++++ .../src/test/java/utility/Methods.java | 99 +++++++++++++++++++ 3 files changed, 195 insertions(+), 4 deletions(-) create mode 100644 zpp-solver/genetic-solver/src/main/java/sortingAlgortihms/MergeSort.java diff --git a/zpp-solver/genetic-solver/src/main/java/implementation/ImplSelector.java b/zpp-solver/genetic-solver/src/main/java/implementation/ImplSelector.java index d893bf0e9..5b0731220 100644 --- a/zpp-solver/genetic-solver/src/main/java/implementation/ImplSelector.java +++ b/zpp-solver/genetic-solver/src/main/java/implementation/ImplSelector.java @@ -1,5 +1,8 @@ package implementation; +import static java.lang.Math.min; +import static java.lang.String.format; +import static java.util.Objects.requireNonNull; import io.jenetics.Optimize; import io.jenetics.Phenotype; import io.jenetics.Selector; @@ -7,6 +10,7 @@ import io.jenetics.util.ISeq; import io.jenetics.util.MSeq; import io.jenetics.util.Seq; import lombok.AllArgsConstructor; +import sortingAlgortihms.MergeSort; import java.util.Comparator; @@ -20,10 +24,40 @@ public class ImplSelector implements Selector { private Comparator> comparator; @Override - public ISeq> select(Seq> seq, int size, Optimize optimize) { - MSeq> mseq = seq.asMSeq().copy(); - mseq.sort(comparator); + public ISeq> select( + final Seq> population, + final int count, + final Optimize opt + ) { + requireNonNull(population, "Population"); + requireNonNull(opt, "Optimization"); + if (count < 0) { + throw new IllegalArgumentException(format( + "Selection count must be greater or equal then zero, but was %s", + count + )); + } - return mseq.subSeq(size).toISeq(); + final MSeq> selection = MSeq + .ofLength(population.isEmpty() ? 0 : count); + + if (count > 0 && !population.isEmpty()) { + final MSeq> copy = population.asISeq().copy(); + MergeSort.sort(copy); + + int size = count; + do { + //final int length = min(min(copy.size(), size), _n); + final int length = min(copy.size(), size); + for (int i = 0; i < length; ++i) { + selection.set((count - size) + i, copy.get(i)); + } + + size -= length; + } while (size > 0); + } + + return selection.toISeq(); } } + diff --git a/zpp-solver/genetic-solver/src/main/java/sortingAlgortihms/MergeSort.java b/zpp-solver/genetic-solver/src/main/java/sortingAlgortihms/MergeSort.java new file mode 100644 index 000000000..4cb4ccad7 --- /dev/null +++ b/zpp-solver/genetic-solver/src/main/java/sortingAlgortihms/MergeSort.java @@ -0,0 +1,58 @@ +package sortingAlgortihms; + +import comparators.StochasticRankingComparator; +import implementation.ImplGene; +import io.jenetics.Phenotype; +import io.jenetics.util.ISeq; +import io.jenetics.util.MSeq; + +import java.util.ArrayList; +import java.util.Comparator; +import java.util.List; + +public class MergeSort { + private static Comparator> comparator = new StochasticRankingComparator(0.1); + + public static void merge(List> list, int from, int mid, int to) { + int ptr1 = 0, ptr2 = 0; + List> left, right; + + + left = list.subList(from, mid); + right = list.subList(mid, to); + + while (ptr1 + ptr2 < to - from) { + if (ptr1 == mid - from) { + list.set(ptr1 + ptr2, right.get(ptr2)); + ptr2++; + } + else if (ptr2 == to - mid) { + list.set(ptr1 + ptr2, left.get(ptr1)); + ptr1++; + } + else if (comparator.compare(left.get(ptr1), right.get(ptr2)) > 0) { + list.set(ptr1 + ptr2, left.get(ptr1)); + ptr1++; + } + else { + list.set(ptr1 + ptr2, right.get(ptr2)); + ptr2++; + } + } + } + + public static void sort(List> list, int from, int to) { + if (to - from < 2) + return; + + int mid = (to + from) / 2; + sort(list, from, mid); + sort(list, mid, to); + + merge(list, from, mid, to); + } + + public static void sort(MSeq> seq) { + sort(seq.asList(), 0, seq.size()); + } +} diff --git a/zpp-solver/genetic-solver/src/test/java/utility/Methods.java b/zpp-solver/genetic-solver/src/test/java/utility/Methods.java index 9cc460488..90f0222d2 100644 --- a/zpp-solver/genetic-solver/src/test/java/utility/Methods.java +++ b/zpp-solver/genetic-solver/src/test/java/utility/Methods.java @@ -90,4 +90,103 @@ public class Methods { }); } + public static Map prepareLessSimpleConstraintProblem() { + /* + @var1 in {1,...,10} + @var2 in {0.5, 1.5, 2.5, 7.5, 10} + @var3 in {0,...,9} + @var4 in {1, 2, 3} + @var5 in {0.5, 7.5, 12.5} + @const1 = 3 + @const2 = 6 + + @constraint1 : @var1 < @var3 + + @constraint2 : @var1 * @var2 * @var3 >= @const1; + + @constraint3: @var1 * @var2 >= @var3 + + @constraint4: @var3 == @var3 + + @constraint5: @var5 * @var1 < @var2 * @const2 + */ + + List variables = Arrays.asList("var1", "var2", "var3", "var4", "var5", "var6", "var7", "var8", "var9", "var10", "var11", "var12"); + EList vars = new BasicEList<>(); + for (int i= 0; i < 5; i++) vars.add(new CpVariableImplMockup(variables.get(i), VariableType.CARDINALITY)); + RangeDomainImpMockup dom1 = new RangeDomainImpMockup(); + RangeDomainImpMockup dom3 = new RangeDomainImpMockup(); + RangeDomainImpMockup dom4 = new RangeDomainImpMockup(); + dom1.setFrom(1); dom1.setTo(10); + dom3.setFrom(0); dom3.setTo(9); + dom4.setFrom(1); dom4.setTo(3); + NumericListDomainImplMockup dom2 = new NumericListDomainImplMockup(); + NumericListDomainImplMockup dom5 = new NumericListDomainImplMockup(); + dom2.setValues(Arrays.asList(0.5, 1.5, 2.5, 7.5, 10.0)); + dom5.setValues(Arrays.asList(0.5, 7.5, 12.5)); + List domains = Arrays.asList(new Domain[] {dom1, dom2, dom3, dom4, dom5}); + for (int i = 0; i < 5 ; i++ ){ + vars.get(i).setDomain(domains.get(i)); + } + + Constant c = new ConstantImplMockup(BasicTypeEnum.DOUBLE, new NumericValueUpperwareImplMockup(3)); + Constant c2 = new ConstantImplMockup(BasicTypeEnum.DOUBLE, new NumericValueUpperwareImplMockup(6)); + + EList exprs = new BasicEList<>(); + exprs.add(vars.get(0)); exprs.add(vars.get(1)); + NumericExpression times = new ComposedExpressionImplMockup(exprs, OperatorEnum.TIMES); + ComparisonExpressionMockup constraint1 = new ComparisonExpressionMockup(); + constraint1.setExp1(vars.get(0));constraint1.setExp2(vars.get(2)); + constraint1.setComparator(ComparatorEnum.LESS_THAN); + + ComparisonExpressionMockup constraint3 = new ComparisonExpressionMockup(); + constraint3.setExp1(times);constraint3.setExp2(vars.get(2)); + constraint3.setComparator(ComparatorEnum.GREATER_OR_EQUAL_TO); + + exprs.add(vars.get(2)); + ComparisonExpressionMockup constraint2 = new ComparisonExpressionMockup(); + times = new ComposedExpressionImplMockup(exprs, OperatorEnum.TIMES); + constraint2.setExp1(times);constraint2.setExp2(c); + constraint2.setComparator(ComparatorEnum.GREATER_OR_EQUAL_TO); + + ComparisonExpressionMockup constraint4 = new ComparisonExpressionMockup(); + constraint4.setExp1(vars.get(2));constraint4.setExp2(vars.get(2)); + constraint4.setComparator(ComparatorEnum.EQUAL_TO); + + + EList exprs2 = new BasicEList<>(); + EList exprs3 = new BasicEList<>(); + exprs2.add(vars.get(0)); exprs2.add(vars.get(4)); + exprs3.add(vars.get(1)); exprs3.add(c2); + ComparisonExpressionMockup constraint5 = new ComparisonExpressionMockup(); + times = new ComposedExpressionImplMockup(exprs2, OperatorEnum.TIMES); + + constraint5.setExp1(times); + times = new ComposedExpressionImplMockup(exprs3, OperatorEnum.TIMES); + constraint5.setExp2(times); + constraint5.setComparator(ComparatorEnum.LESS_OR_EQUAL_TO); + + EList consts = new BasicEList<>(); + consts.add(c); + + EList varsE = new BasicEList<>(); + for (int i = 0; i < 5; i++) varsE.add(vars.get(i)); + + EList constraints = new BasicEList<>(); + constraints.addAll(Arrays.asList(constraint1, constraint2, constraint3, constraint4, constraint5)); + + ConstraintProblem cp = new ConstraintProblemMockup(consts,null, varsE, constraints ); + return Collections.singletonMap(cp, result -> { + double sum = 0; + for (VariableValueDTO v : result) { + if (v.getValue() instanceof Double) { + sum += v.getValue().doubleValue(); + } else { + sum += v.getValue().intValue(); + } + } + return sum; + }); + } + } -- GitLab From f9079559df7c93ecbfb9819ab19bf9cdabd79230 Mon Sep 17 00:00:00 2001 From: tc360950 Date: Fri, 10 Jan 2020 10:44:49 +0100 Subject: [PATCH 063/340] fixed exception messages --- .../src/main/java/cp_wrapper/utils/DomainHandler.java | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/zpp-solver/cp-parser/src/main/java/cp_wrapper/utils/DomainHandler.java b/zpp-solver/cp-parser/src/main/java/cp_wrapper/utils/DomainHandler.java index 54a75554d..59e79ee76 100644 --- a/zpp-solver/cp-parser/src/main/java/cp_wrapper/utils/DomainHandler.java +++ b/zpp-solver/cp-parser/src/main/java/cp_wrapper/utils/DomainHandler.java @@ -74,7 +74,7 @@ public class DomainHandler { List values = ((NumericListDomain) domain).getValues(); return ExpressionEvaluator.convertNumericInterfaceToNumericValue(values.get(values.size() - 1)); } - throw new RuntimeException("Unsupported dmain type"); + throw new RuntimeException("Unsupported domain type"); } public static NumericValue getMinValue(Domain domain) { @@ -84,7 +84,7 @@ public class DomainHandler { List values = ((NumericListDomain) domain).getValues(); return ExpressionEvaluator.convertNumericInterfaceToNumericValue(values.get(0)); } - throw new RuntimeException("Unsupported dmain type"); + throw new RuntimeException("Unsupported domain type"); } private static boolean isInList(NumericValue value, List list) { @@ -108,6 +108,6 @@ public class DomainHandler { } else if (isNumericListDomain(domain)) { return isInList(value, ((NumericListDomain) domain).getValues()); } - throw new RuntimeException(""); + throw new RuntimeException("Unsupported domain type"); } } -- GitLab From 1de857cf753c7361664bf4247b8c8d070274782d Mon Sep 17 00:00:00 2001 From: tc360950 Date: Fri, 10 Jan 2020 10:52:20 +0100 Subject: [PATCH 064/340] Fixes in NumericValue and its extensions --- .../src/main/java/cp_wrapper/CPWrapper.java | 12 ++--- .../java/cp_wrapper/parser/CPParsedData.java | 8 ++-- .../cp_wrapper/utils/ConstraintGraph.java | 4 +- .../java/cp_wrapper/utils/DomainHandler.java | 18 ++++---- .../cp_wrapper/utils/ExpressionEvaluator.java | 18 ++++---- .../utils/constraint/Constraint.java | 4 +- .../utils/constraint/ConstraintImpl.java | 5 +-- .../IntValueInterface.java | 2 +- .../numeric_value/NumericValueInterface.java | 5 +++ .../implementations/DoubleValue.java | 21 +++++++++ .../implementations/IntegerValue.java | 24 ++++++++++ .../implementations/LongValue.java | 26 +++++++++++ .../utils/numeric_value_impl/DoubleValue.java | 23 ---------- .../numeric_value_impl/IntegerValue.java | 26 ----------- .../utils/numeric_value_impl/LongValue.java | 45 ------------------- .../numeric_value_impl/NumericValue.java | 5 --- .../cp_wrapper/mockups/ConstraintMockup.java | 4 +- .../cp_wrapper/utils/ConstraintImplTest.java | 12 ++--- .../utils/ExpressionEvaluatorTest.java | 12 ++--- .../main/java/nc_wrapper/DomainProvider.java | 8 ++-- .../src/main/java/nc_wrapper/NCWrapper.java | 25 ++++++----- .../node_candidate/NodeCandidatesPool.java | 6 +-- .../NodeCandidatesPoolTest.java | 10 ++--- 23 files changed, 151 insertions(+), 172 deletions(-) rename zpp-solver/cp-parser/src/main/java/cp_wrapper/utils/{numeric_value_impl => numeric_value}/IntValueInterface.java (58%) create mode 100644 zpp-solver/cp-parser/src/main/java/cp_wrapper/utils/numeric_value/NumericValueInterface.java create mode 100644 zpp-solver/cp-parser/src/main/java/cp_wrapper/utils/numeric_value/implementations/DoubleValue.java create mode 100644 zpp-solver/cp-parser/src/main/java/cp_wrapper/utils/numeric_value/implementations/IntegerValue.java create mode 100644 zpp-solver/cp-parser/src/main/java/cp_wrapper/utils/numeric_value/implementations/LongValue.java delete mode 100644 zpp-solver/cp-parser/src/main/java/cp_wrapper/utils/numeric_value_impl/DoubleValue.java delete mode 100644 zpp-solver/cp-parser/src/main/java/cp_wrapper/utils/numeric_value_impl/IntegerValue.java delete mode 100644 zpp-solver/cp-parser/src/main/java/cp_wrapper/utils/numeric_value_impl/LongValue.java delete mode 100644 zpp-solver/cp-parser/src/main/java/cp_wrapper/utils/numeric_value_impl/NumericValue.java diff --git a/zpp-solver/cp-parser/src/main/java/cp_wrapper/CPWrapper.java b/zpp-solver/cp-parser/src/main/java/cp_wrapper/CPWrapper.java index f26d6aca2..fcf3895d3 100644 --- a/zpp-solver/cp-parser/src/main/java/cp_wrapper/CPWrapper.java +++ b/zpp-solver/cp-parser/src/main/java/cp_wrapper/CPWrapper.java @@ -3,14 +3,14 @@ package cp_wrapper; import cp_wrapper.parser.CPParsedData; import cp_wrapper.parser.CPParser; import cp_wrapper.utils.DomainHandler; -import cp_wrapper.utils.numeric_value_impl.*; +import cp_wrapper.utils.numeric_value.*; +import cp_wrapper.utils.numeric_value.implementations.DoubleValue; import cp_wrapper.utils.variable_orderer.HeuristicVariableOrderer; import cp_wrapper.utils.VariableNumericType; import cp_wrapper.utils.variable_orderer.VariableOrderer; import eu.melodic.upperware.utilitygenerator.cdo.cp_model.DTO.VariableValueDTO; import eu.melodic.upperware.utilitygenerator.cdo.cp_model.DTO.VariableValueDTOFactory; import eu.paasage.upperware.metamodel.cp.*; -import io.github.cloudiator.rest.model.Runtime; import java.util.ArrayList; import java.util.HashMap; @@ -42,7 +42,7 @@ public class CPWrapper { return cpParsedData.getVariableDomain(variableOrderer.getNameFromIndex(variableIndex)); } - private NumericValue getVariableValueFromDomainIndex(int varIndex, int value) { + private NumericValueInterface getVariableValueFromDomainIndex(int varIndex, int value) { String variableName = variableOrderer.getNameFromIndex(varIndex); Domain domain = cpParsedData.getVariableDomain(variableName); if (DomainHandler.isRangeDomain(domain)) { @@ -54,8 +54,8 @@ public class CPWrapper { throw new RuntimeException("Only domaind of types RangeDomain, NumericListDomain are supported!"); } - private Map getAssignmentFromValueList(List assignments) { - Map vars = new HashMap<>(); + private Map getAssignmentFromValueList(List assignments) { + Map vars = new HashMap<>(); for (int i = 0; i < assignments.size(); i++) { if (variableOrderer.exists(i)) { vars.put(variableOrderer.getNameFromIndex(i), getVariableValueFromDomainIndex(i, assignments.get(i))); @@ -84,7 +84,7 @@ public class CPWrapper { private List assignmentToVariableValueDTOList(List assignments) { List result = new ArrayList<>(); for (int i = 0; i < assignments.size(); i++) { - NumericValue val = getVariableValueFromDomainIndex(i, assignments.get(i)); + NumericValueInterface val = getVariableValueFromDomainIndex(i, assignments.get(i)); if (cpParsedData.getVariableType(variableOrderer.getNameFromIndex(i)) == VariableNumericType.INT) { if (!(val instanceof IntValueInterface)) { throw new RuntimeException(""); diff --git a/zpp-solver/cp-parser/src/main/java/cp_wrapper/parser/CPParsedData.java b/zpp-solver/cp-parser/src/main/java/cp_wrapper/parser/CPParsedData.java index 5997f7d2d..b0574d0fb 100644 --- a/zpp-solver/cp-parser/src/main/java/cp_wrapper/parser/CPParsedData.java +++ b/zpp-solver/cp-parser/src/main/java/cp_wrapper/parser/CPParsedData.java @@ -6,7 +6,7 @@ package cp_wrapper.parser; import cp_wrapper.utils.constraint.Constraint; import cp_wrapper.utils.ConstraintGraph; import cp_wrapper.utils.VariableNumericType; -import cp_wrapper.utils.numeric_value_impl.NumericValue; +import cp_wrapper.utils.numeric_value.NumericValueInterface; import eu.melodic.upperware.cpsolver.solver.parser.creator.IntVarCreator; import eu.paasage.upperware.metamodel.cp.*; import lombok.Getter; @@ -37,7 +37,7 @@ public class CPParsedData { initializeNameToVariable(); } - public boolean checkIfFeasible(Map variables) { + public boolean checkIfFeasible(Map variables) { for (Constraint c : constraints) { if (!c.evaluate(variables)) { return false; @@ -46,13 +46,13 @@ public class CPParsedData { return true; } - public int countViolatedConstraints(Map variables) { + public int countViolatedConstraints(Map variables) { return constraints.stream() .map(c -> c.evaluate(variables) ? 0 : 1) .reduce( 0, Integer::sum); } - public int getHeuristicEvaluation(String variable, Map variables) { + public int getHeuristicEvaluation(String variable, Map variables) { return constraintGraph.getVariableHeuristicEvaluation(variable, variables); } diff --git a/zpp-solver/cp-parser/src/main/java/cp_wrapper/utils/ConstraintGraph.java b/zpp-solver/cp-parser/src/main/java/cp_wrapper/utils/ConstraintGraph.java index 32e42b92d..d395c4411 100644 --- a/zpp-solver/cp-parser/src/main/java/cp_wrapper/utils/ConstraintGraph.java +++ b/zpp-solver/cp-parser/src/main/java/cp_wrapper/utils/ConstraintGraph.java @@ -9,7 +9,7 @@ package cp_wrapper.utils; import cp_wrapper.utils.constraint.Constraint; -import cp_wrapper.utils.numeric_value_impl.NumericValue; +import cp_wrapper.utils.numeric_value.NumericValueInterface; import java.util.*; @@ -152,7 +152,7 @@ public class ConstraintGraph { Heuristic evaluation of a variable is defined to be a sum of violated constrains which involve the variable. */ - public int getVariableHeuristicEvaluation(String variable, Map variables) { + public int getVariableHeuristicEvaluation(String variable, Map variables) { int result = 0; for (Constraint c : variableToConstraint.get(variable)) { if (!c.evaluate(variables)) { diff --git a/zpp-solver/cp-parser/src/main/java/cp_wrapper/utils/DomainHandler.java b/zpp-solver/cp-parser/src/main/java/cp_wrapper/utils/DomainHandler.java index 59e79ee76..f641448d1 100644 --- a/zpp-solver/cp-parser/src/main/java/cp_wrapper/utils/DomainHandler.java +++ b/zpp-solver/cp-parser/src/main/java/cp_wrapper/utils/DomainHandler.java @@ -5,9 +5,9 @@ package cp_wrapper.utils; into corresponding values. Currently only RangeDomain and NumericListDomain domains are supported. */ -import cp_wrapper.utils.numeric_value_impl.IntValueInterface; -import cp_wrapper.utils.numeric_value_impl.IntegerValue; -import cp_wrapper.utils.numeric_value_impl.NumericValue; +import cp_wrapper.utils.numeric_value.IntValueInterface; +import cp_wrapper.utils.numeric_value.implementations.IntegerValue; +import cp_wrapper.utils.numeric_value.NumericValueInterface; import eu.paasage.upperware.metamodel.cp.Domain; import eu.paasage.upperware.metamodel.cp.NumericListDomain; import eu.paasage.upperware.metamodel.cp.RangeDomain; @@ -25,7 +25,7 @@ public class DomainHandler { return domain instanceof NumericListDomain; } - public static NumericValue getRangeValue(int valueIndex, RangeDomain domain) { + public static NumericValueInterface getRangeValue(int valueIndex, RangeDomain domain) { NumericValueUpperware min = domain.getFrom(); if (min instanceof IntegerValueUpperware) { return new IntegerValue(((IntegerValueUpperware) min).getValue() + valueIndex); @@ -34,7 +34,7 @@ public class DomainHandler { } } - public static NumericValue getNumericListValue(int valueIndex, NumericListDomain domain) { + public static NumericValueInterface getNumericListValue(int valueIndex, NumericListDomain domain) { List values = domain.getValues(); if (values.size() <= valueIndex) { throw new RuntimeException(); @@ -67,7 +67,7 @@ public class DomainHandler { throw new RuntimeException("Only integer RangeDomains are supported!"); } - public static NumericValue getMaxValue(Domain domain) { + public static NumericValueInterface getMaxValue(Domain domain) { if (isRangeDomain(domain)) { return ExpressionEvaluator.convertNumericInterfaceToNumericValue(((RangeDomain) domain).getTo()); } else if (isNumericListDomain(domain)) { @@ -77,7 +77,7 @@ public class DomainHandler { throw new RuntimeException("Unsupported domain type"); } - public static NumericValue getMinValue(Domain domain) { + public static NumericValueInterface getMinValue(Domain domain) { if (isRangeDomain(domain)) { return ExpressionEvaluator.convertNumericInterfaceToNumericValue(((RangeDomain) domain).getFrom()); } else if (isNumericListDomain(domain)) { @@ -87,7 +87,7 @@ public class DomainHandler { throw new RuntimeException("Unsupported domain type"); } - private static boolean isInList(NumericValue value, List list) { + private static boolean isInList(NumericValueInterface value, List list) { for (NumericValueUpperware v : list) { if (value.equals(ExpressionEvaluator.convertNumericInterfaceToNumericValue(v))) { return true; @@ -96,7 +96,7 @@ public class DomainHandler { return false; } - public static boolean isInDomain(NumericValue value, Domain domain) { + public static boolean isInDomain(NumericValueInterface value, Domain domain) { if (isRangeDomain(domain)) { if (!(value instanceof IntValueInterface)) { return false; diff --git a/zpp-solver/cp-parser/src/main/java/cp_wrapper/utils/ExpressionEvaluator.java b/zpp-solver/cp-parser/src/main/java/cp_wrapper/utils/ExpressionEvaluator.java index aa80291c4..c11ea961b 100644 --- a/zpp-solver/cp-parser/src/main/java/cp_wrapper/utils/ExpressionEvaluator.java +++ b/zpp-solver/cp-parser/src/main/java/cp_wrapper/utils/ExpressionEvaluator.java @@ -4,10 +4,10 @@ package cp_wrapper.utils; interfaces from eu.paasage.upperware.metamodel.cp package */ -import cp_wrapper.utils.numeric_value_impl.DoubleValue; -import cp_wrapper.utils.numeric_value_impl.IntegerValue; -import cp_wrapper.utils.numeric_value_impl.LongValue; -import cp_wrapper.utils.numeric_value_impl.NumericValue; +import cp_wrapper.utils.numeric_value.implementations.DoubleValue; +import cp_wrapper.utils.numeric_value.implementations.IntegerValue; +import cp_wrapper.utils.numeric_value.implementations.LongValue; +import cp_wrapper.utils.numeric_value.NumericValueInterface; import eu.paasage.upperware.metamodel.types.*; import eu.paasage.upperware.metamodel.cp.*; @@ -23,7 +23,7 @@ public class ExpressionEvaluator { */ public static final double PRECISION = 0.1; - public static NumericValue convertNumericInterfaceToNumericValue(NumericValueUpperware value) { + public static NumericValueInterface convertNumericInterfaceToNumericValue(NumericValueUpperware value) { if (value instanceof IntegerValueUpperware) { return new IntegerValue(((IntegerValueUpperware) value).getValue()); } else if (value instanceof LongValueUpperware) { @@ -87,7 +87,7 @@ public class ExpressionEvaluator { throw new RuntimeException("Unsupported operation type"); } - private static double evaluateComposedExpression(ComposedExpression exp, Map variables) { + private static double evaluateComposedExpression(ComposedExpression exp, Map variables) { List expressionsValues = exp.getExpressions() .stream() .map(e -> evaluateExpression(e, variables)) @@ -95,7 +95,7 @@ public class ExpressionEvaluator { return evaluateOnOperator(exp.getOperator(), expressionsValues); } - private static double castNumericValueToDouble(NumericValue val) { + private static double castNumericValueToDouble(NumericValueInterface val) { if (val instanceof DoubleValue) { return ((DoubleValue) val).getValue(); } else if (val instanceof IntegerValue) { @@ -106,7 +106,7 @@ public class ExpressionEvaluator { throw new RuntimeException("Unsupported NumericValue type!"); } - static double evaluateExpression(Expression exp, Map variables) { + static double evaluateExpression(Expression exp, Map variables) { if (isConstant(exp)) { return getValueOfNumericInterface(((Constant) exp).getValue()); } else if (isCpMetric(exp)) { @@ -119,7 +119,7 @@ public class ExpressionEvaluator { throw new RuntimeException("Unsupported Expression type"); } - public static boolean evaluateComparator(ComparatorEnum comparator, Expression leftExp, Expression rightExp, Map variables) { + public static boolean evaluateComparator(ComparatorEnum comparator, Expression leftExp, Expression rightExp, Map variables) { double leftExpValue = evaluateExpression(leftExp, variables); double rightExpValue = evaluateExpression(rightExp, variables); return evaluateComparator(comparator, leftExpValue, rightExpValue); diff --git a/zpp-solver/cp-parser/src/main/java/cp_wrapper/utils/constraint/Constraint.java b/zpp-solver/cp-parser/src/main/java/cp_wrapper/utils/constraint/Constraint.java index e18ec8aa0..c152de656 100644 --- a/zpp-solver/cp-parser/src/main/java/cp_wrapper/utils/constraint/Constraint.java +++ b/zpp-solver/cp-parser/src/main/java/cp_wrapper/utils/constraint/Constraint.java @@ -1,6 +1,6 @@ package cp_wrapper.utils.constraint; -import cp_wrapper.utils.numeric_value_impl.NumericValue; +import cp_wrapper.utils.numeric_value.NumericValueInterface; import java.util.Collection; import java.util.Map; @@ -9,5 +9,5 @@ public interface Constraint { Collection getVariableNames(); - boolean evaluate(Map variables); + boolean evaluate(Map variables); } diff --git a/zpp-solver/cp-parser/src/main/java/cp_wrapper/utils/constraint/ConstraintImpl.java b/zpp-solver/cp-parser/src/main/java/cp_wrapper/utils/constraint/ConstraintImpl.java index 0b954c3eb..deb3f97cd 100644 --- a/zpp-solver/cp-parser/src/main/java/cp_wrapper/utils/constraint/ConstraintImpl.java +++ b/zpp-solver/cp-parser/src/main/java/cp_wrapper/utils/constraint/ConstraintImpl.java @@ -1,8 +1,7 @@ package cp_wrapper.utils.constraint; import cp_wrapper.utils.ExpressionEvaluator; -import cp_wrapper.utils.constraint.Constraint; -import cp_wrapper.utils.numeric_value_impl.NumericValue; +import cp_wrapper.utils.numeric_value.NumericValueInterface; import eu.paasage.upperware.metamodel.cp.*; import java.util.ArrayList; @@ -47,7 +46,7 @@ public class ConstraintImpl implements Constraint { } @Override - public boolean evaluate(Map variables){ + public boolean evaluate(Map variables){ if (!checkVariables(variables.keySet())) { throw new RuntimeException("Can't evaluate - some variables are missing"); } diff --git a/zpp-solver/cp-parser/src/main/java/cp_wrapper/utils/numeric_value_impl/IntValueInterface.java b/zpp-solver/cp-parser/src/main/java/cp_wrapper/utils/numeric_value/IntValueInterface.java similarity index 58% rename from zpp-solver/cp-parser/src/main/java/cp_wrapper/utils/numeric_value_impl/IntValueInterface.java rename to zpp-solver/cp-parser/src/main/java/cp_wrapper/utils/numeric_value/IntValueInterface.java index 2fff1d878..66aefc929 100644 --- a/zpp-solver/cp-parser/src/main/java/cp_wrapper/utils/numeric_value_impl/IntValueInterface.java +++ b/zpp-solver/cp-parser/src/main/java/cp_wrapper/utils/numeric_value/IntValueInterface.java @@ -1,4 +1,4 @@ -package cp_wrapper.utils.numeric_value_impl; +package cp_wrapper.utils.numeric_value; public interface IntValueInterface { int getIntValue(); diff --git a/zpp-solver/cp-parser/src/main/java/cp_wrapper/utils/numeric_value/NumericValueInterface.java b/zpp-solver/cp-parser/src/main/java/cp_wrapper/utils/numeric_value/NumericValueInterface.java new file mode 100644 index 000000000..4bab31798 --- /dev/null +++ b/zpp-solver/cp-parser/src/main/java/cp_wrapper/utils/numeric_value/NumericValueInterface.java @@ -0,0 +1,5 @@ +package cp_wrapper.utils.numeric_value; + +public interface NumericValueInterface { + boolean equals(NumericValueInterface value); +} diff --git a/zpp-solver/cp-parser/src/main/java/cp_wrapper/utils/numeric_value/implementations/DoubleValue.java b/zpp-solver/cp-parser/src/main/java/cp_wrapper/utils/numeric_value/implementations/DoubleValue.java new file mode 100644 index 000000000..a3888ec7e --- /dev/null +++ b/zpp-solver/cp-parser/src/main/java/cp_wrapper/utils/numeric_value/implementations/DoubleValue.java @@ -0,0 +1,21 @@ +package cp_wrapper.utils.numeric_value.implementations; + +import cp_wrapper.utils.numeric_value.NumericValueInterface; +import lombok.AllArgsConstructor; +import lombok.Getter; +import lombok.Setter; + +@AllArgsConstructor +public class DoubleValue implements NumericValueInterface { + @Getter + @Setter + private double value; + + @Override + public boolean equals(NumericValueInterface value) { + if (value instanceof DoubleValue) { + return this.value == ((DoubleValue) value).getValue(); + } + return false; + } +} diff --git a/zpp-solver/cp-parser/src/main/java/cp_wrapper/utils/numeric_value/implementations/IntegerValue.java b/zpp-solver/cp-parser/src/main/java/cp_wrapper/utils/numeric_value/implementations/IntegerValue.java new file mode 100644 index 000000000..3a063dc51 --- /dev/null +++ b/zpp-solver/cp-parser/src/main/java/cp_wrapper/utils/numeric_value/implementations/IntegerValue.java @@ -0,0 +1,24 @@ +package cp_wrapper.utils.numeric_value.implementations; + +import cp_wrapper.utils.numeric_value.IntValueInterface; +import cp_wrapper.utils.numeric_value.NumericValueInterface; +import lombok.AllArgsConstructor; +import lombok.Getter; +import lombok.Setter; + +@AllArgsConstructor +public class IntegerValue implements NumericValueInterface, IntValueInterface { + @Getter + @Setter + private int value; + + public int getIntValue() { return getValue();} + + @Override + public boolean equals(NumericValueInterface value) { + if (value instanceof IntValueInterface) { + return this.value == ((IntValueInterface) value).getIntValue(); + } + return false; + } +} diff --git a/zpp-solver/cp-parser/src/main/java/cp_wrapper/utils/numeric_value/implementations/LongValue.java b/zpp-solver/cp-parser/src/main/java/cp_wrapper/utils/numeric_value/implementations/LongValue.java new file mode 100644 index 000000000..902e40a64 --- /dev/null +++ b/zpp-solver/cp-parser/src/main/java/cp_wrapper/utils/numeric_value/implementations/LongValue.java @@ -0,0 +1,26 @@ +package cp_wrapper.utils.numeric_value.implementations; + +import cp_wrapper.utils.numeric_value.IntValueInterface; +import cp_wrapper.utils.numeric_value.NumericValueInterface; +import lombok.AllArgsConstructor; +import lombok.Getter; +import lombok.Setter; + +@AllArgsConstructor +public class LongValue implements NumericValueInterface, IntValueInterface { + @Getter + @Setter + private long value; + + public int getIntValue() { return (int) value;} + + @Override + public boolean equals(NumericValueInterface value) { + if (value instanceof LongValue) { + return this.value == ((LongValue) value).getValue(); + } else if (value instanceof IntegerValue) { + return this.value == (long) ((IntegerValue) value).getValue(); + } + return false; + } +} diff --git a/zpp-solver/cp-parser/src/main/java/cp_wrapper/utils/numeric_value_impl/DoubleValue.java b/zpp-solver/cp-parser/src/main/java/cp_wrapper/utils/numeric_value_impl/DoubleValue.java deleted file mode 100644 index 6b202064d..000000000 --- a/zpp-solver/cp-parser/src/main/java/cp_wrapper/utils/numeric_value_impl/DoubleValue.java +++ /dev/null @@ -1,23 +0,0 @@ -package cp_wrapper.utils.numeric_value_impl; - -import eu.paasage.upperware.metamodel.types.DoubleValueUpperware; -import lombok.AllArgsConstructor; - -@AllArgsConstructor -public class DoubleValue implements NumericValue { - double value; - - public double getValue() { return value;} - - public void setValue(double value) { - this.value = value; - } - - @Override - public boolean equals(NumericValue value) { - if (value instanceof DoubleValue) { - return this.value == ((DoubleValue) value).getValue(); - } - return false; - } -} diff --git a/zpp-solver/cp-parser/src/main/java/cp_wrapper/utils/numeric_value_impl/IntegerValue.java b/zpp-solver/cp-parser/src/main/java/cp_wrapper/utils/numeric_value_impl/IntegerValue.java deleted file mode 100644 index b42297657..000000000 --- a/zpp-solver/cp-parser/src/main/java/cp_wrapper/utils/numeric_value_impl/IntegerValue.java +++ /dev/null @@ -1,26 +0,0 @@ -package cp_wrapper.utils.numeric_value_impl; - -import lombok.AllArgsConstructor; - -@AllArgsConstructor -public class IntegerValue implements NumericValue, IntValueInterface { - private int value; - - public int getValue() { - return value; - } - - public int getIntValue() { return getValue();} - - public void setValue(int value) { - this.value = value; - } - - @Override - public boolean equals(NumericValue value) { - if (value instanceof IntValueInterface) { - return this.value == ((IntValueInterface) value).getIntValue(); - } - return false; - } -} diff --git a/zpp-solver/cp-parser/src/main/java/cp_wrapper/utils/numeric_value_impl/LongValue.java b/zpp-solver/cp-parser/src/main/java/cp_wrapper/utils/numeric_value_impl/LongValue.java deleted file mode 100644 index 57f44a6c0..000000000 --- a/zpp-solver/cp-parser/src/main/java/cp_wrapper/utils/numeric_value_impl/LongValue.java +++ /dev/null @@ -1,45 +0,0 @@ -package cp_wrapper.utils.numeric_value_impl; - -import eu.paasage.upperware.metamodel.types.LongValueUpperware; -import lombok.AllArgsConstructor; -import org.eclipse.emf.cdo.CDOLock; -import org.eclipse.emf.cdo.CDOObjectHistory; -import org.eclipse.emf.cdo.CDOState; -import org.eclipse.emf.cdo.common.id.CDOID; -import org.eclipse.emf.cdo.common.lock.CDOLockState; -import org.eclipse.emf.cdo.common.revision.CDORevision; -import org.eclipse.emf.cdo.common.security.CDOPermission; -import org.eclipse.emf.cdo.eresource.CDOResource; -import org.eclipse.emf.cdo.view.CDOView; -import org.eclipse.emf.common.notify.Adapter; -import org.eclipse.emf.common.notify.Notification; -import org.eclipse.emf.common.util.EList; -import org.eclipse.emf.common.util.TreeIterator; -import org.eclipse.emf.ecore.*; -import org.eclipse.emf.ecore.resource.Resource; - -import java.lang.reflect.InvocationTargetException; -@AllArgsConstructor -public class LongValue implements NumericValue, IntValueInterface{ - long value; - - public long getValue() { - return value; - } - - public int getIntValue() { return (int) value;} - - public void setValue(long value) { - this.value = value; - } - - @Override - public boolean equals(NumericValue value) { - if (value instanceof LongValue) { - return this.value == ((LongValue) value).getValue(); - } else if (value instanceof IntegerValue) { - return this.value == (long) ((IntegerValue) value).getValue(); - } - return false; - } -} diff --git a/zpp-solver/cp-parser/src/main/java/cp_wrapper/utils/numeric_value_impl/NumericValue.java b/zpp-solver/cp-parser/src/main/java/cp_wrapper/utils/numeric_value_impl/NumericValue.java deleted file mode 100644 index 4502bc18a..000000000 --- a/zpp-solver/cp-parser/src/main/java/cp_wrapper/utils/numeric_value_impl/NumericValue.java +++ /dev/null @@ -1,5 +0,0 @@ -package cp_wrapper.utils.numeric_value_impl; - -public interface NumericValue { - boolean equals(NumericValue value); -} diff --git a/zpp-solver/cp-parser/src/test/java/cp_wrapper/mockups/ConstraintMockup.java b/zpp-solver/cp-parser/src/test/java/cp_wrapper/mockups/ConstraintMockup.java index 026954b00..d9114e3fe 100644 --- a/zpp-solver/cp-parser/src/test/java/cp_wrapper/mockups/ConstraintMockup.java +++ b/zpp-solver/cp-parser/src/test/java/cp_wrapper/mockups/ConstraintMockup.java @@ -1,7 +1,7 @@ package cp_wrapper.mockups; import cp_wrapper.utils.constraint.Constraint; -import cp_wrapper.utils.numeric_value_impl.NumericValue; +import cp_wrapper.utils.numeric_value.NumericValueInterface; import lombok.AllArgsConstructor; import java.util.Collection; @@ -17,7 +17,7 @@ public class ConstraintMockup implements Constraint { } @Override - public boolean evaluate(Map variables) { + public boolean evaluate(Map variables) { return false; } } diff --git a/zpp-solver/cp-parser/src/test/java/cp_wrapper/utils/ConstraintImplTest.java b/zpp-solver/cp-parser/src/test/java/cp_wrapper/utils/ConstraintImplTest.java index 18622ce20..cda418ada 100644 --- a/zpp-solver/cp-parser/src/test/java/cp_wrapper/utils/ConstraintImplTest.java +++ b/zpp-solver/cp-parser/src/test/java/cp_wrapper/utils/ConstraintImplTest.java @@ -3,8 +3,8 @@ package cp_wrapper.utils; import cp_wrapper.mockups.*; import cp_wrapper.utils.constraint.Constraint; import cp_wrapper.utils.constraint.ConstraintImpl; -import cp_wrapper.utils.numeric_value_impl.DoubleValue; -import cp_wrapper.utils.numeric_value_impl.NumericValue; +import cp_wrapper.utils.numeric_value.implementations.DoubleValue; +import cp_wrapper.utils.numeric_value.NumericValueInterface; import eu.paasage.upperware.metamodel.cp.*; import eu.paasage.upperware.metamodel.types.BasicTypeEnum; import org.eclipse.emf.common.util.BasicEList; @@ -28,7 +28,7 @@ class ConstraintImplTest { } @Test public void shouldThrowEmptyVariables(){ - Map emptyVars = new HashMap<>(); + Map emptyVars = new HashMap<>(); Constraint constraint = new ConstraintImpl(ComparatorEnum.DIFFERENT, variables.get(0), variables.get(1)); assertThrows(RuntimeException.class, () -> { constraint.evaluate(emptyVars); @@ -39,7 +39,7 @@ class ConstraintImplTest { public void shouldThrowWrongVariables(){ Map emptyVars = new HashMap<>(); Constraint constraint = new ConstraintImpl(ComparatorEnum.DIFFERENT, variables.get(0), variables.get(1)); - Map vars = new HashMap<>(); + Map vars = new HashMap<>(); vars.put(names[1], new DoubleValue(0.00123)); vars.put(names[2], new DoubleValue(123.345)); assertThrows(RuntimeException.class, () -> { @@ -51,7 +51,7 @@ class ConstraintImplTest { public void linearConstraintEvaluationTest(){ Constant c = new ConstantImplMockup(BasicTypeEnum.DOUBLE, new NumericValueUpperwareImplMockup(1.0)); - Map vars = new HashMap<>(); + Map vars = new HashMap<>(); vars.put(names[0], new DoubleValue(2.0)); vars.put(names[1], new DoubleValue(0.00123)); vars.put(names[2], new DoubleValue(123.345)); @@ -81,7 +81,7 @@ class ConstraintImplTest { exprs = new BasicEList<>(); exprs.addAll(variables); NumericExpression sum = new ComposedExpressionImplMockup(exprs, OperatorEnum.PLUS); - Map vars = new HashMap<>(); + Map vars = new HashMap<>(); vars.put(names[0], new DoubleValue(2.0)); vars.put(names[1], new DoubleValue(3.0)); vars.put(names[2], new DoubleValue(5.0)); diff --git a/zpp-solver/cp-parser/src/test/java/cp_wrapper/utils/ExpressionEvaluatorTest.java b/zpp-solver/cp-parser/src/test/java/cp_wrapper/utils/ExpressionEvaluatorTest.java index f1cb6a27c..d6556335a 100644 --- a/zpp-solver/cp-parser/src/test/java/cp_wrapper/utils/ExpressionEvaluatorTest.java +++ b/zpp-solver/cp-parser/src/test/java/cp_wrapper/utils/ExpressionEvaluatorTest.java @@ -1,8 +1,8 @@ package cp_wrapper.utils; import cp_wrapper.mockups.*; -import cp_wrapper.utils.numeric_value_impl.DoubleValue; -import cp_wrapper.utils.numeric_value_impl.NumericValue; +import cp_wrapper.utils.numeric_value.implementations.DoubleValue; +import cp_wrapper.utils.numeric_value.NumericValueInterface; import eu.paasage.upperware.metamodel.cp.*; import eu.paasage.upperware.metamodel.types.BasicTypeEnum; import eu.paasage.upperware.metamodel.types.NumericValueUpperware; @@ -67,10 +67,10 @@ class ExpressionEvaluatorTest { double a = Math.random(); NumericValueUpperware val = new NumericValueUpperwareImplMockup(a); Constant c = new ConstantImplMockup(BasicTypeEnum.DOUBLE, val); - assertEquals(ExpressionEvaluator.evaluateExpression(c, new HashMap()), a); + assertEquals(ExpressionEvaluator.evaluateExpression(c, new HashMap()), a); CpMetric m = new CpMetricImplMockup(BasicTypeEnum.DOUBLE, val); - assertEquals(ExpressionEvaluator.evaluateExpression(m, new HashMap()), a); + assertEquals(ExpressionEvaluator.evaluateExpression(m, new HashMap()), a); } @Test @@ -78,7 +78,7 @@ class ExpressionEvaluatorTest { double a = Math.random(); String name = "Variable11"; CpVariable var = new CpVariableImplMockup(name, VariableType.CPU); - Map vars = new HashMap<>(); + Map vars = new HashMap<>(); vars.put(name, new DoubleValue(a)); assertEquals(ExpressionEvaluator.evaluateExpression(var, vars) , a); } @@ -111,7 +111,7 @@ class ExpressionEvaluatorTest { exprs.add(minus); exprs.add(var3); NumericExpression composed = new ComposedExpressionImplMockup(exprs, OperatorEnum.DIV); - Map vars = new HashMap<>(); + Map vars = new HashMap<>(); vars.put(names[0], new DoubleValue(vals[2])); vars.put(names[1],new DoubleValue( vals[3])); vars.put(names[2], new DoubleValue(vals[4])); diff --git a/zpp-solver/node-candidates-solver/src/main/java/nc_wrapper/DomainProvider.java b/zpp-solver/node-candidates-solver/src/main/java/nc_wrapper/DomainProvider.java index 022ddef01..f62640a16 100644 --- a/zpp-solver/node-candidates-solver/src/main/java/nc_wrapper/DomainProvider.java +++ b/zpp-solver/node-candidates-solver/src/main/java/nc_wrapper/DomainProvider.java @@ -1,11 +1,11 @@ package nc_wrapper; -import cp_wrapper.utils.numeric_value_impl.NumericValue; +import cp_wrapper.utils.numeric_value.NumericValueInterface; public interface DomainProvider { - NumericValue getMaxValue(int variable); + NumericValueInterface getMaxValue(int variable); - NumericValue getMinValue(int variable); + NumericValueInterface getMinValue(int variable); - boolean isInDomain(NumericValue value, int index); + boolean isInDomain(NumericValueInterface value, int index); } diff --git a/zpp-solver/node-candidates-solver/src/main/java/nc_wrapper/NCWrapper.java b/zpp-solver/node-candidates-solver/src/main/java/nc_wrapper/NCWrapper.java index cbd7aa2ba..b0bbe5e6c 100644 --- a/zpp-solver/node-candidates-solver/src/main/java/nc_wrapper/NCWrapper.java +++ b/zpp-solver/node-candidates-solver/src/main/java/nc_wrapper/NCWrapper.java @@ -7,7 +7,10 @@ import cp_wrapper.parser.CPParsedData; import cp_wrapper.parser.CPParser; import cp_wrapper.utils.DomainHandler; import cp_wrapper.utils.VariableNumericType; -import cp_wrapper.utils.numeric_value_impl.*; +import cp_wrapper.utils.numeric_value.*; +import cp_wrapper.utils.numeric_value.implementations.DoubleValue; +import cp_wrapper.utils.numeric_value.implementations.IntegerValue; +import cp_wrapper.utils.numeric_value.implementations.LongValue; import eu.melodic.upperware.utilitygenerator.cdo.cp_model.DTO.VariableValueDTO; import eu.melodic.upperware.utilitygenerator.cdo.cp_model.DTO.VariableValueDTOFactory; import eu.paasage.upperware.metamodel.cp.ConstraintProblem; @@ -69,8 +72,8 @@ public class NCWrapper implements DomainProvider { return variableOrderer.getComponents(); } - private Map convertAssignment(Map> assignment) { - Map res = new HashMap<>(); + private Map convertAssignment(Map> assignment) { + Map res = new HashMap<>(); for (Integer comp : assignment.keySet()) { res.put(componentTypeToName.get(new Pair(comp, VariableType.PROVIDER)), new IntegerValue((Integer) assignment.get(comp).getValue(0))); @@ -90,11 +93,11 @@ public class NCWrapper implements DomainProvider { return res; } - private List assignmentToVariableValueDTOList(Map assignments) { + private List assignmentToVariableValueDTOList(Map assignments) { List result = new ArrayList<>(); - for (Map.Entry a : assignments.entrySet()) { + for (Map.Entry a : assignments.entrySet()) { if (a.getKey() == null) continue; - NumericValue val = a.getValue(); + NumericValueInterface val = a.getValue(); if (cpParsedData.getVariableType(a.getKey()) == VariableNumericType.INT) { if (!(val instanceof IntValueInterface)) { throw new RuntimeException("Variable " + a.getKey() + " is not of integer type!"); @@ -110,13 +113,13 @@ public class NCWrapper implements DomainProvider { return result; } - private double getUtility(Map assignments) { + private double getUtility(Map assignments) { List vars = assignmentToVariableValueDTOList(assignments); return utilityProvider.evaluate(vars); } public Evaluation evaluate(Map> assignments) { - Map a = convertAssignment(assignments); + Map a = convertAssignment(assignments); if (cpParsedData.checkIfFeasible(a)) { return new PTEvaluation(getUtility(a)); } else { @@ -127,7 +130,7 @@ public class NCWrapper implements DomainProvider { Returns maximal value of variable @variable */ @Override - public NumericValue getMaxValue(int variable) { + public NumericValueInterface getMaxValue(int variable) { if (!variableOrderer.exists(variable)) { return new IntegerValue(0); } @@ -135,7 +138,7 @@ public class NCWrapper implements DomainProvider { } @Override - public NumericValue getMinValue(int variable) { + public NumericValueInterface getMinValue(int variable) { if (!variableOrderer.exists(variable)) { return new IntegerValue(0); } @@ -143,7 +146,7 @@ public class NCWrapper implements DomainProvider { } @Override - public boolean isInDomain(NumericValue value, int index) { + public boolean isInDomain(NumericValueInterface value, int index) { if (!variableOrderer.exists(index)) { return true; } else { diff --git a/zpp-solver/node-candidates-solver/src/main/java/node_candidate/NodeCandidatesPool.java b/zpp-solver/node-candidates-solver/src/main/java/node_candidate/NodeCandidatesPool.java index 7f24b54b7..04467118a 100644 --- a/zpp-solver/node-candidates-solver/src/main/java/node_candidate/NodeCandidatesPool.java +++ b/zpp-solver/node-candidates-solver/src/main/java/node_candidate/NodeCandidatesPool.java @@ -35,9 +35,9 @@ package node_candidate; */ import cp_components.PTMover; import cp_components.PTSolution; -import cp_wrapper.utils.numeric_value_impl.DoubleValue; -import cp_wrapper.utils.numeric_value_impl.IntegerValue; -import cp_wrapper.utils.numeric_value_impl.LongValue; +import cp_wrapper.utils.numeric_value.implementations.DoubleValue; +import cp_wrapper.utils.numeric_value.implementations.IntegerValue; +import cp_wrapper.utils.numeric_value.implementations.LongValue; import eu.paasage.upperware.metamodel.cp.VariableType; import nc_wrapper.DomainProvider; import variable_orderer.VariableTypeOrderer; diff --git a/zpp-solver/node-candidates-solver/src/test/java/node_candidate/NodeCandidatesPoolTest.java b/zpp-solver/node-candidates-solver/src/test/java/node_candidate/NodeCandidatesPoolTest.java index 3ab5409f0..3d5c7002f 100644 --- a/zpp-solver/node-candidates-solver/src/test/java/node_candidate/NodeCandidatesPoolTest.java +++ b/zpp-solver/node-candidates-solver/src/test/java/node_candidate/NodeCandidatesPoolTest.java @@ -2,8 +2,8 @@ package node_candidate; import cp_components.PTMover; import cp_components.PTSolution; -import cp_wrapper.utils.numeric_value_impl.IntegerValue; -import cp_wrapper.utils.numeric_value_impl.NumericValue; +import cp_wrapper.utils.numeric_value.implementations.IntegerValue; +import cp_wrapper.utils.numeric_value.NumericValueInterface; import nc_wrapper.DomainProvider; import org.javatuples.Quartet; import org.junit.jupiter.api.Test; @@ -21,17 +21,17 @@ class NodeCandidatesPoolTest { return new NodeCandidatesPool(new DomainProvider() { @Override - public NumericValue getMaxValue(int variable) { + public NumericValueInterface getMaxValue(int variable) { return new IntegerValue(2); } @Override - public NumericValue getMinValue(int variable) { + public NumericValueInterface getMinValue(int variable) { return new IntegerValue(0); } @Override - public boolean isInDomain(NumericValue value, int index) { + public boolean isInDomain(NumericValueInterface value, int index) { return true; } }, -- GitLab From 34076c7822887f7f7db02d1c24b615752476509a Mon Sep 17 00:00:00 2001 From: tc360950 Date: Fri, 10 Jan 2020 10:53:33 +0100 Subject: [PATCH 065/340] removed unnecessary printing from COnstraintGraph --- .../src/main/java/cp_wrapper/utils/ConstraintGraph.java | 1 - 1 file changed, 1 deletion(-) diff --git a/zpp-solver/cp-parser/src/main/java/cp_wrapper/utils/ConstraintGraph.java b/zpp-solver/cp-parser/src/main/java/cp_wrapper/utils/ConstraintGraph.java index d395c4411..6984a5d4d 100644 --- a/zpp-solver/cp-parser/src/main/java/cp_wrapper/utils/ConstraintGraph.java +++ b/zpp-solver/cp-parser/src/main/java/cp_wrapper/utils/ConstraintGraph.java @@ -75,7 +75,6 @@ public class ConstraintGraph { for (Constraint constraint : constraints) { Collection variables = constraint.getVariableNames(); for (String var : variables) { - System.out.println(var); knownDistances.get(var).addAll(variables); neighbourhoodList.get(var).get(1).addAll(variables); neighbourhoodList.get(var).get(1).remove(var); -- GitLab From d55a9ba610c7a979d333ad702299b4951ce62611 Mon Sep 17 00:00:00 2001 From: Michal Jankowski Date: Fri, 10 Jan 2020 12:07:02 +0100 Subject: [PATCH 066/340] Modified Mutator. Needed to implement a few changes. Added AssignmentComparator. --- .../main/java/GeneticSolverCoordinator.java | 6 +- .../cPGeneticWrapper/ACPGeneticWrapper.java | 7 -- .../cPGeneticWrapper/CPGeneticWrapper.java | 5 -- .../comparators/AssignmentComparator.java | 29 ++++++ .../StochasticRankingComparator.java | 17 +--- .../main/java/implementation/ImplGene.java | 4 - .../main/java/implementation/ImplMutator.java | 89 ++++++++++++++----- .../java/implementation/ImplSelector.java | 3 - .../java/sortingAlgortihms/MergeSort.java | 8 +- .../java/GeneticSolverCoordinatorTest.java | 38 +++++++- 10 files changed, 138 insertions(+), 68 deletions(-) create mode 100644 zpp-solver/genetic-solver/src/main/java/comparators/AssignmentComparator.java diff --git a/zpp-solver/genetic-solver/src/main/java/GeneticSolverCoordinator.java b/zpp-solver/genetic-solver/src/main/java/GeneticSolverCoordinator.java index 0656e622a..1606fc6e7 100644 --- a/zpp-solver/genetic-solver/src/main/java/GeneticSolverCoordinator.java +++ b/zpp-solver/genetic-solver/src/main/java/GeneticSolverCoordinator.java @@ -22,9 +22,11 @@ public class GeneticSolverCoordinator { @Setter private double crossoverProbability = 0.2; @Setter - private double mutatorProbability = 0.05; + private double mutatorProbability = 0.1; @Setter private double comparatorProbability = 0.1; + @Setter + private int guesses = 10; private final Function, Double> fitnessFunction = new EvalFunction(); @@ -44,7 +46,7 @@ public class GeneticSolverCoordinator { public List run(ACPGeneticWrapper geneticWrapper) { Alterer crossoverAlterer = new SinglePointCrossover<>(crossoverProbability); - Mutator mutator = new ImplMutator(mutatorProbability, geneticWrapper); + Mutator mutator = new ImplMutator(mutatorProbability, geneticWrapper, guesses); Selector selector = new ImplSelector(new StochasticRankingComparator(comparatorProbability)); Factory> gtf = diff --git a/zpp-solver/genetic-solver/src/main/java/cPGeneticWrapper/ACPGeneticWrapper.java b/zpp-solver/genetic-solver/src/main/java/cPGeneticWrapper/ACPGeneticWrapper.java index 33ab43a36..3540b6b4e 100644 --- a/zpp-solver/genetic-solver/src/main/java/cPGeneticWrapper/ACPGeneticWrapper.java +++ b/zpp-solver/genetic-solver/src/main/java/cPGeneticWrapper/ACPGeneticWrapper.java @@ -30,15 +30,8 @@ public abstract class ACPGeneticWrapper { public abstract boolean isValid(int value, int index); - public abstract boolean getIsFeasible(ISeq genes); - public abstract int getSize(); - - public static List phenotypeToIntegerList(Phenotype phenotype) { - return genotypeToIntegerList(phenotype.getGenotype()); - } - public static List genotypeToIntegerList(Genotype genotype) { return chromosomeToIntegerList((ImplChromosome) genotype.getChromosome()); } diff --git a/zpp-solver/genetic-solver/src/main/java/cPGeneticWrapper/CPGeneticWrapper.java b/zpp-solver/genetic-solver/src/main/java/cPGeneticWrapper/CPGeneticWrapper.java index c25ff4a7f..919c8e966 100644 --- a/zpp-solver/genetic-solver/src/main/java/cPGeneticWrapper/CPGeneticWrapper.java +++ b/zpp-solver/genetic-solver/src/main/java/cPGeneticWrapper/CPGeneticWrapper.java @@ -53,11 +53,6 @@ public class CPGeneticWrapper extends ACPGeneticWrapper { return cpWrapper.getMinDomainValue(index) <= value && value <= cpWrapper.getMaxDomainValue(index); } - @Override - public boolean getIsFeasible(ISeq genes) { - return cpWrapper.checkIfFeasible(genesToIntegerList(genes)); - } - @Override public int getSize() { return cpWrapper.getVariablesCount(); diff --git a/zpp-solver/genetic-solver/src/main/java/comparators/AssignmentComparator.java b/zpp-solver/genetic-solver/src/main/java/comparators/AssignmentComparator.java new file mode 100644 index 000000000..04b51004d --- /dev/null +++ b/zpp-solver/genetic-solver/src/main/java/comparators/AssignmentComparator.java @@ -0,0 +1,29 @@ +package comparators; + +import implementation.ImplChromosome; +import io.jenetics.util.RandomRegistry; + +import java.util.Random; + +/* + Compares two chromosomes using their utility and number of broken constraints. + */ +public class AssignmentComparator { + private final static Random random = RandomRegistry.getRandom(); + + public static int compare(ImplChromosome left, ImplChromosome right, double probability) { + return compare(left.getUtility(), right.getUtility(), left.getBrokenConstraints(), right.getBrokenConstraints(), probability); + } + + public static int compare(double leftUtility, double rightUtility, int leftBroken, int rightBroken, double probability) { + if (leftUtility == rightUtility && leftBroken == rightBroken) + return 0; + + if (leftBroken == rightBroken) + return Double.compare(leftUtility, rightUtility); + else if ((leftBroken == 0 || rightBroken == 0) && random.nextDouble() < probability) + return Double.compare(leftUtility, rightUtility); + else + return Integer.compare(rightBroken, leftBroken); + } +} diff --git a/zpp-solver/genetic-solver/src/main/java/comparators/StochasticRankingComparator.java b/zpp-solver/genetic-solver/src/main/java/comparators/StochasticRankingComparator.java index 8ac19f933..b0b94a699 100644 --- a/zpp-solver/genetic-solver/src/main/java/comparators/StochasticRankingComparator.java +++ b/zpp-solver/genetic-solver/src/main/java/comparators/StochasticRankingComparator.java @@ -16,25 +16,10 @@ public class StochasticRankingComparator implements Comparator left, Phenotype right) { - double leftUtility, rightUtility; // Utility value. - int leftBroken, rightBroken; // Number of broken constraints. ImplChromosome l = (ImplChromosome) left.getGenotype().getChromosome(); ImplChromosome r = (ImplChromosome) right.getGenotype().getChromosome(); - leftUtility = left.getFitness(); - rightUtility = right.getFitness(); - leftBroken = l.getBrokenConstraints(); - rightBroken = r.getBrokenConstraints(); - - if (leftUtility == rightUtility && leftBroken == rightBroken) - return 0; - - if (leftBroken == rightBroken) - return Double.compare(leftUtility, rightUtility); - else if ((l.isFeasible() || r.isFeasible()) && random.nextDouble() < probability) - return Double.compare(leftUtility, rightUtility); - else - return Integer.compare(rightBroken, leftBroken); + return AssignmentComparator.compare(l, r, probability); } } diff --git a/zpp-solver/genetic-solver/src/main/java/implementation/ImplGene.java b/zpp-solver/genetic-solver/src/main/java/implementation/ImplGene.java index 78a88740a..b66e4fdc3 100644 --- a/zpp-solver/genetic-solver/src/main/java/implementation/ImplGene.java +++ b/zpp-solver/genetic-solver/src/main/java/implementation/ImplGene.java @@ -42,10 +42,6 @@ public class ImplGene implements Gene { return new ImplGene(cpGeneticWrapper.generateRandomValue(index), index, cpGeneticWrapper); } - public ISeq seq(Integer length) { - return seq(length, cpGeneticWrapper); - } - public static ISeq seq(Integer length, ACPGeneticWrapper cpGeneticWrapper) { List list = new ArrayList<>(); diff --git a/zpp-solver/genetic-solver/src/main/java/implementation/ImplMutator.java b/zpp-solver/genetic-solver/src/main/java/implementation/ImplMutator.java index 4b4241ad2..f1651c082 100644 --- a/zpp-solver/genetic-solver/src/main/java/implementation/ImplMutator.java +++ b/zpp-solver/genetic-solver/src/main/java/implementation/ImplMutator.java @@ -1,10 +1,14 @@ package implementation; import cPGeneticWrapper.ACPGeneticWrapper; +import comparators.AssignmentComparator; import io.jenetics.Chromosome; +import io.jenetics.Gene; import io.jenetics.Mutator; import io.jenetics.MutatorResult; import io.jenetics.util.ISeq; +import io.jenetics.util.MSeq; + import java.util.Random; /* @@ -13,13 +17,15 @@ import java.util.Random; */ public class ImplMutator extends Mutator { private ACPGeneticWrapper geneticWrapper; + private int guesses; - public ImplMutator(double probability, ACPGeneticWrapper geneticWrapper) { + public ImplMutator(double probability, ACPGeneticWrapper geneticWrapper, int guesses) { super(probability); this.geneticWrapper = geneticWrapper; - + this.guesses = guesses; } + @Override protected MutatorResult> mutate( final Chromosome chromosome, @@ -29,47 +35,58 @@ public class ImplMutator extends Mutator { if (((ImplChromosome) chromosome).getBrokenConstraints() == 0) return super.mutate(chromosome, p, random); - // There are broken constraints mutate variable that breaks most constraints. - ISeq genes = chromosome.toSeq(); - int index = geneticWrapper.calculateHeuristicBest(genes); - int currentValue, initValue, bestValue = genes.get(index).getAllele(); - double currentUtility, bestUtility = ((ImplChromosome) chromosome).getUtility(); + // We should mutate randomly sometimes in order to leave local optimum. + if (random.nextDouble() < getProbability()) + return mutateRandomly(chromosome, p, random); + // There are broken constraints mutate variable that breaks most constraints. + MSeq genes = chromosome.toSeq().asMSeq(); + ImplGene mutatedGene; + ImplChromosome tmp, best, decreasingChromosome = null, increasingChromosome = null; + int index = geneticWrapper.calculateHeuristicBest(genes.asISeq()); + int currentValue, initValue = genes.get(index).getAllele(); - initValue = bestValue; + mutatedGene = genes.get(index); currentValue = initValue; + best = (ImplChromosome) chromosome; /* We're going to check whether we should be decreasing or increasing value in order to get better result. */ - double increasedUtility = -1, decreasedUtility = -1; int direction = 0; currentValue--; if (geneticWrapper.isValid(currentValue, index)) { - genes.asMSeq().set(index, genes.get(index).newInstance(currentValue)); - decreasedUtility = geneticWrapper.calculateUtility(genes); + genes.set(index, mutatedGene.newInstance(currentValue)); + decreasingChromosome = (ImplChromosome) best.newInstance(genes.asISeq()); } currentValue += 2; if (geneticWrapper.isValid(currentValue, index)) { - genes.asMSeq().set(index, genes.get(index).newInstance(currentValue)); - increasedUtility = geneticWrapper.calculateUtility(genes); + genes.set(index, mutatedGene.newInstance(currentValue)); + increasingChromosome = (ImplChromosome) best.newInstance(genes.asISeq()); } - if (increasedUtility > bestUtility && increasedUtility > decreasedUtility) - direction = 1; - else if (decreasedUtility > bestUtility) + if (increasingChromosome == null && decreasingChromosome != null && + AssignmentComparator.compare(decreasingChromosome, best, 0) > 0) direction = -1; + else if (increasingChromosome != null && decreasingChromosome == null && + AssignmentComparator.compare(increasingChromosome, best, 0) > 0) + direction = 1; + else if (increasingChromosome != null && decreasingChromosome != null) { + if (AssignmentComparator.compare(increasingChromosome, best, 0) > 0) + direction = 1; + else if (AssignmentComparator.compare(decreasingChromosome, best, 0) > 0) + direction = -1; + } + currentValue = initValue; /* Increase gene's values as long as utility increases. */ while (direction != 0) { currentValue += direction; if (geneticWrapper.isValid(currentValue, index)) { - genes.asMSeq().set(index, genes.get(index).newInstance(currentValue)); - currentUtility = geneticWrapper.calculateUtility(genes); + genes.set(index, mutatedGene.newInstance(currentValue)); + tmp = (ImplChromosome) best.newInstance(genes.asISeq()); - if (currentUtility > bestUtility) { - bestValue = currentValue; - bestUtility = currentUtility; - } + if (AssignmentComparator.compare(tmp, best, 0) > 0) + best = tmp; else // Utility no longer increases -> break from while. direction = 0; @@ -81,8 +98,32 @@ public class ImplMutator extends Mutator { } // Modify chromosome using best value. - genes.asMSeq().set(index, genes.get(index).newInstance(bestValue)); + genes.set(index, mutatedGene.newInstance(best.toSeq().get(index).getAllele())); + return MutatorResult.of(new ImplChromosome(genes.asISeq(), genes.length(), geneticWrapper)); + } + + /* Mutates randomly *guesses* times and returns the best guess. */ + protected MutatorResult> mutateRandomly( + final Chromosome chromosome, + final double p, + final Random random) { + + ImplChromosome best = (ImplChromosome) chromosome, tmp; + MSeq genes = best.toSeq().asMSeq(); + int index = geneticWrapper.calculateHeuristicBest(genes.asISeq()); + ImplGene mutatedGene; + + mutatedGene = genes.get(index); + + for (int i = 0; i < guesses; i++) { + genes.set(index, mutatedGene.newInstance()); + tmp = (ImplChromosome) best.newInstance(genes.asISeq()); + + if (AssignmentComparator.compare(tmp, best, 0) > 0) + best = tmp; + } - return MutatorResult.of(new ImplChromosome(genes, genes.length(), geneticWrapper)); + genes.set(index, mutatedGene.newInstance(best.toSeq().get(index).getAllele())); + return MutatorResult.of(new ImplChromosome(genes.asISeq(), genes.length(), geneticWrapper)); } } diff --git a/zpp-solver/genetic-solver/src/main/java/implementation/ImplSelector.java b/zpp-solver/genetic-solver/src/main/java/implementation/ImplSelector.java index 5b0731220..b69e913a5 100644 --- a/zpp-solver/genetic-solver/src/main/java/implementation/ImplSelector.java +++ b/zpp-solver/genetic-solver/src/main/java/implementation/ImplSelector.java @@ -14,8 +14,6 @@ import sortingAlgortihms.MergeSort; import java.util.Comparator; -import static java.util.Collections.reverseOrder; - /* Important part of this selector is that it can use custom comparators. */ @@ -47,7 +45,6 @@ public class ImplSelector implements Selector { int size = count; do { - //final int length = min(min(copy.size(), size), _n); final int length = min(copy.size(), size); for (int i = 0; i < length; ++i) { selection.set((count - size) + i, copy.get(i)); diff --git a/zpp-solver/genetic-solver/src/main/java/sortingAlgortihms/MergeSort.java b/zpp-solver/genetic-solver/src/main/java/sortingAlgortihms/MergeSort.java index 4cb4ccad7..4a55cd622 100644 --- a/zpp-solver/genetic-solver/src/main/java/sortingAlgortihms/MergeSort.java +++ b/zpp-solver/genetic-solver/src/main/java/sortingAlgortihms/MergeSort.java @@ -3,21 +3,21 @@ package sortingAlgortihms; import comparators.StochasticRankingComparator; import implementation.ImplGene; import io.jenetics.Phenotype; -import io.jenetics.util.ISeq; import io.jenetics.util.MSeq; -import java.util.ArrayList; import java.util.Comparator; import java.util.List; +/* + Simple merge sort that sorts using our comparator. + */ public class MergeSort { - private static Comparator> comparator = new StochasticRankingComparator(0.1); + private static Comparator> comparator = new StochasticRankingComparator(0); public static void merge(List> list, int from, int mid, int to) { int ptr1 = 0, ptr2 = 0; List> left, right; - left = list.subList(from, mid); right = list.subList(mid, to); diff --git a/zpp-solver/genetic-solver/src/test/java/GeneticSolverCoordinatorTest.java b/zpp-solver/genetic-solver/src/test/java/GeneticSolverCoordinatorTest.java index f63819857..e7c7c2ae2 100644 --- a/zpp-solver/genetic-solver/src/test/java/GeneticSolverCoordinatorTest.java +++ b/zpp-solver/genetic-solver/src/test/java/GeneticSolverCoordinatorTest.java @@ -19,9 +19,9 @@ public class GeneticSolverCoordinatorTest { cpWrapper.parse(problem.keySet().iterator().next(), problem.values().iterator().next()); GeneticSolverCoordinator geneticSolverCoordinator = new GeneticSolverCoordinator(); - geneticSolverCoordinator.setMutatorProbability(0.2); - geneticSolverCoordinator.setPopulationSize(10); - geneticSolverCoordinator.setIterations(1000); + geneticSolverCoordinator.setMutatorProbability(0.15); + geneticSolverCoordinator.setPopulationSize(100); + geneticSolverCoordinator.setIterations(100); geneticSolverCoordinator.setComparatorProbability(0.1); List assignment = geneticSolverCoordinator.run(cpWrapper); @@ -35,4 +35,36 @@ public class GeneticSolverCoordinatorTest { assertEquals((double) domain2.get(assignment.get(2)), 2.5, 0.01); assertEquals((double) domain3.get(assignment.get(0)), 9, 0.01); } +/* + @Test + public void LessSimpleTest() { + Map problem = Methods.prepareLessSimpleConstraintProblem(); + CPWrapper cpWrapper = new CPWrapper(); + cpWrapper.parse(problem.keySet().iterator().next(), problem.values().iterator().next()); + + GeneticSolverCoordinator geneticSolverCoordinator = new GeneticSolverCoordinator(); + geneticSolverCoordinator.setMutatorProbability(0.3); + geneticSolverCoordinator.setPopulationSize(100); + geneticSolverCoordinator.setIterations(100); + geneticSolverCoordinator.setComparatorProbability(0.05); + + List assignment = geneticSolverCoordinator.run(cpWrapper); + + + List domain1 = Arrays.asList(1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0); + List domain2 = Arrays.asList(0.5, 1.5, 2.5, 7.5, 10.0); + List domain3 = Arrays.asList(0.0, 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0); + List domain4 = Arrays.asList(1.0, 2.0, 3.0); + List domain5 = Arrays.asList(0.5, 7.5, 12.5); + + for (Integer number : assignment) { + System.out.println(number); + } + + /* + System.out.println("values: " + domain1.get(assignment.get(1)) + domain2.get(assignment.get(2))+ " "+ domain3.get(assignment.get(0))); + assertEquals((double) domain1.get(assignment.get(1)), 5.0, 0.01); + assertEquals((double) domain2.get(assignment.get(2)), 2.5, 0.01); + assertEquals((double) domain3.get(assignment.get(0)), 9, 0.01);*/ + //} } -- GitLab From 3692f3e9cd754113b6f42bc01e58f48ec7e24a32 Mon Sep 17 00:00:00 2001 From: Michal Jankowski Date: Fri, 10 Jan 2020 12:39:16 +0100 Subject: [PATCH 067/340] Modified mutator. Now it uses heuristicEvaluation from cpWrapper for assignment comparisons. --- .../cPGeneticWrapper/ACPGeneticWrapper.java | 4 +- .../cPGeneticWrapper/CPGeneticWrapper.java | 5 ++ .../main/java/implementation/ImplMutator.java | 57 ++++++++++--------- .../test/java/utility/CPGeneticWrapperA.java | 8 +-- 4 files changed, 43 insertions(+), 31 deletions(-) diff --git a/zpp-solver/genetic-solver/src/main/java/cPGeneticWrapper/ACPGeneticWrapper.java b/zpp-solver/genetic-solver/src/main/java/cPGeneticWrapper/ACPGeneticWrapper.java index 3540b6b4e..698238674 100644 --- a/zpp-solver/genetic-solver/src/main/java/cPGeneticWrapper/ACPGeneticWrapper.java +++ b/zpp-solver/genetic-solver/src/main/java/cPGeneticWrapper/ACPGeneticWrapper.java @@ -32,11 +32,13 @@ public abstract class ACPGeneticWrapper { public abstract int getSize(); + public abstract int getHeuristicEvaluation(List assignments, int variableIndex); + public static List genotypeToIntegerList(Genotype genotype) { return chromosomeToIntegerList((ImplChromosome) genotype.getChromosome()); } - private static List chromosomeToIntegerList(ImplChromosome chromosome) { + public static List chromosomeToIntegerList(ImplChromosome chromosome) { return genesToIntegerList(chromosome.toSeq()); } diff --git a/zpp-solver/genetic-solver/src/main/java/cPGeneticWrapper/CPGeneticWrapper.java b/zpp-solver/genetic-solver/src/main/java/cPGeneticWrapper/CPGeneticWrapper.java index 919c8e966..25f11caa4 100644 --- a/zpp-solver/genetic-solver/src/main/java/cPGeneticWrapper/CPGeneticWrapper.java +++ b/zpp-solver/genetic-solver/src/main/java/cPGeneticWrapper/CPGeneticWrapper.java @@ -57,4 +57,9 @@ public class CPGeneticWrapper extends ACPGeneticWrapper { public int getSize() { return cpWrapper.getVariablesCount(); } + + @Override + public int getHeuristicEvaluation(List assignments, int variableIndex) { + return cpWrapper.getHeuristicEvaluation(assignments, variableIndex); + } } diff --git a/zpp-solver/genetic-solver/src/main/java/implementation/ImplMutator.java b/zpp-solver/genetic-solver/src/main/java/implementation/ImplMutator.java index f1651c082..2efc32113 100644 --- a/zpp-solver/genetic-solver/src/main/java/implementation/ImplMutator.java +++ b/zpp-solver/genetic-solver/src/main/java/implementation/ImplMutator.java @@ -9,6 +9,7 @@ import io.jenetics.MutatorResult; import io.jenetics.util.ISeq; import io.jenetics.util.MSeq; +import java.util.List; import java.util.Random; /* @@ -40,39 +41,38 @@ public class ImplMutator extends Mutator { return mutateRandomly(chromosome, p, random); // There are broken constraints mutate variable that breaks most constraints. - MSeq genes = chromosome.toSeq().asMSeq(); - ImplGene mutatedGene; - ImplChromosome tmp, best, decreasingChromosome = null, increasingChromosome = null; - int index = geneticWrapper.calculateHeuristicBest(genes.asISeq()); - int currentValue, initValue = genes.get(index).getAllele(); + List assignments = ACPGeneticWrapper.chromosomeToIntegerList((ImplChromosome) chromosome); + int decreasingValue, increasingValue, bestValue, initValue, currentValue, index, bestHeuristic, tmp; - mutatedGene = genes.get(index); - currentValue = initValue; - best = (ImplChromosome) chromosome; + index = geneticWrapper.calculateHeuristicBest(chromosome.toSeq()); + initValue = assignments.get(index); + bestValue = initValue; + increasingValue = decreasingValue = -1; + bestHeuristic = geneticWrapper.getHeuristicEvaluation(assignments, index); /* We're going to check whether we should be decreasing or increasing value in order to get better result. */ int direction = 0; - currentValue--; + currentValue = initValue - 1; if (geneticWrapper.isValid(currentValue, index)) { - genes.set(index, mutatedGene.newInstance(currentValue)); - decreasingChromosome = (ImplChromosome) best.newInstance(genes.asISeq()); + assignments.set(index, currentValue); + decreasingValue = geneticWrapper.getHeuristicEvaluation(assignments, index); } - currentValue += 2; + currentValue = initValue + 1; if (geneticWrapper.isValid(currentValue, index)) { - genes.set(index, mutatedGene.newInstance(currentValue)); - increasingChromosome = (ImplChromosome) best.newInstance(genes.asISeq()); + assignments.set(index, currentValue); + increasingValue = geneticWrapper.getHeuristicEvaluation(assignments, index); } - if (increasingChromosome == null && decreasingChromosome != null && - AssignmentComparator.compare(decreasingChromosome, best, 0) > 0) + if (increasingValue == -1 && decreasingValue != -1 && + decreasingValue < bestHeuristic) direction = -1; - else if (increasingChromosome != null && decreasingChromosome == null && - AssignmentComparator.compare(increasingChromosome, best, 0) > 0) + else if (increasingValue != -1 && decreasingValue == -1 && + increasingValue < bestHeuristic) direction = 1; - else if (increasingChromosome != null && decreasingChromosome != null) { - if (AssignmentComparator.compare(increasingChromosome, best, 0) > 0) + else if (increasingValue != -1 && decreasingValue != -1) { + if (increasingValue < bestHeuristic) direction = 1; - else if (AssignmentComparator.compare(decreasingChromosome, best, 0) > 0) + else if (decreasingValue < bestHeuristic) direction = -1; } @@ -82,11 +82,14 @@ public class ImplMutator extends Mutator { currentValue += direction; if (geneticWrapper.isValid(currentValue, index)) { - genes.set(index, mutatedGene.newInstance(currentValue)); - tmp = (ImplChromosome) best.newInstance(genes.asISeq()); + assignments.set(index, currentValue); + tmp = geneticWrapper.getHeuristicEvaluation(assignments, index); + - if (AssignmentComparator.compare(tmp, best, 0) > 0) - best = tmp; + if (tmp < bestHeuristic) { + bestHeuristic = tmp; + bestValue = currentValue; + } else // Utility no longer increases -> break from while. direction = 0; @@ -98,7 +101,9 @@ public class ImplMutator extends Mutator { } // Modify chromosome using best value. - genes.set(index, mutatedGene.newInstance(best.toSeq().get(index).getAllele())); + MSeq genes = chromosome.toSeq().asMSeq(); + ImplGene mutatedGene = genes.get(index); + genes.set(index, mutatedGene.newInstance(bestValue)); return MutatorResult.of(new ImplChromosome(genes.asISeq(), genes.length(), geneticWrapper)); } diff --git a/zpp-solver/genetic-solver/src/test/java/utility/CPGeneticWrapperA.java b/zpp-solver/genetic-solver/src/test/java/utility/CPGeneticWrapperA.java index bbc670a85..582dda471 100644 --- a/zpp-solver/genetic-solver/src/test/java/utility/CPGeneticWrapperA.java +++ b/zpp-solver/genetic-solver/src/test/java/utility/CPGeneticWrapperA.java @@ -42,12 +42,12 @@ public class CPGeneticWrapperA extends ACPGeneticWrapper { } @Override - public boolean getIsFeasible(ISeq genes) { - return true; + public int getSize() { + return 10; } @Override - public int getSize() { - return 10; + public int getHeuristicEvaluation(List assignments, int variableIndex) { + return 0; } } -- GitLab From 1085db0b3acae6fc0be54df198b0ae683004e80d Mon Sep 17 00:00:00 2001 From: Michal Jankowski Date: Fri, 10 Jan 2020 13:30:46 +0100 Subject: [PATCH 068/340] Fixed EvalFunction. Added one slightly harder test. --- .../main/java/GeneticSolverCoordinator.java | 6 +++-- .../java/implementation/EvalFunction.java | 6 ++++- .../main/java/implementation/ImplMutator.java | 6 +++-- .../java/GeneticSolverCoordinatorTest.java | 26 ++++++++++--------- .../src/test/java/utility/Methods.java | 2 +- 5 files changed, 28 insertions(+), 18 deletions(-) diff --git a/zpp-solver/genetic-solver/src/main/java/GeneticSolverCoordinator.java b/zpp-solver/genetic-solver/src/main/java/GeneticSolverCoordinator.java index 1606fc6e7..c5d723ea5 100644 --- a/zpp-solver/genetic-solver/src/main/java/GeneticSolverCoordinator.java +++ b/zpp-solver/genetic-solver/src/main/java/GeneticSolverCoordinator.java @@ -22,7 +22,9 @@ public class GeneticSolverCoordinator { @Setter private double crossoverProbability = 0.2; @Setter - private double mutatorProbability = 0.1; + private double mutatorProbability = 0.3; + @Setter + private double mutationProbability = 0.1; @Setter private double comparatorProbability = 0.1; @Setter @@ -46,7 +48,7 @@ public class GeneticSolverCoordinator { public List run(ACPGeneticWrapper geneticWrapper) { Alterer crossoverAlterer = new SinglePointCrossover<>(crossoverProbability); - Mutator mutator = new ImplMutator(mutatorProbability, geneticWrapper, guesses); + Mutator mutator = new ImplMutator(mutationProbability, geneticWrapper, guesses, mutatorProbability); Selector selector = new ImplSelector(new StochasticRankingComparator(comparatorProbability)); Factory> gtf = diff --git a/zpp-solver/genetic-solver/src/main/java/implementation/EvalFunction.java b/zpp-solver/genetic-solver/src/main/java/implementation/EvalFunction.java index 9fb2c0854..da3defa90 100644 --- a/zpp-solver/genetic-solver/src/main/java/implementation/EvalFunction.java +++ b/zpp-solver/genetic-solver/src/main/java/implementation/EvalFunction.java @@ -7,6 +7,10 @@ import java.util.function.Function; public class EvalFunction implements Function, Double> { @Override public Double apply(Genotype chromosomes) { - return ((ImplChromosome) chromosomes.getChromosome()).getUtility(); + ImplChromosome chromosome = (ImplChromosome) chromosomes.getChromosome(); + + if (chromosome.getBrokenConstraints() > 0) + return 0.0; + return chromosome.getUtility(); } } diff --git a/zpp-solver/genetic-solver/src/main/java/implementation/ImplMutator.java b/zpp-solver/genetic-solver/src/main/java/implementation/ImplMutator.java index 2efc32113..d0a762fb7 100644 --- a/zpp-solver/genetic-solver/src/main/java/implementation/ImplMutator.java +++ b/zpp-solver/genetic-solver/src/main/java/implementation/ImplMutator.java @@ -18,12 +18,14 @@ import java.util.Random; */ public class ImplMutator extends Mutator { private ACPGeneticWrapper geneticWrapper; + private double probability; private int guesses; - public ImplMutator(double probability, ACPGeneticWrapper geneticWrapper, int guesses) { + public ImplMutator(double probability, ACPGeneticWrapper geneticWrapper, int guesses, double mutatorProbability) { super(probability); this.geneticWrapper = geneticWrapper; this.guesses = guesses; + this.probability = mutatorProbability; } @@ -37,7 +39,7 @@ public class ImplMutator extends Mutator { return super.mutate(chromosome, p, random); // We should mutate randomly sometimes in order to leave local optimum. - if (random.nextDouble() < getProbability()) + if (random.nextDouble() < probability) return mutateRandomly(chromosome, p, random); // There are broken constraints mutate variable that breaks most constraints. diff --git a/zpp-solver/genetic-solver/src/test/java/GeneticSolverCoordinatorTest.java b/zpp-solver/genetic-solver/src/test/java/GeneticSolverCoordinatorTest.java index e7c7c2ae2..92ac9257a 100644 --- a/zpp-solver/genetic-solver/src/test/java/GeneticSolverCoordinatorTest.java +++ b/zpp-solver/genetic-solver/src/test/java/GeneticSolverCoordinatorTest.java @@ -35,7 +35,7 @@ public class GeneticSolverCoordinatorTest { assertEquals((double) domain2.get(assignment.get(2)), 2.5, 0.01); assertEquals((double) domain3.get(assignment.get(0)), 9, 0.01); } -/* + @Test public void LessSimpleTest() { Map problem = Methods.prepareLessSimpleConstraintProblem(); @@ -43,9 +43,9 @@ public class GeneticSolverCoordinatorTest { cpWrapper.parse(problem.keySet().iterator().next(), problem.values().iterator().next()); GeneticSolverCoordinator geneticSolverCoordinator = new GeneticSolverCoordinator(); - geneticSolverCoordinator.setMutatorProbability(0.3); + geneticSolverCoordinator.setMutatorProbability(0.1); geneticSolverCoordinator.setPopulationSize(100); - geneticSolverCoordinator.setIterations(100); + geneticSolverCoordinator.setIterations(2000); geneticSolverCoordinator.setComparatorProbability(0.05); List assignment = geneticSolverCoordinator.run(cpWrapper); @@ -57,14 +57,16 @@ public class GeneticSolverCoordinatorTest { List domain4 = Arrays.asList(1.0, 2.0, 3.0); List domain5 = Arrays.asList(0.5, 7.5, 12.5); - for (Integer number : assignment) { - System.out.println(number); - } + assertEquals(assignment.get(0), (Integer) 3); + assertEquals(assignment.get(1), (Integer) 9); + assertEquals(assignment.get(2), (Integer) 4); + assertEquals(assignment.get(3), (Integer) 2); + assertEquals(assignment.get(4), (Integer) 2); - /* - System.out.println("values: " + domain1.get(assignment.get(1)) + domain2.get(assignment.get(2))+ " "+ domain3.get(assignment.get(0))); - assertEquals((double) domain1.get(assignment.get(1)), 5.0, 0.01); - assertEquals((double) domain2.get(assignment.get(2)), 2.5, 0.01); - assertEquals((double) domain3.get(assignment.get(0)), 9, 0.01);*/ - //} + System.out.print("values "); + System.out.print(domain1.get(assignment.get(0)) + " " + domain3.get(assignment.get(1)) + " " + + domain2.get(assignment.get(2)) + " " + domain4.get(assignment.get(3)) + " " + domain5.get(assignment.get(4)) + " "); + + + } } diff --git a/zpp-solver/genetic-solver/src/test/java/utility/Methods.java b/zpp-solver/genetic-solver/src/test/java/utility/Methods.java index 90f0222d2..5a3cca921 100644 --- a/zpp-solver/genetic-solver/src/test/java/utility/Methods.java +++ b/zpp-solver/genetic-solver/src/test/java/utility/Methods.java @@ -164,7 +164,7 @@ public class Methods { constraint5.setExp1(times); times = new ComposedExpressionImplMockup(exprs3, OperatorEnum.TIMES); constraint5.setExp2(times); - constraint5.setComparator(ComparatorEnum.LESS_OR_EQUAL_TO); + constraint5.setComparator(ComparatorEnum.LESS_THAN); EList consts = new BasicEList<>(); consts.add(c); -- GitLab From 2de813f87779aac29ded91994a75590fc6405960 Mon Sep 17 00:00:00 2001 From: tc360950 Date: Sun, 12 Jan 2020 17:05:41 +0100 Subject: [PATCH 069/340] Fixed all review comments --- .../src/main/java/cp_wrapper/CPWrapper.java | 13 +- .../java/cp_wrapper/utils/DomainHandler.java | 25 +- .../cp_wrapper/utils/ExpressionEvaluator.java | 28 +- .../numeric_value/IntValueInterface.java | 5 - .../numeric_value/NumericValueFactory.java | 21 ++ .../numeric_value/NumericValueInterface.java | 3 + .../implementations/DoubleValue.java | 18 +- .../implementations/IntegerValue.java | 21 +- .../implementations/LongValue.java | 19 +- .../src/main/java/cp_components/PTMover.java | 15 +- .../main/java/cp_components/PTSolution.java | 66 ++--- .../src/main/java/nc_wrapper/NCWrapper.java | 111 ++++---- .../node_candidate/GeographicCoordinate.java | 39 +-- .../node_candidate/NodeCandidatesPool.java | 264 ++++++++---------- .../java/node_candidate/VMConfiguration.java | 45 +-- .../VariableValueKeeperInterface.java | 13 + .../ComponentVariableOrderer.java | 45 ++- .../variable_orderer/VariableTypeOrderer.java | 1 - 18 files changed, 362 insertions(+), 390 deletions(-) delete mode 100644 zpp-solver/cp-parser/src/main/java/cp_wrapper/utils/numeric_value/IntValueInterface.java create mode 100644 zpp-solver/cp-parser/src/main/java/cp_wrapper/utils/numeric_value/NumericValueFactory.java create mode 100644 zpp-solver/node-candidates-solver/src/main/java/node_candidate/VariableValueKeeperInterface.java diff --git a/zpp-solver/cp-parser/src/main/java/cp_wrapper/CPWrapper.java b/zpp-solver/cp-parser/src/main/java/cp_wrapper/CPWrapper.java index fcf3895d3..f26848ac9 100644 --- a/zpp-solver/cp-parser/src/main/java/cp_wrapper/CPWrapper.java +++ b/zpp-solver/cp-parser/src/main/java/cp_wrapper/CPWrapper.java @@ -5,6 +5,8 @@ import cp_wrapper.parser.CPParser; import cp_wrapper.utils.DomainHandler; import cp_wrapper.utils.numeric_value.*; import cp_wrapper.utils.numeric_value.implementations.DoubleValue; +import cp_wrapper.utils.numeric_value.implementations.IntegerValue; +import cp_wrapper.utils.numeric_value.implementations.LongValue; import cp_wrapper.utils.variable_orderer.HeuristicVariableOrderer; import cp_wrapper.utils.VariableNumericType; import cp_wrapper.utils.variable_orderer.VariableOrderer; @@ -51,7 +53,7 @@ public class CPWrapper { return DomainHandler.getNumericListValue(value, (NumericListDomain) domain); } - throw new RuntimeException("Only domaind of types RangeDomain, NumericListDomain are supported!"); + throw new RuntimeException("Only domains of types RangeDomain, NumericListDomain are supported!"); } private Map getAssignmentFromValueList(List assignments) { @@ -86,13 +88,11 @@ public class CPWrapper { for (int i = 0; i < assignments.size(); i++) { NumericValueInterface val = getVariableValueFromDomainIndex(i, assignments.get(i)); if (cpParsedData.getVariableType(variableOrderer.getNameFromIndex(i)) == VariableNumericType.INT) { - if (!(val instanceof IntValueInterface)) { + if (!(val.isInteger())) { throw new RuntimeException(""); } result.add( - VariableValueDTOFactory.createElement( - variableOrderer.getNameFromIndex(i), - ((IntValueInterface) val).getIntValue() + VariableValueDTOFactory.createElement(variableOrderer.getNameFromIndex(i), val.getIntValue() ) ); } else { @@ -101,8 +101,7 @@ public class CPWrapper { } result.add( VariableValueDTOFactory.createElement( - variableOrderer.getNameFromIndex(i), - ((DoubleValue) val).getValue() + variableOrderer.getNameFromIndex(i), val.getDoubleValue() ) ); } diff --git a/zpp-solver/cp-parser/src/main/java/cp_wrapper/utils/DomainHandler.java b/zpp-solver/cp-parser/src/main/java/cp_wrapper/utils/DomainHandler.java index f641448d1..e74d45a04 100644 --- a/zpp-solver/cp-parser/src/main/java/cp_wrapper/utils/DomainHandler.java +++ b/zpp-solver/cp-parser/src/main/java/cp_wrapper/utils/DomainHandler.java @@ -5,9 +5,10 @@ package cp_wrapper.utils; into corresponding values. Currently only RangeDomain and NumericListDomain domains are supported. */ -import cp_wrapper.utils.numeric_value.IntValueInterface; +import cp_wrapper.utils.numeric_value.NumericValueFactory; import cp_wrapper.utils.numeric_value.implementations.IntegerValue; import cp_wrapper.utils.numeric_value.NumericValueInterface; +import cp_wrapper.utils.numeric_value.implementations.LongValue; import eu.paasage.upperware.metamodel.cp.Domain; import eu.paasage.upperware.metamodel.cp.NumericListDomain; import eu.paasage.upperware.metamodel.cp.RangeDomain; @@ -39,7 +40,7 @@ public class DomainHandler { if (values.size() <= valueIndex) { throw new RuntimeException(); } - return ExpressionEvaluator.convertNumericInterfaceToNumericValue(values.get(valueIndex)); + return NumericValueFactory.fromNumericValueInterface(values.get(valueIndex)); } public static int getMaxDomainValue(Domain domain) { @@ -69,39 +70,35 @@ public class DomainHandler { public static NumericValueInterface getMaxValue(Domain domain) { if (isRangeDomain(domain)) { - return ExpressionEvaluator.convertNumericInterfaceToNumericValue(((RangeDomain) domain).getTo()); + return NumericValueFactory.fromNumericValueInterface(((RangeDomain) domain).getTo()); } else if (isNumericListDomain(domain)) { List values = ((NumericListDomain) domain).getValues(); - return ExpressionEvaluator.convertNumericInterfaceToNumericValue(values.get(values.size() - 1)); + return NumericValueFactory.fromNumericValueInterface(values.get(values.size() - 1)); } throw new RuntimeException("Unsupported domain type"); } public static NumericValueInterface getMinValue(Domain domain) { if (isRangeDomain(domain)) { - return ExpressionEvaluator.convertNumericInterfaceToNumericValue(((RangeDomain) domain).getFrom()); + return NumericValueFactory.fromNumericValueInterface(((RangeDomain) domain).getFrom()); } else if (isNumericListDomain(domain)) { List values = ((NumericListDomain) domain).getValues(); - return ExpressionEvaluator.convertNumericInterfaceToNumericValue(values.get(0)); + return NumericValueFactory.fromNumericValueInterface(values.get(0)); } throw new RuntimeException("Unsupported domain type"); } private static boolean isInList(NumericValueInterface value, List list) { - for (NumericValueUpperware v : list) { - if (value.equals(ExpressionEvaluator.convertNumericInterfaceToNumericValue(v))) { - return true; - } - } - return false; + return list.stream() + .anyMatch(numericValue -> value.equals(NumericValueFactory.fromNumericValueInterface(numericValue))); } public static boolean isInDomain(NumericValueInterface value, Domain domain) { if (isRangeDomain(domain)) { - if (!(value instanceof IntValueInterface)) { + if (!value.isInteger()) { return false; } - int val = ((IntValueInterface) value).getIntValue(); + int val = value.getIntValue(); return val >= ExpressionEvaluator.getValueOfNumericInterface(((RangeDomain) domain).getFrom()) && val <= ExpressionEvaluator.getValueOfNumericInterface(((RangeDomain) domain).getTo()); diff --git a/zpp-solver/cp-parser/src/main/java/cp_wrapper/utils/ExpressionEvaluator.java b/zpp-solver/cp-parser/src/main/java/cp_wrapper/utils/ExpressionEvaluator.java index c11ea961b..838ce5c4e 100644 --- a/zpp-solver/cp-parser/src/main/java/cp_wrapper/utils/ExpressionEvaluator.java +++ b/zpp-solver/cp-parser/src/main/java/cp_wrapper/utils/ExpressionEvaluator.java @@ -23,19 +23,6 @@ public class ExpressionEvaluator { */ public static final double PRECISION = 0.1; - public static NumericValueInterface convertNumericInterfaceToNumericValue(NumericValueUpperware value) { - if (value instanceof IntegerValueUpperware) { - return new IntegerValue(((IntegerValueUpperware) value).getValue()); - } else if (value instanceof LongValueUpperware) { - return new LongValue(((LongValueUpperware) value).getValue()); - } else if (value instanceof DoubleValueUpperware) { - return new DoubleValue(((DoubleValueUpperware) value).getValue()); - } else if (value instanceof FloatValueUpperware) { - return new DoubleValue(((FloatValueUpperware) value).getValue()); - } - throw new RuntimeException("Unsupported NumericValueUpperware implementation"); - } - static double getValueOfNumericInterface(NumericValueUpperware value) { if (value instanceof IntegerValueUpperware) { return ((IntegerValueUpperware) value).getValue(); @@ -51,7 +38,7 @@ public class ExpressionEvaluator { static int getValueOfIntegerNumericInterface(IntegerValueUpperware value) { if (value instanceof IntegerValueUpperware) { - return ((IntegerValueUpperware) value).getValue(); + return (value).getValue(); } throw new RuntimeException("Only integer values are supported"); } @@ -95,24 +82,13 @@ public class ExpressionEvaluator { return evaluateOnOperator(exp.getOperator(), expressionsValues); } - private static double castNumericValueToDouble(NumericValueInterface val) { - if (val instanceof DoubleValue) { - return ((DoubleValue) val).getValue(); - } else if (val instanceof IntegerValue) { - return ((IntegerValue) val).getValue(); - } else if (val instanceof LongValue) { - return ((LongValue) val).getValue(); - } - throw new RuntimeException("Unsupported NumericValue type!"); - } - static double evaluateExpression(Expression exp, Map variables) { if (isConstant(exp)) { return getValueOfNumericInterface(((Constant) exp).getValue()); } else if (isCpMetric(exp)) { return getValueOfNumericInterface(((CpMetric) exp).getValue()); } else if (isCpVariable(exp)) { - return castNumericValueToDouble(variables.get(exp.getId())); + return variables.get(exp.getId()).getDoubleValue(); } else if (isComposedExpression(exp)) { return evaluateComposedExpression((ComposedExpression) exp, variables); } diff --git a/zpp-solver/cp-parser/src/main/java/cp_wrapper/utils/numeric_value/IntValueInterface.java b/zpp-solver/cp-parser/src/main/java/cp_wrapper/utils/numeric_value/IntValueInterface.java deleted file mode 100644 index 66aefc929..000000000 --- a/zpp-solver/cp-parser/src/main/java/cp_wrapper/utils/numeric_value/IntValueInterface.java +++ /dev/null @@ -1,5 +0,0 @@ -package cp_wrapper.utils.numeric_value; - -public interface IntValueInterface { - int getIntValue(); -} diff --git a/zpp-solver/cp-parser/src/main/java/cp_wrapper/utils/numeric_value/NumericValueFactory.java b/zpp-solver/cp-parser/src/main/java/cp_wrapper/utils/numeric_value/NumericValueFactory.java new file mode 100644 index 000000000..627330222 --- /dev/null +++ b/zpp-solver/cp-parser/src/main/java/cp_wrapper/utils/numeric_value/NumericValueFactory.java @@ -0,0 +1,21 @@ +package cp_wrapper.utils.numeric_value; + +import cp_wrapper.utils.numeric_value.implementations.DoubleValue; +import cp_wrapper.utils.numeric_value.implementations.IntegerValue; +import cp_wrapper.utils.numeric_value.implementations.LongValue; +import eu.paasage.upperware.metamodel.types.*; + +public class NumericValueFactory { + public static NumericValueInterface fromNumericValueInterface(NumericValueUpperware value) { + if (value instanceof IntegerValueUpperware) { + return new IntegerValue(((IntegerValueUpperware) value).getValue()); + } else if (value instanceof LongValueUpperware) { + return new LongValue(((LongValueUpperware) value).getValue()); + } else if (value instanceof DoubleValueUpperware) { + return new DoubleValue(((DoubleValueUpperware) value).getValue()); + } else if (value instanceof FloatValueUpperware) { + return new DoubleValue(((FloatValueUpperware) value).getValue()); + } + throw new RuntimeException("Unsupported NumericValueUpperware implementation"); + } +} diff --git a/zpp-solver/cp-parser/src/main/java/cp_wrapper/utils/numeric_value/NumericValueInterface.java b/zpp-solver/cp-parser/src/main/java/cp_wrapper/utils/numeric_value/NumericValueInterface.java index 4bab31798..d7e387e1c 100644 --- a/zpp-solver/cp-parser/src/main/java/cp_wrapper/utils/numeric_value/NumericValueInterface.java +++ b/zpp-solver/cp-parser/src/main/java/cp_wrapper/utils/numeric_value/NumericValueInterface.java @@ -2,4 +2,7 @@ package cp_wrapper.utils.numeric_value; public interface NumericValueInterface { boolean equals(NumericValueInterface value); + double getDoubleValue(); + int getIntValue(); + boolean isInteger(); } diff --git a/zpp-solver/cp-parser/src/main/java/cp_wrapper/utils/numeric_value/implementations/DoubleValue.java b/zpp-solver/cp-parser/src/main/java/cp_wrapper/utils/numeric_value/implementations/DoubleValue.java index a3888ec7e..ef8843e1b 100644 --- a/zpp-solver/cp-parser/src/main/java/cp_wrapper/utils/numeric_value/implementations/DoubleValue.java +++ b/zpp-solver/cp-parser/src/main/java/cp_wrapper/utils/numeric_value/implementations/DoubleValue.java @@ -7,15 +7,29 @@ import lombok.Setter; @AllArgsConstructor public class DoubleValue implements NumericValueInterface { - @Getter @Setter private double value; @Override public boolean equals(NumericValueInterface value) { if (value instanceof DoubleValue) { - return this.value == ((DoubleValue) value).getValue(); + return this.value == value.getDoubleValue(); } return false; } + + @Override + public double getDoubleValue() { + return value; + } + + @Override + public int getIntValue() { + return (int) value; + } + + @Override + public boolean isInteger() { + return false; + } } diff --git a/zpp-solver/cp-parser/src/main/java/cp_wrapper/utils/numeric_value/implementations/IntegerValue.java b/zpp-solver/cp-parser/src/main/java/cp_wrapper/utils/numeric_value/implementations/IntegerValue.java index 3a063dc51..80c9c71bf 100644 --- a/zpp-solver/cp-parser/src/main/java/cp_wrapper/utils/numeric_value/implementations/IntegerValue.java +++ b/zpp-solver/cp-parser/src/main/java/cp_wrapper/utils/numeric_value/implementations/IntegerValue.java @@ -1,24 +1,31 @@ package cp_wrapper.utils.numeric_value.implementations; -import cp_wrapper.utils.numeric_value.IntValueInterface; import cp_wrapper.utils.numeric_value.NumericValueInterface; import lombok.AllArgsConstructor; -import lombok.Getter; import lombok.Setter; @AllArgsConstructor -public class IntegerValue implements NumericValueInterface, IntValueInterface { - @Getter +public class IntegerValue implements NumericValueInterface { @Setter private int value; - public int getIntValue() { return getValue();} + public int getIntValue() { return value;} + + @Override + public boolean isInteger() { + return true; + } @Override public boolean equals(NumericValueInterface value) { - if (value instanceof IntValueInterface) { - return this.value == ((IntValueInterface) value).getIntValue(); + if (value instanceof IntegerValue || value instanceof LongValue) { + return this.value == value.getIntValue(); } return false; } + + @Override + public double getDoubleValue() { + return value; + } } diff --git a/zpp-solver/cp-parser/src/main/java/cp_wrapper/utils/numeric_value/implementations/LongValue.java b/zpp-solver/cp-parser/src/main/java/cp_wrapper/utils/numeric_value/implementations/LongValue.java index 902e40a64..2b42f9a1a 100644 --- a/zpp-solver/cp-parser/src/main/java/cp_wrapper/utils/numeric_value/implementations/LongValue.java +++ b/zpp-solver/cp-parser/src/main/java/cp_wrapper/utils/numeric_value/implementations/LongValue.java @@ -1,26 +1,33 @@ package cp_wrapper.utils.numeric_value.implementations; -import cp_wrapper.utils.numeric_value.IntValueInterface; import cp_wrapper.utils.numeric_value.NumericValueInterface; import lombok.AllArgsConstructor; import lombok.Getter; import lombok.Setter; @AllArgsConstructor -public class LongValue implements NumericValueInterface, IntValueInterface { +public class LongValue implements NumericValueInterface { @Getter @Setter private long value; public int getIntValue() { return (int) value;} + @Override + public boolean isInteger() { + return true; + } + @Override public boolean equals(NumericValueInterface value) { - if (value instanceof LongValue) { - return this.value == ((LongValue) value).getValue(); - } else if (value instanceof IntegerValue) { - return this.value == (long) ((IntegerValue) value).getValue(); + if (value instanceof IntegerValue || value instanceof LongValue) { + return this.value == value.getIntValue(); } return false; } + + @Override + public double getDoubleValue() { + return value; + } } diff --git a/zpp-solver/node-candidates-solver/src/main/java/cp_components/PTMover.java b/zpp-solver/node-candidates-solver/src/main/java/cp_components/PTMover.java index 85f636199..a6d2ac8c7 100644 --- a/zpp-solver/node-candidates-solver/src/main/java/cp_components/PTMover.java +++ b/zpp-solver/node-candidates-solver/src/main/java/cp_components/PTMover.java @@ -1,6 +1,7 @@ package cp_components; import lombok.AllArgsConstructor; +import lombok.EqualsAndHashCode; import org.jamesframework.core.search.neigh.Move; /* Class which abstracts moves in CP search space. @@ -9,6 +10,7 @@ import org.jamesframework.core.search.neigh.Move; */ @AllArgsConstructor +@EqualsAndHashCode public class PTMover implements Move { private PTSolution beforeMoveAssignment; private PTSolution afterMoveAssignment; @@ -23,17 +25,4 @@ public class PTMover implements Move { ptSolution.setVarAssignments(beforeMoveAssignment.getVarAssignments()); } - @Override - public boolean equals(Object o) { - if (o == this) { - return true; - } else if (getClass() != o.getClass()) { - return false; - } else { - PTMover m = (PTMover) o; - return m.afterMoveAssignment.equals(afterMoveAssignment) - && - m.beforeMoveAssignment.equals(beforeMoveAssignment); - } - } } diff --git a/zpp-solver/node-candidates-solver/src/main/java/cp_components/PTSolution.java b/zpp-solver/node-candidates-solver/src/main/java/cp_components/PTSolution.java index 724fe99eb..d47b09f1f 100644 --- a/zpp-solver/node-candidates-solver/src/main/java/cp_components/PTSolution.java +++ b/zpp-solver/node-candidates-solver/src/main/java/cp_components/PTSolution.java @@ -4,6 +4,7 @@ package cp_components; a full assignment of values to variables */ import lombok.AllArgsConstructor; +import lombok.EqualsAndHashCode; import lombok.Getter; import lombok.Setter; import node_candidate.GeographicCoordinate; @@ -13,70 +14,45 @@ import org.javatuples.Quartet; import java.util.*; @AllArgsConstructor +@EqualsAndHashCode public class PTSolution extends Solution { + private final int PROVIDER_INDEX = 0; + private final int CONFIGURATION_INDEX = 1; + private final int LOCATION_INDEX = 2; + private final int CARDINALITY_INDEX = 3; @Getter @Setter /* component -> (provider, Cores, Ram, Disk, latitude, longitude, cardinality) */ private Map> varAssignments; + @Override + public Solution copy() { + Map> varsClone = new HashMap<>(varAssignments); + return new PTSolution(varsClone); + } + public int extractProvider(int component) { - return varAssignments.get(component).getValue0(); + return (Integer) varAssignments.get(component).getValue(PROVIDER_INDEX); } public VMConfiguration extractVMConfiguration(int component) { - return (VMConfiguration) varAssignments.get(component).getValue(1); + return (VMConfiguration) varAssignments.get(component).getValue(CONFIGURATION_INDEX); } public GeographicCoordinate extractVMLocation(int component) { - return (GeographicCoordinate) varAssignments.get(component).getValue(2); + return (GeographicCoordinate) varAssignments.get(component).getValue(LOCATION_INDEX); } public int extractCardinality(int component) { - return (Integer) varAssignments.get(component).getValue(3); - } - - public PTSolution updateComponentConfiguration(int component, int provider, VMConfiguration n, - GeographicCoordinate l, int card) { - PTSolution sol = (PTSolution) this.copy(); - sol.varAssignments.put(component, new Quartet<>(provider, n, l, card)); - return sol; - } - - @Override - public Solution copy() { - Map> varsClone = new HashMap<>(varAssignments); - return new PTSolution(varsClone); - } - - private boolean equals(PTSolution s) { - if (s.varAssignments.size() != varAssignments.size()) { - return false; - } - for (Integer key : varAssignments.keySet()) { - if (!s.varAssignments.containsKey(key) - || !varAssignments.get(key).equals(s.varAssignments.get(key))) { - return false; - } - } - return true; + return (Integer) varAssignments.get(component).getValue(CARDINALITY_INDEX); } - @Override - public boolean equals(Object o) { - if (o == null) { - return false; - } - if (getClass() != o.getClass()) { - return false; - } - final PTSolution other = (PTSolution) o; - return equals(other); - } - - @Override - public int hashCode() { - return Objects.hashCode(varAssignments); + public PTSolution updateComponentConfiguration(int component, int provider, VMConfiguration conf, + GeographicCoordinate loc, int card) { + PTSolution solution = (PTSolution) this.copy(); + solution.varAssignments.put(component, new Quartet<>(provider, conf, loc, card)); + return solution; } } diff --git a/zpp-solver/node-candidates-solver/src/main/java/nc_wrapper/NCWrapper.java b/zpp-solver/node-candidates-solver/src/main/java/nc_wrapper/NCWrapper.java index b0bbe5e6c..8b0a3bb8b 100644 --- a/zpp-solver/node-candidates-solver/src/main/java/nc_wrapper/NCWrapper.java +++ b/zpp-solver/node-candidates-solver/src/main/java/nc_wrapper/NCWrapper.java @@ -38,7 +38,7 @@ public class NCWrapper implements DomainProvider { private CPParsedData cpParsedData; private ComponentVariableOrderer variableOrderer; private NodeCandidatesPool candidatesPool; - UtilityProvider utilityProvider; + private UtilityProvider utilityProvider; /* component, variable type -----> variable name @@ -53,23 +53,71 @@ public class NCWrapper implements DomainProvider { fillComponentTypeToName(cp); } + /* + Returns maximal value of variable @variable + */ + @Override + public NumericValueInterface getMaxValue(int variable) { + if (!variableOrderer.exists(variable)) { + return new IntegerValue(0); + } + return DomainHandler.getMaxValue(cpParsedData.getVariableDomain(variableOrderer.getNameFromIndex(variable))); + } + + @Override + public NumericValueInterface getMinValue(int variable) { + if (!variableOrderer.exists(variable)) { + return new IntegerValue(0); + } + return DomainHandler.getMinValue(cpParsedData.getVariableDomain(variableOrderer.getNameFromIndex(variable))); + } + + @Override + public boolean isInDomain(NumericValueInterface value, int index) { + return !variableOrderer.exists(index) || + DomainHandler.isInDomain(value, cpParsedData.getVariableDomain(variableOrderer.getNameFromIndex(index))); + } + public void setNodeCandidatesPool(NodeCandidatesPool candidatesPool) { this.candidatesPool = candidatesPool; } + public List getComponents() { + return variableOrderer.getComponents(); + } + + public Evaluation evaluate(Map> assignments) { + Map numericAssignment = convertAssignment(assignments); + if (cpParsedData.checkIfFeasible(numericAssignment)) { + return new PTEvaluation(getUtility(numericAssignment)); + } else { + return new PTEvaluation(0); + } + } + + private double getUtility(Map assignments) { + List vars = assignmentToVariableValueDTOList(assignments); + return utilityProvider.evaluate(vars); + } + private void fillComponentTypeToName(ConstraintProblem cp) { componentTypeToName = new HashMap<>(); List components = variableOrderer.getComponents(); for (int i = 0; i getComponents() { - return variableOrderer.getComponents(); + + /* + Generates random solution to the constraint problem. + Used to sample starting point for parallel tempering. + */ + public PTSolution generateRandom(Random random) { + return candidatesPool.generateRandom(random); } private Map convertAssignment(Map> assignment) { @@ -99,66 +147,17 @@ public class NCWrapper implements DomainProvider { if (a.getKey() == null) continue; NumericValueInterface val = a.getValue(); if (cpParsedData.getVariableType(a.getKey()) == VariableNumericType.INT) { - if (!(val instanceof IntValueInterface)) { + if (!(val.isInteger())) { throw new RuntimeException("Variable " + a.getKey() + " is not of integer type!"); } - result.add(VariableValueDTOFactory.createElement(a.getKey(), ((IntValueInterface) val).getIntValue())); + result.add(VariableValueDTOFactory.createElement(a.getKey(), val.getIntValue())); } else { if (!(val instanceof DoubleValue)) { throw new RuntimeException("Variable " + a.getKey() +" is not of double type!"); } - result.add(VariableValueDTOFactory.createElement(a.getKey(), ((DoubleValue) val).getValue())); + result.add(VariableValueDTOFactory.createElement(a.getKey(), val.getDoubleValue())); } } return result; } - - private double getUtility(Map assignments) { - List vars = assignmentToVariableValueDTOList(assignments); - return utilityProvider.evaluate(vars); - } - - public Evaluation evaluate(Map> assignments) { - Map a = convertAssignment(assignments); - if (cpParsedData.checkIfFeasible(a)) { - return new PTEvaluation(getUtility(a)); - } else { - return new PTEvaluation(0); - } - } - /* - Returns maximal value of variable @variable - */ - @Override - public NumericValueInterface getMaxValue(int variable) { - if (!variableOrderer.exists(variable)) { - return new IntegerValue(0); - } - return DomainHandler.getMaxValue(cpParsedData.getVariableDomain(variableOrderer.getNameFromIndex(variable))); - } - - @Override - public NumericValueInterface getMinValue(int variable) { - if (!variableOrderer.exists(variable)) { - return new IntegerValue(0); - } - return DomainHandler.getMinValue(cpParsedData.getVariableDomain(variableOrderer.getNameFromIndex(variable))); - } - - @Override - public boolean isInDomain(NumericValueInterface value, int index) { - if (!variableOrderer.exists(index)) { - return true; - } else { - return DomainHandler.isInDomain(value, cpParsedData.getVariableDomain(variableOrderer.getNameFromIndex(index))); - } - } - - /* - Generates random solution to the constraint problem. - Used to sample starting point for parallel tempering. - */ - public PTSolution generateRandom(Random random) { - return candidatesPool.generateRandom(random); - } } diff --git a/zpp-solver/node-candidates-solver/src/main/java/node_candidate/GeographicCoordinate.java b/zpp-solver/node-candidates-solver/src/main/java/node_candidate/GeographicCoordinate.java index 52fe61ebb..b71527f27 100644 --- a/zpp-solver/node-candidates-solver/src/main/java/node_candidate/GeographicCoordinate.java +++ b/zpp-solver/node-candidates-solver/src/main/java/node_candidate/GeographicCoordinate.java @@ -1,29 +1,24 @@ package node_candidate; +import cp_wrapper.utils.numeric_value.NumericValueInterface; +import cp_wrapper.utils.numeric_value.implementations.DoubleValue; +import eu.paasage.upperware.metamodel.cp.VariableType; import lombok.AllArgsConstructor; +import lombok.Data; import lombok.Getter; +import org.javatuples.Pair; +import variable_orderer.ComponentVariableOrderer; +import variable_orderer.VariableTypeOrderer; +import java.util.Arrays; +import java.util.List; + +@Data @AllArgsConstructor -public class GeographicCoordinate implements Comparable{ - @Getter +public class GeographicCoordinate implements Comparable, VariableValueKeeperInterface{ private double latitude; - @Getter private double longitude; - @Override - public boolean equals(Object obj) { - if (this == obj) { - return true; - } else if (obj == null) { - return false; - } else if (obj instanceof GeographicCoordinate) { - return latitude == ((GeographicCoordinate) obj).latitude - && - longitude == ((GeographicCoordinate) obj).longitude; - } - return false; - } - @Override public int compareTo(GeographicCoordinate o) { if (this.equals(o)) { @@ -34,4 +29,14 @@ public class GeographicCoordinate implements Comparable{ return -1; } } + + @Override + public List> getValues(int component) { + return Arrays.asList( + new Pair( new DoubleValue(latitude), component * ComponentVariableOrderer.VARIABLES_PER_COMPONENT + + VariableTypeOrderer.mapTypeToIndex(VariableType.LATITUDE)), + new Pair( new DoubleValue(longitude), component * ComponentVariableOrderer.VARIABLES_PER_COMPONENT + + VariableTypeOrderer.mapTypeToIndex(VariableType.LONGITUDE)) + ); + } } diff --git a/zpp-solver/node-candidates-solver/src/main/java/node_candidate/NodeCandidatesPool.java b/zpp-solver/node-candidates-solver/src/main/java/node_candidate/NodeCandidatesPool.java index 04467118a..0113c418c 100644 --- a/zpp-solver/node-candidates-solver/src/main/java/node_candidate/NodeCandidatesPool.java +++ b/zpp-solver/node-candidates-solver/src/main/java/node_candidate/NodeCandidatesPool.java @@ -40,9 +40,15 @@ import cp_wrapper.utils.numeric_value.implementations.IntegerValue; import cp_wrapper.utils.numeric_value.implementations.LongValue; import eu.paasage.upperware.metamodel.cp.VariableType; import nc_wrapper.DomainProvider; +import org.apache.commons.collections4.IterableGet; +import variable_orderer.ComponentVariableOrderer; import variable_orderer.VariableTypeOrderer; import java.util.*; +import java.util.stream.Collectors; +import java.util.stream.IntStream; + +import static java.util.stream.Collectors.toList; public class NodeCandidatesPool { private DomainProvider domainHandler; @@ -97,6 +103,15 @@ public class NodeCandidatesPool { fillMasks(); } + private void fillMasks() { + vmConfigurationMasks = new HashMap<>(); + vmLocationMasks = new HashMap<>(); + for (int i = 0; i < components.size(); i++) { + vmConfigurationMasks.put(i, getConfigurationMask(i)); + vmLocationMasks.put(i, getLocationMask(i)); + } + } + private Collection getVMConfigurationOrItsNeighbours(int provider, VMConfiguration conf, int component) { if (!vmConfigurations.containsKey(provider)) { return new ArrayList<>(); @@ -108,6 +123,12 @@ public class NodeCandidatesPool { } } + public List getAllMoves(PTSolution assignment) { + return IntStream.range(0, components.size()).mapToObj( + component -> getAllMovesComponent(assignment, component) + ) .collect(toList()).stream().flatMap(l -> l.stream()).collect(toList()); + } + private Collection getVMLocationOrItsNeighbours(int provider, GeographicCoordinate loc, int component) { if (!vmLocations.containsKey(provider)) { return new ArrayList<>(); @@ -119,104 +140,90 @@ public class NodeCandidatesPool { } } - private > Collection getNeighbours(List list, T element, List mask) { - if (mask.size() !=list.size()) { - throw new RuntimeException("Mask and list must be of equal length"); - } + private > Collection getElementNeighbours(List list, T element) { int index = Collections.binarySearch(list, element); Collection result = new ArrayList<>(); - if(index >= 0) { - if (index > 0) { - int i = index - 1; - while(i >= 0 && !mask.get(i)) i--; - if (i >= 0) { - result.add(list.get(i)); - } - } - if (index + 1 < list.size()) { - int i = index + 1; - while (i < list.size() && !mask.get(i)) i++; - if (i < list.size()) { - result.add(list.get(i)); - } - } - } else { + boolean notFoundInList = index < 0; + if (notFoundInList) { index = (-index) - 1; - if (index > 0) { - int i = index - 1; - while(i >= 0 && !mask.get(i)) i--; - if (i >= 0) { - result.add(list.get(i)); - } - } - if (index < list.size()) { - int i = index; - while (i < list.size() && !mask.get(i)) i++; - if (i < list.size()) { - result.add(list.get(i)); - } - } + } + if (index > 0) { + result.add(list.get(index - 1)); + } + if (notFoundInList && index < list.size()) { + result.add(list.get(index)); + } else if (!notFoundInList && index + 1 < list.size()) { + result.add(list.get(index + 1)); } return result; } - private Collection getVMConfigurationNeighbours(int provider, VMConfiguration conf, int component) { + private > List applyMaskToList(List list, List mask) { + return list.stream().filter( + element -> mask.get(list.indexOf(element)) + ).collect(toList()); + } + + private > Collection getNeighbours(List list, T element, List mask) { + if (mask.size() !=list.size()) { + throw new RuntimeException("Mask and list must be of equal length"); + } + return getElementNeighbours(applyMaskToList(list, mask), element); + } + + private Collection getVMConfigurationNeighbours(int provider, VMConfiguration configuration, int component) { if (!vmConfigurations.containsKey(provider)) { return new ArrayList<>(); } - return getNeighbours(vmConfigurations.get(provider), conf, vmConfigurationMasks.get(component).get(provider)); + return getNeighbours(vmConfigurations.get(provider), configuration, vmConfigurationMasks.get(component).get(provider)); } - private Collection getVMLocationNeighbours(int provider, GeographicCoordinate loc, int component) { + private Collection getVMLocationNeighbours(int provider, GeographicCoordinate location, int component) { if (!vmLocations.containsKey(provider)) { return new ArrayList<>(); } - return getNeighbours(vmLocations.get(provider), loc, vmLocationMasks.get(component).get(provider)); + return getNeighbours(vmLocations.get(provider), location, vmLocationMasks.get(component).get(provider)); } private Collection getAllVMConfigurationChangeMoves(PTSolution assignment, int component) { - Collection result = new ArrayList<>(); - VMConfiguration conf = assignment.extractVMConfiguration(component); int provider = assignment.extractProvider(component); - Collection neighbours = getVMConfigurationNeighbours(provider, conf, component); - for (VMConfiguration n : neighbours) { - result.add(new PTMover( - assignment, - assignment.updateComponentConfiguration( - component, provider, n, assignment.extractVMLocation(component), - assignment.extractCardinality(component)) - )); - } - return result; + return getVMConfigurationNeighbours(provider, assignment.extractVMConfiguration(component), component).stream() + .map( + configuration -> + new PTMover( + assignment, + assignment.updateComponentConfiguration( + component, provider, configuration, assignment.extractVMLocation(component), + assignment.extractCardinality(component)) + ) + + ).collect(toList()); } private Collection getAllVMLocationChangeMoves(PTSolution assignment, int component) { - Collection result = new ArrayList<>(); - GeographicCoordinate loc = assignment.extractVMLocation(component); int provider = assignment.extractProvider(component); - Collection neighbours = getVMLocationNeighbours(provider, loc, component); - for (GeographicCoordinate n : neighbours) { - result.add(new PTMover( + return getVMLocationNeighbours(provider, assignment.extractVMLocation(component), component).stream().map( + location -> + new PTMover( assignment, assignment.updateComponentConfiguration( - component, provider, assignment.extractVMConfiguration(component), n, + component, provider, assignment.extractVMConfiguration(component), location, assignment.extractCardinality(component)) - )); - } - return result; + ) + ).collect(toList()); } private Collection getAllCardinalityChangeMoves(PTSolution assignment, int component) { - int index = component * VariableTypeOrderer.variablesPerComponent + int index = component * ComponentVariableOrderer.VARIABLES_PER_COMPONENT + VariableTypeOrderer.mapTypeToIndex(VariableType.CARDINALITY); Collection result = new ArrayList<>(); - if (assignment.extractCardinality(component) < ((IntegerValue) domainHandler.getMaxValue(index)).getValue()) { + if (assignment.extractCardinality(component) < domainHandler.getMaxValue(index).getIntValue()) { result.add(new PTMover(assignment, assignment.updateComponentConfiguration( component, assignment.extractProvider(component), assignment.extractVMConfiguration(component), assignment.extractVMLocation(component), assignment.extractCardinality(component) + 1)) ); } - if (assignment.extractCardinality(component) > ((IntegerValue) domainHandler.getMinValue(index)).getValue()) { + if (assignment.extractCardinality(component) > domainHandler.getMinValue(index).getIntValue()) { result.add(new PTMover(assignment, assignment.updateComponentConfiguration( component, assignment.extractProvider(component), assignment.extractVMConfiguration(component), assignment.extractVMLocation(component), assignment.extractCardinality(component) - 1)) @@ -226,32 +233,27 @@ public class NodeCandidatesPool { } private Collection getAllProviderChangeMoves(PTSolution assignment, int component, int provider) { - Collection result = new ArrayList<>(); - Collection confs = - getVMConfigurationOrItsNeighbours(provider, assignment.extractVMConfiguration(component), component); - for (VMConfiguration conf : confs) { - Collection locs = - getVMLocationOrItsNeighbours( provider, assignment.extractVMLocation(component), component); - for (GeographicCoordinate loc : locs) { - result.add(new PTMover( - assignment, - assignment.updateComponentConfiguration( - component, - provider, - conf, - loc, - assignment.extractCardinality(component) - ) - )); - } - } - return result; + return getVMConfigurationOrItsNeighbours(provider, assignment.extractVMConfiguration(component), component).stream() + .map( configuration -> + getVMLocationOrItsNeighbours( provider, assignment.extractVMLocation(component), component).stream() + .map( location -> + new PTMover( + assignment, + assignment.updateComponentConfiguration( + component, + provider, + configuration, + location, + assignment.extractCardinality(component) + )) + ).collect(toList()) + ).flatMap(List::stream).collect(toList()); } private Collection getAllProviderChangeMoves(PTSolution assignment, int component) { int provider = assignment.extractProvider(component); - int maxProvider = ((IntegerValue) domainHandler.getMaxValue(component * VariableTypeOrderer.variablesPerComponent)).getValue(); - int minProvider = ((IntegerValue) domainHandler.getMinValue(component * VariableTypeOrderer.variablesPerComponent)).getValue(); + int maxProvider = domainHandler.getMaxValue(component * ComponentVariableOrderer.VARIABLES_PER_COMPONENT).getIntValue(); + int minProvider = domainHandler.getMinValue(component * ComponentVariableOrderer.VARIABLES_PER_COMPONENT).getIntValue(); Collection result = new ArrayList<>(); if (provider < maxProvider) { result.addAll(getAllProviderChangeMoves(assignment, component, provider + 1)); @@ -270,12 +272,19 @@ public class NodeCandidatesPool { return result; } - public List getAllMoves(PTSolution assignment) { - List moves = new ArrayList<>(); - for (int i = 0; i < components.size(); i++) { - moves.addAll(getAllMovesComponent(assignment, i)); + public PTSolution generateRandom(Random random) { + PTSolution solution = new PTSolution(new HashMap<>()); + for (int component = 0; component < components.size(); component++) { + int provider = getRandomProvider(random); + solution = solution.updateComponentConfiguration( + component, + provider, + vmConfigurations.get(provider).get(random.nextInt(vmConfigurations.get(provider).size())), + vmLocations.get(provider).get(random.nextInt(vmLocations.get(provider).size())), + getRandomCardinality(random, component) + ); } - return moves; + return solution; } private int getRandomProvider(Random random) { @@ -284,77 +293,36 @@ public class NodeCandidatesPool { } private int getRandomCardinality(Random random, int component) { - int index = component * VariableTypeOrderer.variablesPerComponent + int index = component * ComponentVariableOrderer.VARIABLES_PER_COMPONENT + VariableTypeOrderer.mapTypeToIndex(VariableType.CARDINALITY); - int max = ((IntegerValue) domainHandler.getMaxValue(index)).getValue(); - int min = ((IntegerValue) domainHandler.getMinValue(index)).getValue(); + int max = domainHandler.getMaxValue(index).getIntValue(); + int min = domainHandler.getMinValue(index).getIntValue(); if (max == min) return min; return min + random.nextInt(max-min); } - public PTSolution generateRandom(Random random) { - PTSolution sol = new PTSolution(new HashMap<>()); - for (int i = 0; i < components.size(); i++) { - int prov = getRandomProvider(random); - sol = sol.updateComponentConfiguration( - i, - prov, - vmConfigurations.get(prov).get(random.nextInt(vmConfigurations.get(prov).size())), - vmLocations.get(prov).get(random.nextInt(vmLocations.get(prov).size())), - getRandomCardinality(random, i) - ); - } - return sol; - } - - private boolean isInDomain(VMConfiguration conf, int component) { - return domainHandler.isInDomain( new LongValue(conf.getCores()), - component * VariableTypeOrderer.variablesPerComponent + VariableTypeOrderer.mapTypeToIndex(VariableType.CORES)) - && domainHandler.isInDomain( new LongValue(conf.getRam()), - component * VariableTypeOrderer.variablesPerComponent + VariableTypeOrderer.mapTypeToIndex(VariableType.RAM)) - && domainHandler.isInDomain( new DoubleValue(conf.getDisk()), - component * VariableTypeOrderer.variablesPerComponent + VariableTypeOrderer.mapTypeToIndex(VariableType.STORAGE)); + private boolean isInDomain(VariableValueKeeperInterface values, int component) { + return values.getValues(component).stream().allMatch( + value -> domainHandler.isInDomain(value.getValue0(), value.getValue1()) + ); } - private boolean isInDomain(GeographicCoordinate loc, int component) { - return domainHandler.isInDomain( new DoubleValue(loc.getLatitude()), - component * VariableTypeOrderer.variablesPerComponent + VariableTypeOrderer.mapTypeToIndex(VariableType.LATITUDE)) - && domainHandler.isInDomain( new DoubleValue(loc.getLongitude()), - component * VariableTypeOrderer.variablesPerComponent + VariableTypeOrderer.mapTypeToIndex(VariableType.LONGITUDE)); - } - - private Map> getConfigurationMask(int component) { + private Map> getMask(int component, Map> map) { Map> result = new HashMap<>(); - for (Integer key : vmConfigurations.keySet()) { - result.put(key, new ArrayList<>()); - List confs = vmConfigurations.get(key); - for (int i = 0; i < confs.size(); i++) { - boolean mask = isInDomain(confs.get(i), component); - result.get(key).add(mask); - } - } + map.keySet().forEach( + key -> { + result.put(key, new ArrayList<>()); + map.get(key).forEach( value -> result.get(key).add(isInDomain(value, component))); + } + ); return result; } - private Map> getLocationMask(int component) { - Map> result = new HashMap<>(); - for (Integer key : vmLocations.keySet()) { - result.put(key, new ArrayList<>()); - List locs = vmLocations.get(key); - for (int i = 0; i < locs.size(); i++) { - boolean mask = isInDomain(locs.get(i), component); - result.get(key).add(mask); - } - } - return result; + private Map> getConfigurationMask(int component) { + return getMask(component, vmConfigurations); } - private void fillMasks() { - vmConfigurationMasks = new HashMap<>(); - vmLocationMasks = new HashMap<>(); - for (int i = 0; i < components.size(); i++) { - vmConfigurationMasks.put(i, getConfigurationMask(i)); - vmLocationMasks.put(i, getLocationMask(i)); - } + private Map> getLocationMask(int component) { + return getMask(component, vmLocations); } } diff --git a/zpp-solver/node-candidates-solver/src/main/java/node_candidate/VMConfiguration.java b/zpp-solver/node-candidates-solver/src/main/java/node_candidate/VMConfiguration.java index 0677b7b5c..9ba47ab8b 100644 --- a/zpp-solver/node-candidates-solver/src/main/java/node_candidate/VMConfiguration.java +++ b/zpp-solver/node-candidates-solver/src/main/java/node_candidate/VMConfiguration.java @@ -1,33 +1,26 @@ package node_candidate; +import cp_wrapper.utils.numeric_value.NumericValueInterface; +import cp_wrapper.utils.numeric_value.implementations.DoubleValue; +import cp_wrapper.utils.numeric_value.implementations.LongValue; +import eu.paasage.upperware.metamodel.cp.VariableType; import lombok.AllArgsConstructor; +import lombok.Data; import lombok.Getter; +import org.javatuples.Pair; +import variable_orderer.ComponentVariableOrderer; +import variable_orderer.VariableTypeOrderer; +import java.util.Arrays; +import java.util.List; + +@Data @AllArgsConstructor -public class VMConfiguration implements Comparable { - @Getter +public class VMConfiguration implements Comparable, VariableValueKeeperInterface{ private long cores; - @Getter private long ram; - @Getter private double disk; - @Override - public boolean equals(Object obj) { - if (this == obj) { - return true; - } else if (obj == null) { - return false; - } else if (obj instanceof VMConfiguration) { - return cores == ((VMConfiguration) obj).cores - && - ram == ((VMConfiguration) obj).ram - && - disk == ((VMConfiguration) obj).disk; - } - return false; - } - @Override public int compareTo(VMConfiguration o) { if (this.equals(o)) { @@ -42,4 +35,16 @@ public class VMConfiguration implements Comparable { return -1; } } + + @Override + public List> getValues(int component) { + return Arrays.asList( + new Pair(new LongValue(cores), component * ComponentVariableOrderer.VARIABLES_PER_COMPONENT + + VariableTypeOrderer.mapTypeToIndex(VariableType.CORES)), + new Pair(new LongValue(ram), component * ComponentVariableOrderer.VARIABLES_PER_COMPONENT + + VariableTypeOrderer.mapTypeToIndex(VariableType.RAM)), + new Pair(new DoubleValue(disk), component * ComponentVariableOrderer.VARIABLES_PER_COMPONENT + + VariableTypeOrderer.mapTypeToIndex(VariableType.STORAGE)) + ); + } } diff --git a/zpp-solver/node-candidates-solver/src/main/java/node_candidate/VariableValueKeeperInterface.java b/zpp-solver/node-candidates-solver/src/main/java/node_candidate/VariableValueKeeperInterface.java new file mode 100644 index 000000000..f4ee85cf3 --- /dev/null +++ b/zpp-solver/node-candidates-solver/src/main/java/node_candidate/VariableValueKeeperInterface.java @@ -0,0 +1,13 @@ +package node_candidate; + +import cp_wrapper.utils.numeric_value.NumericValueInterface; +import org.javatuples.Pair; + +import java.util.List; + +public interface VariableValueKeeperInterface { + /* + Pairs + */ + List> getValues(int component); +} diff --git a/zpp-solver/node-candidates-solver/src/main/java/variable_orderer/ComponentVariableOrderer.java b/zpp-solver/node-candidates-solver/src/main/java/variable_orderer/ComponentVariableOrderer.java index c8fcd4815..ebfb1350e 100644 --- a/zpp-solver/node-candidates-solver/src/main/java/variable_orderer/ComponentVariableOrderer.java +++ b/zpp-solver/node-candidates-solver/src/main/java/variable_orderer/ComponentVariableOrderer.java @@ -5,10 +5,8 @@ import eu.paasage.upperware.metamodel.cp.ConstraintProblem; import eu.paasage.upperware.metamodel.cp.CpVariable; import lombok.Getter; -import java.util.ArrayList; -import java.util.HashMap; -import java.util.List; -import java.util.Map; +import java.util.*; + /* Components are ordered non-deterministically. Variables are ordered according to pairs @@ -22,13 +20,19 @@ import java.util.Map; public class ComponentVariableOrderer implements VariableOrderer { @Getter private List components; - private final int variablesPerComponent = 7; private Map indexToVariableName; + public static final int VARIABLES_PER_COMPONENT = 7; public ComponentVariableOrderer(ConstraintProblem cp) { fillComponents(cp); fillIndexToVariable(cp); } + + @Override + public String getNameFromIndex(int var) { + return indexToVariableName.get(var); + } + /* True if variable with a given index exists in the model */ @@ -38,33 +42,28 @@ public class ComponentVariableOrderer implements VariableOrderer { private void fillComponents(ConstraintProblem cp) { components = new ArrayList<>(); - for (CpVariable var : cp.getCpVariables()) { + cp.getCpVariables().forEach( var -> { if (!components.contains(var.getComponentId())) { components.add(var.getComponentId()); - } - } + }}); } private int getComponentIndex(String name) { - for (int i = 0; i < components.size(); i++) { - if (components.get(i).equals(name)) { - return variablesPerComponent * i; - } + int componentIndex = components.indexOf(name); + if (componentIndex >= 0) { + return VARIABLES_PER_COMPONENT * componentIndex; } - throw new RuntimeException(); + throw new RuntimeException("Component with name " + name + " does not exist!"); } private void fillIndexToVariable(ConstraintProblem cp) { indexToVariableName = new HashMap<>(); - for (CpVariable var : cp.getCpVariables()) { - int componentIndex = getComponentIndex(var.getComponentId()); - int index = componentIndex + VariableTypeOrderer.mapTypeToIndex(var.getVariableType()); - indexToVariableName.put(index, var.getId()); - } - } - - @Override - public String getNameFromIndex(int var) { - return indexToVariableName.get(var); + cp.getCpVariables().forEach( + var -> { + int componentIndex = getComponentIndex(var.getComponentId()); + int index = componentIndex + VariableTypeOrderer.mapTypeToIndex(var.getVariableType()); + indexToVariableName.put(index, var.getId()); + } + ); } } diff --git a/zpp-solver/node-candidates-solver/src/main/java/variable_orderer/VariableTypeOrderer.java b/zpp-solver/node-candidates-solver/src/main/java/variable_orderer/VariableTypeOrderer.java index 5f91a4b27..956980eba 100644 --- a/zpp-solver/node-candidates-solver/src/main/java/variable_orderer/VariableTypeOrderer.java +++ b/zpp-solver/node-candidates-solver/src/main/java/variable_orderer/VariableTypeOrderer.java @@ -3,7 +3,6 @@ package variable_orderer; import eu.paasage.upperware.metamodel.cp.VariableType; public class VariableTypeOrderer { - public static final int variablesPerComponent = 7; public static int mapTypeToIndex(VariableType type) { switch(type) { case PROVIDER: -- GitLab From 702b522bfe4489bf9125c89fdbd2f103f4d35782 Mon Sep 17 00:00:00 2001 From: tc360950 Date: Mon, 13 Jan 2020 21:49:53 +0100 Subject: [PATCH 070/340] Changed Node Quarter to map of NodeCandidateElementInterface --- .../src/main/java/NCSolverCoordinator.java | 7 +--- .../main/java/cp_components/PTSolution.java | 37 +++++++++++-------- .../src/main/java/nc_wrapper/NCWrapper.java | 26 +++++++------ .../node_candidate/NodeCandidatesPool.java | 21 ++++------- .../GeographicCoordinate.java | 7 ++-- .../IntegerNodeCandidateElementImpl.java | 10 +++++ .../NodeCandidateElementInterface.java | 8 ++++ .../VMConfiguration.java | 7 ++-- .../test/java/NCSolverCoordinatorTest.java | 3 +- .../java/cp_components/PTSolutionTest.java | 25 ++++++++++--- .../GeographicCoordinateTest.java | 1 + .../NodeCandidatesPoolTest.java | 13 ++++++- .../node_candidate/VMConfigurationTest.java | 1 + 13 files changed, 106 insertions(+), 60 deletions(-) rename zpp-solver/node-candidates-solver/src/main/java/node_candidate/{ => node_candidate_element}/GeographicCoordinate.java (88%) create mode 100644 zpp-solver/node-candidates-solver/src/main/java/node_candidate/node_candidate_element/IntegerNodeCandidateElementImpl.java create mode 100644 zpp-solver/node-candidates-solver/src/main/java/node_candidate/node_candidate_element/NodeCandidateElementInterface.java rename zpp-solver/node-candidates-solver/src/main/java/node_candidate/{ => node_candidate_element}/VMConfiguration.java (90%) diff --git a/zpp-solver/node-candidates-solver/src/main/java/NCSolverCoordinator.java b/zpp-solver/node-candidates-solver/src/main/java/NCSolverCoordinator.java index fcaf963de..2be783d0c 100644 --- a/zpp-solver/node-candidates-solver/src/main/java/NCSolverCoordinator.java +++ b/zpp-solver/node-candidates-solver/src/main/java/NCSolverCoordinator.java @@ -1,20 +1,17 @@ import cp_components.*; -import cp_wrapper.CPWrapper; import cp_wrapper.UtilityProvider; -import cp_wrapper.parser.CPParsedData; import eu.melodic.cache.NodeCandidates; import io.github.cloudiator.rest.model.NodeCandidate; import nc_wrapper.NCWrapper; -import node_candidate.GeographicCoordinate; +import node_candidate.node_candidate_element.GeographicCoordinate; import node_candidate.NodeCandidatesPool; import eu.paasage.upperware.metamodel.cp.ConstraintProblem; -import node_candidate.VMConfiguration; +import node_candidate.node_candidate_element.VMConfiguration; import org.jamesframework.core.problems.GenericProblem; import org.jamesframework.core.problems.Problem; import org.jamesframework.core.search.algo.ParallelTempering; import org.jamesframework.core.search.stopcriteria.StopCriterion; -import java.util.ArrayList; import java.util.List; import java.util.Map; diff --git a/zpp-solver/node-candidates-solver/src/main/java/cp_components/PTSolution.java b/zpp-solver/node-candidates-solver/src/main/java/cp_components/PTSolution.java index d47b09f1f..fbe1a6faf 100644 --- a/zpp-solver/node-candidates-solver/src/main/java/cp_components/PTSolution.java +++ b/zpp-solver/node-candidates-solver/src/main/java/cp_components/PTSolution.java @@ -7,8 +7,10 @@ import lombok.AllArgsConstructor; import lombok.EqualsAndHashCode; import lombok.Getter; import lombok.Setter; -import node_candidate.GeographicCoordinate; -import node_candidate.VMConfiguration; +import node_candidate.node_candidate_element.GeographicCoordinate; +import node_candidate.node_candidate_element.IntegerNodeCandidateElementImpl; +import node_candidate.node_candidate_element.NodeCandidateElementInterface; +import node_candidate.node_candidate_element.VMConfiguration; import org.jamesframework.core.problems.sol.Solution; import org.javatuples.Quartet; @@ -17,42 +19,47 @@ import java.util.*; @EqualsAndHashCode public class PTSolution extends Solution { - private final int PROVIDER_INDEX = 0; - private final int CONFIGURATION_INDEX = 1; - private final int LOCATION_INDEX = 2; - private final int CARDINALITY_INDEX = 3; + public static final int PROVIDER_INDEX = 0; + public static final int CONFIGURATION_INDEX = 1; + public static final int LOCATION_INDEX = 2; + public static final int CARDINALITY_INDEX = 3; @Getter @Setter /* component -> (provider, Cores, Ram, Disk, latitude, longitude, cardinality) */ - private Map> varAssignments; + private Map> varAssignments; @Override public Solution copy() { - Map> varsClone = new HashMap<>(varAssignments); + Map> varsClone = new HashMap<>(varAssignments); return new PTSolution(varsClone); } public int extractProvider(int component) { - return (Integer) varAssignments.get(component).getValue(PROVIDER_INDEX); + return ((IntegerNodeCandidateElementImpl) varAssignments.get(component).get(PROVIDER_INDEX)).getValue(); } public VMConfiguration extractVMConfiguration(int component) { - return (VMConfiguration) varAssignments.get(component).getValue(CONFIGURATION_INDEX); + return (VMConfiguration) varAssignments.get(component).get(CONFIGURATION_INDEX); } public GeographicCoordinate extractVMLocation(int component) { - return (GeographicCoordinate) varAssignments.get(component).getValue(LOCATION_INDEX); + return (GeographicCoordinate) varAssignments.get(component).get(LOCATION_INDEX); } public int extractCardinality(int component) { - return (Integer) varAssignments.get(component).getValue(CARDINALITY_INDEX); + return ((IntegerNodeCandidateElementImpl) varAssignments.get(component).get(CARDINALITY_INDEX)).getValue(); } - public PTSolution updateComponentConfiguration(int component, int provider, VMConfiguration conf, - GeographicCoordinate loc, int card) { + public PTSolution updateComponentConfiguration(int component, int provider, VMConfiguration configuration, + GeographicCoordinate location, int cardinality) { PTSolution solution = (PTSolution) this.copy(); - solution.varAssignments.put(component, new Quartet<>(provider, conf, loc, card)); + solution.varAssignments.put(component, new HashMap(){{ + put(PROVIDER_INDEX, new IntegerNodeCandidateElementImpl(provider)); + put(CONFIGURATION_INDEX, configuration); + put(LOCATION_INDEX, location); + put(CARDINALITY_INDEX, new IntegerNodeCandidateElementImpl(cardinality)); + }}); return solution; } } diff --git a/zpp-solver/node-candidates-solver/src/main/java/nc_wrapper/NCWrapper.java b/zpp-solver/node-candidates-solver/src/main/java/nc_wrapper/NCWrapper.java index 8b0a3bb8b..e268a8550 100644 --- a/zpp-solver/node-candidates-solver/src/main/java/nc_wrapper/NCWrapper.java +++ b/zpp-solver/node-candidates-solver/src/main/java/nc_wrapper/NCWrapper.java @@ -16,9 +16,11 @@ import eu.melodic.upperware.utilitygenerator.cdo.cp_model.DTO.VariableValueDTOFa import eu.paasage.upperware.metamodel.cp.ConstraintProblem; import eu.paasage.upperware.metamodel.cp.CpVariable; import eu.paasage.upperware.metamodel.cp.VariableType; -import node_candidate.GeographicCoordinate; +import node_candidate.node_candidate_element.GeographicCoordinate; import node_candidate.NodeCandidatesPool; -import node_candidate.VMConfiguration; +import node_candidate.node_candidate_element.IntegerNodeCandidateElementImpl; +import node_candidate.node_candidate_element.NodeCandidateElementInterface; +import node_candidate.node_candidate_element.VMConfiguration; import org.jamesframework.core.problems.objectives.evaluations.Evaluation; import org.javatuples.Pair; import org.javatuples.Quartet; @@ -86,7 +88,7 @@ public class NCWrapper implements DomainProvider { return variableOrderer.getComponents(); } - public Evaluation evaluate(Map> assignments) { + public Evaluation evaluate(Map> assignments) { Map numericAssignment = convertAssignment(assignments); if (cpParsedData.checkIfFeasible(numericAssignment)) { return new PTEvaluation(getUtility(numericAssignment)); @@ -120,23 +122,25 @@ public class NCWrapper implements DomainProvider { return candidatesPool.generateRandom(random); } - private Map convertAssignment(Map> assignment) { + private Map convertAssignment(Map> assignment) { Map res = new HashMap<>(); for (Integer comp : assignment.keySet()) { res.put(componentTypeToName.get(new Pair(comp, VariableType.PROVIDER)), - new IntegerValue((Integer) assignment.get(comp).getValue(0))); + new IntegerValue( + ((IntegerNodeCandidateElementImpl) assignment.get(comp).get(PTSolution.PROVIDER_INDEX)).getValue())); res.put(componentTypeToName.get(new Pair(comp, VariableType.CORES)), - new LongValue(((VMConfiguration) assignment.get(comp).getValue(1)).getCores())); + new LongValue(((VMConfiguration) assignment.get(comp).get(PTSolution.CONFIGURATION_INDEX)).getCores())); res.put(componentTypeToName.get(new Pair(comp, VariableType.RAM)), - new LongValue(((VMConfiguration) assignment.get(comp).getValue(1)).getRam())); + new LongValue(((VMConfiguration) assignment.get(comp).get(PTSolution.CONFIGURATION_INDEX)).getRam())); res.put(componentTypeToName.get(new Pair(comp, VariableType.STORAGE)), - new DoubleValue(((VMConfiguration) assignment.get(comp).getValue(1)).getDisk())); + new DoubleValue(((VMConfiguration) assignment.get(comp).get(PTSolution.CONFIGURATION_INDEX)).getDisk())); res.put(componentTypeToName.get(new Pair(comp, VariableType.LATITUDE)), - new DoubleValue(((GeographicCoordinate) assignment.get(comp).getValue(2)).getLatitude())); + new DoubleValue(((GeographicCoordinate) assignment.get(comp).get(PTSolution.LOCATION_INDEX)).getLatitude())); res.put(componentTypeToName.get(new Pair(comp, VariableType.LONGITUDE)), - new DoubleValue(((GeographicCoordinate) assignment.get(comp).getValue(2)).getLongitude())); + new DoubleValue(((GeographicCoordinate) assignment.get(comp).get(PTSolution.LOCATION_INDEX)).getLongitude())); res.put(componentTypeToName.get(new Pair(comp, VariableType.CARDINALITY)), - new IntegerValue(((Integer) assignment.get(comp).getValue(3)))); + new IntegerValue( + ((IntegerNodeCandidateElementImpl) assignment.get(comp).get(PTSolution.CARDINALITY_INDEX)).getValue())); } return res; } diff --git a/zpp-solver/node-candidates-solver/src/main/java/node_candidate/NodeCandidatesPool.java b/zpp-solver/node-candidates-solver/src/main/java/node_candidate/NodeCandidatesPool.java index 0113c418c..a597f7eee 100644 --- a/zpp-solver/node-candidates-solver/src/main/java/node_candidate/NodeCandidatesPool.java +++ b/zpp-solver/node-candidates-solver/src/main/java/node_candidate/NodeCandidatesPool.java @@ -35,17 +35,14 @@ package node_candidate; */ import cp_components.PTMover; import cp_components.PTSolution; -import cp_wrapper.utils.numeric_value.implementations.DoubleValue; -import cp_wrapper.utils.numeric_value.implementations.IntegerValue; -import cp_wrapper.utils.numeric_value.implementations.LongValue; import eu.paasage.upperware.metamodel.cp.VariableType; import nc_wrapper.DomainProvider; -import org.apache.commons.collections4.IterableGet; +import node_candidate.node_candidate_element.GeographicCoordinate; +import node_candidate.node_candidate_element.VMConfiguration; import variable_orderer.ComponentVariableOrderer; import variable_orderer.VariableTypeOrderer; import java.util.*; -import java.util.stream.Collectors; import java.util.stream.IntStream; import static java.util.stream.Collectors.toList; @@ -188,25 +185,23 @@ public class NodeCandidatesPool { private Collection getAllVMConfigurationChangeMoves(PTSolution assignment, int component) { int provider = assignment.extractProvider(component); return getVMConfigurationNeighbours(provider, assignment.extractVMConfiguration(component), component).stream() - .map( - configuration -> + .map( configuration -> new PTMover( assignment, assignment.updateComponentConfiguration( component, provider, configuration, assignment.extractVMLocation(component), assignment.extractCardinality(component)) ) - ).collect(toList()); } private Collection getAllVMLocationChangeMoves(PTSolution assignment, int component) { int provider = assignment.extractProvider(component); - return getVMLocationNeighbours(provider, assignment.extractVMLocation(component), component).stream().map( - location -> - new PTMover( - assignment, - assignment.updateComponentConfiguration( + return getVMLocationNeighbours(provider, assignment.extractVMLocation(component), component).stream() + .map(location -> + new PTMover( + assignment, + assignment.updateComponentConfiguration( component, provider, assignment.extractVMConfiguration(component), location, assignment.extractCardinality(component)) ) diff --git a/zpp-solver/node-candidates-solver/src/main/java/node_candidate/GeographicCoordinate.java b/zpp-solver/node-candidates-solver/src/main/java/node_candidate/node_candidate_element/GeographicCoordinate.java similarity index 88% rename from zpp-solver/node-candidates-solver/src/main/java/node_candidate/GeographicCoordinate.java rename to zpp-solver/node-candidates-solver/src/main/java/node_candidate/node_candidate_element/GeographicCoordinate.java index b71527f27..cb9fd12e4 100644 --- a/zpp-solver/node-candidates-solver/src/main/java/node_candidate/GeographicCoordinate.java +++ b/zpp-solver/node-candidates-solver/src/main/java/node_candidate/node_candidate_element/GeographicCoordinate.java @@ -1,11 +1,11 @@ -package node_candidate; +package node_candidate.node_candidate_element; import cp_wrapper.utils.numeric_value.NumericValueInterface; import cp_wrapper.utils.numeric_value.implementations.DoubleValue; import eu.paasage.upperware.metamodel.cp.VariableType; import lombok.AllArgsConstructor; import lombok.Data; -import lombok.Getter; +import node_candidate.VariableValueKeeperInterface; import org.javatuples.Pair; import variable_orderer.ComponentVariableOrderer; import variable_orderer.VariableTypeOrderer; @@ -15,7 +15,8 @@ import java.util.List; @Data @AllArgsConstructor -public class GeographicCoordinate implements Comparable, VariableValueKeeperInterface{ +public class GeographicCoordinate implements Comparable, + VariableValueKeeperInterface, NodeCandidateElementInterface { private double latitude; private double longitude; diff --git a/zpp-solver/node-candidates-solver/src/main/java/node_candidate/node_candidate_element/IntegerNodeCandidateElementImpl.java b/zpp-solver/node-candidates-solver/src/main/java/node_candidate/node_candidate_element/IntegerNodeCandidateElementImpl.java new file mode 100644 index 000000000..438cfa92e --- /dev/null +++ b/zpp-solver/node-candidates-solver/src/main/java/node_candidate/node_candidate_element/IntegerNodeCandidateElementImpl.java @@ -0,0 +1,10 @@ +package node_candidate.node_candidate_element; + +import lombok.AllArgsConstructor; +import lombok.Data; + +@AllArgsConstructor +@Data +public class IntegerNodeCandidateElementImpl implements NodeCandidateElementInterface { + private int value; +} diff --git a/zpp-solver/node-candidates-solver/src/main/java/node_candidate/node_candidate_element/NodeCandidateElementInterface.java b/zpp-solver/node-candidates-solver/src/main/java/node_candidate/node_candidate_element/NodeCandidateElementInterface.java new file mode 100644 index 000000000..257fcad17 --- /dev/null +++ b/zpp-solver/node-candidates-solver/src/main/java/node_candidate/node_candidate_element/NodeCandidateElementInterface.java @@ -0,0 +1,8 @@ +package node_candidate.node_candidate_element; + +public interface NodeCandidateElementInterface { + @Override + int hashCode(); + @Override + boolean equals(Object obj); +} diff --git a/zpp-solver/node-candidates-solver/src/main/java/node_candidate/VMConfiguration.java b/zpp-solver/node-candidates-solver/src/main/java/node_candidate/node_candidate_element/VMConfiguration.java similarity index 90% rename from zpp-solver/node-candidates-solver/src/main/java/node_candidate/VMConfiguration.java rename to zpp-solver/node-candidates-solver/src/main/java/node_candidate/node_candidate_element/VMConfiguration.java index 9ba47ab8b..47c1c8e55 100644 --- a/zpp-solver/node-candidates-solver/src/main/java/node_candidate/VMConfiguration.java +++ b/zpp-solver/node-candidates-solver/src/main/java/node_candidate/node_candidate_element/VMConfiguration.java @@ -1,4 +1,4 @@ -package node_candidate; +package node_candidate.node_candidate_element; import cp_wrapper.utils.numeric_value.NumericValueInterface; import cp_wrapper.utils.numeric_value.implementations.DoubleValue; @@ -6,7 +6,7 @@ import cp_wrapper.utils.numeric_value.implementations.LongValue; import eu.paasage.upperware.metamodel.cp.VariableType; import lombok.AllArgsConstructor; import lombok.Data; -import lombok.Getter; +import node_candidate.VariableValueKeeperInterface; import org.javatuples.Pair; import variable_orderer.ComponentVariableOrderer; import variable_orderer.VariableTypeOrderer; @@ -16,7 +16,8 @@ import java.util.List; @Data @AllArgsConstructor -public class VMConfiguration implements Comparable, VariableValueKeeperInterface{ +public class VMConfiguration implements Comparable, + VariableValueKeeperInterface, NodeCandidateElementInterface { private long cores; private long ram; private double disk; diff --git a/zpp-solver/node-candidates-solver/src/test/java/NCSolverCoordinatorTest.java b/zpp-solver/node-candidates-solver/src/test/java/NCSolverCoordinatorTest.java index 74d5f9f3a..06adcd076 100644 --- a/zpp-solver/node-candidates-solver/src/test/java/NCSolverCoordinatorTest.java +++ b/zpp-solver/node-candidates-solver/src/test/java/NCSolverCoordinatorTest.java @@ -4,13 +4,12 @@ import cp_wrapper.mockups.*; import eu.melodic.cache.NodeCandidates; import eu.melodic.upperware.utilitygenerator.cdo.cp_model.DTO.VariableValueDTO; import eu.paasage.upperware.metamodel.cp.*; -import eu.paasage.upperware.metamodel.cp.impl.CpVariableImpl; import eu.paasage.upperware.metamodel.types.BasicTypeEnum; import io.github.cloudiator.rest.model.GeoLocation; import io.github.cloudiator.rest.model.Hardware; import io.github.cloudiator.rest.model.Location; import io.github.cloudiator.rest.model.NodeCandidate; -import node_candidate.VMConfiguration; +import node_candidate.node_candidate_element.VMConfiguration; import org.eclipse.emf.common.util.BasicEList; import org.eclipse.emf.common.util.EList; import org.jamesframework.core.search.stopcriteria.MaxRuntime; diff --git a/zpp-solver/node-candidates-solver/src/test/java/cp_components/PTSolutionTest.java b/zpp-solver/node-candidates-solver/src/test/java/cp_components/PTSolutionTest.java index 89b9ac904..5dfa78796 100644 --- a/zpp-solver/node-candidates-solver/src/test/java/cp_components/PTSolutionTest.java +++ b/zpp-solver/node-candidates-solver/src/test/java/cp_components/PTSolutionTest.java @@ -1,6 +1,8 @@ package cp_components; -import node_candidate.GeographicCoordinate; -import node_candidate.VMConfiguration; +import node_candidate.node_candidate_element.GeographicCoordinate; +import node_candidate.node_candidate_element.IntegerNodeCandidateElementImpl; +import node_candidate.node_candidate_element.NodeCandidateElementInterface; +import node_candidate.node_candidate_element.VMConfiguration; import org.javatuples.Quartet; import org.junit.jupiter.api.Test; @@ -13,10 +15,21 @@ class PTSolutionTest { @Test public void equalsTest() { - Map> map1 = new HashMap(); - map1.put(1, new Quartet<>(0, new VMConfiguration(0,1,1), new GeographicCoordinate(100, 150), 1)); - Map> map2 = new HashMap(); - map2.put(1, new Quartet<>(0, new VMConfiguration(0,1,1), new GeographicCoordinate(100, 150), 1)); + Map> map1 = new HashMap(); + map1.put(1, new HashMap(){{ + put(PTSolution.PROVIDER_INDEX,new IntegerNodeCandidateElementImpl(0)); + put(PTSolution.CARDINALITY_INDEX, new IntegerNodeCandidateElementImpl(1)); + put(PTSolution.CONFIGURATION_INDEX, new VMConfiguration(0,1,1)); + put(PTSolution.LOCATION_INDEX, new GeographicCoordinate(100, 150)); + }}); + + Map> map2 = new HashMap(); + map2.put(1, new HashMap(){{ + put(PTSolution.PROVIDER_INDEX,new IntegerNodeCandidateElementImpl(0)); + put(PTSolution.CARDINALITY_INDEX, new IntegerNodeCandidateElementImpl(1)); + put(PTSolution.CONFIGURATION_INDEX, new VMConfiguration(0,1,1)); + put(PTSolution.LOCATION_INDEX, new GeographicCoordinate(100, 150)); + }}); PTSolution sol1 = new PTSolution(map1); PTSolution sol2 = new PTSolution(map2); assertTrue(sol1.equals(sol2)); diff --git a/zpp-solver/node-candidates-solver/src/test/java/node_candidate/GeographicCoordinateTest.java b/zpp-solver/node-candidates-solver/src/test/java/node_candidate/GeographicCoordinateTest.java index 2263aad15..8dad138e1 100644 --- a/zpp-solver/node-candidates-solver/src/test/java/node_candidate/GeographicCoordinateTest.java +++ b/zpp-solver/node-candidates-solver/src/test/java/node_candidate/GeographicCoordinateTest.java @@ -1,5 +1,6 @@ package node_candidate; +import node_candidate.node_candidate_element.GeographicCoordinate; import org.junit.jupiter.api.Test; import static org.junit.jupiter.api.Assertions.*; diff --git a/zpp-solver/node-candidates-solver/src/test/java/node_candidate/NodeCandidatesPoolTest.java b/zpp-solver/node-candidates-solver/src/test/java/node_candidate/NodeCandidatesPoolTest.java index 3d5c7002f..b118ec171 100644 --- a/zpp-solver/node-candidates-solver/src/test/java/node_candidate/NodeCandidatesPoolTest.java +++ b/zpp-solver/node-candidates-solver/src/test/java/node_candidate/NodeCandidatesPoolTest.java @@ -5,6 +5,10 @@ import cp_components.PTSolution; import cp_wrapper.utils.numeric_value.implementations.IntegerValue; import cp_wrapper.utils.numeric_value.NumericValueInterface; import nc_wrapper.DomainProvider; +import node_candidate.node_candidate_element.GeographicCoordinate; +import node_candidate.node_candidate_element.IntegerNodeCandidateElementImpl; +import node_candidate.node_candidate_element.NodeCandidateElementInterface; +import node_candidate.node_candidate_element.VMConfiguration; import org.javatuples.Quartet; import org.junit.jupiter.api.Test; @@ -39,13 +43,18 @@ class NodeCandidatesPoolTest { } private PTSolution arrayToAssignment(List arr) { - Map> a = new HashMap<>(); + Map> a = new HashMap<>(); for (int i = 0; i < 3; i++) { int cardinality = arr.get(7*i + 6); int provider = arr.get(7*i); VMConfiguration conf = new VMConfiguration(arr.get(i*7 + 1), arr.get(i*7 +2), arr.get(i*7 +3)); GeographicCoordinate loc = new GeographicCoordinate(arr.get(i*7+4), arr.get(i*7 + 5)); - a.put(i, new Quartet<>(provider ,conf, loc, cardinality)); + a.put(i, new HashMap(){{ + put(PTSolution.PROVIDER_INDEX, new IntegerNodeCandidateElementImpl(provider)); + put(PTSolution.CARDINALITY_INDEX, new IntegerNodeCandidateElementImpl(cardinality)); + put(PTSolution.CONFIGURATION_INDEX, conf); + put(PTSolution.LOCATION_INDEX, loc); + }}); } return new PTSolution(a); } diff --git a/zpp-solver/node-candidates-solver/src/test/java/node_candidate/VMConfigurationTest.java b/zpp-solver/node-candidates-solver/src/test/java/node_candidate/VMConfigurationTest.java index 15468d71d..229e4a44b 100644 --- a/zpp-solver/node-candidates-solver/src/test/java/node_candidate/VMConfigurationTest.java +++ b/zpp-solver/node-candidates-solver/src/test/java/node_candidate/VMConfigurationTest.java @@ -1,5 +1,6 @@ package node_candidate; +import node_candidate.node_candidate_element.VMConfiguration; import org.junit.jupiter.api.Test; import static org.junit.jupiter.api.Assertions.*; -- GitLab From 285b411d8033bc058b49f40b76ef72703df9da28 Mon Sep 17 00:00:00 2001 From: tc360950 Date: Tue, 14 Jan 2020 13:52:42 +0100 Subject: [PATCH 071/340] fixed node-candidates-solver module name in zpp-solver pom file --- zpp-solver/pom.xml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/zpp-solver/pom.xml b/zpp-solver/pom.xml index 5c135bf80..303a8666e 100644 --- a/zpp-solver/pom.xml +++ b/zpp-solver/pom.xml @@ -14,7 +14,7 @@ genetic-solver mcts-solver pt-solver - node_candidates_solver + node-candidates-solver zpp-solver -- GitLab From f9ace0130361356cc89b6ea5478de770a1dd31fa Mon Sep 17 00:00:00 2001 From: tc360950 Date: Tue, 14 Jan 2020 14:29:36 +0100 Subject: [PATCH 072/340] Minor fix in zpp solver pom --- zpp-solver/pom.xml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/zpp-solver/pom.xml b/zpp-solver/pom.xml index 303a8666e..237c26209 100644 --- a/zpp-solver/pom.xml +++ b/zpp-solver/pom.xml @@ -8,7 +8,7 @@ 3.0.0-SNAPSHOT 4.0.0 - + pom cp-parser genetic-solver -- GitLab From 1c98c867a9a2173805816698aae98b77f0611f16 Mon Sep 17 00:00:00 2001 From: "DESKTOP-3098C5A\\VasilAngelo" Date: Thu, 16 Jan 2020 01:11:13 +0200 Subject: [PATCH 073/340] added code for incorporating Component Deployment Times in Penalty Calculator result --- .../eu.melodic.penalty.properties | 10 + .../penaltycalculator/ComponMeasurement.java | 24 +- .../penaltycalculator/PenaltyFunction.java | 413 ++++++------------ .../PenaltyFunctionProperties.java | 28 +- .../penaltycalculator/PenaltyTests.java | 3 +- 5 files changed, 184 insertions(+), 294 deletions(-) diff --git a/penalty-calculator/eu.melodic.penalty.properties b/penalty-calculator/eu.melodic.penalty.properties index 54f49e751..d6975f6de 100644 --- a/penalty-calculator/eu.melodic.penalty.properties +++ b/penalty-calculator/eu.melodic.penalty.properties @@ -22,6 +22,16 @@ stateInfo=1,614,0.5;1,1741,160;4,7680,850;8,15360,1690;7,17510,420;5,2048,350;1, host=127.0.0.1 port=11211 + +# InfluxDB info +DBHost=http://134.60.152.213 +DBPort=8086 +User=vasilis +Passwd=EiWeif0w +Name=cloudiator + + +#Predefined VM types resources info vmData.t1_micro.startupTime=50 vmData.t1_micro.cores=1 vmData.t1_micro.ram=614 diff --git a/penalty-calculator/src/main/java/eu/melodic/upperware/penaltycalculator/ComponMeasurement.java b/penalty-calculator/src/main/java/eu/melodic/upperware/penaltycalculator/ComponMeasurement.java index a8a72ae11..52abb8703 100644 --- a/penalty-calculator/src/main/java/eu/melodic/upperware/penaltycalculator/ComponMeasurement.java +++ b/penalty-calculator/src/main/java/eu/melodic/upperware/penaltycalculator/ComponMeasurement.java @@ -19,39 +19,41 @@ import java.util.concurrent.TimeUnit; @Data @Measurement(name = "ComponentTime", timeUnit = TimeUnit.SECONDS) public class ComponMeasurement { - + @Column(name = "time") private Instant time; - + @Column(name = "ComponentName") private String ComponentName; - + @Column(name = "timeDepl") private double timeDepl; - + public Instant getTime() { return time; } - + public void setTime(Instant time) { this.time = time; } - + public String getComponentName() { return ComponentName; } - + public void setComponentName(String ComponentName) { this.ComponentName = ComponentName; } - + public double timeDepl() { return timeDepl; } - + public void timeDepl(double timeDepl) { this.timeDepl = timeDepl; } - - public String toString() { return timeDepl+""; } + + public String toString() { + return timeDepl + ""; + } } \ No newline at end of file diff --git a/penalty-calculator/src/main/java/eu/melodic/upperware/penaltycalculator/PenaltyFunction.java b/penalty-calculator/src/main/java/eu/melodic/upperware/penaltycalculator/PenaltyFunction.java index ec819390b..2bd813c6b 100644 --- a/penalty-calculator/src/main/java/eu/melodic/upperware/penaltycalculator/PenaltyFunction.java +++ b/penalty-calculator/src/main/java/eu/melodic/upperware/penaltycalculator/PenaltyFunction.java @@ -39,6 +39,67 @@ public class PenaltyFunction { @Setter private PenaltyFunctionProperties properties; + public static boolean containsEquivalent(Collection collection, PenaltyConfigurationElement element) { + for (PenaltyConfigurationElement ce : collection) { + if (isEquivalent(ce, element)) { + + return true; + } + } + + return false; + } + + public static boolean isEquivalent(PenaltyConfigurationElement a, PenaltyConfigurationElement b) { + + if (a.getNodeCandidate().getHardware().getRam() - b.getNodeCandidate().getHardware().getRam() == 0) { + + if (a.getNodeCandidate().getHardware().getCores() - b.getNodeCandidate().getHardware().getCores() == 0) { + + if (a.getNodeCandidate().getHardware().getName().equals(b.getNodeCandidate().getHardware().getName())) { + + if (a.getNodeCandidate().getHardware().getDisk() - b.getNodeCandidate().getHardware().getDisk() == 0) { + + return true; + } + } + } + + } + + return false; + } + + public static String toString(PenaltyConfigurationElement ce) { + StringBuilder sb = new StringBuilder(); + sb.append("{"); + sb.append("id=").append(ce.getId()); + sb.append(","); + sb.append("cardinality=").append(ce.getCardinality()); + sb.append(","); + sb.append("nodeCandidate={") + .append("id:").append(ce.getNodeCandidate().getId()).append(",") + .append("Name:").append(ce.getNodeCandidate().getHardware().getName()).append(",") + .append("ram:").append(ce.getNodeCandidate().getHardware().getRam()).append(",") + .append("cores:").append(ce.getNodeCandidate().getHardware().getCores()).append(",") + .append("disk:").append(ce.getNodeCandidate().getHardware().getDisk()).append("}"); + sb.append("}"); + return sb.toString(); + } + + public static String toString(Collection collection) { + boolean first = true; + StringBuilder sb = new StringBuilder(); + sb.append("["); + for (PenaltyConfigurationElement ce : collection) { + if (first) first = false; + else sb.append(","); + sb.append(toString(ce)); + } + sb.append("]"); + return sb.toString(); + } + public PenaltyFunctionResult evaluatePenaltyFunction(Collection actualConfiguration, Collection newConfiguration) { try { return _evaluatePenaltyFunction(actualConfiguration, newConfiguration); @@ -58,11 +119,28 @@ public class PenaltyFunction { List toBeDeleted = new ArrayList<>(); List toBeAdded = new ArrayList<>(); List toBeChanged = new ArrayList<>(); + + //Init Memchache variable info here + String str1 = ""; + String str2 = ""; + //Init InfluxDB variable info here + String str3 = ""; + String str4 = ""; + String str5 = ""; + String str6 = ""; + String str7 = ""; + + // Init variables for OLS algorithm + double resultss = 0; + double result = 0; + int value1 = 0; + double value2 = 0; + double result2 = 0; // find the elements in actual-current config. but not in new configuration // these elements will be deleted. for (PenaltyConfigurationElement s : actualConfiguration) { - //log.debug("LOOP-1: checking CE: {}", toString(s)); + if (!containsEquivalent(newConfiguration, s)) { toBeDeleted.add(s); @@ -108,18 +186,17 @@ public class PenaltyFunction { log.info("Penalty: ++++++"); // Check if there is no difference - if (results.size()==0) { + if (results.size() == 0) { PenaltyFunctionResult pfResult = new PenaltyFunctionResult(0, 0); log.warn("-----> No difference between solutions: result will be: {}", pfResult); return pfResult; } - // Memchache staff here - String str1 = ""; - String str2 = ""; + // Get memcached connection info from properties file str1 = properties.getHost(); str2 = properties.getPort(); + //initialize the SockIOPool that maintains the Memcached Server Connection Pool @@ -128,10 +205,9 @@ public class PenaltyFunction { String[] servers = {str1 + ":" + str2}; SockIOPool pool = SockIOPool.getInstance("Test2"); log.info("servers: {}", Arrays.toString(servers)); - - pool.setServers(servers); - pool.setFailover(true); + + pool.setFailover(true); pool.setInitConn(11); pool.setMinConn(5); pool.setMaxConn(250); @@ -140,56 +216,34 @@ public class PenaltyFunction { pool.setSocketTO(3000); pool.setAliveCheck(true); pool.initialize(); - + //Get the Memcached Client from SockIOPool named Test2 MemCachedClient mcc = new MemCachedClient("Test2"); - // connect to Daniel's InfluxDB and created database with queries...unused yet -//XXX:BEGIN - String dbName = "cloudiator"; + // connect to InfluxDB --specify DB name - log.info("INFLUX point A - START"); - InfluxDB influxDB = InfluxDBFactory.connect("http://134.60.152.213:8086", "vasilis", "EiWeif0w"); - log.info("INFLUX point B - connected"); - // Flush every 2000 Points, at least every 100ms - influxDB.enableBatch(2000, 100, TimeUnit.MILLISECONDS); - - for (int i = 0; i < 5; i++) { - try { - Thread.sleep(1000); - } catch (InterruptedException e) { - e.printStackTrace(); - } - Point point2 = Point.measurement("ComponentTime") - .time(System.currentTimeMillis(), TimeUnit.MILLISECONDS) - .addField("timeDepl", Math.random() * 400L) - .addField("ComponentName", "AppResponse") - .build(); - influxDB.write(dbName, "autogen", point2); - } - log.info("INFLUX point C - Added point"); - Query query = new Query("SELECT * FROM ComponentTime", dbName); - QueryResult queryResult = influxDB.query(query); - log.info("InfluxDB query result: {}", queryResult); + log.info("INFLUX point A - START"); + // Start info for Connection session to Influx DB + str3 = properties.getDBHost(); + str4 = properties.getDBPort(); + str5 = properties.getUser(); + str6 = properties.getPasswd(); + str7 = properties.getName(); + + String dbName = str7; + InfluxDB influxDB = InfluxDBFactory.connect(str3 + ":" + str4,str5,str6); + log.info("INFLUX point B - connected"); - //InfluxDB connection = connectDatabase(); - // querying from centos_test_db DB + // querying from Daniel DB InfluxDBMapper influxDBMapper = new InfluxDBMapper(influxDB); - //Query query1 = select("timeDepl").from(dbName,"ComponentTime"); - //Query query1 = new Query("SELECT timeDepl FROM ComponentTime", dbName); + log.info("INFLUX point D - InfluxDB Mapper initialized"); - /*//Query query1 = new Query("SELECT mean(\"value\") AS \"mean_value\" FROM \"cloudiator\".\"autogen\".\"process-start-time\" WHERE \"task\"='database' GROUP BY time(5s) FILL(null)", dbName); - Query query1 = new Query("SELECT \"time\" AS \"time\", \"task\" AS \"ComponentName\", \"value\" AS \"timeDepl\" FROM \"cloudiator\".\"autogen\".\"process-start-time\" WHERE \"task\"='database'", dbName); - //Logger.info("Executing query "+query1.getCommand()); - List ComponMeasurements = influxDBMapper.query(query1, ComponMeasurement.class); - log.info("INFLUX point E - Query ok: size={}", ComponMeasurements.size()); - ComponMeasurements.forEach(r -> log.info(" - {}", r));*/ - + //query to Influx DB for Component Deployment Times Query query1 = new Query("SELECT \"time\" AS \"time\", \"task\" AS \"ComponentName\", \"value\" AS \"timeDepl\" FROM \"cloudiator\".\"autogen\".\"process-start-time\" WHERE \"task\"='database'", dbName); QueryResult queryResult1 = influxDB.query(query1); //log.info("INFLUX point E-2 - Results: {}", queryResult1); @@ -202,7 +256,7 @@ public class PenaltyFunction { //log.info("################# values: {}", seriesValues); seriesValues.forEach(row -> { - for (int i=0; i {} = {} / {}", seriesColumns.get(i), row.get(i), row.get(i).getClass()); eu.melodic.upperware.penaltycalculator.ComponMeasurement cm; @@ -218,22 +272,18 @@ public class PenaltyFunction { log.info("ComponMeasurements: {}", listComponMeasurements); log.info("INFLUX point F - Query results listed"); - //String arr = ComponMeasurements.toString(); + + String arr = listComponMeasurements.toString(); log.info("INFLUX point G - arr: {}", arr); //String arr = null; log.info(arr); -//XXX:END - - //check if we have Null Component Deployment Times and act accordingy +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ - double resultss = 0; - double result = 0; - int value1 = 0; - double value2 = 0; - double result2 = 0; + //check if we have Null Component Deployment Times and act accordingy + + //if we do not have null Componennt Deployment Times: if (arr != null && !arr.isEmpty()) { @@ -242,33 +292,33 @@ public class PenaltyFunction { double sum = 0; int cnt = 0; double avg = 0; - - for (ComponMeasurement cmmm : listComponMeasurements) { - sum += cmmm.timeDepl(); - cnt++; - } + for (ComponMeasurement cmmm : listComponMeasurements) { - if (cnt > 0) { - avg = sum / cnt; - } else - throw new RuntimeException("some error message"); + sum += cmmm.timeDepl(); + cnt++; + } + + if (cnt > 0) { + avg = sum / cnt; + } else + throw new RuntimeException("some error message"); log.info("cnt={}", cnt); log.info("avg={}", avg); //Find the maximum Component Deployment time double maxx = 0; - - for (ComponMeasurement cmm : listComponMeasurements) { - if (maxx < cmm.timeDepl()) { - maxx = cmm.timeDepl(); //swapping + for (ComponMeasurement cmm : listComponMeasurements) { + + if (maxx < cmm.timeDepl()) { + maxx = cmm.timeDepl(); //swapping + + } } - } - log.info("The max Component Deployment Time value is " + maxx); @@ -281,8 +331,8 @@ public class PenaltyFunction { HashMap hm = new HashMap(); - // load old first properties file DATA - //IPATINI: + // load from properties file DATA of predefined types + Map prop = properties.getStartupTimes(); prop.forEach((key, value) -> mcc.set(String.valueOf(key), String.valueOf(value))); prop.forEach((key, value) -> hm.put((String) key, (String) value)); @@ -427,10 +477,10 @@ public class PenaltyFunction { } - double avgTime = ((((result + result2) / value1) + (avg/1000)) / 2) - min; - resultss = avgTime / ((maxx/1000) - min); - log.info("The max Component Deployment Time value is " + maxx/1000); - log.info("!!!!!!!!!!!!! result={}, result2={}, value1={}, avg={}, min={}, max={} --> resultss={}", result, result2, value1, avg/1000, min, maxx/1000, resultss); + double avgTime = ((((result + result2) / value1) + (avg / 1000)) / 2) - min; + resultss = avgTime / ((maxx / 1000) - min); + log.info("The max Component Deployment Time value is " + maxx / 1000); + log.info("!!!!!!!!!!!!! result={}, result2={}, value1={}, avg={}, min={}, max={} --> resultss={}", result, result2, value1, avg / 1000, min, maxx / 1000, resultss); //return resultss; PenaltyFunctionResult pfResult = new PenaltyFunctionResult(resultss, avgTime); @@ -438,19 +488,11 @@ public class PenaltyFunction { return pfResult; } else { - //do appropriate things for only VM startup times existing - //XXX: HashMap hm = new HashMap(); + //do appropriate things for only VM startup times existing and NOT any Component Deployment Times + log.info("-----> Point A"); - // load first properties file--REMOVED - - - // load old first properties file DATA - //IPAT: - /*XXX: Map prop = properties.getStartupTimes(); - prop.forEach((key, value) -> mcc.set(String.valueOf(key), String.valueOf(value))); - prop.forEach((key, value) -> hm.put((String) key, (String) value)); - log.info(">>>>>>>>>: hm: {}", hm);*/ + //add VM data to Memcache log.info("-----> Adding VM data to Memcache"); properties.getVmData().entrySet() @@ -458,102 +500,39 @@ public class PenaltyFunction { log.info("-----> Point B"); // get the values of the HashMap hm returned as an Array - //XXX: String[] yy = hm.values().toArray(new String[0]); - - //XXX: log.info(Arrays.toString(yy)); - + //Instantiate data for train of OLSMulitple regression algorithm //convert String Array to double Array double[] y = properties.getVmData().values().stream() .mapToDouble(data -> data.getStartupTime()).toArray(); log.info("-----> VM startup times (y-data): {}", y); - //XXX: double[] y = Arrays.stream(yy).mapToDouble(Double::parseDouble).toArray(); + //Find the maximum VM Startup time double max = Arrays.stream(y).max().getAsDouble(); - /*XXX: double max = y[0]; - for (int i = 1; i < y.length; i++) { - if (max < y[i]) { - max = y[i]; //swapping - y[i] = y[0]; - } - }*/ log.info("The max VM Startup value is " + max); //Find the mimimum VM Startup time - double min = Arrays.stream(y).min().getAsDouble(); - /*XXX: double min = y[0]; - for (int i = 1; i < y.length; i++) { - if (min > y[i]) { - min = y[i]; //swapping - y[i] = y[0]; - } - }*/ + double min = Arrays.stream(y).min().getAsDouble(); log.info("The min VM Startup value is " + min); - /*XXX: log.info(">>>>>>>>>: y: {}", y); - - - log.info(">>>>>>>>>: y.length: ", y.length); - - tableStringLength = y.length; - - log.info(">>>>>>>>>: tableStringLength: ", tableStringLength); - - log.info("y={}", y.length);*/ - //instantiate the double array - //XXX: double[][] xx = new double[tableStringLength][3]; + double[][] xx = properties.getVmData().values().stream() .map(PenaltyFunctionProperties.VmData::getX) .collect(Collectors.toList()) .toArray(new double[0][0]); log.info("------> VM core/ram/disk (x-data): {}", Arrays.deepToString(xx)); - //XXX: log.info("xx.len={}", xx.length); + log.info("------> Point C"); OLSMultipleLinearRegression regression = new OLSMultipleLinearRegression(); - -/*XXX: - // load second properties files ----- REMOVED - - // load old second properties file DATA : STEFANIDI - - String[] a = properties.getStateInfo().split(";"); - - - //create the two dimensional array with correct size - String[][] array = new String[a.length][]; - - //combine the arrays split by semicolin and comma - for (int i = 0; i < a.length; i++) { - array[i] = a[i].split(","); - } - - //Convert two dimensions String Array to two dimensions Double Array - - log.info("a={}", a.length); - log.info("xx.len={}", xx.length); - log.info("array: " + java.util.Arrays.deepToString(array)); - log.info("xx: " + java.util.Arrays.deepToString(xx)); - for (int k = 0; k < tableStringLength; k++) { - for (int j = 0; j < 3; j++) { - - xx[k][j] = Double.parseDouble(array[k][j]); - - } - } - - log.info("array: " + java.util.Arrays.deepToString(array)); - log.info("xx_after_fill: " + java.util.Arrays.deepToString(xx)); - - log.info(">>>>>>>>>: xx: {}", xx); -*/ + //Calculate regression parameters log.info("-----> Calculating regression parameters..."); regression.newSampleData(y, xx); @@ -566,53 +545,14 @@ public class PenaltyFunction { //print them log.info("-----> Regression parameters: {}", Arrays.toString(betaHat)); - /*XXX: for (int i = 0; i < betaHat.length; i++) { - log.info("betaHat[{}]={}", i, betaHat[i]); - }*/ + log.info("-----> Residual parameter: {}", Arrays.toString(residuals)); - /*XXX: for (int i = 0; i < residuals.length; i++) { - log.info("residuals[{}]={}", i, residuals[i]); - }*/ + //log.info("residual: " + residuals); log.info("rSquared: {}", rSquared); - -/* for (String key : hm.keySet()) { - int value = 0; - - - // value=((Integer) hm.get(key)).intValue();//here is an ERROR - value = Integer.parseInt((String) hm.get(key)); - for (PenaltyConfigurationElement s33 : results) { - log.info("KEY: {}, s33: {}", key, s33.getNodeCandidate().getHardware().getName()); - - if (key.equals(s33.getNodeCandidate().getHardware().getName())) { - log.info(" MATCH FOUND: {}", key); - - //value = Integer.valueOf((String) hm.get(key)); - result += value; - log.info("RESULT:{}", result); - value1 = value1 + 1; - log.info("KEY:" + key + " VALUE:" + hm.get(key)); - } - - if (!(hm.containsKey(s33.getNodeCandidate().getHardware().getName()))) { - log.info(" NO MATCH FOUND FOR: {}", s33.getNodeCandidate().getHardware().getName()); - - value2 = betaHat[0] + betaHat[1] * (s33.getNodeCandidate().getHardware().getCores()) + betaHat[2] * (s33.getNodeCandidate().getHardware().getRam()) + betaHat[3] * (s33.getNodeCandidate().getHardware().getDisk()); - log.info("value custom:" + value2); - result2 += value2; - value1 = value1 + 1; - } - - - } - - - }*/ - log.info("-----> Point D"); int sumOfStartupTimesPerPCE = 0; int sumOfEstimatedStartupTimesPerPCE = 0; @@ -648,7 +588,7 @@ public class PenaltyFunction { } log.info("-----> new-min={}, new-max={}", min, max); - double averageStartupTime = (sumOfStartupTimesPerPCE+sumOfEstimatedStartupTimesPerPCE)/numOfStartupTimesPerPCE; + double averageStartupTime = (sumOfStartupTimesPerPCE + sumOfEstimatedStartupTimesPerPCE) / numOfStartupTimesPerPCE; double normalizedValue = (averageStartupTime - min) / (max - min); log.info("-----> sum={}, sum-reg={}, num={}, avg={}, min={}, max={} --> resultss={}", @@ -660,80 +600,7 @@ public class PenaltyFunction { return pfResult; - /*resultss = ((((result + result2) / value1) - min) / (max - min)); - log.info("!!!!!!!!!!!!! result={}, result2={}, value1={}, min={}, max={} --> resultss={}", result, result2, value1, min, max, resultss); - - return resultss;*/ - } - } - - - public static boolean containsEquivalent(Collection collection, PenaltyConfigurationElement element) { - for (PenaltyConfigurationElement ce : collection) { - //log.debug("containsEquivalent: comparing col. elem. to given elem.: \n\t{}\n\t{}", toString(ce), toString(element)); - if (isEquivalent(ce, element)) { - //log.debug("containsEquivalent: ARE EQUIV"); - return true; - } - } - //log.debug("containsEquivalent: NO EQUIV FOUND"); - return false; - } - - public static boolean isEquivalent(PenaltyConfigurationElement a, PenaltyConfigurationElement b) { - /*log.debug("isEquivalent: checking: {} <--> {}", toString(a), toString(b)); - log.debug("isEquivalent: ram: {} <--> {}", a.getNodeCandidate().getHardware().getRam()-b.getNodeCandidate().getHardware().getRam()==0); - log.debug("isEquivalent: cores: {} <--> {}", a.getNodeCandidate().getHardware().getCores()-b.getNodeCandidate().getHardware().getCores()==0); - log.debug("isEquivalent: disk: {} <--> {}", a.getNodeCandidate().getHardware().getDisk()-b.getNodeCandidate().getHardware().getDisk()==0);*/ - if (a.getNodeCandidate().getHardware().getRam() - b.getNodeCandidate().getHardware().getRam() == 0) { - //log.debug("isEquivalent: PASS-1"); - if (a.getNodeCandidate().getHardware().getCores() - b.getNodeCandidate().getHardware().getCores() == 0) { - //log.debug("isEquivalent: PASS-2"); - if (a.getNodeCandidate().getHardware().getName().equals( b.getNodeCandidate().getHardware().getName() )) { - //log.debug("isEquivalent: PASS-3"); - if (a.getNodeCandidate().getHardware().getDisk() - b.getNodeCandidate().getHardware().getDisk() == 0) { - /*if (a.getCardinality() == b.getCardinality()){ - return false; - }*/ - //log.debug("isEquivalent: checking: EQUIV"); - return true; - } - } - } - - } - - //log.debug("isEquivalent: checking: NOT EQUIV"); - return false; - } - - public static String toString(PenaltyConfigurationElement ce) { - StringBuilder sb = new StringBuilder(); - sb.append("{"); - sb.append("id=").append(ce.getId()); - sb.append(","); - sb.append("cardinality=").append(ce.getCardinality()); - sb.append(","); - sb.append("nodeCandidate={") - .append("id:").append(ce.getNodeCandidate().getId()).append(",") - .append("Name:").append(ce.getNodeCandidate().getHardware().getName()).append(",") - .append("ram:").append(ce.getNodeCandidate().getHardware().getRam()).append(",") - .append("cores:").append(ce.getNodeCandidate().getHardware().getCores()).append(",") - .append("disk:").append(ce.getNodeCandidate().getHardware().getDisk()).append("}"); - sb.append("}"); - return sb.toString(); - } - - public static String toString(Collection collection) { - boolean first = true; - StringBuilder sb = new StringBuilder(); - sb.append("["); - for (PenaltyConfigurationElement ce : collection) { - if (first) first = false; - else sb.append(","); - sb.append(toString(ce)); + } - sb.append("]"); - return sb.toString(); } } diff --git a/penalty-calculator/src/main/java/eu/melodic/upperware/penaltycalculator/PenaltyFunctionProperties.java b/penalty-calculator/src/main/java/eu/melodic/upperware/penaltycalculator/PenaltyFunctionProperties.java index 52e3bb4ca..5a5fd757b 100644 --- a/penalty-calculator/src/main/java/eu/melodic/upperware/penaltycalculator/PenaltyFunctionProperties.java +++ b/penalty-calculator/src/main/java/eu/melodic/upperware/penaltycalculator/PenaltyFunctionProperties.java @@ -25,16 +25,24 @@ public class PenaltyFunctionProperties { private final Map startupTimes = new HashMap<>(); private String stateInfo; - private String host; - private String port; - - private final Map vmData = new HashMap<>(); - - public Map getVmData() { - return vmData; + private String host; + private String port; + private String DBHost; + private String DBPort; + private String User; + private String Passwd; + private String Name; + + + + + private final Map vmData = new HashMap<>(); + + public Map getVmData() { + return vmData; } - @Data + @Data public static class VmData { int cores; double ram; @@ -46,6 +54,8 @@ public class PenaltyFunctionProperties { return x; } - public double getY() { return startupTime; } + public double getY() { + return startupTime; + } } } diff --git a/penalty-calculator/src/main/java/eu/melodic/upperware/penaltycalculator/PenaltyTests.java b/penalty-calculator/src/main/java/eu/melodic/upperware/penaltycalculator/PenaltyTests.java index 4831812af..97fea1528 100644 --- a/penalty-calculator/src/main/java/eu/melodic/upperware/penaltycalculator/PenaltyTests.java +++ b/penalty-calculator/src/main/java/eu/melodic/upperware/penaltycalculator/PenaltyTests.java @@ -61,7 +61,8 @@ public class PenaltyTests implements CommandLineRunner { protected Collection readConfigElementsFromFile(String fileName) throws IOException { try (Reader reader = new FileReader(fileName)) { - Type listType = new TypeToken>() {}.getType(); + Type listType = new TypeToken>() { + }.getType(); return new Gson().fromJson(reader, listType); } } -- GitLab From d201cc435417d0a6829c2d9230ad2306f5643580 Mon Sep 17 00:00:00 2001 From: "DESKTOP-3098C5A\\VasilAngelo" Date: Thu, 16 Jan 2020 01:13:10 +0200 Subject: [PATCH 074/340] added .jar --- penalty-calculator/penalty-calculator.jar | Bin 0 -> 26020512 bytes 1 file changed, 0 insertions(+), 0 deletions(-) create mode 100644 penalty-calculator/penalty-calculator.jar diff --git a/penalty-calculator/penalty-calculator.jar b/penalty-calculator/penalty-calculator.jar new file mode 100644 index 0000000000000000000000000000000000000000..e6ca7b0d0bdc36386dec1e9b4c0da57a1963d188 GIT binary patch literal 26020512 zcmbTdW0YoH(k+^{ZQHhO+qUgW+qPY4yV6-{+qUgnZ+D+_&*^cy$NSwqo*(PSTCtuT zYe&qvW5!mH1_nU^fPjDi01c0m2lziONB|H3Sy2^1T1h!E`mZqn0AK(GX>f?YW&r(b zn!OPP4 zTOx@Uj{yS{B#d=Z4pNd;#hZlrMN~5M zA_#VXz`ETb?Sfr{PN`kEpu<77?6I#kLURJlkioL47pw&Mczr&RI{;GCI_3xh43bnj znP4MAg`iT+U-_uy%+Bs4Yq%-BY<$mJ@vA7QnaM?o97KD`L!Px(Pvu-SH@@3>jZCpP z=B;l`)2w;dX{0T(1AUX?u(0(D9ZZDN3Kt_R)XHA3qr4jy>C_J9jbj+5t(X{aiA*G8 zGo_w&W=Amtn436VL7~V{nSrxuu67L_&3vr70Y7BZ@gnlv@}gs8PJjLlF6VLr`R%cr z`G;-`*71H52ER2O%|nw-J;kZX7pAH%iPzGh&wW0k&;GsP4ftOtF&T>6BmoEjApYk# z{_{zI{5c7GCv*D$>FNEo#@WHi($3t>$`c>|sD13o3LKZPrMUS{R_(6{ z#OZF$IgJ}=M<&kai}vHMscW7qvLBzHqYR}C)dpgHKVkX;l^b-%>oGMV33qC=N^0;z`BvYY8 z$MrPnusrX1%i2iuXC1bPiK5(9w;Dh&+%H;U{`6{(?p%L*j-aajj>R=$&B>us@Wrb_!%y2 z%+a5d#5tfRDVO5hjycj$(YbiU*c97!omt}1qvN#SvOkl5_OCPHve2ud1lmD7!-6JP#{~%LGDL{RjNxhYznY zd1wb|!qz#WsT_w zrd^2YoQFqd7G#Pdg=tTN@pzCG!%H~B&48|Y=x>FrYwchbPw)V1+pH#P$Q!ZWB>Z9^ zdGTMAIo~oMR@DR^0YncG$iAUPs6y}#@w=XLrVXwUC-ewJaXoTuel3FYq@U~{kKU~W z((VNppw%W1p0fF1^a#tbyKU$aVb_Eu7s~MpGq4p64Pjj@xw20-%{E;PI7K1I^E^gy zw)ZC5kK2f^sC^;BGjRRStli!Fbh)d>=q0Exi9WxGKC%0her8uS*gR@D$(HrM1iJ;Y zNHV1L7QSPMlJrTGT|@R=n53+_E9@M5!R^vK4vDx&+^*eAFn z7NGexi9b_(as%{~N$@Ke{va945;2YnymQc<4yNqMq};zA!n!Q~Li zqDfNJi|*ln@`c2os({3+C**uE9JR86`L;)vJVRTaxg;rx_*m_0T&K$nHmT}1c`_8W zh4Hcrt)Gf-?@-%DR5obZRZvC=|pva=^5r!WD`V06kRARbJzi#{kI{r}q z4V6g#M!vK%{O^hV-*Yg_-?S;{Y;0*MR}A z0xE{oDGLRtyu@OQG-s3vPk@gwhQ>W5yT{TTwFb+*@6=Dd2{PMJ>s4F?3;I=ecveW=YrIG z=rI>%dGW9dWa3jUurzKarqTMQ5SAU=1<&PFxQ;YgWnqVmY`0wh6Q{FY+-HNZ;~Hg2 zUB$pLVe(qf{2p&Gxx0T^*J!MVX`|Zs*UB~C?8IrCIt(7d{1q}UxXVUu@5x!aoqL&aWP%XISS-9c8ZHSGaTt z_nKmT@RqV>;C9kcmTH^D>TSTTbAy27eBZX!QN2~0Sc%I!iP?>eorY5=U}I%q<0qvz z-m#a8rqjaap$qO$${1xrW{hU+pXx%5O-!Wk%jS(9(XO6OPRG)j)|C)$y}a%}#AG6$ z%J49o&21jS-hPjS`5$@AxRX^c6jOMVH~Hrzjq3dJJg>@-%)sU{wNd_vq0&fYb|=%k zpBT(%-7<6*mAqXZJu_|V4oo?AA~|8^wj(DR3Lu3s(rnEjWT3VtEweoH@c%?EC0(M1 z$ivp|O2F=%Zz;QP?yVT?o;I-GK1t4KFcICk+}wM}_-7dkA@U9}jPn8${|V;&6DkwA5dI2h|5dDXDA(B%B_+wg9E zIWK3jWP;YxF_kKc)gGzGmB(U-kjG{Rk;f_@Qyohq3Ob}&kA>t~R1~Ix&9_l)+e6$f zRpx3fg~`0ih0Qo05fNB%0b7GOQ_ee zIeRAN)QK3^wQV6sFz}Y>Ds_c<-z5|CL;@JevzywM-3?^y5`d^JxA7x~vhEgVu8iZg zdwJvZi{kr5rE|UkYR!g7XFhANrQ68LeOHB0tg7J!UtlVb zN;5S`UGd-62fw5lWWLxrKMi)5Zr_!(coi%G$BAas3UGp~0j)^9P}ZcKMon#|gWA%x zJbviG@z>;os;oz?ID-;YHzS!uw`lKzAJD0Dbv6knL3bsTWAU~FxX*UV!`YbR+mhyX zgHG#Vs`WV+?R$3bzk+^Qf9NA?`jbDvPz_Ay^PtFy$oKf)A>_0A5s_9&SG43KC!1_f9*Fv}a0G4H z9;^ut*1n0*w>=miiaG06dXAR*APwWp%|=KVu;?huO1yqhT-Y67?q*Y3^1B$r;e2>R zAsL##P`xZQ%ar6YL_%*rKD_vvnYdj>ga`;xcuj+dg$x+!Rs@=NsBMdnx`xrtn5hPG zn02(R6k{3A#gIILVW@vPdC=9Au%<^y$M=MTyT+B&(e-y5mt!-sdY1FBPeOjL56o}^ zvz1MX!nXR#Z*hf3(KB~WyH*Z6{N32VOl#r3dbWgk2chE9%P(Vc4BRLcRujS z%p(h%(nmPG&28|&ZTOa7=C=e_JD0!k;r9X6t_k%TwtI~^!pU!latEnBphnuhRG-3y zCKMdK%PW_e7WKTkvi4Nux9s{algquRj&N6cF}rc9hZ++r@DdJ%PPd5EYm-X6qnPHT zlj*twuuV>VI3oPCuo&?PhrJq3sXVR5Lwwpxd|;^-=tVVAKxo|BP!3VXP!5qT(V7IM4P7aa9he>%8i+7^HtR7k$llb25hW9LCg1Ij0Xn1?ULl<(=Shg?DEM`G)Mxabge z!Yp~(m1Id49Oyuv5eck(WV z@ERe=fOP+^l8_Sn+R=v0(7Ry)3hI|?->5_3BZF0mskLaKsvpN$d|msE0f`3+b>Ps0 z>rD>GNA`qo7JZTXi^x0Z{GD{^v3m5OF4aq|WT$&Z`t}Xm8!gid@AMshIn?#d<0szZ zjyzL}ZL}M*nk1;h{6IKK%ve2P1ppRwL#KltgdC^0n({1yB>kJgrTFI(L~r2*-|78UNB;XmLw967>5%OI!u~gmk$kHerS-9;H^@< z{JH+grEd>5e=pQW%GbBrU2p^^Mb3TO9#EoRvS!^YZV;I{rW1d={V~qXV^<0Ki@((zs7nDS1c^>SAbQV=CxmY+>nUDr4wsXKZ2W^iNh>qOPru ztd8;p1_W$~5FHtgRwN1wDAU~n)l2}oKqe7YGPKkZX5t?(D#MjQu#(lS|1FCDrnPKk zSYf@`>Q-IzRif9!%q&UZFZJd$HNolq<9$7?ae5-}o96|#SMviwjC;6$C5}13&4 zbT5VBEZ#;4YTr<2L&UWNMsy=b=5OUEQJK!S8#cnyF*-y(Mg0nhU!!?0M%s(}Anqi(1cm&;DhgBC(;m5PA(HY-SL3WNiISzOA@x8W)uY46#Rl|)Kwfav- zHJ}jk%fO^1aoCKMDO>m{NlV!QL7X{;xVBK>6M|OSsfxgX!^NMa71NMO;!}&#NJzs9 z_4$T~WY7x2Xe!o)$@@>9gbIe%zju8>->Idaocb6}V*`5}xxI{XrXnnE1w^`ki`{eb z+D>43ky&Xd!ouA-Ik2M4P;=6t;@$*u9B>$kiY12lWEhTj#{PaC;oeq?Td&5jsTgPo zMfEA)CHA2q%A(hWS!8PkqgZN<(1q6;B9~Y%{1&KX-v}>Eu>6lDUqCavdh2vZ zZUJk4{caVElUiU$SAg6{$>Epu!upih;ha0WgINBEfkQ1*$-WxIjBAq72>-=!98OSi z{6YpS>Xcw9$^Ql5?f<@_9mMMQIdUqbEuWzqeAf#h%r|z2XL`2g~U?wEoy*3+nJ-kTK7Ps^^Ru__s_)#auQW%Q!ztl7h!ulJ5ys9OM5#}4`Wk@ zzXr~tcCNOjPKJMt{|O$=D(iB{iYU5asc^|o;EIvqkqS^;TQLFg7(lbd^=Z^FpxZ$$e%d-T=P_-f)Nq$yxw_>-OFof^H)Cab#OaOHAA!E z%rO?d3OEB2tc099Ok_&4tn{7Wi}~k0Z1pKRlmvSXuwl#<+u+E?@SEZ zr`iPevs2tn6rM0xyM8Q)fV!y|&~1!I%QI248FH#IP|jp=`Folu5^x9j<+m~2!vp_iDSdZR{zfsUhNXx%JEKLk-OJF2KT%kqy`Cc1rK0R{}xf_W&n zJopZEiDNF0XZejbW`7vVqb({gYqO^5vNPDKA0?ZcnfxIKDzUP`ni&XqJlS|zd=0H< z$0hhFt&^4cJ4aViwAd7Ji^cHi}p`wdGJH1_9z6mwwxa5)K>XS>HQgrg0g zYbk_9Y?}8LsETFF^#f19^9|}y?-ET19TxMbVKxr3$vQc>lpw{@JpmM|?e|OWX+bRx z*j%{Kq6INo{scF+<#3t zLA$jz(*AJE(&9FBO@T^WJd3?Y4oYXAk3JUe@1p)cs;C^_3YDo@mjh2GSqKR)ip_NWU*|!-vd*wvKa8Z z%q?D8pluB-+Z6Hk`mZSKw48HZ{G*qB|B1B!S2O!}`X%)@qU=AbIe$qy{}g!sCFH2e zIxDMU_}OJ1gp$m#l}JE0H-pH|3sKNQ(dN^ZWUiqVYgD5?lC{eUCvA8+Ll4DuYya@K zW}`6?(-K!PJBglZbI^IMzp>usDBO?6FJcZqxz7zQrX31#NqElop7P9l_T;~xopj#< zpNUcbT!~~vBp2mr4=~bklYcGPx5Pzux{J=18N1TtXWL5-KX&1{9)NCObs=#f@s)Tr zG#ZOzDg7)L6{8yw$zDoW%s;O38Lqd1E!dqO#w1QCL8G+>{-YyYtWzM0rxQX(b4GlHm$z#7H)+|zBc;)1 z`V_wP(AEhecbr1}Su^UFJFOKGom78^)kOGaD=UjC6Nc||GMV|>#9VE-pKeTIE*7nM zh;*M{6lA%WP^2$@oOD!0fZ~EsvX;que_NrbOo92t39E_-nK_=lJkv##UX;pgF?pzL z8mxx~_)6NS77%a`dGF^`f}Bv$(gr6za8l{BA$q{2%A|YmE#hLu;i9e)9b7QgpW_|Q zfv1_5-BMk1psm(1I5xwjiJ92Z7P3M6yXZVvr-p0!Ll04xsDpa=DWd+x3pDEWAx_iT zZI0&2V?Yb5leAC}M@$~UHXQ7h0T0p$y9InU8V!;6qIhwDG#rct%u%2z)4?90(L?cp zGooe7GQKXxrq8&M_0xRU+M;?T%DmBR?f28_X?u2tdnzwfgwyzxkhERRPE-1QMqp9U z#F2y8$ST2+qufL{NtfQADq3j3WBAX|4yewg`4-m}j@2`}R}}u1Xp?JQ7ewxEgG}b3 zP;(|%xoV@=3ysZZR59b&6{S&lx*r3Y$!s}2B7I|1oJWqrWUGIY@?|DD_H!kJH?sxgrk8P^pV!C!{Nl<53Nmr*w=MksU zt~mX&m${*4!VU=g2c`$enzWs$7X831b8I@QMYS>78wEcoc0NH?z5z2IIb(f;unuJc zhIzb;D?n3)M_SyYzs?@gURvH2VYwzyPtww)?Aoo+D zIJwn)eZs)F;r<0^Wa_G}DunmMR(-Xg|414zNp%@1vXdKSGvOAsL>;ek|x*| zk~eHs3*KYPw(md4w?29`^od{bCBLvvKXs-?-L{_g@|`?>P(tkCaLS%>G{wksTuC+G zU@cSCaI30?)99cllF$ZX*??471Vo9VSV-U)Sg#o!(`Y?uhxBSi>Ew?? zHP%)fL@9PJ_I>*O<@*hwVU)Q`HxL}}w9bZ0nD@(rQr4ox=}_@y)6bJLYvbJlYZ{!o z)Qs_5L1nQtimeLI4i)0LmM!}{R5JbIGYrK|n-!|jJe3^1M0sJscrs5$ zLr2-&(#rTcGgQ}d>uwFr5d;D3Bn+t^A;PIL8A#axI&12bo{w{>OXBM z{~2Bd|Av45GrThXOSOxsmm3g(3H>3wmaGs_WdoDrUAa(VB-A7Uqe|)lbZj&idXBjn za%TtQ3xEgZsJJY*a%ca#TszJGYg-(^S?Bn-vkqdU`X`K9uA3Z0EB%G_Ccg$XBVGIc zR&I-rLI32KcA4XGR48 zDGyhyB2mEwKITXdV^$^VIwIQlQJOn}&W=i2MM4csP!lsuQtTWGrLb>4&gVY}|IF7q zV)q|UVEtELas3Tn{p(r!i+B9>JXxALll;p`)hfF3$bu-m^LCw0G$sB%ltfmuEfmli zij+vmLc+}m$T09ESYd87(BpI&n?x@M+c&f1`W}pmEPOA(ABw}=$}EWsB3Nq|R~g*S z)7{5YIj^_(>+S%cJS+*)y&`-Oa55x)4%89r=`x9vY>cKxnS^+DoPuVN1q!#On{ZFX z`-}RLJ=A*dP9s|npEGX0ddPEIM{|A?rlXESiRe<|Afk79?mXl=2I=E1!U}Y@2TPdI zqQA&6I;dmG)v!CWg!uNe=rp~k{Zcy5b-1j2j965rVANLcgLPay5g@RpS`hh}|I~oN zN%B%q^8@P=ftW$qFy^R*E{AXuhC-eUPwd-+4R@MW2D-Nc*|j()*kkCP&)im_MRkAg{YViw)km|^ z(8({?wI-~+Lb#Ny8_ZOG_E?Dz&TCb1=1WkO)cX*X_x?p}HO{kAC~!Q8V6hV7#6(`vS$&-=tG$sUVJw1~#{9$qXwf3@40p0pj{)d7W(Jrm zQnzfuFuJA+u46%is~Sp{LP(yR=FJV!3lf;|t@I8#4{; zTR+;1bnXO{MJZaQh)-u`g7U!_Krsf4QRHGE*c*mqtJD(F0*eJOvn_nQNrBW+pk~aI zNQ(lBd&IgBFLSNrR)L(S(aGrH*aK3Tn)vCnR#h8hs*58S5v`xDd6h!v6BDo7;}$@bC|Rw-{716sw2emuxCV8~X-4i< z?XT0TjL*mSb9aEv^vD9N%M_M$MjbJ=DK4WEk+hAIr5WU)(5i(8tCOS#{VSe@8;Jq` zP{Gi0Q~D@cuvFvn8?|a9uJIY(%Qk8=$NA=qlx4bY1bbZf%|BgL(=;4Dnr%l|?vrI3 zISo)ob5AhzA=5qMqzO*1wm6JHcWIzB@uK<5yrGcf&@vKtshYoXrU4X_>DZ>A zn-8UqAlOaOAjNRT9WR@|91(JB+nQxDACu+>D%GVc%zln7Bz|N47?=cVRi7}IwkEn( zybQ%)11jN^VB=D86w=n@bYXY^12!zrZd9|mO3@jc{#Z4B%}g{$ofz1F*Q4m=HfV0okx!~tza%hJB~mk-u8I@F)ZPm z;yhqPu#K?SR8et3O>up!n(!D}1m-&g_Aal8nSxR&|2LC44W0gP;UY(6(`j7eGOoi5!Ax7F_kHf%W9?mQgkdDdPvwo3ENn^C23$Ru}&p&I+Aqj?I0Qg1$#@v+C zVs6T1F6;BDYRcW^!FT&C@5lECwg4SeDtV1=jU$s-~4FP1+6PnW&G^-X)Qm z6hbK3Or3*x@0w-xbxSK7=n)tEVStMdCQP?5;5JjqB7wu;P)t+)d28(g) zs^+p-t&E9xlc9sz4umygL` zVoyG%Ho-LyttC$|a`5-JGf^O^Tm^U>vptN@L8;znWeWUGUWORleiZLg+}uj;2NVur zQuDsmAN?Q|n+5Lq+0BkN81`yjzlCzR^bMYJBf|{816V#ZEZ=f(3u#e@D)Sm>e8?PH zPzT@40XuO)q}Y8iMI$#-l)ZZrAy}!l6_sOH&*>}rLfwr|`8vp-$y2tI^a$z{zP?s( zCEh3={cGrXj_U;~9#>S~>qjsf9MambW1D`m@fPu9oi4g2(bRcFKCPvX1Zr+I)rY!b z%i3VfF1;azO*@V}y3jP)*z7qkdEWhg_KJ<6pFvBX&ZfOQzv(^y$%pS35!ri*-fqdO zc16MFD)p1&mP{cVLixD1 z+Dtz8R;&_Ve9rv-XgnkOy*n&fuC!t>t9IXFBr1$tA_(vEggi#t2ayAK5bT3uWE?Q-j`0pGQ4U?&`i2nZc6sq)1ZI7(VYYbgMfIxRg(v(lq zlxq5~fUaKT2?yaVon3^bc^7@2!G&6myh5Z|WR2JD_-S5KE4tfy0q|Z}nO!p7<(ELy zuMKNV`A1`USDhj7CdU|W=+{^2_RbNoS|*u#EYvfsAnFNL*81qAl^NZ;~^E_|7g*tS$g;6`xBh){}*undw>7m z>4SE4v9$Rg^+EIfjfnq;QDskO7gJjWCwm7|Cl^oEKl}Wv8?Rd3+Cj$@({IYmeOga$ z%_K>-lO?1?C(|x5R2r7GTL4Q5OJaUTC!eB)JS)j$eKPmqVzmhru@8s}0;o`_PE{mO ziv?w+6s4S?Ne73%e1d~GcIsu|{6+W&hm56fkNvbA+v#vcn&g!G*7e<1-t*^FkMG%# zIzUw~H=s_SBWfp*gCP$9YNzT2WN(nR%Es9MIdB_n9@2R$^x3@8aV){rpt;HgYLX-V z71DL5Z<}}*KXxzA1`!6|@xU?YG_FzGa@hOe6Z)XTFN7O^j{6}1yg^|;9-Q8^n|KU7 z#Ij!(BkDJ*g1nVRd3ob;uQzS*`uB#v5F7~nYxl7Qc?e;YZe{ty$cG-ZsdAMN&aP~1 zt+(qc?$4ekwL95cYp>f9qH@+B9lI$j%0jceY^W2k^h)x(CS^)&c}<_sN23{|8q4gv z53;wn*H)K%n#;O7U7fA3OD9dvPghnpSM}mAb#o+0FPfpo&Qc$#9a=MjP}qJkCopv| z6#<7X{)8t9d68qTA%AzJCOn!dT*s3vMs0G*TyjwMlF?u@IV~Edn_rt{G01dNo?8Hi z{Yhy|o+!)fJ=emxW}9IgYI=RTuaxPhqA9i}6N|km$!iy#E{Rw6JL-Ju!Bew>q0QE~ zm3E`y@g+9qE!|jiNNfO)5xmpYFqT%d#!W;@8;2T6%xh7T3Mv{^17#r@O|;v%BZbXL zM$X8N&$`>W`k>H!r3Cip!oHiBJlc?a0GkEOX@&_N_Wc~#<(%#OnFK6WCn^OlRG{$? zj%sNNhFr1PsA9-GN@1^gF&M7dw1-?J*0e@yg3-gzVdT?bTbQYd-4D$rWMkkALeK=} zE{!xv2s}hnp|u8FQC4QgR&$!TPG~bJJzq18r5Yo81;&Ej?IaAjQ@3HF?Wu2VDyd4E zjNF-w7qyv3ehek0@sC0iH^e)c>pH_@>zIUXLkAtr!pbS7zGm|wuNKj)M6wQ%!~s!o zFL4^@GzrGWR{6fb0+C7#3^NbH|nsfcUP$7`e>$efVSZlo(+ zO1ffRWOkzUCSY@Ob1@yb_=@j zzCyiTh7oY>Iudk9$ra~4FXu3ne96z}QbD5AxzJYmPI8`1I%HMISq=n@;Hgi!AjhdsKQT*VL#tZoHMdq&k$b-Bo+2up>9Xu(f-vE!9ZB=Wm3&rovk?G7bz_ zOxG04{EDjbPn7i1=LC>krHj0{GE)_^*jAbbTN1G3HO!<2^GT_AyoHAxVaacrBH3A^ ziAoAE(=0up?eFK(Ta4#>-H7d`HO?Frkm+1W@5alyW+ps=RTYI3h``PL`iRdm(o;vIA?fmO%jPZVcF z@V}U=SxKvsC;P22i;g%<)zYj+nUx8XWYM0~N;M#Ct*I?7hni?SBO=Zly3aGGVsl|b zuGS>kT4iAC?RvWd?E zUE-~6ym0u(G?BMy%sh<33V5jFS{xq6hN9{ti&DA$7c~Z2@vR+6yc3y zDh7?jch{USOqCtvow{YlGDp~F#FA=DHy%ZqembVGRH){vc4?5KQ0h#cS~@@26yT+C z=*#myCe^>awLd;6$>Tq65Iim%yp*@&Qdp>%Sv_>N!B?;ntns;*FS>%0rT~xa72Via za=_R}brK$o_itZ7dh39rs1M>k$q>$5z5U9zW3Q0+M{VjVJT|+#2{`XCU@4s zqvH*A(F!dXPQa_0C}Qrejwyr-qp5}|`qHT3D`KB2MNySg25WyHenVD4FXD`3hGSJC zb^z}Jq|nBdo9+srL2Csfvf?0U_t|RF*v$UMqN%GyltmbEKZhUu6!kYCpViZ4F2}h>Af`zb)XjN zB1RJ$dBx~e8k`LmB$^@!4#n6q+;T7KG97lHcH5&$Y1L?XT$(qX68y#Enwfx@DCE+gV{u<=fH5l129vrd4 z4w6VvSALANV)BI00Z0m!aAhPtIGNyW^qdd{w|88b{Vv&m8|j5lL}Cc-5akU8mHqac zCw#qGX5ciM~(KgspYF>{)Gy&{2|a%u9p5Uj)xDykDJZeX4R zlRMU+iZIHVd`GQRnv^8&s%SZmkuGkWBEnMc~--MU=zD z!ZYbeugdbb`$CXK!cE6WJ%~#OkP+v=6luzpfo2yQsM(rf9{( z#g?>3&OQNP^>>UzaL+`_&q!9cOuNp}pRcNHkINV_%a}LpC(GOieo4F+v}j9lCNOLa zrp?h~1ibF|F1dGgS;t82c#kxbgsZ&sAsQt)8jxpH8E^z?d>PPV3~p{U zVxHeo-rGI)MBs(kdSAYLFt0uv_XcSy>z4hr59+L9(38QkC~HlZ)%l|LL#$-i)s^L?$A@ zk7*{MXd%=XNW%{|0u>2@P@`dMwqhSe0ve^0Ws6)}v&?&2Am7eDmDazE&Z*c-j^%SJ z{h_k%Y?nHj$TSakQ}?{p{haIUckIsB@Oodny#;{LmqgZNs93U#2A@~S5u6-2{n1w4 zA2yA;p}0Gu+v64&Mz3Naajz#Ps3r>05lD(kOOtAhJI-@}T2+1`5NTg?r?68{-m73h zrGX4V1}jW2i`L|%Ne^8<{~GAWm^3^7;A9}x*i>AvR*zPdSc7`%G3v_0Yn|#8ai>LT ze~>DrrTD`jRSns4z6l9bdHk$IB=rE9orTyM?Wa&xJnh5ML^LEzrnI!_CK3YkgVIb) zcC$>BvnR2A40O}5nR?T^7Lh%fhE0{dVlTI)nX3>-7W+fH6k~Oooz*GOWz%FPW_4Y8 z%H4;Zy;t=i4kG*4ViMzhp=)%&lN%ZLn< zM0e4KvqzyXL|xnPN5z&GCeTJ5Ut&2G*|jTPRt5qGLwJ`sNsQb_Ks+$(NcqOS(QXR2 zuG=d3TZV}NiOGJ<7KR>lXql)E12rkk?o9mMoSK{+8;C-5@gR%=69oKSBZLtL(VcLa z{wKuGbuCTK{ULj|SI|nrr%81vwv}0fSot+RkE?A>o+=Lf& zw6{o&CQ@!^?HyO$VR#%IM|5|BHOWK1XBFRP`Ek!mf$vBA4DTF``oFL@+*(-T>W9X)nn&y`6p;HHPE8rE`J=xX%huTR}doE)44mPIWuM&Au{r!Nc?Ax8k34jtbw0 z-NJgje+%4``BbzF!&2DqXWf*&4S{9q3B}AKgg^fhx*;8;CzwUmzR%CKzRnjHbJy% zUECgIIQ)*OkPPVRWy^sFS(elVIE9#fZ_&^3>IHbY(10nH?IsxjTqJx)d=QCw_Z!vu zAcZ0m`vm9&q6xBtL*@%2!Ytej?P26c$Q#xqJq|#O({}?4M%7k5tdep+<$4w(Q=j=6 znNS4>qffrxK$Ucml{JSf{CG}*If}Wh?zSSx%4vbb{Jgov^)4gI=`2L1#~U$FmW8Bk z{^KRtni5P}u7Jq-YHuI99EvatFn$pQ6iSfN7s!DWnv9k zTvR1vWMAsfo=W6fGO-7!%g371uL0FJQUc?ubMnL;5{#Gy?$*g|xV1B%_5083uf`sa z6?998_br=VXX=Zeo;s83oyjE6Gg9A(aKy4RjV5|!6twL~W($S}fBnn|C*gk-veZd#a+D5BQ zdX_WZyg+Uhy&^a|q%+1V@w?vGtwGM>1RUf4g*|w7tqSmeYA&_#{|$RY{zi%9FGWw- z^pBQjXd`0j^rv0V{vRr_sf6iYpS%APfV$P+wNaKa{ldDLU^*ylL_I-_qQ{XmYFQEO zb%>LrT&r&rqXw9I&l-fyz)|Ou$znp;Y?E3fvDe9L=b}m%MHv0Xtgl}S9^p^*6UweR znLDep76UzV?|8hY-08O8H-9mIoZrh|1FS^;s9Xt7ld1>YMjA-Q=%Ecw8@h?a=qcJ$ z&88mk>_Y2pfC&2oz9y}X#ZqfyKv zeKLvIq}u9Vr}B%;i`d0QMZa;be};YzJ?01eP}=!L9h%nQGimggi{XblSQ~HD)19{+8vM2BVSc;w4M!=YWWh_*Ei=A9Q8#Uwy#9MIXqx@H`wekVWGzx(+i@7IYVx(6V-zVHthGd9bCc>PkScY2l;4NtR+ET zhM^qP?!fPOJJO-G&4;z3(dfYLD5km`FAc9sVoOZO^(L~;M9P8LFfelBk+qJrvod2_ z>BAF5w$L{i?**K-T4=cSI*R~x9d!d*sVKtDC1dc1hj`AVObLt(8E|$jv@+i~JJ&hb zeh(?T1UhsNnELdFgju=v*sFN+b$lgq(D4QVO_T4s$k zi^>hzmJKeu^N1whx3(-=tK*DdMmzFJ7c&2CMow{w-*3$Lpz+IguF|WZ(C(Tgk^~G4bK>nqy zA0){|#ctGnYpB7TY<7$_!wNi}OAZST}FzO89}J-I(h&v9KjT4mK?BcqE_To#4MU}16zgros}nM1gd zDcNDG?jHrGFo0AAuDwfJqe);r6{-#(zf^{j*9!|nw^*%ErgnlfV|xR&mG2_)!R)|e zeT9!hWu~c73Js?K@Xg&Y)>y5O^|l&Y11z&l>~w_6JID;65!#_SV}&vz^>&3~w_)~{ zVcG4rg!1po0sL6HLH|%4*uHTG?fjM97@{U`c_J1UiY`D-%~<~k4{8uZ_i#rPb2SFN zCKZvuV!R35-cqzP+a*VE_iMXpA9;Vj)D&CTa~TVbxO#FlGE!x(MOn<;i=v_o{+=q^hzMCbz|Lw&iQr7n7hq{Sio^SYYHhRyC z$uQgSikR#8969n4hikZ4kA~=`XiIT3AlvL<`Hl081iWdkTx6K(_*}IC_4k-B7cGDN zgdyl-g5B%#jejhT76;eZ#i?2F81vj9oUulp#Hyz((Y0FCd@;OCaWEn4^9IK__FX2= z;iT#_w=-Um&G!~cdu?tA6bDT(UF+nOBQxXw!`V5oX%=nUxw~weUADinZChQoZQHhO z+qP}nc2!sUoST~`xk=7*lHah_-gAyM-!UfE2~$$>^-|nEtMI%_L1gOyXq(1$ zPRT>_9qP}yS|2n&P{9s!Yct($kO*c%Hxf%I6y&lMaiJTi_IoeFt0Hep>Y-;bz9;Fe%0Shf*Hx`uy zr99GLIifHw*1B$Ls4mN`yZf06B?IL|gLGOqan-zml+js^GU&ixD5@WFq8Hd^-^iy$ zChw=U-Z+Ea+uXgZl+g)VSx4taTv28?!`N*8F19EschuDf?4Q`}Fe^+jq+iLaWstO->PUcEMZW1Va5NOM*9@>t~Hi9hrMO83J!rL3|%V~*~#y1UaSM0z%HDB~}nqPUKa-+3r$ z7F9qU45n}dQlJsyk@BY7k{tXcQh11Fl-n=Z?IElrB@N+tsDij+4yuDUT&b&*AqkjD zQwPEYC=A@(laC%38BPTn<+|A_ehESPWXDn_IJP5j))~V8Y;S_P*;n;CKLH5*G5#Wl{RlC!s8%L|iVh5LDKx zOeaJntkXa+qD4H^8d&304{K6fV3k|haRh#Ha4j^0yEwizC0QmzPt+jT)6t8|F^TIL z7UIo8&+^l91k*Ya`o=T@;b!FE3EJq#CbQpO-D_t~d=L?HKalWK)tPxPCqG$AfbT7% z4u3F~&s+qyRY4tc>mZ-Tm=`whS5-qs4_^*cZ_ND+n!G_X!kbY?aB$G32ZvhvlS|IT ztD}94NE$2FFf8|QrE9Yc9+fRJ2ViSD5m4;iM6kYWx-a#VgQ|2+Sc@_nz-bM5-d^$2h6j`SC&c4^Wz z`@!;xfbQ|E5=QDfVfPfFtitu$CU`&I8F{V>7Zp|d31UYy)XdecQ{qHcl)cFsGiD~} zOf}J~dwRED2c5*;&gVY`J>Z4{<=}7XRKmX$^ql`jQ}uro^#2_ularSHOWk<|1VI7i zhyDqA-v9kLC|*E{1T&1sO>?CXUL@&^&in@e|L2EKqTMnugR28Pr_Hu!SK3U?3;Yig zHn=%>JE7C#@hz2#Cdo{BdvUg~{W}33NqN&dDth9^Y8}NU`=Dye(4Tn&MPu&f%IEC; z^jJ~*bu4YQREkP(lcPoMbI0ORP0sm?jEW+L^Wt~EDx~P>=9SbvhCp0ywkTLv*18^* zWiTa8PuC_XM{<>vua5(LiwrIEU+?10cxMAQs|vrc|Gi_h7JW_esTdmPrg9}x;@j`EwIJ{myG6&3zd08#xVwg zEF79)R*r3R!Ec)NF?a_3KfjrAy#E>RG1p!?Px_ZwJNlQ@8r{Ef9RKKX|ECm=C^=aR zWPTj41j8*B7M8MNbEK*!kaVc(*?r-=+I$3Y<K*zV=YGiJZBw_^WkYSAVRAwhlc|&x`2aM;+{)>Ft%s>?sdqoh9-j8!u0l_>C2({M{mI5JWk$Xv+o zm8x?=WOE;O{*-0k`3n^n>o@N{3s@ougUPTkko0ui=^SXq4_MM4KC+E^T^XGd~MuS20X%*9T3s3M{?% zKjXiW++{ScsH=t-`V%9-A=Mnybw0!YL;G-AQE+wqy%VPYOBmUIHC71zoA=_sY9C>1 zLj@xP8+*h5_*{!rv~943QMj>dt_HUN)fwp!rUpPkgFmJ65KP~Xh-K`sM@VD@6M)9t zxn-K2oVT8eXW@B%Q}zMd9R0-8@QZy{AdWQ^EK}NklMb~vUUu5NEz=!ia=4k?_BhVu zZ1}ji;oSkR#m^C9Ko*25!T?M<*Rhjiu&;H}c$ElRI$I5Jq2;q74{R3;NHnOGi<=OJQKk+_1C6^4OEB-%QJAg*RDr|i*K*pi1aFax+Q|gSkIJ4v zmq0}neG13~B(KbJUvt3jIDWD>G?NN21_v7wcxY5%)1g7NovjU(Z9dkmu?jL4N6u%$ z<~t_cj}$jFlo;C+Kn8udJ(dma9~x4yQVG78pQeo&k)e$ghaZqFJ~$#n^dF^LAnJ{z zF~B0WXjnn$1Z>yRL9T;ajXc9!u+g&}xlg2tY&B#Zm77$Dzi8iR6<@Y{7aymi?io=Q z+ZY>5mF!m=(?|lakR2o8rWjURHT7zbf z8<63H^fW$GmD~Uq#sgz+z+y|L!$dm?1aWDDK67bsuzq+*^~l;~OwuOv3{paKWf!-P zrYv1HGo4(Y;CBT%Y-gl0uxK3fEg>V=vtDnnWIg5xNX3LNaEjEpA?C)^VMLYw!fopP zvXlwC;ysCf9dpNUCYFdSd%b{ScSiZT3`tWgZ(2PNLfN<=3I*M&{di@)oLL&`uo!0P zL8m1KSv;lAqwoM9aQ9$4+7Kx4%>ghlx*bLM1X%U1ATa)(0qhsH?R`_a8jA%rt4`xj z8Jg9nmFJSl+|SfiWQvg|#i%CtttZdE_b3|>isTuj(qPpV;tr%#7ip#BuJ#Vo26H0g zE?OL8cRgEkCLij$p1efi$3xveImMh_thQ#SxStOK)vHgckYTnT!7aMu3s@RW;wrAU zuXd1XDg6j7fTKM8cREy7Qlo>knze2nKw#WLmE15_-N1GYwqV;OA|Y5B2q#rnRg_@Qq7?^)nWa)aM7QXXwv|(ozQa z@bi~4p8oF%S5SiP>%1p|Nz7dlcU;`F$6Gkq3y7`Y>}WC@qD+}@h%cTD+anf2E#xmK z^!bOzCldCrg7=G;9%1=t+Tgu}Dp zKerKxCn{40S0$w%mN!LCuZ9aU&VibuibY16OF>cfZaPHqx;tDsO(6P1lvi{rySfx{ z*hGg2x8;5s{X!db##;`!5Z38&yP^_$%9s^w(MTjC=$YB>r=3Jl4|C!iSuEKwonn5e zh3~?VWigB5zgh7fP<)qv>vN10a3oLFu_ep86xASy38LMoKN!cG1Exh~i$fxcGbApH zxX}nCMe#$s$Q6+DKdXRR^agb;6uuNoSY?Y@#MpDPbwYBBcH}|svx_FYVzgl6&jM;p z!Ia8Q+mk-6&zMEFqAc4PI=G6rQFUKTd*gC&x2lJ4nT2hcUs2OCot??Au(=`VN6d;QKdgk%pPAxV5pR-d|Suf6HjhQqq*g zRz>&|-8GD!Y~jnNFSdX^46vl2kOuyF4iXyX2Ouru%g+o^PZ z#Nah5S%^@sV!rc{P+ofO5{-T!axH1)#%1Dc+|9l-dHI)DeCPD7SdGx9_~|E$guzeh z2i=NU;w))Cp-?GSM`_hkq@#kjlHW>1!%neWv>H3ZLS*VG04w~%?Mx<# z`W9ryY1~%_BBYW#!*S2e^pIq;gy-6Pqlvoi0?KiG6@Enr5m{&-gJG~*9ap7v;l2Gr z{a{PWSx1w**W>!uks`NiI1%CS*wGU1@R_!;6Xt;=)b{vlFzzLxY= zZ-S?x)4uH|Z>zmytJPrWHcYg@k^l)L7nqrD86>X~6Z62$EmcCB;GoEX4n-F-5Oa zlU9)=p+ShB;bmXWKkTngN;mXZKOgZ$?GB6dJmk z@?`}JDEla9MEp9Vx$wE6G18Gi}BJtQkdO z;m#xr3s)gbD?By^rUTAFusDC{@Hx~_n|ZWK7id%xX!MVdsVyBUL|P-YSiQxI=fz;Z zIbS;lPYAS%pV?dJCcpO{4{Z=Q*C7SQYJB)#K{PnrB1aui-$;#G?mf`IFh<-8Z3X4bY_C z+zr`+a=-+YvHAl|iXTxqa{R=?*WQa^5-b>e4Q6?B$CQ>O6_rKES^{gDl|7ZYK`@b{ z!j*IjUXgWqJC1PJcc+&GtD%^zh$5cyh~D>-s^Ad0^J_0zWOJHC9{KT=FbODIMXRyp zZ%ib^JcDBTi2(&BuEMtalM4DL6~|d;Zz{N7zfQ-cVDJ2KwUg}33ejTKJ!7_ZTWXd1#D8v?6LK{ujO zVlXRR@r4w?QeG&;u@k>t&+9*XU0apk2={;aO4NS|KXd(?|Chfmuzxu9|A#IAKfOCy z^3t-{3Wl8wT)xz}6%nVqxxK{<-VkrDkoM*n*kXm!lm&z0opb*&e|k zMG1!C%%Mb8?judMJ5SQGdRkb0eq8Qqg9>+s-*WVWzE|?+4CO#I+EgU4wH&0THxuHO}>wthFBspNW3U!oInZrsBM9QbCiZ6a^yd;kpbT?{5Rrn z_%mcFP~wJAUQs7b*i}&NEB`(Y*E^-VM(b~0*L(|8N-6LanK_TO#Rl{}{8<`t6Q(Qx zJ@mFY94Q&1Ll!%^_Rgo`YmNq;u)I9HsNs7I zHxbOJ+N@+g1)#OxIZwE87&Q)sJL&vS?Loq30MvL}G_4R(}~9%s}=@rjsC+YRkb z*Uk3F@y+-9gwD^#f>Tix1MfycZRvqleCF9VdV)Q!942p9hA~yJ6Gjq4_9Hi5>O;1* zXQG+5`_|qN3jE@))IMmWZnC`(ZxB2A{s<)6w>n4z9AseD7Y?LRTWyg>WjZ zCn|5PA?D~~j*_of_;z^SeWtoU7_6SHW2`mrcUZquZoxwAA{4h1Z;`?Jw3XhO90EM+7RRVLgLs| zIa>0$Nc}=>75zKBIoK_paob;wXxKC*kOq@daqmx%TeC99WC`iag~UwJ{EEtqC8&}o z9x3Fj2kz1Q*UFXF1I@-V9B|`y1GANCB4bAYj;Jaq=rRmEu|X*$WveZKv&uQ~PN0^G zBIfx!z++P?OQDrevq7wfwWtj4G_1+3tNG&gc(Su7eyO}r{1+b8R*1Dohp}bVLVaS| zpU$kQ4dPOY1marjS(U{HFNx)-EHcAX@H2ETWOLE~B&Js#> zt3IFLcT~9%P5nUQOcW1BQo$;#;bBw@d1HstB7xHTNZU8dhQeSeor2A zD7Vrhm@`=m=gN9gygb`OR=?3~%B}clLPAS}16UOX8223kgtzmUf(czgp=-}b+)O1FfeHvOX&0&b?(Nhul zf$r~Z2h5(q4W#Wo^X((3or26nJMf!{*B|%_Z!qvrm+a(wM40#osxX|Y3ExU35n-q^ zhK-H!dG(D=jNq)y6SZELnk7lovI-i?r|Yc%@s4}<;LSX#7;N;!$ZT`_h(?N&_N7Mc z;hH;a%$}i}QZO^tPy)Q74W#SwSMEQ*4Dg>P*uckazaQ~NK!Qa3@r^bIyv(PrIT5C? zPhcIw5n>1__GB6VM9N}te4lv6-TeT?3n44rqHSNz$^3O3A_fgA`83KIKmAbQ6B$m6 zViCr9$hI^1W)@|Y%oL2QIql4FsSUe2omqaN#WJ!ny;hByA!r-qJvimAY|fPB3<=gm z7IsZiV;9R0)D~YXikqIdCJz;t!2c=IRg_`K_F8oHPOv~_wyi|L0kBR}{3IdoQ>s^= z$~EpbA>mDq+Y}rj1PM!ln!zf03K5b5D z$4UNO<>^cb3qc0#JhwVGXf31=E~s+$N}EIDTMrazU^=f z> zs4mC6$1owh$Nc0hK5og}xGbU6to{Q_h%3t(Qo*iue}tUvJk4__4%aehMu;_rxLsyvOxS0SUI;8*|Rr}6_Y!P(0|>HP|fu6fV= zoA4xaa{<{uX0Qcw=J1N~0fgvE@+iqhvS&7YsvSo!*U)o}k8pOfDbh637R7TSayn** ze8R+m#y&WzqL)aUS8WZq5hKzZek2_-d+G+i#NX!t-jM?8esRynDzU(?_qe=euV6*0 z+BZzzvas4eJU8ixV~Biegh|GAMFL{f0zPgH&&GeJi+eO%d+>}l@460&0`Ci-JtL00 zA%CXt{|9DfR~@S@LO#8Xk>L}v{5q*(dLoSa;#aIB3@y+wua?%HS9NU+wBj9g(v0fp z$N2qYU1NQxtxMSFWcd9|($xzxEAIy1J?Ed`bo!^*Ecn_08}y0hMSfZVeL8*a4y`=oi9t>`{2LiICXi-VVJBu~bGUSwxSN;Txy&BGz9G ztW=+-wpO=E5^f`CgcNjzIII;Mib`7-j{JWyeYv1ZEgER5_cyO+5TzXm9rJX@iwE0mXtr?e|I?3 ze58Mr(1W^jEzvCy^A(8^sK*ixX<3dsf~M}Jq$%vDD5ND(8F?>`Sq5bn08S{M>;;eC z<_sUmA5gb|x_abHB3ys5p4F-$s-D&g?NL58N|-FQwh+Gaim@Am-6GTga-K#~dx_}?nSCOK( zqBpjJ9^QX?c~S$ulOvw&!juLN2nk^R>a*369`P$hy|fB{1o>Ej_PomLwx#F6Ajv$<6S|wx`PKlOhbpH@a>6HgR}jaWx4t4%F+T!%8oXu$`y8{Q!Wvx)aKgs zVtqraqu{sP3QE}X(jXYh)gSUEZ(^jbl44Gzu$4zq|1OorV_kX;!3G3q@!%@FBip=iL-8nTZgvx9b3Vqhrnsqd4TskPw6X|bXRBn{;p-@q|^HO5tCm0dI zy8`B_F{U6#Ge?n+GZ%2tHofang<8u_nAO|Cj0OS}xFJ?ZymAbyI7sn(Gz_yb8GaS* z!jyXyKv2KR!)~56)jHy(N*CCr?J8zuu;Z1r@eq65 zwQ!r!Bby_nPF~^t**y2lB?MgS=%<%Tr`=#AGpZ!1>FDR8(?(Ybl3;oOx+8q>y9YM6 z@nkrx8n-{p1rNU)l&5H|j}Ni?==o8X(j;bm_F7I_=Jq9mgLJp&=VUa-7BNuFH%b&e zCr4ljLOB5!J;q5iD%YSE3(&~rKKtw|l-pkTNFbvju%h87AHaSvBOOGOl50`39e!Q{ z`GKd&r1{8{$d;Q{BOreEW&o_eBuVP8F_xH+@kd zqcTLR9DYgo(Mc5Am3E5P;!{K>l9Oa#uY4e|&-VA=ZgNqt=X%HCf;^ac0+;WHDt`t$ zav>S<_P$F6t(MSyY=jnX!4(IGkIlAie=Tv=KX0t{;y?_;TSkb$QJ`Wmj0pz}XjrqI zjoV=RP#0gEpWQM1Q8C^etJmPzFABJm^KrMPz`U?6+ywP-uT-<#yFZ!$eM(qVcDI_@ znq9bAruXqMq+d5+7w=^I+GjMH7?j6hvIBWZbB*cT8oW8b%yOL_?0C}s@seJzZZ7?a zhR1McmkBV82#XQV3M;W4Ppo?F4BHtoAk7a=b5*PHfxrh8{SL8W6IacNRI3DjFi$;{ zZd0~qvcsB5eS8y9Y?e&WzEhm5$h^_zka1b3(a^0VkGaF>N>N%)o2RBJZlu(7*lz8w zb@_z#%9-!lN@O{sFI-5>vJc6%jcgQK?vJzQe4ZFc?9sZ&%&L`YQ*4J>GulUfC4#e0 zA?T29(|k@n9U(y0>3t}^O!D$yvsoRPU%o`q#-cQg^;4hbqu!~pJ<6kZ>9Ct0G`XXm zh!$lm-r=DXcQ4iRgpp+o$(WBYk(MF0>2`zImKh!t;Ecy@+TkzS7go6qm4sQ%hv2vd}0G#%Gt&(9VI z_k`S`KPtsp2yjWY=j9f|i*-qN#qsGC!+5YGNEODXUcpht3yV&*5DK_VeKg$a#9|pv zfLcH;j|2y8vf&s7mD9RWVDFiRNq9WCFfcWDmvZG^+$d0zEi}RkTA?_7ENhG}2VH>} zI){fHj9J$Pj<8t*QE=BF0w{!#u5Y|;il}x3;4FK0ECAT-Ob<2owpVcpuH3>$2wNm4 zE_GcdmA406$ptx8FV(X;(H`(}iLNzgCn8a&x!ZEl*sxP3y zyokUpt%Iu8AWhIDw3p5h$O`kKVU@0-V%ct9iQN2@?RN5M(e=MHy*Lc$wvF5Yl#(2G z>H1JlS!`~rXW5^rec0?$mot#L7!C=HP@5ENWt*W_S7|X`v&g8FSZg*o&!=$13%5*H z;+H*Luj_R(m;UTq3NF7eq{rkr&e>16i5{&`SvfLn_m@S@ z8&D1QWjKzv4!n^g0}lqho7h+=xMLQ|d&KA7sFm(?$#EPcD|yl2MGma3C_D0gV*{`q zqp6UvtU(TwEy=XEhFdR9rsYg@nAk@)!j8xVAozGb*GB~qjwyi=6VDU;9~8X)))qD} zH}6#*y5n>kM2{SJMI&&VVvuTEJ$~YJyp@95Gc3JRcKvbu*f7Rx%YP@mP z*YvW1A261%Lmp=HF`IN#sVS9(BtgC+k9PdXY0%8=V0UK(X<)nnx>t^r(u{l?JzAA! zaE}FtHd>9LeAFX>(?!1K$E_+LOoOvhEref{GC8bztfgD$?C7lCli2ezGzv%J$ym(T zN&c%`uAhEAw}p0{X7_@#Q?}!6%a^u^&p|6amZ`?7sBkWDYF zoaZ~Vo>3ga8`!Dl>O)Ax%F!GDFbG~`0z8>H?!&adE;idPC!4hoR8uLEDSwK4h7*=Kf{sp8(OCd) z∋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