public code v1

plugins/afryca.consensusmodel.transrisk2018/src/afryca/consensusmodel/transrisk2018/TRANSRisk2018.java

@@ -0,0 +1,271 @@
+package afryca.consensusmodel.transrisk2018;
+
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.List;
+
+import afryca.ase.RunnableScript;
+import afryca.consensusmodel.ConsensusEngine;
+import afryca.consensusmodel.ConsensusModelMulticriteria;
+import afryca.consensusmodel.definition.EResultElements;
+import afryca.decisionmatrix.DecisionMatrix;
+import afryca.domain.fuzzyset.FuzzySet;
+import afryca.structure.Structure;
+import afryca.consensumodel.addon.E4DIAddon;
+import afryca.twotuple.TwoTuple;
+
+public class TRANSRisk2018 extends ConsensusModelMulticriteria {
+
+	private static final String CONSENSUS_MODEL_NAME = "TRANSrisk et al. (2018)"; //$NON-NLS-1$
+	
+	private static final String EPSILON = "epsilon"; //$NON-NLS-1$ //
+	private static final String ALPHA = "alpha"; //$NON-NLS-1$ //
+	private static final String COST = "cost"; //$NON-NLS-1$ //
+	private static final String WEIGHTS = "weights"; //$NON-NLS-1$ //
+	
+	private Float epsilon;
+	private Float alpha;
+	private Integer[] cost;
+	private Float[] weights;
+	
+	private float consensusDegree;
+	
+	private FuzzySet blts;
+	
+	private DecisionMatrix collective;
+	
+	private ArrayList<Structure> twoTuplePreferencesDM;
+	
+	private Structure[] preferencesArray;
+
+	@Override
+	protected void setModelConfiguration() {
+	}
+
+	@Override
+	protected void obtainConfigurationValues() {
+		epsilon = (Float) configuration.getValue(EPSILON);
+		alpha = (Float) configuration.getValue(ALPHA);
+		cost = (Integer[]) configuration.getValue(COST);
+		weights = (Float[]) configuration.getValue(WEIGHTS);
+		
+		transformValuationToTwoTuple();
+	}
+	
+	@SuppressWarnings("unchecked")
+	private void transformValuationToTwoTuple() {
+		
+		List<Structure> preferencesDM = new ArrayList<Structure>();
+		for(int i = 0; i < numberOfCriteria * numberOfExperts; i++){
+			preferencesDM.add(preferences[i]);
+		}
+	
+		ArrayList<Structure> unifiedValuations = (ArrayList<Structure>) ((RunnableScript) E4DIAddon.aseService.createExecutionBuilder()
+				.setFunction("Unification")
+				.putVariable("preferences", preferencesDM)
+				.putVariable("blts", getBLTS(preferencesDM))
+				.execute())
+				.getResult();
+		
+		twoTuplePreferencesDM = (ArrayList<Structure>) ((RunnableScript) E4DIAddon.aseService.createExecutionBuilder()
+				.setFunction("Disunification")
+				.putVariable("preferences", unifiedValuations)
+				.execute())
+				.getResult();
+	}
+	
+	private FuzzySet getBLTS(List<Structure> preferencesDM ) {
+		FuzzySet result=(FuzzySet) E4DIAddon.aseService
+				.createFragmentBuilder()
+				.putVariable("preferences", preferencesDM.toArray()) //$NON-NLS-1$
+				.setCode("unification.getBLTS(preferences)") //$NON-NLS-1$
+				.setOutputType(FuzzySet.class.getName())
+				.eval()
+				.getResult();
+		return result;
+	}
+
+	@Override
+	protected void preFirstSaveRoundResults() {
+		preSaveRoundResult(1, preferencesArray, obtainVisualizeValues(), consensusDegree);
+
+		result.put(EResultElements.initial_consensus_degree, consensusDegree);
+		result.put(EResultElements.maxround, 1);
+		result.put(EResultElements.consensus_threshold, alpha);
+		result.put(EResultElements.consensus_model, CONSENSUS_MODEL_NAME);
+	}
+
+	@Override
+	protected void preSaveRoundResults() {
+		computeConsensusDegree();
+		preSaveRoundResult(1, preferencesArray, obtainVisualizeValues(), consensusDegree);
+	}
+
+	@Override
+	protected void posSaveRoundResults() {
+		posSaveRoundResult(preferencesArray, obtainVisualizeValues(), consensusDegree, null);
+	}
+
+	@Override
+	protected boolean mustBeCarriedOutAnotherRound() {
+		return false;
+	}
+
+	@Override
+	protected void saveExecutionResults() {
+		this.configuration.setValue(PREFERENCES, preferencesArray);
+		result.put(EResultElements.number_of_rounds_required, 1);
+		result.put(EResultElements.consensus_degree_achieved, consensusDegree);
+	}
+
+	@Override
+	protected void consensusRound() {
+		if(consensusDegree < alpha) {
+			List<Float> minimumCostResults = new ArrayList<Float>();
+			
+			DecisionMatrix[] numericPreferences = convertPreferencesToNumber();
+			
+			Float[] preferencesMinimumCost = new Float[numberOfExperts];
+			for(int i = 0; i < numberOfCriteria; ++i) {
+				for(int j = 0; j < numberOfAlternatives; ++j) {
+					for(int k = 0; k < numberOfExperts; ++k) {
+						DecisionMatrix exp = numericPreferences[k];
+						preferencesMinimumCost[k] = (Float) exp.getValue(i, j);
+					}
+					minimumCostResults.addAll(Arrays.asList((Float[]) ((RunnableScript) E4DIAddon.aseService.createExecutionBuilder()
+							.setFunction("zhang2011minimumcostLinguistic")
+							.putVariable("epsilon", epsilon)
+							.putVariable("alpha", alpha)
+							.putVariable("cost", cost)
+							.putVariable("weights", weights)
+							.putVariable("pref", preferencesMinimumCost)
+							.execute())
+							.getResult()));
+				}
+			}
+			
+			//Decision matrix separated by criteria
+			List<Structure> aux = new ArrayList<>();
+			aux.addAll(twoTuplePreferencesDM);
+			twoTuplePreferencesDM.clear();
+			
+			int g = blts.getLabelSet().getCardinality() - 1;
+			
+			DecisionMatrix dmExpCrit = null;
+			for(int k = 0; k < numberOfExperts; ++k) {
+				for(int i = 0; i < numberOfCriteria; ++i) {
+					dmExpCrit = new DecisionMatrix(1, numberOfAlternatives);
+					for(int j = 0; j < numberOfAlternatives; ++j) {
+						TwoTuple twoTuple = new TwoTuple(blts);
+						twoTuple.calculateDelta(minimumCostResults.get((i * numberOfExperts * numberOfAlternatives) + (j * numberOfExperts) + k) * g);
+						dmExpCrit.setValue(0, j, twoTuple);
+					}
+					twoTuplePreferencesDM.add(dmExpCrit);
+				}
+			}
+		}
+	}
+
+	private DecisionMatrix[] convertPreferencesToNumber() {
+		DecisionMatrix[] result = new DecisionMatrix[preferences.length - 1];
+		
+		DecisionMatrix dmExpert, dmByCriterion;
+		TwoTuple preference;
+		
+		int g = blts.getLabelSet().getCardinality() - 1;
+		for(int k = 0; k < numberOfExperts; ++k) {
+			dmExpert = new DecisionMatrix(numberOfCriteria, numberOfAlternatives);
+			for(int i = 0; i < numberOfCriteria; ++i) {
+				dmByCriterion = (DecisionMatrix) twoTuplePreferencesDM.get(k * numberOfCriteria + i);
+				for(int col = 0; col < numberOfAlternatives; ++col) {
+					preference =  (TwoTuple) dmByCriterion.getValue(0, col); 
+					dmExpert.setValue(i, col, 1f - ((g - Math.round(preference.calculateInverseDelta())) / (float) g));
+					dmExpert.setDomain(i, col, dmByCriterion.getDomain(0, col));
+				}
+			}
+			result[k] = dmExpert;
+		}
+	
+		return result;
+	}
+
+	private void computeCollective() {
+		
+		Structure[] preferecesAux = new Structure[preferences.length - 1];
+		List<Structure> preferencesDM = new ArrayList<Structure>();
+	
+		for (int i = 0; i < preferecesAux.length; i++) {
+			try {
+				preferecesAux[i] = (Structure) preferences[i].clone();
+				preferencesDM.add((Structure) preferences[i].clone());
+			} catch (CloneNotSupportedException e) {
+				e.printStackTrace();
+			}
+		}
+		
+		blts = getBLTS(preferencesDM);
+		
+		
+		Object[][] collectiveASE = (Object[][]) ((RunnableScript) 
+				E4DIAddon.aseService.createExecutionBuilder()
+				.setFunction("arithmeticAggregationLPR")
+				.putVariable("preferences", preferecesAux)
+				.putVariable("alternatives", numberOfAlternatives)
+				.putVariable("criteria", numberOfCriteria)
+				.putVariable("experts", numberOfExperts)
+				.execute())
+				.getResult();
+
+		if ((collectiveASE != null)) {
+
+			DecisionMatrix result = new DecisionMatrix(numberOfCriteria,numberOfAlternatives);
+			for (int i = 0; i < numberOfCriteria; i++) {
+				for (int j = 0; j < numberOfAlternatives; j++) {
+					result.setDomain(i,j,blts);
+				}
+			}
+			result.prepareStructureForPreferences(collectiveASE);
+			collective=result;
+		}
+		
+	}
+
+	private void computeConsensusDegree() {
+		consensusDegree = ConsensusEngine.twoTupleConsensusBasedOnDistanceIndividualCollectiveWeightedAverage(
+				Arrays.copyOf(preferencesArray, preferencesArray.length - 1), weights);
+	}
+
+	@Override
+	protected void groupPreferencesByCriteria() {
+		computeCollective();
+		
+		preferencesArray = new Structure[numberOfExperts+1];
+
+		DecisionMatrix dmExpert, dmByCriterion;
+		for (int k = 0; k < numberOfExperts; ++k) {
+			dmExpert = new DecisionMatrix(numberOfCriteria, numberOfAlternatives);
+			for (int i = 0; i < numberOfCriteria; ++i) {
+				dmByCriterion = (DecisionMatrix) twoTuplePreferencesDM.get(k * numberOfCriteria + i);
+				for (int col = 0; col < numberOfAlternatives; ++col) {
+					dmExpert.setValue(i, col, dmByCriterion.getValue(0, col));
+					dmExpert.setDomain(i, col, dmByCriterion.getDomain(0, col));
+				}
+			}
+			preferencesArray[k]=dmExpert;
+		}
+		
+		preferencesArray[numberOfExperts]=collective;
+		
+		computeConsensusDegree();
+	}
+	
+	@Override
+	protected Float[][][] obtainVisualizeValues() {
+		Float[][][] preferencesGroupVisualization=new Float[preferencesArray.length][numberOfCriteria][numberOfAlternatives];
+		
+		for (int k = 0; k < preferencesArray.length; k++) {
+			preferencesGroupVisualization[k]= preferencesArray[k].obtainVisualizeValues();
+		}
+		return preferencesGroupVisualization;
+	}
+}