public code v1

plugins/afryca.consensusmodel.rodriguez2018/.classpath

@@ -0,0 +1,7 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<classpath>
+	<classpathentry kind="con" path="org.eclipse.jdt.launching.JRE_CONTAINER/org.eclipse.jdt.internal.debug.ui.launcher.StandardVMType/JavaSE-1.8"/>
+	<classpathentry kind="con" path="org.eclipse.pde.core.requiredPlugins"/>
+	<classpathentry kind="src" path="src"/>
+	<classpathentry kind="output" path="bin"/>
+</classpath>

plugins/afryca.consensusmodel.rodriguez2018/.gitignore

@@ -0,0 +1 @@
+/bin/

plugins/afryca.consensusmodel.rodriguez2018/.project

@@ -0,0 +1,34 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<projectDescription>
+	<name>afryca.consensusmodel.rodriguez2018</name>
+	<comment></comment>
+	<projects>
+	</projects>
+	<buildSpec>
+		<buildCommand>
+			<name>org.eclipse.jdt.core.javabuilder</name>
+			<arguments>
+			</arguments>
+		</buildCommand>
+		<buildCommand>
+			<name>org.eclipse.pde.ManifestBuilder</name>
+			<arguments>
+			</arguments>
+		</buildCommand>
+		<buildCommand>
+			<name>org.eclipse.pde.SchemaBuilder</name>
+			<arguments>
+			</arguments>
+		</buildCommand>
+		<buildCommand>
+			<name>org.eclipse.m2e.core.maven2Builder</name>
+			<arguments>
+			</arguments>
+		</buildCommand>
+	</buildSpec>
+	<natures>
+		<nature>org.eclipse.m2e.core.maven2Nature</nature>
+		<nature>org.eclipse.pde.PluginNature</nature>
+		<nature>org.eclipse.jdt.core.javanature</nature>
+	</natures>
+</projectDescription>

plugins/afryca.consensusmodel.rodriguez2018/.settings/org.eclipse.jdt.core.prefs

@@ -0,0 +1,7 @@
+eclipse.preferences.version=1
+org.eclipse.jdt.core.compiler.codegen.inlineJsrBytecode=enabled
+org.eclipse.jdt.core.compiler.codegen.targetPlatform=1.8
+org.eclipse.jdt.core.compiler.compliance=1.8
+org.eclipse.jdt.core.compiler.problem.assertIdentifier=error
+org.eclipse.jdt.core.compiler.problem.enumIdentifier=error
+org.eclipse.jdt.core.compiler.source=1.8

plugins/afryca.consensusmodel.rodriguez2018/.settings/org.eclipse.m2e.core.prefs

@@ -0,0 +1,4 @@
+activeProfiles=
+eclipse.preferences.version=1
+resolveWorkspaceProjects=true
+version=1

plugins/afryca.consensusmodel.rodriguez2018/META-INF/MANIFEST.MF

@@ -0,0 +1,10 @@
+Manifest-Version: 1.0
+Bundle-ManifestVersion: 2
+Bundle-Name: %Bundle-Name
+Bundle-SymbolicName: afryca.consensusmodel.rodriguez2018;singleton:=true
+Bundle-Version: 1.0.0.qualifier
+Bundle-RequiredExecutionEnvironment: JavaSE-1.8
+Require-Bundle: afryca.consensusmodel,
+ afryca.fpr,
+ afryca.hpr
+Automatic-Module-Name: afryca.consensusmodel.rodriguez2017

plugins/afryca.consensusmodel.rodriguez2018/OSGI-INF/l10n/bundle.properties

@@ -0,0 +1,13 @@
+#Properties file for afryca.consensusmodel.rodriguez2017
+afryca.consensusModel.rodriguez2017.information=Paper: R. Rodríguez, Á. Labella, Guy De Tré and Luis Martínez. A large scale consensus reaching process managing group hesitation. Knowledge-Based Systems (86-97), vol.159, (2018).\\n\\nConsensus model to deal with large scale group decision making which uses a clustering process, based on FuzzyCMeans method, to weight experts's sub-groups taking into account its size and cohesion. The expert's sub-groups are modeled using hesitant fuzzy sets to avoid losing of information. Furthermore, an adaptive feedback process is defined in which generates advises depending on the consensus level achieved to reduce the time cost of the consensus reaching process.
+afryca.consensusModel.rodriguez2017.mainFeatures = Fuzzy preference relations\\nHesitant preference relations\\nClustering\\nFeedback process
+afryca.consensusModel.rodriguez2017.name=R. Rodriguez et al. (2018)
+afryca.consensusModel.rodriguez2017.observations = No observations
+afryca.consensusmodel.rodriguez2017.variable.theta.description=Consensus threshold
+afryca.consensusmodel.rodriguez2017.variable.delta.description=Level of consensus for the advice generation
+afryca.consensusmodel.rodriguez2017.variable.beta.description=Modify the cohesion
+afryca.consensusmodel.rodriguez2017.variable.pointA.description=Point A Membership Function
+afryca.consensusmodel.rodriguez2017.variable.pointB.description=Point B Membership Function
+afryca.consensusmodel.rodriguez.variable.h_max.description = Maximum number of discussion rounds allowed
+afryca.consensusmodel.rodriguez2017.variable.distance_measure_minkowski.description =  Minkowski distance measure
+Bundle-Name = Rodriguez2017

plugins/afryca.consensusmodel.rodriguez2018/OSGI-INF/l10n/bundle_es.properties

@@ -0,0 +1,13 @@
+#Properties file for afryca.consensusmodel.rodriguez2017
+afryca.consensusModel.rodriguez2017.information=Paper: R. Rodríguez, Á. Labella, Guy De Tré y Luis Martínez. A large scale consensus reaching process managing group hesitation. Knowledge-Based Systems (86-97), vol.159, (2018).\\n\\\nModelo de consenso para tratar con problemas de toma de decisión en grupo a gran escala que emplea un proceso de agrupación, basado en el método FuzzyCMean, para ponderar los subgrupos de expertos teniendo en cuenta su tamaño y cohesion. Los subgrupos de los expertos se modelan usando conjuntos difusos dudosos para evitar la pérdida de información. Además se incluye un proceso de generación de recomendaciones adaptativo en el que se generan las recomendaciones dependiendo del nivel de consenso alcanzado, reduciendo así el tiempo de coste del proceso de alcance de consenso.
+afryca.consensusModel.rodriguez2017.mainFeatures = Relaciones de preferencias difusas\\nRelaciones de preferencias dudosas\\nAgrupación\\nGeneración de recomendaciones
+afryca.consensusModel.rodriguez2017.name=R. Rodriguez et al. (2018)
+afryca.consensusModel.rodriguez2017.observations = Sin observaciones
+afryca.consensusmodel.rodriguez2017.variable.theta.description=Umbral de consenso
+afryca.consensusmodel.rodriguez2017.variable.delta.description=Nivel de consenso para la generación de recomendaciones
+afryca.consensusmodel.rodriguez2017.variable.beta.description=Modifica la cohesion
+afryca.consensusmodel.rodriguez2017.variable.pointA.description=Point A Funcion de pertenencia
+afryca.consensusmodel.rodriguez2017.variable.pointB.description=Point B Funcion de pertenencia
+afryca.consensusmodel.rodriguez.variable.h_max.description = Máximo número de rondas de discusión permitidas
+afryca.consensusmodel.rodriguez2017.variable.distance_measure_minkowski.description =  Medida de distancia de Minkowski
+Bundle-Name = Rodriguez2017

plugins/afryca.consensusmodel.rodriguez2018/build.properties

@@ -0,0 +1,7 @@
+source.. = src/
+output.. = bin/
+bin.includes = META-INF/,\
+               .,\
+               plugin.xml,\
+               OSGI-INF/l10n/bundle.properties,\
+               OSGI-INF/

plugins/afryca.consensusmodel.rodriguez2018/plugin.xml

@@ -0,0 +1,115 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<?eclipse version="3.4"?>
+<plugin>
+   <extension
+         point="afryca.consensusmodel">
+      <ConsensusModel
+            ConsensusModel="afryca.consensusmodel.Rodriguez2018"
+            Information="%afryca.consensusModel.rodriguez2017.information"
+            MainFeatures="%afryca.consensusModel.rodriguez2017.mainFeatures"
+            Multicriteria="false"
+            Name="%afryca.consensusModel.rodriguez2017.name"
+            Observations="%afryca.consensusModel.rodriguez2017.observations"
+            Structure="afryca.fpr"
+            WithFeedback="true"
+            id="Rodriguez2017">
+         <Variable
+               default_value="30"
+               description="%afryca.consensusmodel.rodriguez.variable.h_max.description"
+               id="max_rounds"
+               is_array="false"
+               is_internal="false"
+               type="Integer">
+            <Restriction
+                  type="lower_limit"
+                  value="1">
+            </Restriction>
+         </Variable>
+         <Variable
+               default_value="0.85"
+               description="%afryca.consensusmodel.rodriguez2017.variable.theta.description"
+               id="theta"
+               is_array="false"
+               is_internal="false"
+               type="Float">
+            <Restriction
+                  type="lower_limit"
+                  value="0">
+            </Restriction>
+            <Restriction
+                  type="upper_limit"
+                  value="1">
+            </Restriction>
+         </Variable>
+         <Variable
+               default_value="0.7"
+               description="%afryca.consensusmodel.rodriguez2017.variable.delta.description"
+               id="delta"
+               is_array="false"
+               is_internal="false"
+               type="Float">
+         </Variable>
+         <Variable
+               default_value="Math.round(experts/alternatives)"
+               description="%afryca.consensusmodel.rodriguez2017.variable.pointB.description"
+               id="pointB"
+               is_array="false"
+               is_internal="false"
+               type="Operation">
+            <Restriction
+                  type="upper_limit"
+                  value="100">
+            </Restriction>
+            <Restriction
+                  type="lower_limit"
+                  value="2">
+            </Restriction>
+            <Relation
+                  type="greater_than"
+                  variable="pointA">
+            </Relation>
+         </Variable>
+         <Variable
+               default_value="1.8"
+               description="%afryca.consensusmodel.rodriguez2017.variable.beta.description"
+               id="beta"
+               is_array="false"
+               is_internal="false"
+               type="Float">
+         </Variable>
+         <Variable
+               default_value="Math.round((experts/alternatives)/3)"
+               description="%afryca.consensusmodel.rodriguez2017.variable.pointA.description"
+               id="pointA"
+               is_array="false"
+               is_internal="false"
+               type="Operation">
+            <Restriction
+                  type="lower_limit"
+                  value="0">
+            </Restriction>
+            <Restriction
+                  type="upper_limit"
+                  value="99">
+            </Restriction>
+            <Relation
+                  type="lower_than"
+                  variable="pointB">
+            </Relation>
+         </Variable>
+         <Variable
+               default_value="2"
+               description="%afryca.consensusmodel.rodriguez2017.variable.distance_measure_minkowski.description"
+               id="distance_measure_minkowski"
+               is_array="false"
+               is_internal="false"
+               type="Integer">
+            <Restriction
+                  type="lower_limit"
+                  value="1">
+            </Restriction>
+         </Variable>
+      </ConsensusModel>
+   </extension>
+
+</plugin>

plugins/afryca.consensusmodel.rodriguez2018/src/afryca/consensusmodel/GenerateRecommendations.java

@@ -0,0 +1,185 @@
+package afryca.consensusmodel;
+
+import java.util.LinkedList;
+import java.util.List;
+
+import afryca.hpr.HPR;
+import afryca.hpr.valuation.ExpertDegree;
+import afryca.hpr.valuation.HesitantNumericValuation;
+
+/**
+ *
+ * @author Rosa M. Rodriguez
+ */
+public class GenerateRecommendations {
+
+	GenerateRecommendations() {
+	}
+
+	public static List<Recommendation> recommendationsForGroup(List<HPR> hesitantPreferenceRelations, HPR collectiveMatrix, double consensusThreshold, List<Double> consensusAlternatives) {
+
+		List<Recommendation> recommendations = new LinkedList<Recommendation>();
+		double hprDistance, hprProximity, hesitantDistance, hesitantSim, averagePR, averagePRA;
+		int idGroup, idAlternative1, idAlternative2;
+		float averageCollective, averageHesitant;
+
+		averagePR = averageProximityRelation(hesitantPreferenceRelations, collectiveMatrix);
+		averagePR = truncateToTwoDecimals(averagePR);
+
+		for (HPR hpr : hesitantPreferenceRelations) {
+			hprDistance = collectiveMatrix.distanceEuclideanHesitantPreferenceRelations(hpr);
+			hprProximity = 1 - hprDistance;
+			hprProximity = truncateToTwoDecimals(hprProximity);
+
+			if (hprProximity <= averagePR) { 
+				idGroup = hpr.getId();
+				for (int i = 0; i < hpr.getNumberOfAlternatives(); i++) {
+					double ca_i = consensusAlternatives.get(i);
+					if (ca_i <= consensusThreshold) {
+						
+						averagePRA = averageProximityAlternative_i(hpr, collectiveMatrix, i);
+						averagePRA = truncateToTwoDecimals(averagePRA);
+
+						for (int j = i + 1; j < hpr.getNumberOfAlternatives(); j++) {
+
+							HesitantNumericValuation hesitant = (HesitantNumericValuation) hpr.getValue(i, j);
+							hesitantDistance = hesitant.distanceEuclideanHesitantFuzzySet((HesitantNumericValuation) collectiveMatrix.getValue(i, j));
+							hesitantSim = 1 - hesitantDistance;
+							hesitantSim = truncateToTwoDecimals(hesitantSim);
+
+							if (hesitantSim <= averagePRA) {
+								// select pair of alternatives
+								idAlternative1 = i + 1;
+								idAlternative2 = j + 1;
+								// computeDirection
+								averageCollective = ((HesitantNumericValuation) collectiveMatrix.getValue(i, j)).computeFscoreFahradiniaHesitantFuzzySet();
+								averageHesitant = hesitant.computeFscoreFahradiniaHesitantFuzzySet();
+								EChangeType direction = computeDirection(averageHesitant, averageCollective);
+								Recommendation recommendation = new Recommendation(idGroup, idAlternative1, idAlternative2, -1, direction);
+								recommendations.add(recommendation);
+							}
+						} // END-FOR
+					} // END-IF
+				} // END-FOR
+			}
+		} // END-FOR
+		return recommendations;
+	}
+
+	public static List<Recommendation> recommendationsForExperts(List<HPR> hesitantPreferenceRelations, HPR collectiveMatrix, double consensusThreshold, List<Double> consensusAlternatives) {
+
+		List<Recommendation> recommendations = new LinkedList<Recommendation>();
+		double hprDistance, hprProximity, hesitantDistance, hesitantSim, difference, averagePR, averagePRA;
+		int idGroup, idAlternative1, idAlternative2, idExpert;
+		float averageCollective, value;
+
+		averagePR = averageProximityRelation(hesitantPreferenceRelations, collectiveMatrix);
+		averagePR = truncateToTwoDecimals(averagePR);
+
+		for (HPR hpr : hesitantPreferenceRelations) {
+			hprDistance = collectiveMatrix.distanceEuclideanHesitantPreferenceRelations(hpr);
+			hprProximity = 1 - hprDistance;
+			hprProximity = truncateToTwoDecimals(hprProximity);
+
+			if (hprProximity <= averagePR) {
+				idGroup = hpr.getId();
+				for (int i = 0; i < hpr.getNumberOfAlternatives(); i++) {
+					double ca_i = consensusAlternatives.get(i);
+					if (ca_i <= consensusThreshold) {
+						
+						averagePRA = averageProximityAlternative_i(hpr, collectiveMatrix, i);
+						averagePRA = truncateToTwoDecimals(averagePRA);
+						
+						for (int j = i + 1; j < hpr.getNumberOfAlternatives(); j++) {
+							HesitantNumericValuation hesitant = (HesitantNumericValuation) hpr.getValue(i, j);
+							hesitantDistance = hesitant.distanceEuclideanHesitantFuzzySet((HesitantNumericValuation) collectiveMatrix.getValue(i, j));
+							hesitantSim = 1 - hesitantDistance;
+							hesitantSim = truncateToTwoDecimals(hesitantSim);
+
+							if (hesitantSim <= averagePRA) {// select pair of alternatives
+								idAlternative1 = i + 1;
+								idAlternative2 = j + 1;
+
+								for (ExpertDegree expertDegree : hesitant.getHesitantValues()) {
+									if (expertDegree.getId() != -1) {// it is a real expert
+										value = expertDegree.getDegree();
+										difference = 1 - ((HesitantNumericValuation) collectiveMatrix.getValue(i, j)).distanceValorHesitant(value);
+										difference = truncateToTwoDecimals(difference);
+										if (difference <= averagePRA) { // select expert
+											idExpert = expertDegree.getId();// computeDirection
+											averageCollective = ((HesitantNumericValuation) collectiveMatrix.getValue(i, j)).computeFscoreFahradiniaHesitantFuzzySet();
+											EChangeType direction = computeDirection(value, averageCollective);
+											Recommendation recommendation = new Recommendation(idGroup, idAlternative1, idAlternative2, idExpert, direction);
+											recommendations.add(recommendation);
+										}
+									}
+								} // END-FOR
+							}
+						} // END-FOR
+					} // END-IF
+				} // END-FOR
+			}
+		} // END-FOR
+
+		return recommendations;
+	}
+
+	public static double averageProximityRelation(List<HPR> hesitantPreferenceRelations, HPR collectiveMatrix) {
+		double hprDistance, hprProximity, average;
+		double sum = 0;
+
+		for (HPR hpr : hesitantPreferenceRelations) {
+			hprDistance = collectiveMatrix.distanceEuclideanHesitantPreferenceRelations(hpr);
+			hprProximity = 1 - hprDistance;
+			sum += hprProximity;
+		}
+		average = sum / hesitantPreferenceRelations.size();
+		return average;
+	}
+
+	public static double averageProximityAlternative(List<HPR> hesitantPreferenceRelations, HPR collectiveMatrix, int alt1, int alt2) {
+		double hesitantDistance, hesitantSim, average;
+		double sum = 0;
+
+		for (HPR hpr : hesitantPreferenceRelations) {
+			HesitantNumericValuation hesitant = (HesitantNumericValuation) hpr.getValue(alt1, alt2);
+			hesitantDistance = hesitant.distanceEuclideanHesitantFuzzySet((HesitantNumericValuation) collectiveMatrix.getValue(alt1, alt2));
+			hesitantSim = 1 - hesitantDistance;
+			sum += hesitantSim;
+		}
+		average = sum / hesitantPreferenceRelations.size();
+		return average;
+	}
+
+	public static double averageProximityAlternative_i(HPR hpr, HPR collectiveMatrix, int alt_i) {
+		double hesitantDistance, hesitantSim, average;
+		double sum = 0;
+		int alt_j = hpr.getNumberOfAlternatives();
+
+		for (int j = 0; j < alt_j; j++) {
+			HesitantNumericValuation hesitant = (HesitantNumericValuation) hpr.getValue(alt_i, j);
+			hesitantDistance = hesitant.distanceEuclideanHesitantFuzzySet((HesitantNumericValuation) collectiveMatrix.getValue(alt_i, j));
+			hesitantSim = 1 - hesitantDistance;
+			sum += hesitantSim;
+		}
+		average = sum / alt_j;
+		return average;
+	}
+
+	public static EChangeType computeDirection(float value1, float value2) {
+		EChangeType direction = EChangeType.NotChange;
+		if (value1 < value2) {
+			direction = EChangeType.Increase;
+		} else {
+			if (value1 > value2) {
+				direction = EChangeType.Decrease;
+			}
+		}
+		return direction;
+	}
+
+	public static Double truncateToTwoDecimals(Double value) {
+		return Math.round(value * 100.0d) / 100.0d;
+	}
+
+}

plugins/afryca.consensusmodel.rodriguez2018/src/afryca/consensusmodel/Recommendation.java

@@ -0,0 +1,93 @@
+package afryca.consensusmodel;
+
+/**
+ *
+ * @author Rosa M. Rodriguez
+ */
+public class Recommendation {
+    private int idCluster;
+    private int idAlternative1;
+    private int idAlternative2;
+    private int idExpert;
+    private EChangeType direction;
+    
+    Recommendation(){
+        idCluster = -1;
+        idAlternative1 = -1;
+        idAlternative2 = -1;
+        idExpert = -1;
+        direction = EChangeType.NotChange;
+    }
+    
+    Recommendation(int idCluster, int idAlternative1, int idAlternative2, int idExpert, EChangeType direction){
+        this();
+        setIdCluster(idCluster);
+        setIdAlternative1(idAlternative1);
+        setIdAlternative2(idAlternative2);
+        setIdExpert(idExpert);
+        setDirection(direction);
+    }
+
+    Recommendation(int idCluster, int idAlternative1, int idAlternative2, EChangeType direction){
+        this();
+        setIdCluster(idCluster);
+        setIdAlternative1(idAlternative1);
+        setIdAlternative2(idAlternative2);
+        setIdExpert(-1);
+        setDirection(direction);
+    }
+    
+    public int getIdCluster() {
+        return idCluster;
+    }
+
+    private void setIdCluster(int idCluster) {
+        this.idCluster = idCluster;
+    }
+
+    public int getIdAlternative1() {
+        return idAlternative1;
+    }
+
+    private void setIdAlternative1(int idAlternative1) {
+        this.idAlternative1 = idAlternative1;
+    }
+
+    public int getIdAlternative2() {
+        return idAlternative2;
+    }
+
+    private void setIdAlternative2(int idAlternative2) {
+        this.idAlternative2 = idAlternative2;
+    }
+
+    public int getIdExpert() {
+        return idExpert;
+    }
+
+    private void setIdExpert(int idExpert) {
+        this.idExpert = idExpert;
+    }
+
+    public EChangeType getDirection() {
+        return direction;
+    }
+
+    private void setDirection(EChangeType direction) {
+        this.direction = direction;
+    }
+    
+    @Override
+    public String toString() {
+        StringBuilder result = new StringBuilder();
+        
+        result.append("\nId cluster: " + idCluster);
+        result.append("\nExpert: "+ idExpert);
+        result.append("\n(A1,A2): " + "("+idAlternative1+","+idAlternative2+")");
+        result.append("\nDirection: " + direction);
+        result.append("\n");
+        return result.toString();
+    }
+    
+    
+}

plugins/afryca.consensusmodel.rodriguez2018/src/afryca/consensusmodel/Rodriguez2018.java

@@ -0,0 +1,531 @@
+package afryca.consensusmodel;
+
+import java.util.HashMap;
+import java.util.LinkedList;
+import java.util.List;
+import java.util.Map;
+import java.util.TreeMap;
+
+import afryca.ase.RunnableScript;
+import afryca.consensusmodel.cluster.ClusterFPR;
+import afryca.consensusmodel.clustering.FuzzyCMeansFPR;
+import afryca.consensusmodel.definition.EResultElements;
+import afryca.consensusmodel.definition.ERoundResult;
+import afryca.fpr.FPR;
+import afryca.hpr.HPR;
+import afryca.hpr.valuation.ExpertDegree;
+import afryca.hpr.valuation.HesitantNumericValuation;
+import afryca.pr.PR;
+import afryca.consensumodel.addon.E4DIAddon;
+
+public class Rodriguez2018 extends ConsensusModel {
+
+	private static final String CONSENSUS_MODEL_NAME = "Rodriguez (2018)"; //$NON-NLS-1$
+
+	private static final String CONSENSUS_THRESHOLD = "theta"; //$NON-NLS-1$
+	private static final String CONSENSUS_LEVEL = "delta"; //$NON-NLS-1$
+	private static final String MAX_ROUNDS = "max_rounds"; //$NON-NLS-1$
+	private static final String BETA = "beta"; //$NON-NLS-1$
+	private static final String POINT_A = "pointA"; //$NON-NLS-1$
+	private static final String POINT_B = "pointB"; //$NON-NLS-1$
+	private static final String DISTANCE_MEASURE_MINKOWSKI = "distance_measure_minkowski"; //$NON-NLS-1$
+
+	private float pointA;
+	private float pointB;
+	private float beta;
+
+	private double consensusDegree;
+	private Float consensusThreshold;
+	private Float consensusLevel;
+
+	private Integer maxRounds;
+	private int currentRound;
+	private int p;
+
+	private int[] advises;
+
+	private FPR consensusMatrix;
+	private FPR[] preferencesWithoutGroup;
+
+	private List<ClusterFPR> postClusters = new LinkedList<ClusterFPR>();
+	private List<ClusterFPR> clustersAfterChanges = new LinkedList<ClusterFPR>();
+	
+	private List<HPR> postHesitantPreferenceRelations = new LinkedList<HPR>();
+	private List<Double> consensusAlternatives;
+
+	@Override
+	protected void setModelConfiguration() {	
+	}
+
+	@Override
+	protected void obtainConfigurationValues() {
+		pointA = (Float) configuration.getValue(POINT_A);
+		pointB = (Float) configuration.getValue(POINT_B);
+		beta = (Float) configuration.getValue(BETA);
+		consensusThreshold = (Float) configuration.getValue(CONSENSUS_THRESHOLD);
+		consensusLevel = (Float) configuration.getValue(CONSENSUS_LEVEL);
+		maxRounds = (Integer) configuration.getValue(MAX_ROUNDS);
+		p = (Integer) configuration.getValue(DISTANCE_MEASURE_MINKOWSKI);
+		currentRound = 0;
+		consensusDegree = 0f;
+		preferencesWithoutGroup = new FPR[preferences.length - 1];
+
+		initializePreferencesWithoutGroup();
+		initializeAdvises();
+		
+		
+	}
+
+	private void initializePreferencesWithoutGroup() {
+		// Copy preferences except groupal
+		for (int i = 0; i < preferences.length - 1; i++) {
+			try {
+				preferencesWithoutGroup[i] = (FPR) preferences[i].clone();
+			} catch (CloneNotSupportedException e) {
+				e.printStackTrace();
+			}
+		}
+	}
+
+	private void initializeAdvises() {
+		advises = new int[experts.length];
+		for (int i = 0; i < advises.length; i++) {
+			advises[i] = 0;
+		}
+	}
+	
+	@Override
+	protected Float[][][] obtainVisualizeValues() {
+		Float[][][] preferencesGroupVisualization = new Float[numberOfExperts + 1][numberOfAlternatives][numberOfAlternatives];
+
+		for (int k = 0; k < numberOfExperts+1; k++) {
+			preferencesGroupVisualization[k] =  preferences[k].obtainVisualizeValues();
+		}
+		
+		return preferencesGroupVisualization;
+	}
+	
+	@Override
+	protected void preFirstSaveRoundResults() {
+		postClusters = generateClusters(alternatives, experts, (FPR[]) preferencesWithoutGroup, p);
+		postHesitantPreferenceRelations = generateHesitant(postClusters, alternatives.length);
+	
+		FPR consensusMatrixAux;
+		double consensusDegree = 0;
+		try {
+			consensusMatrixAux = computeConsensusMatrix(cloneHesitantPreferenceRelations(postHesitantPreferenceRelations));
+			consensusDegree = computeConsensusDegree(consensusMatrixAux);
+		} catch (CloneNotSupportedException e) {
+			e.printStackTrace();
+		}
+	
+		HPR collective =  (HPR) ((RunnableScript) E4DIAddon.aseService
+				.createExecutionBuilder()
+				.setFunction("weithedAverageHPR")
+				.putVariable("hesitant", postHesitantPreferenceRelations)
+				.execute()).getResult();
+		
+		computeGroupPreference(collective);
+		preSaveRoundResult(1, preferences,obtainVisualizeValues(), (float) consensusDegree);
+		roundsResults.get(roundsResults.size() - 1).put(ERoundResult.clusters, postClusters);
+		roundsResults.get(roundsResults.size() - 1).put(ERoundResult.hprs, postHesitantPreferenceRelations);
+		
+		result.put(EResultElements.initial_consensus_degree, consensusDegree);
+		result.put(EResultElements.maxround, maxRounds);
+		result.put(EResultElements.consensus_threshold, consensusThreshold);
+		result.put(EResultElements.consensus_model, CONSENSUS_MODEL_NAME);
+	}
+
+	@Override
+	protected void preSaveRoundResults() {
+		preSaveRoundResult(currentRound + 1, preferences,obtainVisualizeValues(), (float) consensusDegree);
+		roundsResults.get(roundsResults.size() - 1).put(ERoundResult.clusters, postClusters);
+		roundsResults.get(roundsResults.size() - 1).put(ERoundResult.hprs, postHesitantPreferenceRelations);
+	}
+
+	@Override
+	protected void consensusRound() {
+		HPR collective = (HPR) ((RunnableScript) E4DIAddon.aseService.createExecutionBuilder()
+				.setFunction("weithedAverageHPR")
+				.putVariable("hesitant",postHesitantPreferenceRelations)
+				.putVariable("beta", beta).putVariable("pointA", pointA)
+				.putVariable("pointB", pointB).execute())
+				.getResult();
+		
+		computeGroupPreference(collective);
+
+		
+		consensusMatrix = computeConsensusMatrix(postHesitantPreferenceRelations);
+		consensusDegree = computeConsensusDegree(consensusMatrix);		
+		consensusAlternatives = computeConsensusAlternatives(consensusMatrix);
+
+		// control consensus
+		if ((float) consensusDegree < consensusThreshold) {
+			// feedback
+			// obtain collective preference relation by HesitantWeightedMean
+			// aggregation operator
+			
+			initializeAdvises();
+			
+			List<Recommendation> recommendations;
+
+			if (consensusDegree >= consensusLevel) {
+				recommendations = GenerateRecommendations.recommendationsForExperts(postHesitantPreferenceRelations, collective, consensusThreshold, consensusAlternatives);
+				for (Recommendation r : recommendations) {
+					if (r.getIdExpert() != -1) {
+						advises[r.getIdExpert()] = 1;
+					}
+				}
+				
+				
+			} else {
+				// Consensus low. Recommend group
+				recommendations = GenerateRecommendations.recommendationsForGroup(postHesitantPreferenceRelations, collective, consensusThreshold, consensusAlternatives);
+				for (Recommendation r : recommendations) {
+					if (r.getIdExpert() != -1) {
+						advises[r.getIdExpert()] = 1;
+					}
+				}
+			}
+			
+			if (!recommendations.isEmpty()) {
+				clustersAfterChanges = changePreferencesExperts(postClusters, recommendations);
+				FPR[] preferences = unifyPreferencesClusters(clustersAfterChanges);
+				postClusters = generateClusters(alternatives, experts, preferences, p);	
+				postHesitantPreferenceRelations = generateHesitant(postClusters, alternatives.length);
+
+			}
+			
+			currentRound++;
+		}
+	}
+
+	private void computeGroupPreference(HPR collective) {
+		HPR HPRClone = null;
+
+		try {
+			HPRClone = (HPR) collective.clone();
+		} catch (CloneNotSupportedException e) {
+			e.printStackTrace();
+		}
+
+		FPR groupPreference = new FPR(alternatives.length);
+		orderHPRPreferences(HPRClone);
+
+		float value;
+		List<ExpertDegree> degrees;
+		for (int i = 0; i < HPRClone.getPreferences().length; i++) {
+			for (int j = 0; j < HPRClone.getPreferences()[i].length; j++) {
+				value = 0.5f;
+				int pos = ((HesitantNumericValuation) collective.getPreferences()[i][j]).getHesitantValues().size() / 2;
+				degrees = ((HesitantNumericValuation) collective.getPreferences()[i][j]).getHesitantValues();
+				if ((pos % 2) == 0) {
+					value = ((float) degrees.get(pos - 1).getDegree() + (float) (degrees.get(pos).getDegree())) / 2f;
+				} else {
+					value = (float) degrees.get(pos).getDegree();
+				}
+				groupPreference.setValueSymmetrically(i, j, value);
+			}
+		}
+		preferences[numberOfExperts] = groupPreference;
+	}
+
+	private void orderHPRPreferences(HPR HPRClone) {
+		for (Object[] h : HPRClone.getPreferences()) {
+			for (Object hAux : h) {
+				((HesitantNumericValuation) hAux).OrderHesitantDegreesIncreasing();
+			}
+		}
+	}
+
+	@Override
+	protected void posSaveRoundResults() {
+		HPR collective = (HPR) ((RunnableScript) E4DIAddon.aseService.createExecutionBuilder()
+				.setFunction("weithedAverageHPR")
+				.putVariable("hesitant",postHesitantPreferenceRelations)
+				.putVariable("beta", beta).putVariable("pointA", pointA)
+				.putVariable("pointB", pointB).execute())
+				.getResult();
+		
+		computeGroupPreference(collective);
+		consensusMatrix = computeConsensusMatrix(postHesitantPreferenceRelations);
+		consensusDegree = computeConsensusDegree(consensusMatrix);
+		consensusAlternatives = computeConsensusAlternatives(consensusMatrix);
+		
+		posSaveRoundResult(preferences,obtainVisualizeValues(), (float) consensusDegree, advises, preferences[numberOfExperts]);
+		roundsResults.get(roundsResults.size() - 1).put(ERoundResult.clusters, postClusters);
+		roundsResults.get(roundsResults.size() - 1).put(ERoundResult.hprs, postHesitantPreferenceRelations);
+	}
+
+	@Override
+	protected boolean mustBeCarriedOutAnotherRound() {
+		return (((float) consensusDegree < consensusThreshold) && (currentRound < maxRounds));
+	}
+
+	@Override
+	protected void saveExecutionResults() {
+		this.configuration.setValue(PREFERENCES, preferences);
+		result.put(EResultElements.number_of_rounds_required, currentRound);
+		result.put(EResultElements.consensus_degree_achieved, consensusDegree);
+	}
+
+	@SuppressWarnings("unchecked")
+	public List<ClusterFPR> generateClusters(String[] alternatives, String[] experts, FPR[] preferences, int parameter) {
+		// Do clustering
+		if (roundsResults.isEmpty()) {
+			return FuzzyCMeansFPR.doClusteringFuzzyCMeansClusterForEachAlternative(alternatives, experts, preferences, null, parameter);
+		} else {
+			return FuzzyCMeansFPR.doClusteringFuzzyCMeansClusterForEachAlternative(alternatives, experts, preferences, 
+					(List<ClusterFPR>) roundsResults.get(roundsResults.size() - 1).get(ERoundResult.clusters), parameter);
+		}
+	}
+
+	public List<HPR> generateHesitant(List<ClusterFPR> clusters, int nAlternatives) {
+		List<HPR> hesitantPreferenceRelations = new LinkedList<HPR>();
+		// computeFscoreFahradiniaHesitantFuzzySet
+		// obtain a hesitant preference relation for each cluster
+		for (ClusterFPR cluster : clusters) {
+			if (!cluster.getExperts().isEmpty()) {
+				hesitantPreferenceRelations.add(generateHesitantPreferenceRelation(cluster, nAlternatives));
+			}
+		}
+		// Normalization process for hesitant preference relations
+		// (1) Take the maximum number of elements among all HPRs
+		int nElements = HPR.maximumSizeForNormalization(hesitantPreferenceRelations);
+		// (2) Normalization
+		for (HPR hprAux : hesitantPreferenceRelations) {
+			hprAux.normalize(nElements);
+		}
+
+		return hesitantPreferenceRelations;
+	}
+
+	public static HPR generateHesitantPreferenceRelation(ClusterFPR cluster, int nAlternatives) {
+
+		HPR hesitantPreferenceRelation = new HPR(cluster.getId(), cluster.getExperts().size(), nAlternatives);
+
+		float value;
+		HesitantNumericValuation[][] preferences = new HesitantNumericValuation[nAlternatives][nAlternatives];
+
+		for (int i = 0; i < nAlternatives; i++) {
+			for (int j = 0; j < nAlternatives; j++) {
+				HesitantNumericValuation hesitant = new HesitantNumericValuation();
+				for (Integer expert : cluster.getExperts()) {
+					value = (float) cluster.getPreferences().get(expert).getValue(i, j);
+					ExpertDegree expertDegree = new ExpertDegree(expert, value);
+					hesitant.addHesitantValue(expertDegree);
+				}
+				preferences[i][j] = hesitant;
+			}
+		}
+		hesitantPreferenceRelation.setPreferences(preferences);
+
+		return hesitantPreferenceRelation;
+	}
+
+	public FPR computeConsensusMatrix(List<HPR> HPRs) {
+		List<FPR> listSimilarityMatrix = new LinkedList<FPR>();
+		int nGroups = HPRs.size();
+		// Compute similarity matrix among hpr
+		for (int i = 0; i < nGroups - 1; i++) {
+			HPR hpr1 = HPRs.get(i);
+			for (int j = i + 1; j < nGroups; j++) {
+				HPR hpr2 = HPRs.get(j);
+				FPR similarityMatrix = hpr1.similarityMatrixHesitantPreferenceRelations(hpr2);
+				listSimilarityMatrix.add(similarityMatrix);
+			}
+		}
+		// Compute consensus matrix
+		FPR fpr = new FPR();
+
+		int nAlt = HPRs.get(0).getNumberOfAlternatives();
+		Float[][] consensusMatrix = new Float[nAlt][nAlt];
+		float sum;
+		float value;
+		for (int i = 0; i < nAlt; i++) {
+			for (int j = 0; j < nAlt; j++) {
+				sum = 0;
+				for (FPR similarityMatrix : listSimilarityMatrix) {
+					sum += (float) similarityMatrix.getValue(i, j);
+				}
+				value = sum / listSimilarityMatrix.size();
+				consensusMatrix[i][j] = value;
+			}
+		}
+		fpr.prepareStructureForPreferences(consensusMatrix);
+		return fpr;
+	}
+
+	public double computeConsensusDegree(FPR matrix) {
+		List<Float> ca = new LinkedList<Float>();
+		double consensusDegree;
+		float sum;
+		for (int i = 0; i < matrix.getNumberOfAlternatives(); i++) {
+			sum = 0;
+			for (int j = 0; j < matrix.getNumberOfAlternatives(); j++) {
+				if (i != j)
+					sum += (float) matrix.getValue(i, j);
+			}
+			sum = sum / (matrix.getNumberOfAlternatives() - 1);
+			ca.add(sum);
+		}
+
+		sum = 0;
+		for (Float v : ca) {
+			sum += v;
+		}
+		consensusDegree = sum / matrix.getNumberOfAlternatives();
+		consensusDegree = truncateToTwoDecimals(consensusDegree);
+
+		return consensusDegree;
+	}
+
+	public List<Double> computeConsensusAlternatives(FPR matrix) {
+		List<Double> ca = new LinkedList<Double>();
+		double sum;
+		for (int i = 0; i < matrix.getNumberOfAlternatives(); i++) {
+			sum = 0;
+			for (int j = 0; j < matrix.getNumberOfAlternatives(); j++) {
+				if (i != j)
+					sum += (float) matrix.getValue(i, j);
+			}
+			sum = sum / (matrix.getNumberOfAlternatives() - 1);
+			sum = truncateToTwoDecimals(sum);
+			ca.add(sum);
+		}
+		return ca;
+	}
+
+	public double truncateToTwoDecimals(double value) {
+		return (double) (Math.round(value * 100.0d) / 100.0d);
+	}
+
+	public FPR[] unifyPreferencesClusters(List<ClusterFPR> clusters) {
+		Map<Integer, PR> allPreferences = new HashMap<Integer, PR>();
+		Map<Integer, PR> preferences = null;
+		FPR[] result;
+
+		for (ClusterFPR cluster : clusters) {
+			if (!cluster.getExperts().isEmpty()) {
+				preferences = cluster.getPreferences();
+				allPreferences.putAll(preferences);
+			}
+		}
+
+		result = new FPR[allPreferences.size()];
+
+		Map<Integer, PR> treeMap = new TreeMap<Integer, PR>(allPreferences);
+		for (Integer str : treeMap.keySet()) {
+			result[str] = (FPR) treeMap.get(str);
+		}
+
+		return result;
+	}
+
+	public List<ClusterFPR> changePreferencesExperts(List<ClusterFPR> clusters, List<Recommendation> recommendations) {
+		List<ClusterFPR> postClusters = new LinkedList<ClusterFPR>();
+
+		for (ClusterFPR cluster : clusters) {
+			if (!cluster.getExperts().isEmpty()) {
+				ClusterFPR postCluster = changePreferences(cluster, recommendations);
+				postClusters.add(postCluster);
+			}
+		}
+		return postClusters;
+	}
+
+	private ClusterFPR changePreferences(ClusterFPR cluster, List<Recommendation> recommendations) {
+		double change = 0;
+		int nChanges=0;
+		
+		for (Recommendation recommendation : recommendations) {
+			if(recommendation.getIdCluster()==cluster.getId()){
+				nChanges++;
+			}
+		}
+		double [] changesIndividual=getNChanges(nChanges);
+		int n=0;
+		try {
+			ClusterFPR postCluster = (ClusterFPR) cluster.clone();
+			// Random random = new Random();//añadido
+			for (Recommendation recommendation : recommendations) {
+				int m=0;
+				if (cluster.getId() == recommendation.getIdCluster()) {
+					int idAlt1 = recommendation.getIdAlternative1();
+					int idAlt2 = recommendation.getIdAlternative2();
+					int idExpert = recommendation.getIdExpert();
+					if (idExpert != -1) {// change expert' preference
+						if(changesIndividual[n]!=0){
+							change=changesIndividual[n];
+							float value = (float) ((FPR) cluster.getPreferencesExpert(idExpert)).getValue(idAlt1 - 1, idAlt2 - 1);
+							if (recommendation.getDirection() == EChangeType.Increase) {
+								value += change;
+								if (value > 1){
+									value = 1f;
+								}else if(value < 0){
+									value=0f;
+								}
+							} else {
+								if (recommendation.getDirection() == EChangeType.Decrease) {
+									value -= change;
+									if (value < 0){
+										value = 0f;
+									}else if(value > 1){
+										value=1f;
+									}
+								}
+							}
+							((FPR) postCluster.getPreferencesExpert(idExpert)).setValueSymmetrically(idAlt1 - 1, idAlt2 - 1, value);
+							((FPR) preferences[idExpert]).setValueSymmetrically(idAlt1 - 1, idAlt2 - 1, value);
+						}
+						n++;
+					} else {// change preferences for all experts
+						
+						double [] changes=getNChanges(cluster.getExperts().size());
+						for (Integer expert : cluster.getExperts()) {
+							if(changes[m]!=0){
+								change=changes[m];
+								float value = (float) ((FPR) cluster.getPreferencesExpert(expert)).getValue(idAlt1 - 1, idAlt2 - 1);
+								if (recommendation.getDirection() == EChangeType.Increase) {
+									value += change;
+									if (value > 1){
+										value = 1f;
+									}else if(value < 0){
+										value=0f;
+									}
+										
+								} else {
+									if (recommendation.getDirection() == EChangeType.Decrease) {
+										value -= change;
+										if (value < 0){
+											value = 0f;
+										}else if(value > 1){
+											value=1f;
+										}
+											
+									}
+								}
+
+								((FPR) postCluster.getPreferencesExpert(expert)).setValueSymmetrically(idAlt1 - 1, idAlt2 - 1,value);
+								((FPR) preferences[expert]).setValueSymmetrically(idAlt1 - 1, idAlt2 - 1, value);
+							}
+							m++;
+						} // END-FOR
+						
+					}
+				}
+			} // END-FOR
+			return postCluster;
+		} catch (Exception e) {
+			throw new IllegalArgumentException(e.getMessage());
+		}
+	}
+
+	private List<HPR> cloneHesitantPreferenceRelations(List<HPR> input) throws CloneNotSupportedException {
+		List<HPR> hesitantPreferenceRelations = new LinkedList<HPR>();
+		for (HPR hpr : input) {
+			hesitantPreferenceRelations.add((HPR) hpr.clone());
+		}
+		return hesitantPreferenceRelations;
+	}
+}

plugins/afryca.consensusmodel.rodriguez2018/target/MANIFEST.MF

@@ -0,0 +1,9 @@
+Manifest-Version: 1.0
+Bundle-ManifestVersion: 2
+Bundle-Name: %Bundle-Name
+Bundle-SymbolicName: afryca.consensusmodel.rodriguez2018;singleton:=true
+Bundle-Version: 1.0.0.202101221157
+Bundle-RequiredExecutionEnvironment: JavaSE-1.8
+Require-Bundle: afryca.consensusmodel,afryca.fpr,afryca.hpr
+Automatic-Module-Name: afryca.consensusmodel.rodriguez2017
+

plugins/afryca.consensusmodel.rodriguez2018/target/local-artifacts.properties

@@ -0,0 +1,4 @@
+#Fri Jan 22 13:01:39 CET 2021
+artifact.main=C\:\\Users\\\u00C1lvaro\\Workspaces\\afryca_2020\\afryca\\plugins\\afryca.consensusmodel.rodriguez2018\\target\\afryca.consensusmodel.rodriguez2018-1.0.0-SNAPSHOT.jar
+artifact.attached.p2artifacts=C\:\\Users\\\u00C1lvaro\\Workspaces\\afryca_2020\\afryca\\plugins\\afryca.consensusmodel.rodriguez2018\\target\\p2artifacts.xml
+artifact.attached.p2metadata=C\:\\Users\\\u00C1lvaro\\Workspaces\\afryca_2020\\afryca\\plugins\\afryca.consensusmodel.rodriguez2018\\target\\p2content.xml

plugins/afryca.consensusmodel.rodriguez2018/target/maven-archiver/pom.properties

@@ -0,0 +1,3 @@
+artifactId=afryca.consensusmodel.rodriguez2018
+groupId=afryca.group
+version=1.0.0-SNAPSHOT

plugins/afryca.consensusmodel.rodriguez2018/target/p2artifacts.xml

@@ -0,0 +1,13 @@
+<?xml version='1.0' encoding='UTF-8'?>
+<?artifactRepository version='1.1.0'?>
+<artifacts size='1'>
+  <artifact classifier='osgi.bundle' id='afryca.consensusmodel.rodriguez2018' version='1.0.0.202101221157'>
+    <properties size='5'>
+      <property name='artifact.size' value='17915'/>
+      <property name='download.size' value='17915'/>
+      <property name='maven-groupId' value='afryca.group'/>
+      <property name='maven-artifactId' value='afryca.consensusmodel.rodriguez2018'/>
+      <property name='maven-version' value='1.0.0-SNAPSHOT'/>
+    </properties>
+  </artifact>
+</artifacts>

plugins/afryca.consensusmodel.rodriguez2018/target/p2content.xml

@@ -0,0 +1,47 @@
+<?xml version='1.0' encoding='UTF-8'?>
+<units size='1'>
+  <unit id='afryca.consensusmodel.rodriguez2018' version='1.0.0.202101221157' generation='2'>
+    <update id='afryca.consensusmodel.rodriguez2018' range='[0.0.0,1.0.0.202101221157)' severity='0'/>
+    <properties size='6'>
+      <property name='es.Bundle-Name' value='Rodriguez2017'/>
+      <property name='df_LT.Bundle-Name' value='Rodriguez2017'/>
+      <property name='org.eclipse.equinox.p2.name' value='%Bundle-Name'/>
+      <property name='maven-groupId' value='afryca.group'/>
+      <property name='maven-artifactId' value='afryca.consensusmodel.rodriguez2018'/>
+      <property name='maven-version' value='1.0.0-SNAPSHOT'/>
+    </properties>
+    <provides size='6'>
+      <provided namespace='org.eclipse.equinox.p2.iu' name='afryca.consensusmodel.rodriguez2018' version='1.0.0.202101221157'/>
+      <provided namespace='osgi.bundle' name='afryca.consensusmodel.rodriguez2018' version='1.0.0.202101221157'/>
+      <provided namespace='osgi.identity' name='afryca.consensusmodel.rodriguez2018' version='1.0.0.202101221157'>
+        <properties size='1'>
+          <property name='type' value='osgi.bundle'/>
+        </properties>
+      </provided>
+      <provided namespace='org.eclipse.equinox.p2.eclipse.type' name='bundle' version='1.0.0'/>
+      <provided namespace='org.eclipse.equinox.p2.localization' name='es' version='1.0.0'/>
+      <provided namespace='org.eclipse.equinox.p2.localization' name='df_LT' version='1.0.0'/>
+    </provides>
+    <requires size='4'>
+      <required namespace='osgi.bundle' name='afryca.consensusmodel' range='0.0.0'/>
+      <required namespace='osgi.bundle' name='afryca.fpr' range='0.0.0'/>
+      <required namespace='osgi.bundle' name='afryca.hpr' range='0.0.0'/>
+      <requiredProperties namespace='osgi.ee' match='(&amp;(osgi.ee=JavaSE)(version=1.8))'>
+        <description>
+          afryca.consensusmodel.rodriguez2018
+        </description>
+      </requiredProperties>
+    </requires>
+    <artifacts size='1'>
+      <artifact classifier='osgi.bundle' id='afryca.consensusmodel.rodriguez2018' version='1.0.0.202101221157'/>
+    </artifacts>
+    <touchpoint id='org.eclipse.equinox.p2.osgi' version='1.0.0'/>
+    <touchpointData size='1'>
+      <instructions size='1'>
+        <instruction key='manifest'>
+          Bundle-SymbolicName: afryca.consensusmodel.rodriguez2018;singleton:=true&#xA;Bundle-Version: 1.0.0.202101221157&#xA;
+        </instruction>
+      </instructions>
+    </touchpointData>
+  </unit>
+</units>