public code v1

plugins/afryca.consensusmodel.labella2019/.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.labella2019/.gitignore

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

plugins/afryca.consensusmodel.labella2019/.project

@@ -0,0 +1,34 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<projectDescription>
+	<name>afryca.consensusmodel.labella2019</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.labella2019/.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.labella2019/.settings/org.eclipse.m2e.core.prefs

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

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

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

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

@@ -0,0 +1,12 @@
+#Properties file for afryca.consensusmodel.labella2019
+Bundle-Vendor = Sinbad2
+Bundle-Name = Labella2019
+
+afryca.consensusmodel.labella2019.name = A. Labella et al. (2019)
+afryca.consensusmodel.labella2019.information = Paper: Not yet
+afryca.consensusmodel.labella2019.features = Hesitant fuzzy linguistic information\\nHesitant fuzzy linguistic preference relations\\nFeedback mechanism\\nLarge-scale\\nFuzzy clustering
+afryca.consensusmodel.labella2019.observations = \u0020
+afryca.consensusmodel.labella2019.h_max.description = Maximum number of discussion rounds allowed
+afryca.consensusmodel.labella2019.delta.description=Consensus threshold for the advice generation
+afryca.consensusmodel.labella2019.mu.description = Consensus threshold
+afryca.consensusmodel.labella2019.epsilon.description = Acceptability threshold

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

@@ -0,0 +1,12 @@
+#Properties file for afryca.consensusmodel.labella2019
+Bundle-Vendor = Sinbad2
+Bundle-Name = Labella2019
+
+afryca.consensusmodel.Labella2019.name = A. Labella et al. (2019)
+afryca.consensusmodel.Labella2019.information = Paper: Próximamente...
+afryca.consensusmodel.Labella2019.features = Información lingüística difusa dudosa\\nRelaciones de preferencia lingüísticas difusas dudosas\\nMecanismo de feedback\\nGran escala\\Clustering difuso
+afryca.consensusmodel.Labella2019.observations = \u0020
+afryca.consensusmodel.Labella2019.h_max.description = Máximo número de rondas de discusión permitidas
+afryca.consensusmodel.labella2019.delta.description=Umbral de consenso para la generación de recomendaciones
+afryca.consensusmodel.Labella2019.mu.description = Umbral de consenso
+afryca.consensusmodel.Labella2019.epsilon.description = Umbral de aceptabilidad

plugins/afryca.consensusmodel.labella2019/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.labella2019/plugin.xml

@@ -0,0 +1,51 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<?eclipse version="3.4"?>
+<plugin>
+   <extension
+         point="afryca.consensusmodel">
+      <ConsensusModel
+            ConsensusModel="afryca.consensusmodel.labella2019.Labella2019"
+            Information="%afryca.consensusmodel.labella2019.information"
+            MainFeatures="%afryca.consensusmodel.labella2019.features"
+            Multicriteria="false"
+            Name="%afryca.consensusmodel.labella2019.name"
+            Observations="%afryca.consensusmodel.labella2019.observations"
+            Structure="afryca.hlpr"
+            WithFeedback="true"
+            id="Labella2019">
+         <Variable
+               default_value="0.05"
+               description="%afryca.consensusmodel.labella2019.epsilon.description"
+               id="epsilon"
+               is_array="false"
+               is_internal="false"
+               type="Float">
+         </Variable>
+         <Variable
+               default_value="0.85"
+               description="%afryca.consensusmodel.labella2019.mu.description"
+               id="mu"
+               is_array="false"
+               is_internal="false"
+               type="Float">
+         </Variable>
+         <Variable
+               default_value="0.7"
+               description="%afryca.consensusmodel.labella2019.delta.description"
+               id="delta"
+               is_array="false"
+               is_internal="false"
+               type="Float">
+         </Variable>
+         <Variable
+               default_value="15"
+               description="%afryca.consensusmodel.labella2019.h_max.description"
+               id="h_max"
+               is_array="false"
+               is_internal="false"
+               type="Integer">
+         </Variable>
+      </ConsensusModel>
+   </extension>
+
+</plugin>

plugins/afryca.consensusmodel.labella2019/src/afryca/consensusmodel/labella2019/Labella2019.java

@@ -0,0 +1,655 @@
+package afryca.consensusmodel.labella2019;
+
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.HashMap;
+import java.util.LinkedHashMap;
+import java.util.LinkedList;
+import java.util.List;
+import java.util.Map;
+
+import afryca.cm.CM;
+import afryca.consensusmodel.ConsensusEngine;
+import afryca.consensusmodel.ConsensusModel;
+import afryca.consensusmodel.EChangeType;
+import afryca.consensusmodel.cluster.ClusterHLPR;
+import afryca.consensusmodel.clustering.FuzzyCMeansHLPR;
+import afryca.consensusmodel.definition.EResultElements;
+import afryca.consensusmodel.definition.ERoundResult;
+import afryca.domain.fuzzyset.FuzzySet;
+import afryca.domain.fuzzyset.function.types.TrapezoidalFunction;
+import afryca.domain.fuzzyset.labelset.LabelSet;
+import afryca.hlpr.HLPR;
+import afryca.hlpr.valuation.EUnaryRelationType;
+import afryca.hlpr.valuation.HesitantLinguisticValuation;
+import afryca.structure.Structure;
+import afryca.structure.pair.Pair;
+
+public class Labella2019 extends ConsensusModel {
+
+	private static final String CONSENSUS_MODEL_NAME = "Labella et al. (2019)"; //$NON-NLS-1$
+	
+	private static final int CHANGE_DEGREE = 3;
+	
+	private static final String MU = "mu"; //$NON-NLS-1$
+	private static final String DELTA = "delta"; //$NON-NLS-1$
+	private static final String MAX_ROUNDS = "h_max"; //$NON-NLS-1$
+	private static final String EPSILON = "epsilon"; //$NON-NLS-1$
+	
+	private ArrayList<TrapezoidalFunction[][]> trapezoidalPreferences;
+	private ArrayList<Float[][]> proximityMatrices;
+	private Map<Pair<Integer, Integer>, Float[][]> similarityMatrices;
+	
+	private HLPR[] preferencesWithoutCollective;
+	private Structure[] preferencesAux;
+	
+	private List<ClusterHLPR> postClusters;
+	
+	private CM cm;
+	private Float[] consensusAlternatives;
+	private TrapezoidalFunction[][] collective;
+	private int[] advises;
+	private int numberOfChanges;
+	
+	private Integer h_max;
+	private Integer round;
+	private Float cr;
+	private Float delta;
+	private Float mu;
+	private Float epsilon;
+	
+	@Override
+	protected void setModelConfiguration() {}
+
+	@Override
+	protected void obtainConfigurationValues() {
+		mu = (Float) configuration.getValue(MU);
+		delta = (Float) configuration.getValue(DELTA);
+		h_max = (Integer) configuration.getValue(MAX_ROUNDS);
+		epsilon = (Float) configuration.getValue(EPSILON);
+		
+		preferencesWithoutCollective = new HLPR[preferences.length - 1];
+		preferencesAux = clonePreferencesUnion(preferences, preferences[0].groupPreferences(numberOfExperts, numberOfAlternatives, numberOfCriteria,
+						Arrays.copyOfRange(preferences, 0, preferences.length - 1)));
+		
+		postClusters = new LinkedList<ClusterHLPR>();
+		
+		round = 0;
+		numberOfChanges = 0;
+		advises = null;
+		
+		computePreferencesWithoutCollective();
+		initializeAdvises();
+	}
+
+	/**
+	 * Initialize preferences without collective opinion
+	 */
+	private void computePreferencesWithoutCollective() {
+		// Copy preferences except collective
+		for (int i = 0; i < preferences.length - 1; i++) {
+			try {
+				preferencesWithoutCollective[i] = (HLPR) preferencesAux[i].clone();
+			} catch (CloneNotSupportedException e) {
+				e.printStackTrace();
+			}
+		}
+	}
+	
+	/**
+	 * Initialize advises array
+	 */
+	private void initializeAdvises() {
+		advises = new int[experts.length];
+		for (int i = 0; i < advises.length; i++) {
+			advises[i] = 0;
+		}
+	}
+	
+	@Override
+	protected void preFirstSaveRoundResults() {	
+		Structure[] auxPreferences = clonePreferencesUnion(preferencesAux,
+				preferencesAux[0].groupPreferences(numberOfExperts, numberOfAlternatives, numberOfCriteria,
+						Arrays.copyOfRange(preferencesAux, 0, preferencesAux.length - 1)));
+
+		postClusters = generateClusters(alternatives, experts, preferencesWithoutCollective, 1);
+		
+		computeConsensusDegree();
+		
+		preSaveRoundResult(1, auxPreferences, obtainVisualizeValues(), cr);
+		
+		roundsResults.get(roundsResults.size() - 1).put(ERoundResult.clusters, postClusters);
+		
+		result.put(EResultElements.initial_consensus_degree, cr);
+		result.put(EResultElements.maxround, h_max);
+		result.put(EResultElements.consensus_threshold, mu);
+		result.put(EResultElements.consensus_model, CONSENSUS_MODEL_NAME);
+	}
+	
+	@SuppressWarnings("unchecked")
+	public List<ClusterHLPR> generateClusters(String[] alternatives, String[] experts, HLPR[] preferences, float parameter) {
+		return (roundsResults.isEmpty() 
+				? FuzzyCMeansHLPR.doClusteringFuzzyCMeansClusterForEachAlternative(alternatives, experts, preferences, null, parameter) 
+				: FuzzyCMeansHLPR.doClusteringFuzzyCMeansClusterForEachAlternative(alternatives, experts, preferences, 
+					(List<ClusterHLPR>) roundsResults.get(roundsResults.size() - 1).get(ERoundResult.clusters), parameter));
+	}
+	
+	private void computeConsensusDegree() {
+		transformValuationIntroTrapezoidalFuctions();
+		computeSimilarityMatrices();
+		computeConsensusMatrix();
+		computeConsensusAlternatives();
+		computeOverallConsensusDegree();
+		computeCollective();
+	}
+
+	private void transformValuationIntroTrapezoidalFuctions() {
+		Structure[] auxPreferences = Arrays.copyOfRange(preferencesAux, 0, preferencesAux.length - 1);
+
+		trapezoidalPreferences = new ArrayList<>();
+
+		TrapezoidalFunction[][] trapezoidalMatrix;
+		for (Structure hlpr : auxPreferences) {
+			trapezoidalMatrix = new TrapezoidalFunction[numberOfAlternatives][numberOfAlternatives];
+			for (int i = 0; i < numberOfAlternatives; ++i) {
+				for (int j = 0; j < numberOfAlternatives; ++j) {
+					trapezoidalMatrix[i][j] = ConsensusEngine.calculateFuzzyEnvelope((FuzzySet) hlpr.getDomain(),
+							(HesitantLinguisticValuation) hlpr.getValue(i, j));
+				}
+			}
+			trapezoidalPreferences.add(trapezoidalMatrix);
+		}
+	}
+	
+	private void computeSimilarityMatrices() {
+		similarityMatrices = new LinkedHashMap<>();
+
+		Float similarityValue;
+		for (int i = 0; i < numberOfExperts - 1; ++i) {
+			Float[][] similarityMatrix = new Float[numberOfAlternatives][numberOfAlternatives];
+			for (int t = i + 1; t < numberOfExperts; ++t) {
+				Pair<Integer, Integer> pairExperts = new Pair<Integer, Integer>(i, t);
+				for (int l = 0; l < numberOfAlternatives - 1; ++l) {
+					for (int k = l + 1; k < numberOfAlternatives; ++k) {
+						similarityValue = computeSimilarity(trapezoidalPreferences.get(i)[l][k], trapezoidalPreferences.get(t)[l][k]);
+						similarityMatrix[l][k] = similarityValue;
+						similarityMatrix[k][l] = similarityValue;
+					}
+				}
+				similarityMatrices.put(pairExperts, similarityMatrix);
+			}
+		}
+	}
+	
+	private Float computeSimilarity(TrapezoidalFunction trp1, TrapezoidalFunction trp2) {
+		return (float) (1f - trp1.distance(trp2, 1));
+	}
+	
+	private void computeConsensusMatrix() {
+		List<Float> sim = new LinkedList<Float>();
+
+		cm = new CM(numberOfAlternatives);
+		for (int l = 0; l < numberOfAlternatives; ++l) {
+			for (int k = 0; k < numberOfAlternatives; ++k) {
+				sim.clear();
+				if(l != k) {
+					for (Pair<Integer, Integer> pairExperts : similarityMatrices.keySet())
+						sim.add(similarityMatrices.get(pairExperts)[l][k]);
+					cm.setValue(l, k, aggregateSIMValues(sim));
+				} else {
+					cm.setValue(l, k, 1f);
+				}
+			}
+		}		
+	}
+	
+	private Float aggregateSIMValues(List<Float> sim) {
+		Float arithmeticMean = 0f;
+		for (Float simValue : sim)
+			arithmeticMean += simValue;
+		
+		return arithmeticMean / sim.size();
+	}
+	
+	private void computeConsensusAlternatives() {
+		consensusAlternatives = ConsensusEngine.computeAlternativesConsensus(numberOfAlternatives, cm);
+	}
+
+	private void computeOverallConsensusDegree() {
+		cr = Math.round(ConsensusEngine.consensusBasedOnAlternativesConsensus(numberOfAlternatives, consensusAlternatives) * 10000f) / 10000f;
+	}
+	
+	private void computeCollective() {
+		preferencesAux[preferencesAux.length - 1] = preferencesAux[0].groupPreferences(numberOfExperts, numberOfAlternatives, numberOfCriteria,
+				Arrays.copyOfRange(preferencesAux, 0, preferencesAux.length - 1));
+	}
+
+	@Override
+	protected void preSaveRoundResults() {
+		preSaveRoundResult(round + 1, preferencesAux, obtainVisualizeValues(), cr);
+		roundsResults.get(roundsResults.size() - 1).put(ERoundResult.clusters, postClusters);
+	}
+	
+	@Override
+	protected void consensusRound() {
+		advises = null;
+		
+		computeConsensusDegree();
+		computeTrapezoidalCollective();
+		
+		if(cr < mu) {
+			
+			if (cr < delta) {
+				groupAdviceGeneration();
+			} else {
+				individualAdviceGeneration();
+			}
+			
+			computePreferencesWithoutCollective();
+			postClusters = generateClusters(alternatives, experts, preferencesWithoutCollective, 1f);
+			round++;
+		}	
+	}
+
+	private void computeTrapezoidalCollective() {
+		collective = new TrapezoidalFunction[numberOfAlternatives][numberOfAlternatives];
+		
+		for(int l = 0; l < numberOfAlternatives; ++l) {
+			for(int k = 0; k < numberOfAlternatives; ++k) {
+				if(l != k) {
+					collective[l][k] = new TrapezoidalFunction(new double[] {0d, 0d, 0d, 0d});
+					for (ClusterHLPR cluster : postClusters) {
+						TrapezoidalFunction envelope = ((TrapezoidalFunction[][]) cluster.getCentroid())[l][k];
+						collective[l][k] = collective[l][k].addition(envelope);
+					}
+					collective[l][k] = collective[l][k].divisionScalar(postClusters.size());
+				} else {
+					LabelSet labels = ((ClusterHLPR) postClusters.get(0)).getDomain().getLabelSet();
+					collective[l][k] = (TrapezoidalFunction) labels.getLabel((labels.getCardinality() + 1) / 2).getSemantic();
+				}
+			}
+		}
+	}
+	
+	private void groupAdviceGeneration() {
+		computeProximityMatrices();
+		computeGroupChanges();
+	}
+	
+	private void individualAdviceGeneration() {
+		computeProximityMatrices();
+		computeIndividualChanges();
+	}
+	
+	private void computeProximityMatrices() {
+		proximityMatrices = new ArrayList<>();
+		
+		Float[][] proximityMatrix;
+		for (int i = 0; i < postClusters.size(); ++i) {
+			proximityMatrix = new Float[numberOfAlternatives][numberOfAlternatives];
+			for (int l = 0; l < numberOfAlternatives; ++l) {
+				for (int k = 0; k < numberOfAlternatives; ++k)
+					proximityMatrix[l][k] = computeSimilarity(((TrapezoidalFunction[][]) postClusters.get(i).getCentroid())[l][k], collective[l][k]);
+			}
+			
+			proximityMatrices.add(proximityMatrix);
+		}
+	}
+	
+	private void computeGroupChanges() {
+		Map<Integer, List<Pair<Integer, Integer>>> groupsToChange = identifyChangesToDoByGroup();
+		
+		EChangeType[][][] changesDirection = computeGroupChangesDirection(groupsToChange);
+		makeChanges(changesDirection);
+		
+		computeNumberOfAdvises(changesDirection);
+	}
+	
+	private Map<Integer, List<Pair<Integer, Integer>>> identifyChangesToDoByGroup() {
+		Map<Integer, List<Pair<Integer, Integer>>> changes = new HashMap<>();
+		
+		List<Integer> alternativesToChange = identifyAlternativesToChange();
+		Float[][] overallProximityMatrix = computeOverallProximityValues();
+		
+		for(ClusterHLPR cluster: postClusters) {
+			for(int alt:  alternativesToChange) {
+				for(int j = 0 ; j < numberOfAlternatives; ++j) {
+					if(j > alt) {
+						if(proximityMatrices.get(cluster.getId())[alt][j] < overallProximityMatrix[alt][j]) {
+							
+							Pair<Integer, Integer> pair = new Pair<Integer, Integer>(alt, j);
+							
+							if(changes.get(cluster.getId()) == null) {
+								List<Pair<Integer, Integer>> pairsAlternatives = new LinkedList<>();
+								pairsAlternatives.add(pair);
+								changes.put(cluster.getId(), pairsAlternatives);
+							} else {
+								List<Pair<Integer, Integer>> pairsAlternatives = changes.get(cluster.getId());
+								pairsAlternatives.add(pair);
+							}
+						}
+					}
+				}
+			}
+		}
+		
+		return changes;	
+	}
+	
+	private List<Integer> identifyAlternativesToChange() {
+		List<Integer> alternativesToChange = new LinkedList<>();
+		
+		for (int l = 0; l < numberOfAlternatives; ++l) {
+			Float consensusAlternative = consensusAlternatives[l];
+			if (consensusAlternative < mu)
+				alternativesToChange.add(l);
+		}
+		
+		return alternativesToChange;
+	}
+	
+	private Float[][] computeOverallProximityValues() {
+		Float[][] overallProximityMatrix = new Float[numberOfAlternatives][numberOfAlternatives];
+		
+		Float[][] proximityMatrix;
+		float acum;
+		for(int l = 0; l < numberOfAlternatives; ++l) {
+			for(int j = 0; j < numberOfAlternatives; ++j) {
+				acum = 0;
+				for(int u = 0; u < postClusters.size(); ++u) {
+					proximityMatrix = proximityMatrices.get(u);
+					acum += proximityMatrix[l][j];
+				}
+				overallProximityMatrix[l][j] = acum / postClusters.size();
+			}
+		}
+		
+		return overallProximityMatrix;
+	}
+	
+	private EChangeType[][][] computeGroupChangesDirection(Map<Integer, List<Pair<Integer, Integer>>> groupsToChange) {
+		int a1, a2;
+	
+		Float difference;
+
+		EChangeType[][][] result = initializeChanges();
+		
+		for (Integer group : groupsToChange.keySet()) {
+			List<Pair<Integer, Integer>> pairAlternativesToChange = groupsToChange.get(group);
+			for(Pair<Integer, Integer> pairAlternatives: pairAlternativesToChange) {
+				a1 = pairAlternatives.getLeft();
+				a2 = pairAlternatives.getRight();
+				difference = (float) (((TrapezoidalFunction[][]) postClusters.get(group).getCentroid())[a1][a2].getSimpleDefuzzifiedValue() - collective[a1][a2].getSimpleDefuzzifiedValue());
+				if (difference < (-epsilon)) {
+					for(Integer exp: postClusters.get(group).getExperts()) {
+						result[exp][a1][a2] = EChangeType.Increase;
+						numberOfChanges++;
+					}
+				} else if (difference > epsilon) {
+					for(Integer exp: postClusters.get(group).getExperts()) {
+						result[exp][a1][a2] = EChangeType.Decrease;
+						numberOfChanges++;
+					}
+				}
+			}
+		}
+		
+		return result;
+	}
+
+	private EChangeType[][][] initializeChanges() {
+		EChangeType[][][] result = new EChangeType[numberOfExperts][numberOfAlternatives][numberOfAlternatives];
+		for (int i = 0; i < numberOfExperts; i++) {
+			for (int l = 0; l < numberOfAlternatives; l++) {
+				for (int k = 0; k < numberOfAlternatives; k++) {
+					result[i][l][k] = EChangeType.NotChange;
+				}
+			}
+		}
+		numberOfChanges = 0;
+
+		return result;
+	}
+	
+	private void makeChanges(EChangeType[][][] changes) {
+		HesitantLinguisticValuation value;
+		EChangeType change;
+		
+		double[] changesToMake = getNChanges(numberOfChanges);
+
+		int currentChange = 0;
+
+		float ch;
+		for (int i = 0; i < numberOfExperts; i++) {
+			for (int l = 0; l < numberOfAlternatives; l++) {
+				for (int k = 0; k < numberOfAlternatives; k++) {
+					if (l != k) {
+						change = changes[i][l][k];
+						if (change != EChangeType.NotChange) {
+							ch = (float) changesToMake[currentChange++];
+							if (ch != 0f) {
+								value = (HesitantLinguisticValuation) preferencesAux[i].getValue(l, k);
+								if (change == EChangeType.Increase) {
+									value = increaseCase(i, l, k);
+								} else if (change == EChangeType.Decrease) {
+									value = decreaseCase(i, l, k);
+								}
+								((HLPR) preferencesAux[i]).setValueSymmetrically(l, k, value);
+							}
+						}
+					}
+				}
+			}
+		}
+	}
+	
+	private void computeNumberOfAdvises(EChangeType[][][] changesDirection) {
+		advises = new int[numberOfExperts];
+
+		for (int i = 0; i < numberOfExperts; i++) {
+			advises[i] = 0;
+			for (int l = 0; l < numberOfAlternatives; l++) {
+				for (int k = 0; k < numberOfAlternatives; k++) {
+					if (changesDirection[i][l][k] != EChangeType.NotChange) {
+						advises[i] = advises[i] + 1;
+					}
+				}
+			}
+		}
+	}
+
+	private void computeIndividualChanges() {
+		Map<Integer, List<Pair<Integer, Integer>>> changesToDo = identifyChangesToDoByIndividual();
+		
+		EChangeType[][][] changesDirection = computeIndividualChangesDirection(changesToDo);
+		makeChanges(changesDirection);
+
+		computeNumberOfAdvises(changesDirection);
+	}
+	
+	private Map<Integer, List<Pair<Integer, Integer>>> identifyChangesToDoByIndividual() {
+		Float similarity;
+		
+		List<Integer> alternativesToChange = identifyAlternativesToChange();
+		Float[][] overallProximityMatrix = computeOverallProximityValues();
+
+		Map<Integer, List<Pair<Integer, Integer>>> expertsToChange = new HashMap<>();
+		for (ClusterHLPR cluster: postClusters) {
+			for (Integer exp : cluster.getExperts()) {
+				for (int alt: alternativesToChange) {
+					for(int j = 0; j < numberOfAlternatives; ++j) {
+						if(alt > j) {
+							similarity = computeSimilarity(collective[alt][j], trapezoidalPreferences.get(exp)[alt][j]);
+							if (similarity <= overallProximityMatrix[alt][j]) {
+								if (expertsToChange.get(exp) == null) {
+									List<Pair<Integer, Integer>> pairAlternativesToChangeByGroup = new LinkedList<>();
+									pairAlternativesToChangeByGroup.add(new Pair<Integer, Integer>(alt, j));
+									expertsToChange.put(exp, pairAlternativesToChangeByGroup);
+								} else {
+									expertsToChange.get(exp).add(new Pair<Integer, Integer>(alt, j));
+								}
+							}
+						}
+					}
+				}
+			}
+		}
+
+		return expertsToChange;
+	}
+	
+	private EChangeType[][][] computeIndividualChangesDirection(Map<Integer, List<Pair<Integer, Integer>>> expertsToChange) {
+		EChangeType[][][] result = initializeIndividualChanges();
+
+		Float difference;
+		for (Integer i:  expertsToChange.keySet()) {
+			List<Pair<Integer, Integer>> pairAlternativesToChange = expertsToChange.get(i);
+			for (int l = 0; l < numberOfAlternatives; l++) {
+				for (int k = 0; k < numberOfAlternatives; k++) {
+					if(l != k) {
+						Pair<Integer, Integer> pairAlternatives = new Pair<Integer, Integer>(l, k);
+						if (pairAlternativesToChange.contains(pairAlternatives)) {
+							difference = (float) ((float) trapezoidalPreferences.get(i)[l][k].getSimpleDefuzzifiedValue() - collective[l][k].getSimpleDefuzzifiedValue());
+							if (difference < (-epsilon)) {
+								result[i][l][k] = EChangeType.Increase;
+								numberOfChanges++;
+							} else if (difference > epsilon) {
+								result[i][l][k] = EChangeType.Decrease;
+								numberOfChanges++;
+							} else if((-epsilon) <= difference && difference <= epsilon) {
+								result[i][l][k] = EChangeType.NotChange;
+							}
+						}
+					}
+				}
+			}
+		}
+
+		return result;
+	}
+	
+	private EChangeType[][][] initializeIndividualChanges() {
+		EChangeType[][][] result = new EChangeType[numberOfExperts][numberOfAlternatives][numberOfAlternatives];
+		for (int i = 0; i < numberOfExperts; i++) {
+			for (int l = 0; l < numberOfAlternatives; l++) {
+				for (int k = 0; k < numberOfAlternatives; k++) {
+					result[i][l][k] = EChangeType.NotChange;
+				}
+			}
+		}
+		numberOfChanges = 0;
+		
+		return result;
+	}
+	
+	private HesitantLinguisticValuation increaseCase(int i, int l, int k) {
+		HesitantLinguisticValuation hlv = (HesitantLinguisticValuation) preferencesAux[i].getValue(l, k);
+		FuzzySet fuzzySet = (FuzzySet) hlv.getDomain();
+		
+		if (hlv.isPrimary()) {
+			
+			int posLabel = fuzzySet.getLabelSet().getPos(hlv.getLabel());
+			if(posLabel + CHANGE_DEGREE < fuzzySet.getLabelSet().getCardinality() - 1)
+				hlv.setLabel(posLabel + CHANGE_DEGREE);
+		
+		} else if (hlv.isUnary()) {
+			
+			int posTerm = fuzzySet.getLabelSet().getPos(hlv.getTerm()), cardinality = fuzzySet.getLabelSet().getCardinality();
+			
+			if(posTerm + CHANGE_DEGREE < fuzzySet.getLabelSet().getCardinality() - 1) {//Is it possible the change?
+				
+				if((hlv.getUnaryRelation().equals(EUnaryRelationType.AtMost) || hlv.getUnaryRelation().equals(EUnaryRelationType.LowerThan))
+						&& (posTerm + CHANGE_DEGREE > (cardinality + 1) / 2)) {//Too many labels in the unary expression
+					
+					hlv.setLabel(posTerm + CHANGE_DEGREE);
+				
+				} else if((posTerm + CHANGE_DEGREE == cardinality - 1) && (hlv.getUnaryRelation().equals(EUnaryRelationType.GreaterThan)))
+						
+					hlv.setLabel(cardinality - 1);
+				else
+					hlv.setUnaryRelation(hlv.getUnaryRelation(), posTerm + CHANGE_DEGREE);
+			}
+			
+		} else {
+			
+			int posTerm1 = fuzzySet.getLabelSet().getPos(hlv.getLowerTerm());
+			int posTerm2 = fuzzySet.getLabelSet().getPos(hlv.getUpperTerm());
+			if (posTerm1 + CHANGE_DEGREE == posTerm2) 
+				hlv.setLabel(posTerm2);
+			else if (posTerm1 + CHANGE_DEGREE < posTerm2)
+				hlv.setBinaryRelation(posTerm1 + CHANGE_DEGREE, posTerm2);
+		}
+		
+		return hlv;
+	}
+
+	private HesitantLinguisticValuation decreaseCase(int i, int l, int k) {
+		HesitantLinguisticValuation hlv = (HesitantLinguisticValuation) preferencesAux[i].getValue(l, k);
+		FuzzySet fuzzySet = (FuzzySet) hlv.getDomain();
+		
+		if (hlv.isPrimary()) {
+			
+			int posLabel = fuzzySet.getLabelSet().getPos(hlv.getLabel());
+			if(posLabel - CHANGE_DEGREE >= 0)
+				hlv.setLabel(posLabel - CHANGE_DEGREE);
+			
+		} else if (hlv.isUnary()) {
+			
+			int posTerm = fuzzySet.getLabelSet().getPos(hlv.getTerm()), cardinality = fuzzySet.getLabelSet().getCardinality();
+			if(posTerm - CHANGE_DEGREE >= 0)
+				if((hlv.getUnaryRelation().equals(EUnaryRelationType.AtLeast) || hlv.getUnaryRelation().equals(EUnaryRelationType.GreaterThan))
+						&& (posTerm - CHANGE_DEGREE < ((cardinality + 1) / 2) - 1)) {//To many labels in the unary expression
+					
+					hlv.setLabel(posTerm - CHANGE_DEGREE);
+				
+				} else if((posTerm - CHANGE_DEGREE == 0) && (hlv.getUnaryRelation().equals(EUnaryRelationType.LowerThan)))
+						
+					hlv.setLabel(0);
+				else
+					hlv.setUnaryRelation(hlv.getUnaryRelation(), posTerm - CHANGE_DEGREE);
+		} else {
+			
+			int posTerm1 = fuzzySet.getLabelSet().getPos(hlv.getLowerTerm());
+			int posTerm2 = fuzzySet.getLabelSet().getPos(hlv.getUpperTerm());
+
+			if (posTerm2 - CHANGE_DEGREE == posTerm1)
+				hlv.setLabel(posTerm1);
+			else if(posTerm2 - CHANGE_DEGREE >= posTerm1)
+				hlv.setBinaryRelation(posTerm1, posTerm2 - CHANGE_DEGREE);
+		}
+		
+		return hlv;
+	}
+		
+	@Override
+	protected void posSaveRoundResults() {
+		computeConsensusDegree();
+		posSaveRoundResult(preferencesAux, obtainVisualizeValues(), cr, advises, preferencesAux[preferencesAux.length - 1]);
+	}
+
+	@Override
+	protected boolean mustBeCarriedOutAnotherRound() {
+		return (cr < mu) && (round < h_max);
+	}
+	
+	@Override
+	protected Float[][][] obtainVisualizeValues() {
+		Structure[] auxPreferences = clonePreferencesUnion(preferencesAux, preferencesAux[0].groupPreferences(numberOfExperts, numberOfAlternatives, numberOfCriteria,
+						Arrays.copyOfRange(preferencesAux, 0, preferencesAux.length - 1)));
+		
+		Float[][][] preferencesGroupVisualization = new Float[numberOfExperts + 1][numberOfAlternatives][numberOfAlternatives];
+
+		for (int i = 0; i < numberOfExperts + 1; i++)
+			preferencesGroupVisualization[i] = auxPreferences[i].obtainVisualizeValues();
+
+		return preferencesGroupVisualization;
+	}
+
+	@Override
+	protected void saveExecutionResults() {
+		this.configuration.setValue(PREFERENCES, preferencesAux);
+		result.put(EResultElements.number_of_rounds_required, round);
+		result.put(EResultElements.consensus_degree_achieved, cr);
+	}
+	
+}

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

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

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

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

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

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

plugins/afryca.consensusmodel.labella2019/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.labella2019' version='1.0.0.202101221157'>
+    <properties size='5'>
+      <property name='artifact.size' value='13756'/>
+      <property name='download.size' value='13756'/>
+      <property name='maven-groupId' value='afryca.group'/>
+      <property name='maven-artifactId' value='afryca.consensusmodel.labella2019'/>
+      <property name='maven-version' value='1.0.0-SNAPSHOT'/>
+    </properties>
+  </artifact>
+</artifacts>

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

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