Fixed wrong DSL assumption.

src/core/de.evoal.core/src/main/java/de/evoal/core/api/ea/correlations/Correlation.java

@@ -28,11 +28,11 @@ public class Correlation {
      */
     private double correlationFactor;
 
-    public boolean matchesSource(int chromosomeIndex, double chromosomeValue) {
+    public boolean matchesSource(int chromosomeIndex, final Number chromosomeValue) {
         return chromosomeOne == chromosomeIndex;
     }
 
-    public boolean matchesTarget(int chromosomeIndex, double chromosomeValue) {
+    public boolean matchesTarget(int chromosomeIndex, final Number chromosomeValue) {
         return chromosomeTwo == chromosomeIndex;
     }
 }

src/core/de.evoal.core/src/main/java/de/evoal/core/api/ea/correlations/Correlations.java

@@ -33,7 +33,7 @@ public class Correlations<G extends Gene<?, G>> {
         final Properties properties = codec.decode(genotype);
 
         return correlations.stream()
-                           .filter(c -> c.matchesSource(chromosomeIndex, properties.getAsDouble(chromosomeIndex)))
+                           .filter(c -> c.matchesSource(chromosomeIndex, (Number)properties.get(chromosomeIndex)))
                            .collect(Collectors.toList());
     }
 

src/core/de.evoal.core/src/main/java/de/evoal/core/api/ea/correlations/RangedCorrelation.java

@@ -15,20 +15,20 @@ public class RangedCorrelation extends Correlation {
     private Range chromosomeTwoRange;
 
     @Override
-    public boolean matchesSource(int chromosomeIndex, double chromosomeValue) {
+    public boolean matchesSource(int chromosomeIndex, final Number chromosomeValue) {
         if(!super.matchesSource(chromosomeIndex, chromosomeValue)) {
             return false;
         }
 
-        return getChromosomeOneRange().includes(chromosomeValue);
+        return getChromosomeOneRange().includes(chromosomeValue.doubleValue());
     }
 
     @Override
-    public boolean matchesTarget(int chromosomeIndex, double chromosomeValue) {
+    public boolean matchesTarget(int chromosomeIndex, final Number chromosomeValue) {
         if(!super.matchesTarget(chromosomeIndex, chromosomeValue)) {
             return false;
         }
 
-        return getChromosomeTwoRange().includes(chromosomeValue);
+        return getChromosomeTwoRange().includes(chromosomeValue.doubleValue());
     }
 }

src/core/de.evoal.core/src/main/java/de/evoal/core/main/ea/constraints/correlation/el/AstHelper.java

@@ -2,8 +2,9 @@ package de.evoal.core.main.ea.constraints.correlation.el;
 
 import de.evoal.core.api.properties.PropertiesSpecification;
 import de.evoal.core.api.properties.PropertySpecification;
-import de.evoal.core.main.ea.constraints.el.StringSwitch;
+import de.evoal.core.main.ea.constraints.el.DataReferenceSwitch;
 import de.evoal.core.api.ea.correlations.Range;
+import de.evoal.languages.model.ddl.DataDescription;
 import de.evoal.languages.model.el.Expression;
 
 public final class AstHelper {
@@ -15,8 +16,8 @@ public final class AstHelper {
     }
 
     public static int findChromosomeIndex(final PropertiesSpecification specification, final Expression expression) {
-        final String name = new StringSwitch().doSwitch(expression);
+        final DataDescription data = new DataReferenceSwitch().doSwitch(expression);
 
-        return specification.indexOf(name);
+        return specification.indexOf(data.getName());
     }
 }

src/core/de.evoal.core/src/main/java/de/evoal/core/main/ea/constraints/el/DataReferenceSwitch.java

+package de.evoal.core.main.ea.constraints.el;
+
+import de.evoal.languages.model.ddl.DataDescription;
+import de.evoal.languages.model.ddl.DataReference;
+import de.evoal.languages.model.ddl.SelfReference;
+import de.evoal.languages.model.el.*;
+import de.evoal.languages.model.el.util.ELSwitch;
+
+import java.util.Objects;
+
+public class DataReferenceSwitch extends ELSwitch<DataDescription> {
+    @Override
+    public DataDescription caseOrExpression(final OrExpression object) {
+        Objects.equals(object.getSubExpressions().size(), 1);
+
+        return this.doSwitch(object.getSubExpressions().get(0));
+    }
+
+    @Override
+    public DataDescription caseXorExpression(final XorExpression object) {
+        Objects.equals(object.getSubExpressions().size(), 1);
+
+        return this.doSwitch(object.getSubExpressions().get(0));
+    }
+
+    @Override
+    public DataDescription caseAndExpression(final AndExpression object) {
+        Objects.equals(object.getSubExpressions().size(), 1);
+
+        return this.doSwitch(object.getSubExpressions().get(0));
+    }
+
+    @Override
+    public DataDescription caseNotExpression(final NotExpression object) {
+        return this.doSwitch(object.getOperand());
+    }
+
+    @Override
+    public DataDescription caseComparisonExpression(final ComparisonExpression object) {
+        Objects.equals(object.getComparison().size(), 0);
+
+        return this.doSwitch(object.getLeftOperand());
+    }
+
+    @Override
+    public DataDescription caseAddOrSubtractExpression(AddOrSubtractExpression object) {
+        Objects.equals(object.getOperators().size(), 0);
+
+        return this.doSwitch(object.getLeftOperand());
+    }
+
+    @Override
+    public DataDescription caseMultiplyDivideModuloExpression(MultiplyDivideModuloExpression object) {
+        Objects.equals(object.getOperators().size(), 0);
+
+        return this.doSwitch(object.getLeftOperand());
+    }
+
+    @Override
+    public DataDescription casePowerOfExpression(PowerOfExpression object) {
+        Objects.isNull(object.getRightOperand());
+
+        return this.doSwitch(object.getLeftOperand());
+    }
+
+    @Override
+    public DataDescription caseUnaryAddOrSubtractExpression(UnaryAddOrSubtractExpression object) {
+        Objects.equals(object.getOperators().size(), 0);
+
+        return this.doSwitch(object.getSubExpression());
+    }
+    /*
+        @Override
+        public DataDescription caseCallOrLiteralOrReferenceOrParantheses(CallOrLiteralOrReferenceOrParantheses object) {
+            return super.caseCallOrLiteralOrReferenceOrParantheses(object);
+        }
+    */
+
+    @Override
+    public DataDescription caseIntegerLiteral(final IntegerLiteral object) {
+        throw new IllegalStateException("Searching for Data but found a integer literal.");
+    }
+
+    @Override
+    public DataDescription caseDoubleLiteral(final DoubleLiteral object) {
+        throw new IllegalStateException("Searching for Data but found a double literal.");
+    }
+
+    @Override
+    public DataDescription caseStringLiteral(StringLiteral object) {
+        throw new IllegalStateException("Searching for Data but found a string literal.");
+    }
+
+    @Override
+    public DataDescription caseBooleanLiteral(BooleanLiteral object) {
+        throw new IllegalStateException("Searching for Data but found a boolean literal.");
+    }
+
+    @Override
+    public DataDescription caseCall(final Call object) {
+        throw new IllegalStateException("Searching for Data but found a call.");
+    }
+
+    @Override
+    public DataDescription caseParantheses(Parantheses object) {
+        return this.doSwitch(object.getSubExpression());
+    }
+
+    @Override
+    public DataDescription caseValueReference(final ValueReference object) {
+        if(object instanceof SelfReference) {
+            throw  new IllegalStateException("Not yet implemented");
+        } else {
+            return ((DataReference)object).getDefinition();
+        }
+    }
+}