Added deviation validations.
Signed-off-by: Raphael Weber <raphael.weber@vector.com>
diff --git a/plugins/org.eclipse.app4mc.amalthea.validations.ta/src/org/eclipse/app4mc/amalthea/validations/ta/TimingArchitectsProfile.java b/plugins/org.eclipse.app4mc.amalthea.validations.ta/src/org/eclipse/app4mc/amalthea/validations/ta/TimingArchitectsProfile.java
index 3c6a671..7e1b1f4 100644
--- a/plugins/org.eclipse.app4mc.amalthea.validations.ta/src/org/eclipse/app4mc/amalthea/validations/ta/TimingArchitectsProfile.java
+++ b/plugins/org.eclipse.app4mc.amalthea.validations.ta/src/org/eclipse/app4mc/amalthea/validations/ta/TimingArchitectsProfile.java
@@ -15,10 +15,24 @@
package org.eclipse.app4mc.amalthea.validations.ta;
-import org.eclipse.app4mc.amalthea.validations.ta.basic.TA005;
-import org.eclipse.app4mc.amalthea.validations.ta.basic.TA006;
-import org.eclipse.app4mc.amalthea.validations.ta.basic.TA010;
-import org.eclipse.app4mc.amalthea.validations.ta.basic.TA011;
+import org.eclipse.app4mc.amalthea.validations.ta.basic.TABasicContinuousValueBetaDistribution;
+import org.eclipse.app4mc.amalthea.validations.ta.basic.TABasicContinuousValueGaussDistribution;
+import org.eclipse.app4mc.amalthea.validations.ta.basic.TABasicContinuousValueInterval;
+import org.eclipse.app4mc.amalthea.validations.ta.basic.TABasicContinuousValueStatistics;
+import org.eclipse.app4mc.amalthea.validations.ta.basic.TABasicContinuousValueWeibullEstimatorsDistribution;
+import org.eclipse.app4mc.amalthea.validations.ta.basic.TABasicDiscreteValueBetaDistribution;
+import org.eclipse.app4mc.amalthea.validations.ta.basic.TABasicDiscreteValueGaussDistribution;
+import org.eclipse.app4mc.amalthea.validations.ta.basic.TABasicDiscreteValueInterval;
+import org.eclipse.app4mc.amalthea.validations.ta.basic.TABasicDiscreteValueStatistics;
+import org.eclipse.app4mc.amalthea.validations.ta.basic.TABasicDiscreteValueWeibullEstimatorsDistribution;
+import org.eclipse.app4mc.amalthea.validations.ta.basic.TABasicTimeBetaDistribution;
+import org.eclipse.app4mc.amalthea.validations.ta.basic.TABasicTimeGaussDistribution;
+import org.eclipse.app4mc.amalthea.validations.ta.basic.TABasicTimeInterval;
+import org.eclipse.app4mc.amalthea.validations.ta.basic.TABasicTimeStatistics;
+import org.eclipse.app4mc.amalthea.validations.ta.basic.TABasicTimeWeibullEstimatorsDistribution;
+import org.eclipse.app4mc.amalthea.validations.ta.basic.TABasicTruncatedContinuousValueDistribution;
+import org.eclipse.app4mc.amalthea.validations.ta.basic.TABasicTruncatedDiscreteValueDistribution;
+import org.eclipse.app4mc.amalthea.validations.ta.basic.TABasicTruncatedTimeDistribution;
import org.eclipse.app4mc.validation.annotation.Profile;
import org.eclipse.app4mc.validation.annotation.ValidationGroup;
import org.eclipse.app4mc.validation.core.IProfile;
@@ -33,12 +47,31 @@
)
@ValidationGroup(
severity = Severity.ERROR,
- validations = { TA005.class, TA006.class }
+ validations = {
+ TABasicContinuousValueBetaDistribution.class,
+ TABasicContinuousValueGaussDistribution.class,
+ TABasicContinuousValueInterval.class,
+ TABasicContinuousValueStatistics.class,
+ TABasicContinuousValueWeibullEstimatorsDistribution.class,
+ TABasicDiscreteValueBetaDistribution.class,
+ TABasicDiscreteValueGaussDistribution.class,
+ TABasicDiscreteValueInterval.class,
+ TABasicDiscreteValueStatistics.class,
+ TABasicDiscreteValueWeibullEstimatorsDistribution.class,
+ TABasicTimeBetaDistribution.class,
+ TABasicTimeGaussDistribution.class,
+ TABasicTimeInterval.class,
+ TABasicTimeStatistics.class,
+ TABasicTimeWeibullEstimatorsDistribution.class,
+ TABasicTruncatedContinuousValueDistribution.class,
+ TABasicTruncatedDiscreteValueDistribution.class,
+ TABasicTruncatedTimeDistribution.class
+ }
)
-@ValidationGroup(
+/*@ValidationGroup(
severity = Severity.WARNING,
- validations = { TA010.class, TA011.class }
-)
+ validations = { TA011.class }
+)*/
public class TimingArchitectsProfile implements IProfile {
// Do nothing
}
diff --git a/plugins/org.eclipse.app4mc.amalthea.validations.ta/src/org/eclipse/app4mc/amalthea/validations/ta/basic/TA005.java b/plugins/org.eclipse.app4mc.amalthea.validations.ta/src/org/eclipse/app4mc/amalthea/validations/ta/basic/TA005.java
deleted file mode 100644
index c357217..0000000
--- a/plugins/org.eclipse.app4mc.amalthea.validations.ta/src/org/eclipse/app4mc/amalthea/validations/ta/basic/TA005.java
+++ /dev/null
@@ -1,45 +0,0 @@
-/**
- ********************************************************************************
- * Copyright (c) 2019 Robert Bosch GmbH and others.
- *
- * This program and the accompanying materials are made
- * available under the terms of the Eclipse Public License 2.0
- * which is available at https://www.eclipse.org/legal/epl-2.0/
- *
- * SPDX-License-Identifier: EPL-2.0
- *
- * Contributors:
- * Robert Bosch GmbH - initial API and implementation
- ********************************************************************************
- */
-
-package org.eclipse.app4mc.amalthea.validations.ta.basic;
-
-import java.util.List;
-
-import org.eclipse.app4mc.amalthea.model.Label;
-import org.eclipse.app4mc.amalthea.validation.core.AmaltheaValidation;
-import org.eclipse.app4mc.validation.core.ValidationDiagnostic;
-import org.eclipse.emf.ecore.EClassifier;
-import org.eclipse.emf.ecore.EObject;
-
-/**
- * At least one label shall have ...
- */
-
-public class TA005 extends AmaltheaValidation {
-
- @Override
- public EClassifier getEClassifier() {
- return ePackage.getLabel();
- }
-
- @Override
- public void validate(final EObject object, List<ValidationDiagnostic> results) {
- Label label = (Label) object;
-
- // dummy
- results.add(new ValidationDiagnostic("validation executed.", label));
- }
-
-}
diff --git a/plugins/org.eclipse.app4mc.amalthea.validations.ta/src/org/eclipse/app4mc/amalthea/validations/ta/basic/TA006.java b/plugins/org.eclipse.app4mc.amalthea.validations.ta/src/org/eclipse/app4mc/amalthea/validations/ta/basic/TA006.java
deleted file mode 100644
index 5e99ae2..0000000
--- a/plugins/org.eclipse.app4mc.amalthea.validations.ta/src/org/eclipse/app4mc/amalthea/validations/ta/basic/TA006.java
+++ /dev/null
@@ -1,45 +0,0 @@
-/**
- ********************************************************************************
- * Copyright (c) 2019 Robert Bosch GmbH and others.
- *
- * This program and the accompanying materials are made
- * available under the terms of the Eclipse Public License 2.0
- * which is available at https://www.eclipse.org/legal/epl-2.0/
- *
- * SPDX-License-Identifier: EPL-2.0
- *
- * Contributors:
- * Robert Bosch GmbH - initial API and implementation
- ********************************************************************************
- */
-
-package org.eclipse.app4mc.amalthea.validations.ta.basic;
-
-import java.util.List;
-
-import org.eclipse.app4mc.amalthea.model.Runnable;
-import org.eclipse.app4mc.amalthea.validation.core.AmaltheaValidation;
-import org.eclipse.app4mc.validation.core.ValidationDiagnostic;
-import org.eclipse.emf.ecore.EClassifier;
-import org.eclipse.emf.ecore.EObject;
-
-/**
- * All runnables shall have ...
- */
-
-public class TA006 extends AmaltheaValidation {
-
- @Override
- public EClassifier getEClassifier() {
- return ePackage.getRunnable();
- }
-
- @Override
- public void validate(final EObject object, List<ValidationDiagnostic> results) {
- Runnable runnable = (Runnable) object;
-
- // dummy
- results.add(new ValidationDiagnostic("validation executed.", runnable));
- }
-
-}
\ No newline at end of file
diff --git a/plugins/org.eclipse.app4mc.amalthea.validations.ta/src/org/eclipse/app4mc/amalthea/validations/ta/basic/TA010.java b/plugins/org.eclipse.app4mc.amalthea.validations.ta/src/org/eclipse/app4mc/amalthea/validations/ta/basic/TA010.java
deleted file mode 100644
index 0cd50a7..0000000
--- a/plugins/org.eclipse.app4mc.amalthea.validations.ta/src/org/eclipse/app4mc/amalthea/validations/ta/basic/TA010.java
+++ /dev/null
@@ -1,43 +0,0 @@
-/**
- ********************************************************************************
- * Copyright (c) 2019 Robe accompanying materials are made
- * available under the terms of the Eclipse Public License 2.0
- * which is available at https://www.eclipse.org/legal/epl-2.0/
- *
- * SPDX-License-Identifier: EPL-2.0
- *
- * Contributors:
- * Robert Bosch GmbH - initial API and implementation
- ********************************************************************************
- */
-
-package org.eclipse.app4mc.amalthea.validations.ta.basic;
-
-import java.util.List;
-
-import org.eclipse.app4mc.amalthea.model.BaseTypeDefinition;
-import org.eclipse.app4mc.amalthea.validation.core.AmaltheaValidation;
-import org.eclipse.app4mc.validation.core.ValidationDiagnostic;
-import org.eclipse.emf.ecore.EClassifier;
-import org.eclipse.emf.ecore.EObject;
-
-/**
- * Check if all type definitions ...
- */
-
-public class TA010 extends AmaltheaValidation {
-
- @Override
- public EClassifier getEClassifier() {
- return ePackage.getBaseTypeDefinition();
- }
-
- @Override
- public void validate(final EObject object, List<ValidationDiagnostic> results) {
- BaseTypeDefinition typeDef = (BaseTypeDefinition) object;
-
- // dummy
- addIssue(results, typeDef, null, "validation executed.");
- }
-
-}
diff --git a/plugins/org.eclipse.app4mc.amalthea.validations.ta/src/org/eclipse/app4mc/amalthea/validations/ta/basic/TABasicContinuousValueBetaDistribution.java b/plugins/org.eclipse.app4mc.amalthea.validations.ta/src/org/eclipse/app4mc/amalthea/validations/ta/basic/TABasicContinuousValueBetaDistribution.java
new file mode 100644
index 0000000..7b8f55a
--- /dev/null
+++ b/plugins/org.eclipse.app4mc.amalthea.validations.ta/src/org/eclipse/app4mc/amalthea/validations/ta/basic/TABasicContinuousValueBetaDistribution.java
@@ -0,0 +1,64 @@
+/**
+ ********************************************************************************
+ * Copyright (c) 2016-2019 Vector Informatik GmbH and others.
+ *
+ * This program and the accompanying materials are made
+ * available under the terms of the Eclipse Public License 2.0
+ * which is available at https://www.eclipse.org/legal/epl-2.0/
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ *
+ * Contributors:
+ * Vector Informatik GmbH - initial API and implementation
+ ********************************************************************************
+ */
+package org.eclipse.app4mc.amalthea.validations.ta.basic;
+
+import java.util.List;
+
+import org.eclipse.app4mc.amalthea.model.ContinuousValueBetaDistribution;
+import org.eclipse.app4mc.amalthea.validation.core.AmaltheaValidation;
+import org.eclipse.app4mc.validation.annotation.Validation;
+import org.eclipse.app4mc.validation.core.ValidationDiagnostic;
+import org.eclipse.emf.ecore.EClassifier;
+import org.eclipse.emf.ecore.EObject;
+
+/**
+ * Checks sanity of alpha and beta of continuous value beta distributions
+ *
+ * <ul>
+ * <li>alpha must be greater than 0.0d</li>
+ * <li>beta must be greater than 0.0d</li>
+ * </ul>
+ */
+
+@Validation(id = "TA-Basic-ContinuousValueBetaDistribution-alphabeta")
+public class TABasicContinuousValueBetaDistribution extends AmaltheaValidation {
+
+ @Override
+ public EClassifier getEClassifier() {
+ return ePackage.getContinuousValueBetaDistribution();
+ }
+
+ @Override
+ public void validate(EObject eObject, List<ValidationDiagnostic> results) {
+ if (eObject instanceof ContinuousValueBetaDistribution) {
+ ContinuousValueBetaDistribution dvbd = (ContinuousValueBetaDistribution) eObject;
+ double alpha = dvbd.getAlpha();
+ if (Double.isFinite(alpha)) {
+ if (Double.compare(0.0d, alpha) >= 0) {
+ addIssue(results, dvbd, ePackage.getContinuousValueBetaDistribution_Alpha(),
+ getEClassifier().getName() + ": alpha must be greater than 0.0d: (" + alpha + " <= 0.0d, in " + objectInfo(dvbd) + " )");
+ }
+ }
+ double beta = dvbd.getBeta();
+ if (Double.isFinite(beta)) {
+ if (Double.compare(0.0d, beta) >= 0) {
+ addIssue(results, dvbd, ePackage.getContinuousValueBetaDistribution_Beta(),
+ getEClassifier().getName() + ": beta must be greater than 0.0d: (" + beta + " <= 0.0d, in " + objectInfo(dvbd) + " )");
+ }
+ }
+ }
+ }
+
+}
diff --git a/plugins/org.eclipse.app4mc.amalthea.validations.ta/src/org/eclipse/app4mc/amalthea/validations/ta/basic/TABasicContinuousValueGaussDistribution.java b/plugins/org.eclipse.app4mc.amalthea.validations.ta/src/org/eclipse/app4mc/amalthea/validations/ta/basic/TABasicContinuousValueGaussDistribution.java
new file mode 100644
index 0000000..0cc9b63
--- /dev/null
+++ b/plugins/org.eclipse.app4mc.amalthea.validations.ta/src/org/eclipse/app4mc/amalthea/validations/ta/basic/TABasicContinuousValueGaussDistribution.java
@@ -0,0 +1,67 @@
+/**
+ ********************************************************************************
+ * Copyright (c) 2016-2019 Vector Informatik GmbH and others.
+ *
+ * This program and the accompanying materials are made
+ * available under the terms of the Eclipse Public License 2.0
+ * which is available at https://www.eclipse.org/legal/epl-2.0/
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ *
+ * Contributors:
+ * Vector Informatik GmbH - initial API and implementation
+ ********************************************************************************
+ */
+package org.eclipse.app4mc.amalthea.validations.ta.basic;
+
+import java.util.List;
+
+import org.eclipse.app4mc.amalthea.model.ContinuousValueGaussDistribution;
+import org.eclipse.app4mc.amalthea.validation.core.AmaltheaValidation;
+import org.eclipse.app4mc.validation.annotation.Validation;
+import org.eclipse.app4mc.validation.core.ValidationDiagnostic;
+import org.eclipse.emf.ecore.EClassifier;
+import org.eclipse.emf.ecore.EObject;
+
+/**
+ * Checks sanity of mean of continuous value Gauss distributions
+ *
+ * <ul>
+ * <li>mean must not be less than the lower bound</li>
+ * <li>mean must not be greater than the upper bound</li>
+ * </ul>
+ */
+
+@Validation(id = "TA-Basic-ContinuousValueGaussDistribution-mean")
+public class TABasicContinuousValueGaussDistribution extends AmaltheaValidation {
+
+ @Override
+ public EClassifier getEClassifier() {
+ return ePackage.getContinuousValueGaussDistribution();
+ }
+
+ @Override
+ public void validate(EObject eObject, List<ValidationDiagnostic> results) {
+ if (eObject instanceof ContinuousValueGaussDistribution) {
+ ContinuousValueGaussDistribution cvgd = (ContinuousValueGaussDistribution) eObject;
+ double mean = cvgd.getMean();
+ if (Double.isFinite(mean)) {
+ Double lower = cvgd.getLowerBound();
+ if (lower != null && !lower.isNaN() && !lower.isInfinite()) {
+ if (Double.compare(lower, mean) > 0) {
+ addIssue(results, cvgd, ePackage.getContinuousValueGaussDistribution_Mean(),
+ getEClassifier().getName() + ": mean is less than the lower bound: (" + mean + " < " + lower + ", in " + objectInfo(cvgd) + " )");
+ }
+ }
+ Double upper = cvgd.getUpperBound();
+ if (upper != null && !upper.isNaN() && !upper.isInfinite()) {
+ if (Double.compare(upper, mean) < 0) {
+ addIssue(results, cvgd, ePackage.getContinuousValueGaussDistribution_Mean(),
+ getEClassifier().getName() + ": mean is greater than the upper bound: (" + mean + " > " + upper + ", in " + objectInfo(cvgd) + " )");
+ }
+ }
+ }
+ }
+ }
+
+}
diff --git a/plugins/org.eclipse.app4mc.amalthea.validations.ta/src/org/eclipse/app4mc/amalthea/validations/ta/basic/TABasicContinuousValueInterval.java b/plugins/org.eclipse.app4mc.amalthea.validations.ta/src/org/eclipse/app4mc/amalthea/validations/ta/basic/TABasicContinuousValueInterval.java
new file mode 100644
index 0000000..5b8616b
--- /dev/null
+++ b/plugins/org.eclipse.app4mc.amalthea.validations.ta/src/org/eclipse/app4mc/amalthea/validations/ta/basic/TABasicContinuousValueInterval.java
@@ -0,0 +1,58 @@
+/**
+ ********************************************************************************
+ * Copyright (c) 2016-2019 Vector Informatik GmbH and others.
+ *
+ * This program and the accompanying materials are made
+ * available under the terms of the Eclipse Public License 2.0
+ * which is available at https://www.eclipse.org/legal/epl-2.0/
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ *
+ * Contributors:
+ * Vector Informatik GmbH - initial API and implementation
+ ********************************************************************************
+ */
+package org.eclipse.app4mc.amalthea.validations.ta.basic;
+
+import java.util.List;
+
+import org.eclipse.app4mc.amalthea.model.ContinuousValueInterval;
+import org.eclipse.app4mc.amalthea.validation.core.AmaltheaValidation;
+import org.eclipse.app4mc.validation.annotation.Validation;
+import org.eclipse.app4mc.validation.core.ValidationDiagnostic;
+import org.eclipse.emf.ecore.EClassifier;
+import org.eclipse.emf.ecore.EObject;
+
+/**
+ * Checks sanity of lower and upper bound of continuous value intervals
+ *
+ * <ul>
+ * <li>upper bounds must be greater than or equal to lower bounds</li>
+ * </ul>
+ */
+
+@Validation(id = "TA-Basic-ContinuousValueInterval-LowerUpper")
+public class TABasicContinuousValueInterval extends AmaltheaValidation {
+
+ @Override
+ public EClassifier getEClassifier() {
+ return ePackage.getContinuousValueInterval();
+ }
+
+ @Override
+ public void validate(EObject eObject, List<ValidationDiagnostic> results) {
+ if (eObject instanceof ContinuousValueInterval) {
+ ContinuousValueInterval cvi = (ContinuousValueInterval) eObject;
+ Double lower = cvi.getLowerBound();
+ Double upper = cvi.getUpperBound();
+ // if lower or upper are null the error will be generated by the intrinsic emf check
+ if (lower != null && !lower.isNaN() && !lower.isInfinite() && upper != null && !upper.isNaN() && !upper.isInfinite()) {
+ if (lower.compareTo(upper) > 0) {
+ addIssue(results, cvi, ePackage.getContinuousValueInterval_LowerBound(),
+ getEClassifier().getName() + ": lower bound is higher than the upper: (" + lower + " > " + upper + ", in " + objectInfo(cvi) + " )");
+ }
+ }
+ }
+ }
+
+}
diff --git a/plugins/org.eclipse.app4mc.amalthea.validations.ta/src/org/eclipse/app4mc/amalthea/validations/ta/basic/TABasicContinuousValueStatistics.java b/plugins/org.eclipse.app4mc.amalthea.validations.ta/src/org/eclipse/app4mc/amalthea/validations/ta/basic/TABasicContinuousValueStatistics.java
new file mode 100644
index 0000000..c204ad4
--- /dev/null
+++ b/plugins/org.eclipse.app4mc.amalthea.validations.ta/src/org/eclipse/app4mc/amalthea/validations/ta/basic/TABasicContinuousValueStatistics.java
@@ -0,0 +1,67 @@
+/**
+ ********************************************************************************
+ * Copyright (c) 2016-2019 Vector Informatik GmbH and others.
+ *
+ * This program and the accompanying materials are made
+ * available under the terms of the Eclipse Public License 2.0
+ * which is available at https://www.eclipse.org/legal/epl-2.0/
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ *
+ * Contributors:
+ * Vector Informatik GmbH - initial API and implementation
+ ********************************************************************************
+ */
+package org.eclipse.app4mc.amalthea.validations.ta.basic;
+
+import java.util.List;
+
+import org.eclipse.app4mc.amalthea.model.ContinuousValueStatistics;
+import org.eclipse.app4mc.amalthea.validation.core.AmaltheaValidation;
+import org.eclipse.app4mc.validation.annotation.Validation;
+import org.eclipse.app4mc.validation.core.ValidationDiagnostic;
+import org.eclipse.emf.ecore.EClassifier;
+import org.eclipse.emf.ecore.EObject;
+
+/**
+ * Checks sanity of average of continuous value statistics
+ *
+ * <ul>
+ * <li>average must not be less than the lower bound</li>
+ * <li>average must not be greater than the upper bound</li>
+ * </ul>
+ */
+
+@Validation(id = "TA-Basic-ContinuousValueStatistics-average")
+public class TABasicContinuousValueStatistics extends AmaltheaValidation {
+
+ @Override
+ public EClassifier getEClassifier() {
+ return ePackage.getContinuousValueStatistics();
+ }
+
+ @Override
+ public void validate(EObject eObject, List<ValidationDiagnostic> results) {
+ if (eObject instanceof ContinuousValueStatistics) {
+ ContinuousValueStatistics dvs = (ContinuousValueStatistics) eObject;
+ double average = dvs.getAverage();
+ if (Double.isFinite(average)) {
+ Double lower = dvs.getLowerBound();
+ if (lower != null && !lower.isNaN() && !lower.isInfinite()) {
+ if (Double.compare(lower, average) > 0) {
+ addIssue(results, dvs, ePackage.getContinuousValueStatistics_Average(),
+ getEClassifier().getName() + ": average is less than the lower bound: (" + average + " < " + lower + ", in " + objectInfo(dvs) + " )");
+ }
+ }
+ Double upper = dvs.getUpperBound();
+ if (upper != null && !upper.isNaN() && !upper.isInfinite()) {
+ if (Double.compare(upper, average) < 0) {
+ addIssue(results, dvs, ePackage.getContinuousValueStatistics_Average(),
+ getEClassifier().getName() + ": average is greater than the upper bound: (" + average + " > " + upper + ", in " + objectInfo(dvs) + " )");
+ }
+ }
+ }
+ }
+ }
+
+}
diff --git a/plugins/org.eclipse.app4mc.amalthea.validations.ta/src/org/eclipse/app4mc/amalthea/validations/ta/basic/TABasicContinuousValueWeibullEstimatorsDistribution.java b/plugins/org.eclipse.app4mc.amalthea.validations.ta/src/org/eclipse/app4mc/amalthea/validations/ta/basic/TABasicContinuousValueWeibullEstimatorsDistribution.java
new file mode 100644
index 0000000..b864341
--- /dev/null
+++ b/plugins/org.eclipse.app4mc.amalthea.validations.ta/src/org/eclipse/app4mc/amalthea/validations/ta/basic/TABasicContinuousValueWeibullEstimatorsDistribution.java
@@ -0,0 +1,67 @@
+/**
+ ********************************************************************************
+ * Copyright (c) 2016-2019 Vector Informatik GmbH and others.
+ *
+ * This program and the accompanying materials are made
+ * available under the terms of the Eclipse Public License 2.0
+ * which is available at https://www.eclipse.org/legal/epl-2.0/
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ *
+ * Contributors:
+ * Vector Informatik GmbH - initial API and implementation
+ ********************************************************************************
+ */
+package org.eclipse.app4mc.amalthea.validations.ta.basic;
+
+import java.util.List;
+
+import org.eclipse.app4mc.amalthea.model.ContinuousValueWeibullEstimatorsDistribution;
+import org.eclipse.app4mc.amalthea.validation.core.AmaltheaValidation;
+import org.eclipse.app4mc.validation.annotation.Validation;
+import org.eclipse.app4mc.validation.core.ValidationDiagnostic;
+import org.eclipse.emf.ecore.EClassifier;
+import org.eclipse.emf.ecore.EObject;
+
+/**
+ * Checks sanity of average of continuous value Weibull estimators distributions
+ *
+ * <ul>
+ * <li>average must not be less than the lower bound</li>
+ * <li>average must not be greater than the upper bound</li>
+ * </ul>
+ */
+
+@Validation(id = "TA-Basic-ContinuousValueWeibullEstimatorsDistribution-average")
+public class TABasicContinuousValueWeibullEstimatorsDistribution extends AmaltheaValidation {
+
+ @Override
+ public EClassifier getEClassifier() {
+ return ePackage.getContinuousValueWeibullEstimatorsDistribution();
+ }
+
+ @Override
+ public void validate(EObject eObject, List<ValidationDiagnostic> results) {
+ if (eObject instanceof ContinuousValueWeibullEstimatorsDistribution) {
+ ContinuousValueWeibullEstimatorsDistribution cvwed = (ContinuousValueWeibullEstimatorsDistribution) eObject;
+ double average = cvwed.getAverage();
+ if (Double.isFinite(average)) {
+ Double lower = cvwed.getLowerBound();
+ if (lower != null && !lower.isNaN() && !lower.isInfinite()) {
+ if (lower.compareTo(average) > 0) {
+ addIssue(results, cvwed, ePackage.getContinuousValueWeibullEstimatorsDistribution_Average(),
+ getEClassifier().getName() + ": average is less than the lower bound: (" + average + " < " + lower + ", in " + objectInfo(cvwed) + " )");
+ }
+ }
+ Double upper = cvwed.getUpperBound();
+ if (upper != null && !upper.isNaN() && !upper.isInfinite()) {
+ if (upper.compareTo(average) < 0) {
+ addIssue(results, cvwed, ePackage.getContinuousValueWeibullEstimatorsDistribution_Average(),
+ getEClassifier().getName() + ": average is greater than the upper bound: (" + average + " > " + upper + ", in " + objectInfo(cvwed) + " )");
+ }
+ }
+ }
+ }
+ }
+
+}
diff --git a/plugins/org.eclipse.app4mc.amalthea.validations.ta/src/org/eclipse/app4mc/amalthea/validations/ta/basic/TABasicDiscreteValueBetaDistribution.java b/plugins/org.eclipse.app4mc.amalthea.validations.ta/src/org/eclipse/app4mc/amalthea/validations/ta/basic/TABasicDiscreteValueBetaDistribution.java
new file mode 100644
index 0000000..fc007bc
--- /dev/null
+++ b/plugins/org.eclipse.app4mc.amalthea.validations.ta/src/org/eclipse/app4mc/amalthea/validations/ta/basic/TABasicDiscreteValueBetaDistribution.java
@@ -0,0 +1,64 @@
+/**
+ ********************************************************************************
+ * Copyright (c) 2016-2019 Vector Informatik GmbH and others.
+ *
+ * This program and the accompanying materials are made
+ * available under the terms of the Eclipse Public License 2.0
+ * which is available at https://www.eclipse.org/legal/epl-2.0/
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ *
+ * Contributors:
+ * Vector Informatik GmbH - initial API and implementation
+ ********************************************************************************
+ */
+package org.eclipse.app4mc.amalthea.validations.ta.basic;
+
+import java.util.List;
+
+import org.eclipse.app4mc.amalthea.model.DiscreteValueBetaDistribution;
+import org.eclipse.app4mc.amalthea.validation.core.AmaltheaValidation;
+import org.eclipse.app4mc.validation.annotation.Validation;
+import org.eclipse.app4mc.validation.core.ValidationDiagnostic;
+import org.eclipse.emf.ecore.EClassifier;
+import org.eclipse.emf.ecore.EObject;
+
+/**
+ * Checks sanity of alpha and beta of discrete value beta distributions
+ *
+ * <ul>
+ * <li>alpha must be greater than 0.0d</li>
+ * <li>beta must be greater than 0.0d</li>
+ * </ul>
+ */
+
+@Validation(id = "TA-Basic-DiscreteValueBetaDistribution-alphabeta")
+public class TABasicDiscreteValueBetaDistribution extends AmaltheaValidation {
+
+ @Override
+ public EClassifier getEClassifier() {
+ return ePackage.getDiscreteValueBetaDistribution();
+ }
+
+ @Override
+ public void validate(EObject eObject, List<ValidationDiagnostic> results) {
+ if (eObject instanceof DiscreteValueBetaDistribution) {
+ DiscreteValueBetaDistribution dvbd = (DiscreteValueBetaDistribution) eObject;
+ double alpha = dvbd.getAlpha();
+ if (Double.isFinite(alpha)) {
+ if (Double.compare(0.0d, alpha) >= 0) {
+ addIssue(results, dvbd, ePackage.getDiscreteValueBetaDistribution_Alpha(),
+ getEClassifier().getName() + ": alpha must be greater than 0.0d: (" + alpha + " <= 0.0d, in " + objectInfo(dvbd) + " )");
+ }
+ }
+ double beta = dvbd.getBeta();
+ if (Double.isFinite(beta)) {
+ if (Double.compare(0.0d, beta) >= 0) {
+ addIssue(results, dvbd, ePackage.getDiscreteValueBetaDistribution_Beta(),
+ getEClassifier().getName() + ": beta must be greater than 0.0d: (" + beta + " <= 0.0d, in " + objectInfo(dvbd) + " )");
+ }
+ }
+ }
+ }
+
+}
diff --git a/plugins/org.eclipse.app4mc.amalthea.validations.ta/src/org/eclipse/app4mc/amalthea/validations/ta/basic/TABasicDiscreteValueGaussDistribution.java b/plugins/org.eclipse.app4mc.amalthea.validations.ta/src/org/eclipse/app4mc/amalthea/validations/ta/basic/TABasicDiscreteValueGaussDistribution.java
new file mode 100644
index 0000000..2346bb8
--- /dev/null
+++ b/plugins/org.eclipse.app4mc.amalthea.validations.ta/src/org/eclipse/app4mc/amalthea/validations/ta/basic/TABasicDiscreteValueGaussDistribution.java
@@ -0,0 +1,67 @@
+/**
+ ********************************************************************************
+ * Copyright (c) 2016-2019 Vector Informatik GmbH and others.
+ *
+ * This program and the accompanying materials are made
+ * available under the terms of the Eclipse Public License 2.0
+ * which is available at https://www.eclipse.org/legal/epl-2.0/
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ *
+ * Contributors:
+ * Vector Informatik GmbH - initial API and implementation
+ ********************************************************************************
+ */
+package org.eclipse.app4mc.amalthea.validations.ta.basic;
+
+import java.util.List;
+
+import org.eclipse.app4mc.amalthea.model.DiscreteValueGaussDistribution;
+import org.eclipse.app4mc.amalthea.validation.core.AmaltheaValidation;
+import org.eclipse.app4mc.validation.annotation.Validation;
+import org.eclipse.app4mc.validation.core.ValidationDiagnostic;
+import org.eclipse.emf.ecore.EClassifier;
+import org.eclipse.emf.ecore.EObject;
+
+/**
+ * Checks sanity of mean of discrete value Gauss distributions
+ *
+ * <ul>
+ * <li>mean must not be less than the lower bound</li>
+ * <li>mean must not be greater than the upper bound</li>
+ * </ul>
+ */
+
+@Validation(id = "TA-Basic-DiscreteValueGaussDistribution-mean")
+public class TABasicDiscreteValueGaussDistribution extends AmaltheaValidation {
+
+ @Override
+ public EClassifier getEClassifier() {
+ return ePackage.getDiscreteValueGaussDistribution();
+ }
+
+ @Override
+ public void validate(EObject eObject, List<ValidationDiagnostic> results) {
+ if (eObject instanceof DiscreteValueGaussDistribution) {
+ DiscreteValueGaussDistribution dvgd = (DiscreteValueGaussDistribution) eObject;
+ double mean = dvgd.getMean();
+ if (Double.isFinite(mean)) {
+ Long lower = dvgd.getLowerBound();
+ if (lower != null) {
+ if (Double.compare(lower, mean) > 0) {
+ addIssue(results, dvgd, ePackage.getDiscreteValueGaussDistribution_Mean(),
+ getEClassifier().getName() + ": mean is less than the lower bound: (" + mean + " < " + lower + ", in " + objectInfo(dvgd) + " )");
+ }
+ }
+ Long upper = dvgd.getUpperBound();
+ if (upper != null) {
+ if (Double.compare(upper, mean) < 0) {
+ addIssue(results, dvgd, ePackage.getDiscreteValueGaussDistribution_Mean(),
+ getEClassifier().getName() + ": mean is greater than the upper bound: (" + mean + " > " + upper + ", in " + objectInfo(dvgd) + " )");
+ }
+ }
+ }
+ }
+ }
+
+}
diff --git a/plugins/org.eclipse.app4mc.amalthea.validations.ta/src/org/eclipse/app4mc/amalthea/validations/ta/basic/TABasicDiscreteValueInterval.java b/plugins/org.eclipse.app4mc.amalthea.validations.ta/src/org/eclipse/app4mc/amalthea/validations/ta/basic/TABasicDiscreteValueInterval.java
new file mode 100644
index 0000000..4d50f3b
--- /dev/null
+++ b/plugins/org.eclipse.app4mc.amalthea.validations.ta/src/org/eclipse/app4mc/amalthea/validations/ta/basic/TABasicDiscreteValueInterval.java
@@ -0,0 +1,58 @@
+/**
+ ********************************************************************************
+ * Copyright (c) 2016-2019 Vector Informatik GmbH and others.
+ *
+ * This program and the accompanying materials are made
+ * available under the terms of the Eclipse Public License 2.0
+ * which is available at https://www.eclipse.org/legal/epl-2.0/
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ *
+ * Contributors:
+ * Vector Informatik GmbH - initial API and implementation
+ ********************************************************************************
+ */
+package org.eclipse.app4mc.amalthea.validations.ta.basic;
+
+import java.util.List;
+
+import org.eclipse.app4mc.amalthea.model.DiscreteValueInterval;
+import org.eclipse.app4mc.amalthea.validation.core.AmaltheaValidation;
+import org.eclipse.app4mc.validation.annotation.Validation;
+import org.eclipse.app4mc.validation.core.ValidationDiagnostic;
+import org.eclipse.emf.ecore.EClassifier;
+import org.eclipse.emf.ecore.EObject;
+
+/**
+ * Checks sanity of lower and upper bound of discrete value intervals
+ *
+ * <ul>
+ * <li>upper bounds must be greater than or equal to lower bounds</li>
+ * </ul>
+ */
+
+@Validation(id = "TA-Basic-DiscreteValueInterval-LowerUpper")
+public class TABasicDiscreteValueInterval extends AmaltheaValidation {
+
+ @Override
+ public EClassifier getEClassifier() {
+ return ePackage.getDiscreteValueInterval();
+ }
+
+ @Override
+ public void validate(EObject eObject, List<ValidationDiagnostic> results) {
+ if (eObject instanceof DiscreteValueInterval) {
+ DiscreteValueInterval dvi = (DiscreteValueInterval) eObject;
+ Long lower = dvi.getLowerBound();
+ Long upper = dvi.getUpperBound();
+ // if lower or upper are null the error will be generated by the intrinsic emf check
+ if (lower != null && upper != null) {
+ if (lower > upper) {
+ addIssue(results, dvi, ePackage.getDiscreteValueInterval_LowerBound(),
+ getEClassifier().getName() + ": lower bound is higher than the upper: (" + lower + " > " + upper + ", in " + objectInfo(dvi) + " )");
+ }
+ }
+ }
+ }
+
+}
diff --git a/plugins/org.eclipse.app4mc.amalthea.validations.ta/src/org/eclipse/app4mc/amalthea/validations/ta/basic/TABasicDiscreteValueStatistics.java b/plugins/org.eclipse.app4mc.amalthea.validations.ta/src/org/eclipse/app4mc/amalthea/validations/ta/basic/TABasicDiscreteValueStatistics.java
new file mode 100644
index 0000000..0bf4a9f
--- /dev/null
+++ b/plugins/org.eclipse.app4mc.amalthea.validations.ta/src/org/eclipse/app4mc/amalthea/validations/ta/basic/TABasicDiscreteValueStatistics.java
@@ -0,0 +1,67 @@
+/**
+ ********************************************************************************
+ * Copyright (c) 2016-2019 Vector Informatik GmbH and others.
+ *
+ * This program and the accompanying materials are made
+ * available under the terms of the Eclipse Public License 2.0
+ * which is available at https://www.eclipse.org/legal/epl-2.0/
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ *
+ * Contributors:
+ * Vector Informatik GmbH - initial API and implementation
+ ********************************************************************************
+ */
+package org.eclipse.app4mc.amalthea.validations.ta.basic;
+
+import java.util.List;
+
+import org.eclipse.app4mc.amalthea.model.DiscreteValueStatistics;
+import org.eclipse.app4mc.amalthea.validation.core.AmaltheaValidation;
+import org.eclipse.app4mc.validation.annotation.Validation;
+import org.eclipse.app4mc.validation.core.ValidationDiagnostic;
+import org.eclipse.emf.ecore.EClassifier;
+import org.eclipse.emf.ecore.EObject;
+
+/**
+ * Checks sanity of average of discrete value statistics
+ *
+ * <ul>
+ * <li>average must not be less than the lower bound</li>
+ * <li>average must not be greater than the upper bound</li>
+ * </ul>
+ */
+
+@Validation(id = "TA-Basic-DiscreteValueStatistics-average")
+public class TABasicDiscreteValueStatistics extends AmaltheaValidation {
+
+ @Override
+ public EClassifier getEClassifier() {
+ return ePackage.getDiscreteValueStatistics();
+ }
+
+ @Override
+ public void validate(EObject eObject, List<ValidationDiagnostic> results) {
+ if (eObject instanceof DiscreteValueStatistics) {
+ DiscreteValueStatistics dvs = (DiscreteValueStatistics) eObject;
+ double average = dvs.getAverage();
+ if (Double.isFinite(average)) {
+ Long lower = dvs.getLowerBound();
+ if (lower != null) {
+ if (Double.compare(lower, average) > 0) {
+ addIssue(results, dvs, ePackage.getDiscreteValueStatistics_Average(),
+ getEClassifier().getName() + ": average is less than the lower bound: (" + average + " < " + lower + ", in " + objectInfo(dvs) + " )");
+ }
+ }
+ Long upper = dvs.getUpperBound();
+ if (upper != null) {
+ if (Double.compare(upper, average) < 0) {
+ addIssue(results, dvs, ePackage.getDiscreteValueStatistics_Average(),
+ getEClassifier().getName() + ": average is greater than the upper bound: (" + average + " > " + upper + ", in " + objectInfo(dvs) + " )");
+ }
+ }
+ }
+ }
+ }
+
+}
diff --git a/plugins/org.eclipse.app4mc.amalthea.validations.ta/src/org/eclipse/app4mc/amalthea/validations/ta/basic/TABasicDiscreteValueWeibullEstimatorsDistribution.java b/plugins/org.eclipse.app4mc.amalthea.validations.ta/src/org/eclipse/app4mc/amalthea/validations/ta/basic/TABasicDiscreteValueWeibullEstimatorsDistribution.java
new file mode 100644
index 0000000..fd7a4da
--- /dev/null
+++ b/plugins/org.eclipse.app4mc.amalthea.validations.ta/src/org/eclipse/app4mc/amalthea/validations/ta/basic/TABasicDiscreteValueWeibullEstimatorsDistribution.java
@@ -0,0 +1,67 @@
+/**
+ ********************************************************************************
+ * Copyright (c) 2016-2019 Vector Informatik GmbH and others.
+ *
+ * This program and the accompanying materials are made
+ * available under the terms of the Eclipse Public License 2.0
+ * which is available at https://www.eclipse.org/legal/epl-2.0/
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ *
+ * Contributors:
+ * Vector Informatik GmbH - initial API and implementation
+ ********************************************************************************
+ */
+package org.eclipse.app4mc.amalthea.validations.ta.basic;
+
+import java.util.List;
+
+import org.eclipse.app4mc.amalthea.model.DiscreteValueWeibullEstimatorsDistribution;
+import org.eclipse.app4mc.amalthea.validation.core.AmaltheaValidation;
+import org.eclipse.app4mc.validation.annotation.Validation;
+import org.eclipse.app4mc.validation.core.ValidationDiagnostic;
+import org.eclipse.emf.ecore.EClassifier;
+import org.eclipse.emf.ecore.EObject;
+
+/**
+ * Checks sanity of average of discrete value Weibull estimators distributions
+ *
+ * <ul>
+ * <li>average must not be less than the lower bound</li>
+ * <li>average must not be greater than the upper bound</li>
+ * </ul>
+ */
+
+@Validation(id = "TA-Basic-DiscreteValueWeibullEstimatorsDistribution-average")
+public class TABasicDiscreteValueWeibullEstimatorsDistribution extends AmaltheaValidation {
+
+ @Override
+ public EClassifier getEClassifier() {
+ return ePackage.getDiscreteValueWeibullEstimatorsDistribution();
+ }
+
+ @Override
+ public void validate(EObject eObject, List<ValidationDiagnostic> results) {
+ if (eObject instanceof DiscreteValueWeibullEstimatorsDistribution) {
+ DiscreteValueWeibullEstimatorsDistribution dvwed = (DiscreteValueWeibullEstimatorsDistribution) eObject;
+ double average = dvwed.getAverage();
+ if (Double.isFinite(average)) {
+ Long lower = dvwed.getLowerBound();
+ if (lower != null) {
+ if (Double.compare(lower, average) > 0) {
+ addIssue(results, dvwed, ePackage.getDiscreteValueWeibullEstimatorsDistribution_Average(),
+ getEClassifier().getName() + ": average is less than the lower bound: (" + average + " < " + lower + ", in " + objectInfo(dvwed) + " )");
+ }
+ }
+ Long upper = dvwed.getUpperBound();
+ if (upper != null) {
+ if (Double.compare(upper, average) < 0) {
+ addIssue(results, dvwed, ePackage.getDiscreteValueWeibullEstimatorsDistribution_Average(),
+ getEClassifier().getName() + ": average is greater than the upper bound: (" + average + " > " + upper + ", in " + objectInfo(dvwed) + " )");
+ }
+ }
+ }
+ }
+ }
+
+}
diff --git a/plugins/org.eclipse.app4mc.amalthea.validations.ta/src/org/eclipse/app4mc/amalthea/validations/ta/basic/TABasicTimeBetaDistribution.java b/plugins/org.eclipse.app4mc.amalthea.validations.ta/src/org/eclipse/app4mc/amalthea/validations/ta/basic/TABasicTimeBetaDistribution.java
new file mode 100644
index 0000000..34be32f
--- /dev/null
+++ b/plugins/org.eclipse.app4mc.amalthea.validations.ta/src/org/eclipse/app4mc/amalthea/validations/ta/basic/TABasicTimeBetaDistribution.java
@@ -0,0 +1,64 @@
+/**
+ ********************************************************************************
+ * Copyright (c) 2016-2019 Vector Informatik GmbH and others.
+ *
+ * This program and the accompanying materials are made
+ * available under the terms of the Eclipse Public License 2.0
+ * which is available at https://www.eclipse.org/legal/epl-2.0/
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ *
+ * Contributors:
+ * Vector Informatik GmbH - initial API and implementation
+ ********************************************************************************
+ */
+package org.eclipse.app4mc.amalthea.validations.ta.basic;
+
+import java.util.List;
+
+import org.eclipse.app4mc.amalthea.model.TimeBetaDistribution;
+import org.eclipse.app4mc.amalthea.validation.core.AmaltheaValidation;
+import org.eclipse.app4mc.validation.annotation.Validation;
+import org.eclipse.app4mc.validation.core.ValidationDiagnostic;
+import org.eclipse.emf.ecore.EClassifier;
+import org.eclipse.emf.ecore.EObject;
+
+/**
+ * Checks sanity of alpha and beta of time beta distributions
+ *
+ * <ul>
+ * <li>alpha must be greater than 0.0d</li>
+ * <li>beta must be greater than 0.0d</li>
+ * </ul>
+ */
+
+@Validation(id = "TA-Basic-TimeBetaDistribution-alphabeta")
+public class TABasicTimeBetaDistribution extends AmaltheaValidation {
+
+ @Override
+ public EClassifier getEClassifier() {
+ return ePackage.getTimeBetaDistribution();
+ }
+
+ @Override
+ public void validate(EObject eObject, List<ValidationDiagnostic> results) {
+ if (eObject instanceof TimeBetaDistribution) {
+ TimeBetaDistribution dvbd = (TimeBetaDistribution) eObject;
+ double alpha = dvbd.getAlpha();
+ if (Double.isFinite(alpha)) {
+ if (Double.compare(0.0d, alpha) >= 0) {
+ addIssue(results, dvbd, ePackage.getTimeBetaDistribution_Alpha(),
+ getEClassifier().getName() + ": alpha must be greater than 0.0d: (" + alpha + " <= 0.0d, in " + objectInfo(dvbd) + " )");
+ }
+ }
+ double beta = dvbd.getBeta();
+ if (Double.isFinite(beta)) {
+ if (Double.compare(0.0d, beta) >= 0) {
+ addIssue(results, dvbd, ePackage.getTimeBetaDistribution_Beta(),
+ getEClassifier().getName() + ": beta must be greater than 0.0d: (" + beta + " <= 0.0d, in " + objectInfo(dvbd) + " )");
+ }
+ }
+ }
+ }
+
+}
diff --git a/plugins/org.eclipse.app4mc.amalthea.validations.ta/src/org/eclipse/app4mc/amalthea/validations/ta/basic/TABasicTimeGaussDistribution.java b/plugins/org.eclipse.app4mc.amalthea.validations.ta/src/org/eclipse/app4mc/amalthea/validations/ta/basic/TABasicTimeGaussDistribution.java
new file mode 100644
index 0000000..d7afd62
--- /dev/null
+++ b/plugins/org.eclipse.app4mc.amalthea.validations.ta/src/org/eclipse/app4mc/amalthea/validations/ta/basic/TABasicTimeGaussDistribution.java
@@ -0,0 +1,68 @@
+/**
+ ********************************************************************************
+ * Copyright (c) 2016-2019 Vector Informatik GmbH and others.
+ *
+ * This program and the accompanying materials are made
+ * available under the terms of the Eclipse Public License 2.0
+ * which is available at https://www.eclipse.org/legal/epl-2.0/
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ *
+ * Contributors:
+ * Vector Informatik GmbH - initial API and implementation
+ ********************************************************************************
+ */
+package org.eclipse.app4mc.amalthea.validations.ta.basic;
+
+import java.util.List;
+
+import org.eclipse.app4mc.amalthea.model.Time;
+import org.eclipse.app4mc.amalthea.model.TimeGaussDistribution;
+import org.eclipse.app4mc.amalthea.validation.core.AmaltheaValidation;
+import org.eclipse.app4mc.validation.annotation.Validation;
+import org.eclipse.app4mc.validation.core.ValidationDiagnostic;
+import org.eclipse.emf.ecore.EClassifier;
+import org.eclipse.emf.ecore.EObject;
+
+/**
+ * Checks sanity of mean of time Gauss distributions
+ *
+ * <ul>
+ * <li>mean must not be less than the lower bound</li>
+ * <li>mean must not be greater than the upper bound</li>
+ * </ul>
+ */
+
+@Validation(id = "TA-Basic-TimeGaussDistribution-mean")
+public class TABasicTimeGaussDistribution extends AmaltheaValidation {
+
+ @Override
+ public EClassifier getEClassifier() {
+ return ePackage.getTimeGaussDistribution();
+ }
+
+ @Override
+ public void validate(EObject eObject, List<ValidationDiagnostic> results) {
+ if (eObject instanceof TimeGaussDistribution) {
+ TimeGaussDistribution tgd = (TimeGaussDistribution) eObject;
+ Time mean = tgd.getMean();
+ if (mean != null) {
+ Time lower = tgd.getLowerBound();
+ if (lower != null) {
+ if (lower.compareTo(mean) > 0) {
+ addIssue(results, tgd, ePackage.getTimeGaussDistribution_Mean(),
+ getEClassifier().getName() + ": mean is less than the lower bound: (" + mean + " < " + lower + ", in " + objectInfo(tgd) + " )");
+ }
+ }
+ Time upper = tgd.getUpperBound();
+ if (upper != null) {
+ if (upper.compareTo(mean) < 0) {
+ addIssue(results, tgd, ePackage.getTimeGaussDistribution_Mean(),
+ getEClassifier().getName() + ": mean is greater than the upper bound: (" + mean + " > " + upper + ", in " + objectInfo(tgd) + " )");
+ }
+ }
+ }
+ }
+ }
+
+}
diff --git a/plugins/org.eclipse.app4mc.amalthea.validations.ta/src/org/eclipse/app4mc/amalthea/validations/ta/basic/TABasicTimeInterval.java b/plugins/org.eclipse.app4mc.amalthea.validations.ta/src/org/eclipse/app4mc/amalthea/validations/ta/basic/TABasicTimeInterval.java
new file mode 100644
index 0000000..cbee9ff
--- /dev/null
+++ b/plugins/org.eclipse.app4mc.amalthea.validations.ta/src/org/eclipse/app4mc/amalthea/validations/ta/basic/TABasicTimeInterval.java
@@ -0,0 +1,59 @@
+/**
+ ********************************************************************************
+ * Copyright (c) 2016-2019 Vector Informatik GmbH and others.
+ *
+ * This program and the accompanying materials are made
+ * available under the terms of the Eclipse Public License 2.0
+ * which is available at https://www.eclipse.org/legal/epl-2.0/
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ *
+ * Contributors:
+ * Vector Informatik GmbH - initial API and implementation
+ ********************************************************************************
+ */
+package org.eclipse.app4mc.amalthea.validations.ta.basic;
+
+import java.util.List;
+
+import org.eclipse.app4mc.amalthea.model.Time;
+import org.eclipse.app4mc.amalthea.model.TimeInterval;
+import org.eclipse.app4mc.amalthea.validation.core.AmaltheaValidation;
+import org.eclipse.app4mc.validation.annotation.Validation;
+import org.eclipse.app4mc.validation.core.ValidationDiagnostic;
+import org.eclipse.emf.ecore.EClassifier;
+import org.eclipse.emf.ecore.EObject;
+
+/**
+ * Checks sanity of lower and upper bound of time intervals
+ *
+ * <ul>
+ * <li>upper bounds must be greater than or equal to lower bounds</li>
+ * </ul>
+ */
+
+@Validation(id = "TA-Basic-TimeInterval-LowerUpper")
+public class TABasicTimeInterval extends AmaltheaValidation {
+
+ @Override
+ public EClassifier getEClassifier() {
+ return ePackage.getTimeInterval();
+ }
+
+ @Override
+ public void validate(EObject eObject, List<ValidationDiagnostic> results) {
+ if (eObject instanceof TimeInterval) {
+ TimeInterval ti = (TimeInterval) eObject;
+ Time lower = ti.getLowerBound();
+ Time upper = ti.getUpperBound();
+ // if lower or upper are null the error will be generated by the intrinsic emf check
+ if (lower != null && upper != null) {
+ if (lower.compareTo(upper) > 0) {
+ addIssue(results, ti, ePackage.getTimeInterval_LowerBound(),
+ getEClassifier().getName() + ": lower bound is higher than the upper: (" + lower + " > " + upper + ", in " + objectInfo(ti) + " )");
+ }
+ }
+ }
+ }
+
+}
diff --git a/plugins/org.eclipse.app4mc.amalthea.validations.ta/src/org/eclipse/app4mc/amalthea/validations/ta/basic/TABasicTimeStatistics.java b/plugins/org.eclipse.app4mc.amalthea.validations.ta/src/org/eclipse/app4mc/amalthea/validations/ta/basic/TABasicTimeStatistics.java
new file mode 100644
index 0000000..ea09542
--- /dev/null
+++ b/plugins/org.eclipse.app4mc.amalthea.validations.ta/src/org/eclipse/app4mc/amalthea/validations/ta/basic/TABasicTimeStatistics.java
@@ -0,0 +1,68 @@
+/**
+ ********************************************************************************
+ * Copyright (c) 2016-2019 Vector Informatik GmbH and others.
+ *
+ * This program and the accompanying materials are made
+ * available under the terms of the Eclipse Public License 2.0
+ * which is available at https://www.eclipse.org/legal/epl-2.0/
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ *
+ * Contributors:
+ * Vector Informatik GmbH - initial API and implementation
+ ********************************************************************************
+ */
+package org.eclipse.app4mc.amalthea.validations.ta.basic;
+
+import java.util.List;
+
+import org.eclipse.app4mc.amalthea.model.Time;
+import org.eclipse.app4mc.amalthea.model.TimeStatistics;
+import org.eclipse.app4mc.amalthea.validation.core.AmaltheaValidation;
+import org.eclipse.app4mc.validation.annotation.Validation;
+import org.eclipse.app4mc.validation.core.ValidationDiagnostic;
+import org.eclipse.emf.ecore.EClassifier;
+import org.eclipse.emf.ecore.EObject;
+
+/**
+ * Checks sanity of average of time statistics
+ *
+ * <ul>
+ * <li>average must not be less than the lower bound</li>
+ * <li>average must not be greater than the upper bound</li>
+ * </ul>
+ */
+
+@Validation(id = "TA-Basic-TimeStatistics-average")
+public class TABasicTimeStatistics extends AmaltheaValidation {
+
+ @Override
+ public EClassifier getEClassifier() {
+ return ePackage.getTimeStatistics();
+ }
+
+ @Override
+ public void validate(EObject eObject, List<ValidationDiagnostic> results) {
+ if (eObject instanceof TimeStatistics) {
+ TimeStatistics dvs = (TimeStatistics) eObject;
+ Time average = dvs.getAverage();
+ if (average != null) {
+ Time lower = dvs.getLowerBound();
+ if (lower != null) {
+ if (lower.compareTo(average) > 0) {
+ addIssue(results, dvs, ePackage.getTimeStatistics_Average(),
+ getEClassifier().getName() + ": average is less than the lower bound: (" + average + " < " + lower + ", in " + objectInfo(dvs) + " )");
+ }
+ }
+ Time upper = dvs.getUpperBound();
+ if (upper != null) {
+ if (upper.compareTo(average) < 0) {
+ addIssue(results, dvs, ePackage.getTimeStatistics_Average(),
+ getEClassifier().getName() + ": average is greater than the upper bound: (" + average + " > " + upper + ", in " + objectInfo(dvs) + " )");
+ }
+ }
+ }
+ }
+ }
+
+}
diff --git a/plugins/org.eclipse.app4mc.amalthea.validations.ta/src/org/eclipse/app4mc/amalthea/validations/ta/basic/TABasicTimeWeibullEstimatorsDistribution.java b/plugins/org.eclipse.app4mc.amalthea.validations.ta/src/org/eclipse/app4mc/amalthea/validations/ta/basic/TABasicTimeWeibullEstimatorsDistribution.java
new file mode 100644
index 0000000..c57bdcb
--- /dev/null
+++ b/plugins/org.eclipse.app4mc.amalthea.validations.ta/src/org/eclipse/app4mc/amalthea/validations/ta/basic/TABasicTimeWeibullEstimatorsDistribution.java
@@ -0,0 +1,68 @@
+/**
+ ********************************************************************************
+ * Copyright (c) 2016-2019 Vector Informatik GmbH and others.
+ *
+ * This program and the accompanying materials are made
+ * available under the terms of the Eclipse Public License 2.0
+ * which is available at https://www.eclipse.org/legal/epl-2.0/
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ *
+ * Contributors:
+ * Vector Informatik GmbH - initial API and implementation
+ ********************************************************************************
+ */
+package org.eclipse.app4mc.amalthea.validations.ta.basic;
+
+import java.util.List;
+
+import org.eclipse.app4mc.amalthea.model.Time;
+import org.eclipse.app4mc.amalthea.model.TimeWeibullEstimatorsDistribution;
+import org.eclipse.app4mc.amalthea.validation.core.AmaltheaValidation;
+import org.eclipse.app4mc.validation.annotation.Validation;
+import org.eclipse.app4mc.validation.core.ValidationDiagnostic;
+import org.eclipse.emf.ecore.EClassifier;
+import org.eclipse.emf.ecore.EObject;
+
+/**
+ * Checks sanity of average of time Weibull estimators distributions
+ *
+ * <ul>
+ * <li>average must not be less than the lower bound</li>
+ * <li>average must not be greater than the upper bound</li>
+ * </ul>
+ */
+
+@Validation(id = "TA-Basic-TimeWeibullEstimatorsDistribution-average")
+public class TABasicTimeWeibullEstimatorsDistribution extends AmaltheaValidation {
+
+ @Override
+ public EClassifier getEClassifier() {
+ return ePackage.getTimeWeibullEstimatorsDistribution();
+ }
+
+ @Override
+ public void validate(EObject eObject, List<ValidationDiagnostic> results) {
+ if (eObject instanceof TimeWeibullEstimatorsDistribution) {
+ TimeWeibullEstimatorsDistribution twed = (TimeWeibullEstimatorsDistribution) eObject;
+ Time average = twed.getAverage();
+ if (average != null) {
+ Time lower = twed.getLowerBound();
+ if (lower != null) {
+ if (lower.compareTo(average) > 0) {
+ addIssue(results, twed, ePackage.getTimeWeibullEstimatorsDistribution_Average(),
+ getEClassifier().getName() + ": average is less than the lower bound: (" + average + " < " + lower + ", in " + objectInfo(twed) + " )");
+ }
+ }
+ Time upper = twed.getUpperBound();
+ if (upper != null) {
+ if (upper.compareTo(average) < 0) {
+ addIssue(results, twed, ePackage.getTimeWeibullEstimatorsDistribution_Average(),
+ getEClassifier().getName() + ": average is greater than the upper bound: (" + average + " > " + upper + ", in " + objectInfo(twed) + " )");
+ }
+ }
+ }
+ }
+ }
+
+}
diff --git a/plugins/org.eclipse.app4mc.amalthea.validations.ta/src/org/eclipse/app4mc/amalthea/validations/ta/basic/TABasicTruncatedContinuousValueDistribution.java b/plugins/org.eclipse.app4mc.amalthea.validations.ta/src/org/eclipse/app4mc/amalthea/validations/ta/basic/TABasicTruncatedContinuousValueDistribution.java
new file mode 100644
index 0000000..c198b55
--- /dev/null
+++ b/plugins/org.eclipse.app4mc.amalthea.validations.ta/src/org/eclipse/app4mc/amalthea/validations/ta/basic/TABasicTruncatedContinuousValueDistribution.java
@@ -0,0 +1,57 @@
+/**
+ ********************************************************************************
+ * Copyright (c) 2016-2019 Vector Informatik GmbH and others.
+ *
+ * This program and the accompanying materials are made
+ * available under the terms of the Eclipse Public License 2.0
+ * which is available at https://www.eclipse.org/legal/epl-2.0/
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ *
+ * Contributors:
+ * Vector Informatik GmbH - initial API and implementation
+ ********************************************************************************
+ */
+package org.eclipse.app4mc.amalthea.validations.ta.basic;
+
+import java.util.List;
+
+import org.eclipse.app4mc.amalthea.model.TruncatedContinuousValueDistribution;
+import org.eclipse.app4mc.amalthea.validation.core.AmaltheaValidation;
+import org.eclipse.app4mc.validation.annotation.Validation;
+import org.eclipse.app4mc.validation.core.ValidationDiagnostic;
+import org.eclipse.emf.ecore.EClassifier;
+import org.eclipse.emf.ecore.EObject;
+
+/**
+ * Checks sanity of lower and upper bound of truncated continuous value distributions
+ *
+ * <ul>
+ * <li>upper bounds must be greater than or equal to lower bounds</li>
+ * </ul>
+ */
+
+@Validation(id = "TA-Basic-TruncatedContinuousValueDistribution-LowerUpper")
+public class TABasicTruncatedContinuousValueDistribution extends AmaltheaValidation {
+
+ @Override
+ public EClassifier getEClassifier() {
+ return ePackage.getTruncatedContinuousValueDistribution();
+ }
+
+ @Override
+ public void validate(EObject eObject, List<ValidationDiagnostic> results) {
+ if (eObject instanceof TruncatedContinuousValueDistribution) {
+ TruncatedContinuousValueDistribution tcvd = (TruncatedContinuousValueDistribution) eObject;
+ Double lower = tcvd.getLowerBound();
+ Double upper = tcvd.getUpperBound();
+ if (lower != null && !lower.isNaN() && !lower.isInfinite() && upper != null && !upper.isNaN() && !upper.isInfinite()) {
+ if (lower.compareTo(upper) > 0) {
+ addIssue(results, tcvd, ePackage.getTruncatedContinuousValueDistribution_LowerBound(),
+ getEClassifier().getName() + ": lower bound is higher than the upper: (" + lower + " > " + upper + ", in " + objectInfo(tcvd) + " )");
+ }
+ }
+ }
+ }
+
+}
diff --git a/plugins/org.eclipse.app4mc.amalthea.validations.ta/src/org/eclipse/app4mc/amalthea/validations/ta/basic/TABasicTruncatedDiscreteValueDistribution.java b/plugins/org.eclipse.app4mc.amalthea.validations.ta/src/org/eclipse/app4mc/amalthea/validations/ta/basic/TABasicTruncatedDiscreteValueDistribution.java
new file mode 100644
index 0000000..7f846ca
--- /dev/null
+++ b/plugins/org.eclipse.app4mc.amalthea.validations.ta/src/org/eclipse/app4mc/amalthea/validations/ta/basic/TABasicTruncatedDiscreteValueDistribution.java
@@ -0,0 +1,57 @@
+/**
+ ********************************************************************************
+ * Copyright (c) 2016-2019 Vector Informatik GmbH and others.
+ *
+ * This program and the accompanying materials are made
+ * available under the terms of the Eclipse Public License 2.0
+ * which is available at https://www.eclipse.org/legal/epl-2.0/
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ *
+ * Contributors:
+ * Vector Informatik GmbH - initial API and implementation
+ ********************************************************************************
+ */
+package org.eclipse.app4mc.amalthea.validations.ta.basic;
+
+import java.util.List;
+
+import org.eclipse.app4mc.amalthea.model.TruncatedDiscreteValueDistribution;
+import org.eclipse.app4mc.amalthea.validation.core.AmaltheaValidation;
+import org.eclipse.app4mc.validation.annotation.Validation;
+import org.eclipse.app4mc.validation.core.ValidationDiagnostic;
+import org.eclipse.emf.ecore.EClassifier;
+import org.eclipse.emf.ecore.EObject;
+
+/**
+ * Checks sanity of lower and upper bound of truncated discrete value distributions
+ *
+ * <ul>
+ * <li>upper bounds must be greater than or equal to lower bounds</li>
+ * </ul>
+ */
+
+@Validation(id = "TA-Basic-TruncatedDiscreteValueDistribution-LowerUpper")
+public class TABasicTruncatedDiscreteValueDistribution extends AmaltheaValidation {
+
+ @Override
+ public EClassifier getEClassifier() {
+ return ePackage.getTruncatedDiscreteValueDistribution();
+ }
+
+ @Override
+ public void validate(EObject eObject, List<ValidationDiagnostic> results) {
+ if (eObject instanceof TruncatedDiscreteValueDistribution) {
+ TruncatedDiscreteValueDistribution tdvd = (TruncatedDiscreteValueDistribution) eObject;
+ Long lower = tdvd.getLowerBound();
+ Long upper = tdvd.getUpperBound();
+ if (lower != null && upper != null) {
+ if (lower > upper) {
+ addIssue(results, tdvd, ePackage.getTruncatedDiscreteValueDistribution_LowerBound(),
+ getEClassifier().getName() + ": lower bound is higher than the upper: (" + lower + " > " + upper + ", in " + objectInfo(tdvd) + " )");
+ }
+ }
+ }
+ }
+
+}
diff --git a/plugins/org.eclipse.app4mc.amalthea.validations.ta/src/org/eclipse/app4mc/amalthea/validations/ta/basic/TABasicTruncatedTimeDistribution.java b/plugins/org.eclipse.app4mc.amalthea.validations.ta/src/org/eclipse/app4mc/amalthea/validations/ta/basic/TABasicTruncatedTimeDistribution.java
new file mode 100644
index 0000000..71e918c
--- /dev/null
+++ b/plugins/org.eclipse.app4mc.amalthea.validations.ta/src/org/eclipse/app4mc/amalthea/validations/ta/basic/TABasicTruncatedTimeDistribution.java
@@ -0,0 +1,58 @@
+/**
+ ********************************************************************************
+ * Copyright (c) 2016-2019 Vector Informatik GmbH and others.
+ *
+ * This program and the accompanying materials are made
+ * available under the terms of the Eclipse Public License 2.0
+ * which is available at https://www.eclipse.org/legal/epl-2.0/
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ *
+ * Contributors:
+ * Vector Informatik GmbH - initial API and implementation
+ ********************************************************************************
+ */
+package org.eclipse.app4mc.amalthea.validations.ta.basic;
+
+import java.util.List;
+
+import org.eclipse.app4mc.amalthea.model.Time;
+import org.eclipse.app4mc.amalthea.model.TruncatedTimeDistribution;
+import org.eclipse.app4mc.amalthea.validation.core.AmaltheaValidation;
+import org.eclipse.app4mc.validation.annotation.Validation;
+import org.eclipse.app4mc.validation.core.ValidationDiagnostic;
+import org.eclipse.emf.ecore.EClassifier;
+import org.eclipse.emf.ecore.EObject;
+
+/**
+ * Checks sanity of lower and upper bound of truncated time distributions
+ *
+ * <ul>
+ * <li>upper bounds must be greater than or equal to lower bounds</li>
+ * </ul>
+ */
+
+@Validation(id = "TA-Basic-TruncatedTimeDistribution-LowerUpper")
+public class TABasicTruncatedTimeDistribution extends AmaltheaValidation {
+
+ @Override
+ public EClassifier getEClassifier() {
+ return ePackage.getTruncatedTimeDistribution();
+ }
+
+ @Override
+ public void validate(EObject eObject, List<ValidationDiagnostic> results) {
+ if (eObject instanceof TruncatedTimeDistribution) {
+ TruncatedTimeDistribution ttd = (TruncatedTimeDistribution) eObject;
+ Time lower = ttd.getLowerBound();
+ Time upper = ttd.getUpperBound();
+ if (lower != null && upper != null) {
+ if (lower.compareTo(upper) > 0) {
+ addIssue(results, ttd, ePackage.getTruncatedTimeDistribution_LowerBound(),
+ getEClassifier().getName() + ": lower bound is higher than the upper: (" + lower + " > " + upper + ", in " + objectInfo(ttd) + " )");
+ }
+ }
+ }
+ }
+
+}
diff --git a/plugins/org.eclipse.app4mc.amalthea.validations.ta/src/org/eclipse/app4mc/amalthea/validations/ta/todo/AmaltheaModelValidatorImpl.java b/plugins/org.eclipse.app4mc.amalthea.validations.ta/src/org/eclipse/app4mc/amalthea/validations/ta/todo/AmaltheaModelValidatorImpl.java
deleted file mode 100644
index 84fd61a..0000000
--- a/plugins/org.eclipse.app4mc.amalthea.validations.ta/src/org/eclipse/app4mc/amalthea/validations/ta/todo/AmaltheaModelValidatorImpl.java
+++ /dev/null
@@ -1,352 +0,0 @@
-/**
- ********************************************************************************
- * Copyright (c) 2016-2018 Timing-Architects Embedded Systems GmbH and others.
- *
- * This program and the accompanying materials are made
- * available under the terms of the Eclipse Public License 2.0
- * which is available at https://www.eclipse.org/legal/epl-2.0/
- *
- * SPDX-License-Identifier: EPL-2.0
- *
- * Contributors:
- * Timing-Architects Embedded Systems GmbH - initial API and implementation
- ********************************************************************************
- */
-
-package org.eclipse.app4mc.amalthea.validations.ta.todo;
-
-import java.util.HashMap;
-import java.util.HashSet;
-import java.util.Map;
-import java.util.Set;
-
-import org.eclipse.app4mc.amalthea.model.Amalthea;
-import org.eclipse.app4mc.amalthea.model.IReferable;
-import org.eclipse.app4mc.amalthea.model.Time;
-import org.eclipse.app4mc.amalthea.model.TimeUnit;
-import org.eclipse.emf.common.util.TreeIterator;
-import org.eclipse.emf.ecore.EObject;
-
-public class AmaltheaModelValidatorImpl {
-
- private double getSecondsFromTimeUnit(final Time time) {
- double value = 0;
- if (null != time) {
- value = time.getValue().doubleValue();
- if (time.getUnit().getLiteral().equalsIgnoreCase(TimeUnit.PS.getLiteral())) {
- value *= Math.pow(10, -12);
- } else if (time.getUnit().getLiteral().equalsIgnoreCase(TimeUnit.NS.getLiteral())) {
- value *= Math.pow(10, -9);
- } else if (time.getUnit().getLiteral().equalsIgnoreCase(TimeUnit.US.getLiteral())) {
- value *= Math.pow(10, -6);
- } else if (time.getUnit().getLiteral().equalsIgnoreCase(TimeUnit.MS.getLiteral())) {
- value *= Math.pow(10, -3);
- } else if (time.getUnit().getLiteral().equalsIgnoreCase(TimeUnit.S.getLiteral())) {
- value *= Math.pow(10, 0);
- }
- }
- return value;
- }
-
- /*
- * Checks if all referable objects have a unique name. If this is not the case, it will be handled as an error.
- */
- public void checkUniqueName(final Amalthea amalthea) {
-// TODO already checked by basic validations
- final TreeIterator<EObject> amaIter = amalthea.eAllContents();
- final Map<String, IReferable> names = new HashMap<>();
- final Set<IReferable> ambiguousObjects = new HashSet<>();
-
- while (amaIter.hasNext()) {
- final EObject elem = amaIter.next();
- if (elem instanceof IReferable) {
- final IReferable referable = (IReferable) elem;
- final String name = referable.getUniqueName();
- if (true == names.containsKey(name)) {
- ambiguousObjects.add(referable);
- ambiguousObjects.add(names.get(name));
- } else {
- names.put(name, referable);
- }
- }
- }
-
- for (final IReferable object : ambiguousObjects) {
- //this.issueCreator.issue(object, AmaltheaPackage.eINSTANCE.getIReferable_UniqueName(), object.getUniqueName());
- }
- }
-
- /*
- * Checks the parameters of {@link Deviation}.
- * The parameter distribution must be set and the parameter lowerBound must be lower than or equal to upperBound.
- * If this is not the case, it will be handled as an error.
- */
- public void checkDeviation(final Amalthea amalthea) {
-
- final TreeIterator<EObject> amaIter = amalthea.eAllContents();
-// TODO ???
-// while (amaIter.hasNext()) {
-// final EObject elem = amaIter.next();
-// if (elem instanceof Deviation<?>) {
-// final Deviation<?> deviation = (Deviation<?>) elem;
-// final Distribution<?> distribution = deviation.getDistribution();
-// if (null == distribution) {
-// this.issueCreator.issue(deviation, AmaltheaPackage.eINSTANCE.getDeviation_Distribution());
-// } else {
-// if ((false == ((distribution instanceof UniformDistribution<?>) || (distribution instanceof GaussDistribution<?>)
-// || (distribution instanceof WeibullDistribution<?>) || (distribution instanceof Boundaries<?>)))) {
-// this.issueCreator.issue(deviation, AmaltheaPackage.eINSTANCE.getDeviation_Distribution());
-// }
-// }
-// final Object object1 = deviation.getLowerBound();
-// final Object object2 = deviation.getUpperBound();
-// if (((null == object1) && (null != object2)) || ((null == object2) && (null != object1))) {
-// // if only one boundary is set
-// if (null == object1) {
-// this.issueCreator.issue(deviation, AmaltheaPackage.eINSTANCE.getDeviation_LowerBound());
-// }
-// if (null == object2) {
-// this.issueCreator.issue(deviation, AmaltheaPackage.eINSTANCE.getDeviation_UpperBound());
-// }
-// } else if ((null != object1) && (null != object2)) {
-// if (object1.getClass() != object2.getClass()) {
-// // if one boundary uses time, the other not
-// this.issueCreator.issue(deviation, AmaltheaPackage.eINSTANCE.getDeviation_UpperBound());
-// } else {
-// if (object1 instanceof LongObject) {
-// final LongObject lowerBound = (LongObject) object1;
-// final LongObject upperBound = (LongObject) object2;
-// if (lowerBound.getValue() > upperBound.getValue()) {
-// this.issueCreator.issue(deviation, AmaltheaPackage.eINSTANCE.getDeviation_UpperBound());
-// }
-// } else if (object1 instanceof Time) {
-// final Time lowerBound = (Time) object1;
-// final Time upperBound = (Time) object2;
-// final double lowerValue = getSecondsFromTimeUnit(lowerBound);
-// final double upperValue = getSecondsFromTimeUnit(upperBound);
-// if (lowerValue > upperValue) {
-// this.issueCreator.issue(deviation, AmaltheaPackage.eINSTANCE.getDeviation_UpperBound());
-// }
-// }
-// }
-// }
-// }
-// }
- }
-
- /*
- * Checks the parameters of {@link UniformDistribution}.
- * The parameters lowerBound and upperBpound of Deviation must be set.
- * If this is not the case, it will be handled as an error.
- */
- public void checkUniformDistribution(final Amalthea amalthea) {
- final TreeIterator<EObject> amaIter = amalthea.eAllContents();
-// TODO remove ? already checked by intrinsic checks
-// while (amaIter.hasNext()) {
-// final EObject elem = amaIter.next();
-// if (elem instanceof Deviation<?>) {
-// final Deviation<?> deviation = (Deviation<?>) elem;
-// final Distribution<?> distribution = deviation.getDistribution();
-// if (null != distribution) {
-// if (distribution instanceof UniformDistribution<?>) {
-// final Object object1 = deviation.getLowerBound();
-// final Object object2 = deviation.getUpperBound();
-// if ((null == object1) && (null == object2)) {
-// this.issueCreator.issue(deviation, AmaltheaPackage.eINSTANCE.getDeviation_LowerBound());
-// this.issueCreator.issue(deviation, AmaltheaPackage.eINSTANCE.getDeviation_UpperBound());
-// }
-// }
-// }
-// }
-// }
- }
-
- /*
- * Checks the parameters of {@link BetaDistribution}.
- * The parameters alpha and beta of BetaDeviation must be set and both must be larger than zero.
- * If this is not the case, it will be handled as an error.
- */
- public void checkBetaDistribution(final Amalthea amalthea) {
- final TreeIterator<EObject> amaIter = amalthea.eAllContents();
-// TODO remove ? already checked by intrinsic checks
-// while (amaIter.hasNext()) {
-// final EObject elem = amaIter.next();
-// if (elem instanceof Deviation<?>) {
-// final Deviation<?> deviation = (Deviation<?>) elem;
-// final Distribution<?> distribution = deviation.getDistribution();
-// if (null != distribution) {
-// if (distribution instanceof BetaDistribution<?>) {
-// double alpha = ((BetaDistribution<?>) distribution).getAlpha();
-// if(false == (0 < alpha)) {
-// this.issueCreator.issue(distribution, AmaltheaPackage.eINSTANCE.getBetaDistribution_Alpha());
-// }
-// double beta = ((BetaDistribution<?>) distribution).getBeta();
-// if(false == (0 < beta)) {
-// this.issueCreator.issue(distribution, AmaltheaPackage.eINSTANCE.getBetaDistribution_Beta());
-// }
-// }
-// }
-// }
-// }
- }
-
- /*
- * Checks the parameters of {@link GaussDistribution}.
- * The parameters mean and sd must be set and parameter mean must be larger than lowerBound of deviation
- * and smaller than upperBound of deviation.
- * If this is not the case, it will be handled as an error.
- */
- public void checkGaussDistribution(final Amalthea amalthea) {
-
- final TreeIterator<EObject> amaIter = amalthea.eAllContents();
-// TODO
-// while (amaIter.hasNext()) {
-// final EObject elem = amaIter.next();
-// if (elem instanceof Deviation<?>) {
-// final Deviation<?> deviation = (Deviation<?>) elem;
-// final Distribution<?> distribution = deviation.getDistribution();
-// if ((null != distribution) && (distribution instanceof GaussDistribution<?>)) {
-// final GaussDistribution<?> gauss = (GaussDistribution<?>) distribution;
-// final Object mean = gauss.getMean();
-// final Object sd = gauss.getSd();
-// if ((null == mean) || (null == sd)) {
-// if (null == mean) {
-// this.issueCreator.issue(distribution, AmaltheaPackage.eINSTANCE.getGaussDistribution_Mean());
-// }
-// if (null == sd) {
-// this.issueCreator.issue(distribution, AmaltheaPackage.eINSTANCE.getGaussDistribution_Sd());
-// }
-// } else {
-// if (false == mean.getClass().equals(sd.getClass())) {
-// this.issueCreator.issue(distribution, AmaltheaPackage.eINSTANCE.getGaussDistribution_Sd());
-// }
-// final Object lowerBound = deviation.getLowerBound();
-// final Object upperBound = deviation.getUpperBound();
-// if (mean instanceof Time) {
-// final Time meanTime = (Time) mean;
-// final double meanValue = getSecondsFromTimeUnit(meanTime);
-// if (false == (lowerBound instanceof Time)) {
-// this.issueCreator.issue(distribution, AmaltheaPackage.eINSTANCE.getGaussDistribution_Mean());
-// } else {
-// final Time lowerTime = (Time) lowerBound;
-// final double lowerValue = getSecondsFromTimeUnit(lowerTime);
-// if (meanValue < lowerValue) {
-// this.issueCreator.issue(distribution, AmaltheaPackage.eINSTANCE.getGaussDistribution_Mean());
-// }
-// }
-// if (false == (upperBound instanceof Time)) {
-// this.issueCreator.issue(distribution, AmaltheaPackage.eINSTANCE.getGaussDistribution_Mean());
-// } else {
-// final Time upperTime = (Time) upperBound;
-// final double upperValue = getSecondsFromTimeUnit(upperTime);
-// if (meanValue > upperValue) {
-// this.issueCreator.issue(distribution, AmaltheaPackage.eINSTANCE.getGaussDistribution_Mean());
-// }
-// }
-// } else if (mean instanceof LongObject) {
-// final LongObject meanLong = (LongObject) mean;
-// final long meanValue = meanLong.getValue();
-// if (false == (lowerBound instanceof LongObject)) {
-// this.issueCreator.issue(distribution, AmaltheaPackage.eINSTANCE.getGaussDistribution_Mean());
-// } else {
-// final LongObject lowerLong = (LongObject) lowerBound;
-// final long lowerValue = lowerLong.getValue();
-// if (meanValue < lowerValue) {
-// this.issueCreator.issue(distribution, AmaltheaPackage.eINSTANCE.getGaussDistribution_Mean());
-// }
-// }
-// if (false == (upperBound instanceof LongObject)) {
-// this.issueCreator.issue(distribution, AmaltheaPackage.eINSTANCE.getGaussDistribution_Mean());
-// } else {
-// final LongObject upperTime = (LongObject) upperBound;
-// final long upperValue = upperTime.getValue();
-// if (meanValue > upperValue) {
-// this.issueCreator.issue(distribution, AmaltheaPackage.eINSTANCE.getGaussDistribution_Mean());
-// }
-// }
-// }
-// }
-// }
-// }
-// }
- }
-
- /*
- * Checks the parameters of {@link WeibullEstimators}.
- * The parameters mean and pRemainPromille must be set and parameter mean must be between the lower and upper bound of the deviation.
- * If this is not the case, it will be handled as an error.
- */
- public void checkWeibullEstimators(final Amalthea amalthea) {
- final TreeIterator<EObject> amaIter = amalthea.eAllContents();
-
-// TODO
-// while (amaIter.hasNext()) {
-// final EObject elem = amaIter.next();
-// if (elem instanceof Deviation<?>) {
-// final Deviation<?> deviation = (Deviation<?>) elem;
-// final Distribution<?> distribution = deviation.getDistribution();
-// if ((null != distribution) && (distribution instanceof WeibullEstimators<?>)) {
-// final WeibullEstimators<?> weibull = (WeibullEstimators<?>) distribution;
-// final Object mean = weibull.getMean();
-// if (null == mean) {
-// this.issueCreator.issue(distribution, AmaltheaPackage.eINSTANCE.getWeibullEstimators_Mean());
-// } else {
-// // mean
-// final Object lowerBound = deviation.getLowerBound();
-// final Object upperBound = deviation.getUpperBound();
-// if ((null != lowerBound) && (null != upperBound)) {
-// if (mean instanceof Time) {
-// final Time meanTime = (Time) mean;
-// final double meanValue = getSecondsFromTimeUnit(meanTime);
-// if (false == (lowerBound instanceof Time)) {
-// this.issueCreator.issue(distribution, AmaltheaPackage.eINSTANCE.getWeibullEstimators_Mean());
-// } else {
-// final Time lowerTime = (Time) lowerBound;
-// final double lowerValue = getSecondsFromTimeUnit(lowerTime);
-// if (meanValue < lowerValue) {
-// this.issueCreator.issue(distribution, AmaltheaPackage.eINSTANCE.getWeibullEstimators_Mean());
-// }
-// }
-// if (false == (upperBound instanceof Time)) {
-// this.issueCreator.issue(distribution, AmaltheaPackage.eINSTANCE.getWeibullEstimators_Mean());
-// } else {
-// final Time upperTime = (Time) upperBound;
-// final double upperValue = getSecondsFromTimeUnit(upperTime);
-// if (meanValue > upperValue) {
-// this.issueCreator.issue(distribution, AmaltheaPackage.eINSTANCE.getWeibullEstimators_Mean());
-// }
-// }
-// } else if (mean instanceof LongObject) {
-// final LongObject meanLong = (LongObject) mean;
-// final long meanValue = meanLong.getValue();
-// if (false == (lowerBound instanceof LongObject)) {
-// this.issueCreator.issue(distribution, AmaltheaPackage.eINSTANCE.getWeibullEstimators_Mean());
-// } else {
-// final LongObject lowerLong = (LongObject) lowerBound;
-// final long lowerValue = lowerLong.getValue();
-// if (meanValue < lowerValue) {
-// this.issueCreator.issue(distribution, AmaltheaPackage.eINSTANCE.getWeibullEstimators_Mean());
-// }
-// }
-// if (false == (upperBound instanceof LongObject)) {
-// this.issueCreator.issue(distribution, AmaltheaPackage.eINSTANCE.getWeibullEstimators_Mean());
-// } else {
-// final LongObject upperTime = (LongObject) upperBound;
-// final long upperValue = upperTime.getValue();
-// if (meanValue > upperValue) {
-// this.issueCreator.issue(distribution, AmaltheaPackage.eINSTANCE.getWeibullEstimators_Mean());
-// }
-// }
-// }
-// }
-// }
-// // pRemainPromille
-// final double pRemainPromille = weibull.getPRemainPromille();
-// if (0 > pRemainPromille) {
-// this.issueCreator.issue(distribution, AmaltheaPackage.eINSTANCE.getWeibullEstimators_PRemainPromille());
-// }
-// }
-// }
-// }
- }
-}