295 lines
8.7 KiB
Plaintext
295 lines
8.7 KiB
Plaintext
<snippet>
|
|
<subclass>afryca.ase.Snippet</subclass>
|
|
<file></file>
|
|
<category>Library</category>
|
|
<name>aggregation</name>
|
|
<description>Aggregation</description>
|
|
<code>
|
|
var aggregation = (typeof exports === "undefined")?(function aggregation() {}):(exports);
|
|
if(typeof global !== "undefined") { global.aggregation = aggregation; }
|
|
|
|
aggregation.powerFunction = function powerFunction(valor1,valor2,beta) {
|
|
var result=0;
|
|
result=Math.pow(1+valor2,valor1*beta);
|
|
return result;
|
|
}
|
|
|
|
aggregation.obtainWeightsGroups=function obtainWeightsGroups(hesitant,beta,pointA,pointB) {
|
|
var weights=new ArrayList();
|
|
var cohesion,size,degreeSize;
|
|
var func=[pointA,pointB,100,100];
|
|
var membershipFunctionSize= new TrapezoidalFunction(func);
|
|
for(var i=0;i<hesitant.length;i++){
|
|
cohesion = hesitant[i].computeCohesionHesitantPreferenceRelation();
|
|
size = hesitant[i].getNExperts();
|
|
degreeSize = membershipFunctionSize.getMembershipValue(size);
|
|
weights.add(aggregation.powerFunction(cohesion, degreeSize,beta));
|
|
}
|
|
var sum=0;
|
|
for (var n = 0; n < weights.size(); n++) {
|
|
sum += weights.get(n);
|
|
}
|
|
|
|
var weightsNorm=new ArrayList();
|
|
for (var j = 0; j < weights.size(); j++) {
|
|
weightsNorm.add(weights.get(j) / sum);
|
|
}
|
|
|
|
return weightsNorm;
|
|
|
|
}
|
|
|
|
aggregation.hesitantWeigthedAverageNormalized = function (hesitant,beta,pointA,pointB){
|
|
var max=0;
|
|
for(var k = 0;k < hesitant.length;k++){
|
|
for(var i = 0;i < hesitant.get(k | 0).numberOfAlternatives;i++){
|
|
for(var j = 0;j < hesitant.get(k | 0).numberOfAlternatives;j++){
|
|
var value=hesitant.get(k | 0).getValue(i | 0, j | 0).getHesitantValues().size();
|
|
if(max < value){
|
|
max=hesitant.get(k | 0).getValue(i | 0, j | 0).getHesitantValues().size();
|
|
}
|
|
}
|
|
}
|
|
}
|
|
var pref=new ArrayList();
|
|
for(var k = 0;k < hesitant.length;k++){
|
|
pref.add(consistency.calculateNHPR(hesitant.get(k | 0),0.5,max));
|
|
}
|
|
|
|
return aggregation.hesitantWeigthedAverage(pref,beta,pointA,pointB);
|
|
}
|
|
|
|
/*
|
|
Return a collective hesitant preference relation
|
|
In this function the weights are calculated inside
|
|
*/
|
|
aggregation.hesitantWeigthedAverage = function hesitantWeigthedAverage(hesitant,beta,pointA,pointB){
|
|
|
|
var weights=new ArrayList();
|
|
weights=aggregation.obtainWeightsGroups(hesitant,beta,pointA,pointB);
|
|
var nAlt = hesitant.get(0).getNumberOfAlternatives();
|
|
var nElements = hesitant.get(0).getValue(0, 1).getHesitantValues().size();
|
|
var numberHPR = hesitant.size();
|
|
var collectivePreferences=new Array(nAlt);
|
|
|
|
for(var p=0;p<nAlt;p++){
|
|
collectivePreferences[p]=new Array(nAlt);
|
|
}
|
|
//var [][] collectivePreferences = new HesitantNumericValuation[nAlt][nAlt];
|
|
|
|
for (var i = 0; i < nAlt; i++) {
|
|
for (var j = 0; j < nAlt; j++) {
|
|
var hesitantCollective = new HesitantNumericValuation();
|
|
for (var l = 0; l < nElements; l++) {
|
|
var result = 0;
|
|
if(i==j){
|
|
result=0.5;
|
|
}else{
|
|
for (var hpr = 0; hpr < numberHPR; hpr++) {
|
|
result += hesitant.get(hpr).getValue(i | 0, j | 0).getHesitantValues().get(l).getDegree() * weights.get(hpr);
|
|
}
|
|
}
|
|
var exp=new ExpertDegree(-1, result);
|
|
hesitantCollective.addHesitantValue(exp);
|
|
}
|
|
collectivePreferences[i][j] = hesitantCollective;
|
|
}
|
|
}
|
|
|
|
var collectiveHPR = new HPR(-1, -1, nAlt);
|
|
|
|
collectiveHPR.setPreferences(collectivePreferences);
|
|
|
|
return collectiveHPR;
|
|
|
|
}
|
|
|
|
/*
|
|
Return a collective hesitant preference relation
|
|
*/
|
|
aggregation.hesitantWeigthedAverageWithWeights = function hesitantWeigthedAverageWithWeights(hesitant,weights){
|
|
|
|
var nAlt = hesitant.get(0).getNumberOfAlternatives();
|
|
var nElements = hesitant.get(0).getValue(0, 1).getHesitantValues().size();
|
|
var numberHPR = hesitant.size();
|
|
var collectivePreferences=new Array(nAlt);
|
|
|
|
for(var p=0;p<nAlt;p++){
|
|
collectivePreferences[p]=new Array(nAlt);
|
|
}
|
|
for (var i = 0; i < nAlt; i++) {
|
|
for (var j = 0; j < nAlt; j++) {
|
|
var hesitantCollective = new HesitantNumericValuation();
|
|
for (var l = 0; l < nElements; l++) {
|
|
var result = 0;
|
|
if(i==j){
|
|
result=0.5;
|
|
}else{
|
|
for (var hpr = 0; hpr < numberHPR; hpr++) {
|
|
result += hesitant.get(hpr).getValue(i | 0, j | 0).getHesitantValues().get(l).getDegree() * weights[hpr];
|
|
}
|
|
}
|
|
var exp=new ExpertDegree(-1, result);
|
|
hesitantCollective.addHesitantValue(exp);
|
|
}
|
|
collectivePreferences[i][j] = hesitantCollective;
|
|
}
|
|
}
|
|
|
|
var collectiveHPR = new HPR(-1, -1, nAlt);
|
|
|
|
collectiveHPR.setPreferences(collectivePreferences);
|
|
|
|
return collectiveHPR;
|
|
|
|
}
|
|
|
|
aggregation.groupPreferencesTwoTupleArithmeticMeanDM = function groupPreferencesTwoTupleArithmeticMeanDM(twoTuplePreferences, alternatives, criteria, experts, blts) {
|
|
var dm;
|
|
var twoTuple;
|
|
var collectiveTwoTuple;
|
|
var beta;
|
|
var collective=[];
|
|
|
|
if(twoTuplePreferences.length != experts) {
|
|
for(var i = 0; i < criteria; ++i) {
|
|
collective[i] = [];
|
|
for(var j = 0; j < alternatives; ++j) {
|
|
beta = 0;
|
|
for(var k = 0; k < experts; ++k) {
|
|
dm = twoTuplePreferences.get(k * criteria + i);
|
|
twoTuple = dm.getPreferences()[0][j];
|
|
beta += twoTuple.calculateInverseDelta();
|
|
}
|
|
beta /= experts;
|
|
collectiveTwoTuple = twoTuple.clone();
|
|
collectiveTwoTuple.calculateDelta(beta);
|
|
collective[i][j] = collectiveTwoTuple;
|
|
}
|
|
}
|
|
} else {
|
|
for(var i = 0; i < criteria; ++i) {
|
|
collective[i] = [];
|
|
for(var j = 0; j < alternatives; ++j) {
|
|
beta = 0;
|
|
for(var k = 0; k < experts; ++k) {
|
|
dm = twoTuplePreferences.get(k);
|
|
twoTuple = dm.getPreferences()[i][j];
|
|
beta += twoTuple.calculateInverseDelta();
|
|
}
|
|
beta /= experts;
|
|
collectiveTwoTuple = twoTuple.clone();
|
|
collectiveTwoTuple.calculateDelta(beta);
|
|
collective[i][j] = collectiveTwoTuple;
|
|
}
|
|
}
|
|
}
|
|
|
|
return collective;
|
|
}
|
|
|
|
aggregation.groupPreferencesTwoTupleArithmeticMean = function groupPreferencesTwoTupleArithmeticMean(preferences, alternatives, criteria, experts) {
|
|
|
|
var blts = unification.getBLTS(preferences);
|
|
if(blts == null) { //only numeric domains
|
|
if(preferences.length != experts){ //multi-criteria
|
|
var pref = new ArrayList(experts);
|
|
for(var ex = 0; ex < experts; ex++){
|
|
var prefCriteria = [];
|
|
for(var cr = 0; cr < criteria; cr++){
|
|
prefCriteria[cr] = preferences[ex * criteria + cr];
|
|
}
|
|
|
|
var aux = aggregation.groupNumercialValuesArithmeticMean(prefCriteria, experts, criteria, alternatives);
|
|
pref.add(aux);
|
|
}
|
|
return aggregation.groupNumercialValuesArithmeticMean(pref, experts, criteria, alternatives);
|
|
} else {
|
|
return aggregation.groupNumercialValuesArithmeticMean(preferences, experts, criteria, alternatives);
|
|
}
|
|
|
|
} else {
|
|
|
|
var unifiedPreferences = unification.unify(preferences, blts);
|
|
var twoTuplePreferences = disunification.disunite(unifiedPreferences);
|
|
|
|
if(preferences[0] instanceof DecisionMatrix){
|
|
return aggregation.groupPreferencesTwoTupleArithmeticMeanDM(twoTuplePreferences, alternatives, criteria, experts, blts);
|
|
}
|
|
|
|
if(preferences.length != experts){
|
|
var pref = new ArrayList(experts);
|
|
for(var ex = 0; ex < experts; ex++){
|
|
var prefCriteria = [];
|
|
for(var cr = 0; cr < criteria; cr++){
|
|
prefCriteria[cr] = twoTuplePreferences.get(ex * criteria + cr);
|
|
}
|
|
var aux = aggregation.groupDisunifiedTwoTupleArithmeticMean(prefCriteria, experts, criteria, alternatives, blts);
|
|
pref.add(aux);
|
|
}
|
|
return aggregation.groupDisunifiedTwoTupleArithmeticMean(pref, experts, criteria, alternatives, blts);
|
|
}else{
|
|
return aggregation.groupDisunifiedTwoTupleArithmeticMean(twoTuplePreferences, experts, criteria, alternatives, blts);
|
|
}
|
|
}
|
|
}
|
|
|
|
aggregation.groupNumercialValuesArithmeticMean = function(preferences, experts, criteria, alternatives){
|
|
var value;
|
|
var acum;
|
|
var preference;
|
|
var collective = [];
|
|
|
|
for(var i = 0;i < criteria;++i){
|
|
collective[i] = new Array(alternatives);
|
|
for(var j = 0;j < alternatives; ++j){
|
|
acum = 0;
|
|
for(var ex = 0; ex < experts; ++ex){
|
|
preference = preferences[ex];
|
|
if(preference instanceof Structure) {
|
|
value = preference.getPreferences()[i][j];
|
|
} else {
|
|
value = preference[i][j];
|
|
}
|
|
|
|
acum += value;
|
|
}
|
|
acum /= experts;
|
|
collective[i][j] = acum;
|
|
}
|
|
}
|
|
return collective;
|
|
}
|
|
|
|
aggregation.groupDisunifiedTwoTupleArithmeticMean = function(disunitePreferences, experts, criteria, alternatives, blts) {
|
|
var lpr;
|
|
var twoTuple;
|
|
var collectiveTwoTuple;
|
|
var beta;
|
|
var collective = [];
|
|
for(var i = 0;i < alternatives;++i){
|
|
collective[i] = [];
|
|
for(var j = 0;j < alternatives; ++j){
|
|
beta = 0;
|
|
for(var ex = 0; ex < experts; ++ex){
|
|
lpr = disunitePreferences[ex];
|
|
if(lpr instanceof Structure) {
|
|
twoTuple = lpr.getPreferences()[i][j];
|
|
} else {
|
|
twoTuple = lpr[i][j];
|
|
}
|
|
beta += twoTuple.calculateInverseDelta();
|
|
}
|
|
beta /= experts;
|
|
collectiveTwoTuple = twoTuple.clone();
|
|
collectiveTwoTuple.calculateDelta(beta);
|
|
collective[i][j] = collectiveTwoTuple;
|
|
}
|
|
}
|
|
return collective;
|
|
}
|
|
|
|
|
|
aggregation
|
|
</code>
|
|
</snippet> |