Пример #1
0
        public DecisionResultBase Solve(AlternativesBase alternatives)
        {
            _alternatives = alternatives;

            double[,] normalize = GetNormalizedMatrix();
            List <double>[,] discordanceSets = GetDiscordances(normalize);
            double[,] concordances           = GetConcordances(normalize);

            double[,] nonDiscordance    = GetNonDiscordanceIndices(discordanceSets, concordances);
            double[,] generalPreference = GetGeneralPreferences(concordances, nonDiscordance);
            int[,] rangeMatrix          = GetResultMatrix(generalPreference);
            int[,] finalRange           = GetFinalRanking(rangeMatrix);

            DecisionResultBase result = new DecisionResultBase();

            for (int i = 0; i < _alternatives.Alternatives.Count; ++i)
            {
                int rank = _alternatives.Alternatives.Count;
                for (int j = 0; j < _alternatives.Alternatives.Count; ++j)
                {
                    rank -= finalRange[i, j];
                }
                result.Ranks.Add(rank);
            }
            return(result);
        }
Пример #2
0
        public DecisionResultBase Solve(AlternativesBase alternatives)
        {
            _alternatives = alternatives;

            double[,] normalizedDecisionMarix = GetNormalizedMatrix();

            double[] ranks = GetResultValues(
                GetAdditiveValues(normalizedDecisionMarix),
                GetMultiplicativeValues(normalizedDecisionMarix)
                );

            //calculate range with pairwise comparison
            DecisionResultBase result = new DecisionResultBase();

            for (int i = 0; i < alternatives.Alternatives.Count; ++i)
            {
                int dominated = 0;
                for (int j = 0; j < alternatives.Alternatives.Count; ++j)
                {
                    if (i != j && ranks[i] >= ranks[j])
                    {
                        ++dominated;
                    }
                }
                result.Ranks.Add(alternatives.Alternatives.Count - dominated);
            }

            return(result);
        }
Пример #3
0
        public DecisionResultBase Solve(AlternativesBase alternatives)
        {
            double epsilon = 1e-3;// epsilon for double comparison

            _alternatives = alternatives;

            var PreferenceIndex = ComputePreferenceMatrix();

            double[,] Flows = ComputeIOFlows(PreferenceIndex, _alternatives.Alternatives.Count);

            double [] NetFlows = ComputeNetFlows(Flows, _alternatives.Alternatives.Count);

            List <int> Ranks = new List <int>();

            for (int i = 0; i < _alternatives.Alternatives.Count; ++i)
            {
                int Rank = 1;
                for (int j = 0; j < _alternatives.Alternatives.Count; ++j)
                {
                    if (i != j && NetFlows[i] - NetFlows[j] < epsilon)
                    {
                        ++Rank;
                    }
                }
                Ranks.Add(Rank);
            }

            var Result = new DecisionResultBase();

            Result.Ranks = Ranks;

            return(Result);
        }
        public DecisionResultBase Solve(AlternativesBase alternatives)
        {
            _alternatives = alternatives;
            double[,] normalizeWeights = GetNormalizedMatrix();
            double[] bestAlternative = GetBestAlternative(normalizeWeights);
            double[] distances       = GetBlockDistances(
                normalizeWeights,
                bestAlternative
                );

            DecisionResultBase result = new DecisionResultBase();

            for (int i = 0; i < distances.Length; ++i)
            {
                int rank = distances.Length;
                for (int j = 0; j < distances.Length; ++j)
                {
                    if (i != j && distances[i] <= distances[j])
                    {
                        --rank;
                    }
                }
                result.Ranks.Add(rank);
            }
            return(result);
        }
Пример #5
0
        public DecisionResultBase Solve(AlternativesBase alternatives)
        {
            _alternatives = alternatives;

            //Impacts Matrix
            double[,] impact_matrix = CalculateImpactMatrix();

            //calculate range with pairwise comparison
            DecisionResultBase result = new DecisionResultBase();

            for (int i = 0; i < alternatives.Alternatives.Count; ++i)
            {
                int dominated = 0;
                for (int j = 0; j < alternatives.Alternatives.Count; ++j)
                {
                    if (i != j)
                    {
                        if (impact_matrix[i, j] - impact_matrix[j, i] >= 0)
                        {
                            dominated++;
                        }
                    }
                }
                result.Ranks.Add(alternatives.Alternatives.Count - dominated);
            }
            return(result);
        }
Пример #6
0
        public DecisionResultBase Solve(AlternativesBase alternatives)
        {
            _alternatives = alternatives;
            //Main constant for algorithm
            var basis     = 1.0 + _configuration.Epsilon;
            var intervals = 6;
            var factor    = Math.Pow(basis, intervals); // = 64 (default)
            var root2     = Math.Sqrt(2.0);

            double[,] g = new double[_alternatives.Criterias.Count, _alternatives.Alternatives.Count];
            int i, j;

            for (i = 0; i < _alternatives.Criterias.Count; i++) //i - criteria number
            {
                var critera          = _alternatives.Criterias[i];
                var minCriteriaValue = critera.MinValue;
                var maxCriteriaValue = critera.MaxValue;
                //posible correcting minCriteraValue
                //minCriteriaValue += (maxCriteriaValue - minCriteriaValue) / factor;
                var deltaCriteraValue = maxCriteriaValue - minCriteriaValue;

                for (j = 0; j < _alternatives.Alternatives.Count; j++) // j - alternative number
                {
                    var alternative = _alternatives.Alternatives[j];
                    if (critera is IQualitativeCriteria)
                    {
                        g[i, j] = alternative.Values[i].Value;
                    }
                    else
                    {
                        double v;
                        v       = Math.Log((alternative.Values[i].Value - minCriteriaValue) * factor / deltaCriteraValue, basis);
                        g[i, j] = critera.CriteriaDirection == CriteriaDirectionType.Maximization ? 4 + v : 10 - v;
                    }
                }
            }
            var w = new double[_alternatives.Criterias.Count];

            if (IsCriterialWeightsNormalized() == false)
            {
                double sum = 0;
                for (i = 0; i < alternatives.Criterias.Count; i++)
                {
                    w[i] = Math.Pow(root2, _configuration.CriteriaRanks[i]);
                    sum += w[i];
                }
                //Normalizing w
                for (i = 0; i < alternatives.Criterias.Count; i++)
                {
                    w[i] /= sum;
                }
            }
            else
            {
                for (i = 0; i < alternatives.Criterias.Count; i++)
                {
                    w[i] = _configuration.CriteriaRanks[i];
                }
            }

            var f = new double[alternatives.Alternatives.Count];

            //count alternative ranks
            for (j = 0; j < alternatives.Alternatives.Count; j++)
            {
                f[j] = 0;
                for (i = 0; i < alternatives.Criterias.Count; i++)
                {
                    f[j] += w[i] * g[i, j];
                }
            }
            var permutation = new int[alternatives.Alternatives.Count];
            var number      = new int[alternatives.Alternatives.Count];

            for (j = 0; j < alternatives.Alternatives.Count; j++)
            {
                number[j] = j;
            }

            for (int j1 = 0; j1 < alternatives.Alternatives.Count - 1; j1++)
            {
                var maxIndex = j1;
                for (int j2 = j1 + 1; j2 < alternatives.Alternatives.Count; j2++)
                {
                    if (f[j2] > f[maxIndex])
                    {
                        maxIndex = j2;
                    }
                }
                var temp = f[j1];
                f[j1]       = f[maxIndex];
                f[maxIndex] = temp;

                var tempNumber = number[j1];
                number[j1]              = number[maxIndex];
                number[maxIndex]        = tempNumber;
                permutation[number[j1]] = j1;
            }
            permutation[number[alternatives.Alternatives.Count - 1]] = alternatives.Alternatives.Count - 1;

            var result = new DecisionResultBase();

            for (j = 0; j < alternatives.Alternatives.Count; j++)
            {
                result.Ranks.Add(permutation[j] + 1);
            }
            return(result);
        }