// For steps 25-33 in stage one
        private static Matrix NAPTStageOneHelper2(Matrix CAP, Matrix SRG, Matrix FA1, Matrix UA11, Matrix REL, Vector AOC, int stage, int networkid)
        {
            // 25. Generate a Non-Aggression matrix NAG
            Matrix NAG = new Matrix(FA1.Rows, FA1.Cols);
            for (int i = 0; i < FA1.Rows; i++)
            {
                for (int j = 0; j < FA1.Cols; j++)
                {
                    if (FA1[i, j] == 2)
                        NAG[i, j] = 1;
                    else
                        NAG[i, j] = 0;
                }
            }

            Vector NAG_vec = new Vector(NAG.Rows);
            for (int i = 0; i < NAG_vec.Size; i++)
            {
                NAG_vec[i] = NAG.GetRowSum(i);
            }

            // 26.  Generate an Allies Attractiveness matrix AAT = DP1 * UA11
            //      Calculate the sum row entry
            Matrix AAT = new Matrix(UA11.Rows, UA11.Cols);
            /*
            for (int i = 0; i < DP1.Rows; i++)
                for (int j = 0; j < UA11.Cols; j++)
                    AAT[i, j] = DP1[i, j] * UA11[i, j];
            */
            //FA1.Binarize();
            for (int i = 0; i < FA1.Rows; i++)
                for (int j = 0; j < FA1.Cols; j++)
                    if (FA1[i, j] != 1)
                        FA1[i, j] = 0;

            // Generate the vector DEF for Output Matrix
            Vector DEF = new Vector(FA1.Rows);
            for (int i = 0; i < DEF.Size; i++)
            {
                DEF[i] = FA1.GetRowSum(i);
            }

            // follows the excel instructions
            for (int i = 0; i < FA1.Rows; i++)
            {
                for (int j = 0; j < UA11.Cols; j++)
                {
                    //AAT[i, j] = (FA1[i, j] == 1 ? 1 : 0) * UA11[i, j];
                    AAT[i, j] = FA1[i, j] * UA11[i, j];
                }
            }

            // 27. Generate the attractiveness coefficient atc for each row
            /*
            double[] atc = new double[AAT.Rows];
            for (int i = 0; i < AAT.Rows; i++)
                atc[i] = AAT.GetRowSum(i) * DP1.GetRowSum(i);
            */
            // follow excel instructions
            //double[] ATC = new double[AAT.Rows];
            Vector ATC = new Vector(AAT.Rows);
            for (int i = 0; i < AAT.Rows; i++)
            {
                if (FA1.GetRowSum(i) > 0)
                    ATC[i] = AAT.GetRowSum(i) / FA1.GetRowSum(i);
                else
                    ATC[i] = 0;
            }

            // 28. Generate an Allies Reliability matrix ARE = BFA1 * REL (where BAF1 is the binarized FA1 matrix)
            //FA1.Binarize();
            Matrix ARE = new Matrix(FA1.Rows, REL.Cols);
            if (stage == 1)
            {
                for (int i = 0; i < FA1.Rows; i++)
                    for (int j = 0; j < REL.Cols; j++)
                        ARE[i, j] = FA1[i, j] * REL[i, i]; // may need to be changed to [j, j]
            }
            else
            {
                for (int i = 0; i < FA1.Rows; i++)
                    for (int j = 0; j < REL.Cols; j++)
                        ARE[i, j] = NAG[i, j] * REL[j, j];
            }

            Vector REC = new Vector(ARE.Rows);
            if (stage == 1)
            {
                for (int i = 0; i < REC.Size; i++)
                {
                    if ((DEF[i] + NAG_vec[i]) > 0)
                        REC[i] = ARE.GetRowSum(i) / (DEF[i] + NAG_vec[i]);
                    else
                        REC[i] = 0;
                }
            }
            else
            {
                for (int i = 0; i < REC.Size; i++)
                {
                    REC[i] = ARE.GetRowAverage(i);
                }
            }
            // 29. Generate an alliance capabilities matrix defined as AC1 = DP1 * CAP
            /*
            Matrix AC1 = new Matrix(DP1.Rows, CAP.Cols);
            for (int i = 0; i < DP1.Rows; i++)
                for (int j = 0; j < CAP.Cols; j++)
                    AC1[i, j] = DP1[i, j] * CAP[i, i];
            */
            // follow excel instructions
            Matrix AC1 = new Matrix(FA1.Rows, CAP.Cols);
            for (int i = 0; i < FA1.Rows; i++)
            {
                for (int j = 0; j < CAP.Cols; j++)
                {
                    if (i == j)
                        AC1[i, j] = CAP[j, j];
                    else
                        AC1[i, j] = FA1[i, j] * CAP[j, j];
                }
            }

            // 30. Generate a cumulative alliance capability vector CAL
            Vector CAL = new Vector(AC1.Rows);
            for (int i = 0; i < AC1.Rows; i++)
                CAL[i] = AC1.GetRowSum(i);

            // 31.  Generate a finals SRG capabilities matrix SRGC1
            //      Generate a SRG capability vector SRGC
            Matrix SRGC1 = new Matrix(FA1.Rows, FA1.Cols);
            for (int i = 0; i < FA1.Rows; i++)
            {
                for (int j = 0; j < FA1.Cols; j++)
                {
                    if (SRG[i, j] == 1 && FA1[i, j] == 0)
                        SRGC1[i, j] = CAP[j, j];
                    else
                        SRGC1[i, j] = 0;
                }
            }

            Vector SRGC_vec = new Vector(SRGC1.Rows);
            for (int i = 0; i < SRGC1.Rows; i++)
                SRGC_vec[i] = SRGC1.GetRowSum(i);

            // 32. Generate a revised AOC1 vector
            Vector AOC1 = new Vector(SRGC_vec.Size);
            for (int i = 0; i < SRGC_vec.Size; i++)
            {
                if (CAL[i] >= SRGC_vec[i])
                    AOC1[i] = 0;
                else
                    AOC1[i] = SRGC_vec[i] - CAL[i];
            }

            // 33. Save output
            Matrix Output = new Matrix(FA1.Rows, 9);
            string[] colNames = {"Node", "DEF", "NAG", "CAP", "CAL", "AOC0", "AOC1", "ATC", "REC"};
            //Output.NetworkId = 101 + stage;
            Output.NetworkId = int.Parse(networkid + "0" + stage);
            for (int i = 0; i < colNames.Length; i++)
                Output.ColLabels[i] = colNames[i];
            for (int i = 0; i < Output.Rows; i++)
            {
                //Output.RowLabels[i] = (101 + stage).ToString();
                Output.RowLabels[i] = (int.Parse(networkid + "0" + stage)).ToString();
                Output[i, 0] = i + 1;
            }
            Output.SetColVector(1, DEF);
            Output.SetColVector(2, NAG_vec);
            for (int i = 0; i < CAP.Rows; i++)
                Output[i, 3] = CAP[i, i];
            Output.SetColVector(4, CAL);
            Output.SetColVector(5, AOC);
            Output.SetColVector(6, AOC1);
            Output.SetColVector(7, ATC);
            Output.SetColVector(8, REC);

            return Output;
        }
Пример #2
0
        public static Matrix StructuralEquivalenceCorrelation(Matrix m)
        {
            Matrix SEC = new Matrix(m);

            for (int i = 0; i < m.Rows; ++i)
            {
                for (int j = 0; j < m.Cols; ++j)
                {
                    double sec = 0.0;
                    double sqrtSum1 = 0.0, sqrtSum2 = 0.0;
                    for (int k = 0; k < m.Rows; ++k)
                    {
                        sec += ((m[i, k] - m.GetRowAverage(i)) * (m[j, k] - m.GetRowAverage(j)));
                        sec += ((m[k, i] - m.GetColAverage(i)) * (m[k, j] - m.GetColAverage(j)));

                        sqrtSum1 += (m[i, k] - m.GetRowAverage(i)) * (m[i, k] - m.GetRowAverage(i));
                        sqrtSum1 += (m[k, i] - m.GetColAverage(i)) * (m[k, i] - m.GetColAverage(i));

                        sqrtSum2 += (m[j, k] - m.GetRowAverage(j)) * (m[j, k] - m.GetRowAverage(j));
                        sqrtSum2 += (m[k, j] - m.GetColAverage(j)) * (m[k, j] - m.GetColAverage(j));
                    }
                    sqrtSum1 = Math.Sqrt(sqrtSum1);
                    sqrtSum2 = Math.Sqrt(sqrtSum2);
                    if (Math.Abs(sqrtSum1 * sqrtSum2) > 0.0)
                        sec /= (sqrtSum1 * sqrtSum2);
                    else
                        sec = 0.0;

                    SEC[i, j] = sec;
                }
            }

            return SEC;
        }