Beispiel #1
0
        //Tính khoảng cách tới giải pháp lý tưởng
        public float[,] distanceIdealSolution(Topsis dataTopsis)
        {
            float[,] S = new float[2, dataTopsis.data.GetLength(0)];
            for (int i = 0; i < S.GetLength(0); i++)
            {
                for (int j = 0; j < S.GetLength(1); j++)
                {
                    S[i, j] = 0f;
                }
            }

            for (int i = 0; i < dataTopsis.data.GetLength(0); i++)
            {
                for (int j = 0; j < dataTopsis.data.GetLength(1); j++)
                {
                    S[0, i] += (float)Math.Pow(dataTopsis.data[i, j] - dataTopsis.A[0, j], 2);
                    S[1, i] += (float)Math.Pow(dataTopsis.data[i, j] - dataTopsis.A[1, j], 2);
                }
                S[0, i] = (float)Math.Sqrt(S[0, i]);
                S[1, i] = (float)Math.Sqrt(S[1, i]);
            }

            return(S);
        }
Beispiel #2
0
        public async Task <IActionResult> DSS([FromBody] InputData inputData)
        {
            if (inputData.location == "all")
            {
                inputData.location = "";
            }

            var dataDss = await _context.Universites
                          .Join(
                _context.Majors,
                u => u.university_code,
                m => m.university_code,
                (u, m) => new
            {
                universityName = u.university_name,
                location       = u.location,
                linkWebsite    = u.link_website,
                rank           = u.rank,
                majorId        = m.id,
                majorsGroupId  = m.majors_group_id,
                majorsName     = m.majors_name,
                benchmarks2019 = m.benchmarks_2019,
                benchmarks2020 = m.benchmarks_2020,
                examGroup      = m.exam_group,
                c = m.c
            })
                          .Join(
                _context.MajorsGroups,
                mu => mu.majorsGroupId,
                mg => mg.majors_group_id,
                (mu, mg) => new
            {
                universityName = mu.universityName,
                location       = mu.location,
                linkWebsite    = mu.linkWebsite,
                rank           = mu.rank,
                majorId        = mu.majorId,
                majorsGroupId  = mu.majorsGroupId,
                majorsName     = mu.majorsName,
                benchmarks2019 = mu.benchmarks2019,
                benchmarks2020 = mu.benchmarks2020,
                examGroup      = mu.examGroup,
                c = mu.c,
                majorsGroupName = mg.majors_group_name
            })
                          .Where(major => major.majorsGroupId == inputData.majorGroupId && major.examGroup == inputData.examGroup && major.location.Contains(inputData.location) && (major.benchmarks2019 <= inputData.score || major.benchmarks2020 <= inputData.score))
                          .ToListAsync();

            if (dataDss.Count == 0)
            {
                return(NotFound(new { message = "Hệ thống chưa tìm được thông tin phù hợp" }));
            }

            // Xử lý tư vấn
            float[,] data = new float[dataDss.Count, 3];

            // Data tư vấn
            int           i          = 0;
            List <Majors> listMajors = new List <Majors>();

            foreach (var item in dataDss)
            {
                data[i, 0] = (float)item.benchmarks2019;
                data[i, 1] = (float)item.benchmarks2020;
                data[i, 2] = (float)item.rank;

                Majors major = new Majors();
                major.id = item.majorId;
                listMajors.Add(major);

                i++;
            }

            // Chuẩn hóa miền [0;1]
            data = normalizeMatrix(data);

            // Ma trận trọng số
            data = weightedMatrix(data);

            // Tính các giải pháp lý tưởng
            float[,] A = new float[2, 3];
            A          = idealSolution(data);

            // Tính khoảng cách tới giải pháp lý tưởng
            float[,] S = new float[2, data.GetLength(0)];
            Topsis ts = new Topsis();

            ts.data = data;
            ts.A    = A;
            S       = distanceIdealSolution(ts);

            // Tính độ tương tự tới giải pháp lý tưởng
            float[] C = new float[S.GetLength(1)];
            C = calculateC(S);

            // Update C trong bảng major
            for (int j = 0; j < C.Length; j++)
            {
                listMajors[j].c = C[j];
            }
            updateC(listMajors);

            // Trả về danh sách kết quả tư vấn
            var ResultDSS = await _context.Universites
                            .Join(
                _context.Majors,
                u => u.university_code,
                m => m.university_code,
                (u, m) => new
            {
                universityName = u.university_name,
                location       = u.location,
                linkWebsite    = u.link_website,
                rank           = u.rank,
                majorId        = m.id,
                majorsGroupId  = m.majors_group_id,
                majorsName     = m.majors_name,
                benchmarks2019 = m.benchmarks_2019,
                benchmarks2020 = m.benchmarks_2020,
                examGroup      = m.exam_group,
                c = m.c
            })
                            .Join(
                _context.MajorsGroups,
                mu => mu.majorsGroupId,
                mg => mg.majors_group_id,
                (mu, mg) => new
            {
                universityName = mu.universityName,
                location       = mu.location,
                linkWebsite    = mu.linkWebsite,
                rank           = mu.rank,
                majorId        = mu.majorId,
                majorsGroupId  = mu.majorsGroupId,
                majorsName     = mu.majorsName,
                benchmarks2019 = mu.benchmarks2019,
                benchmarks2020 = mu.benchmarks2020,
                examGroup      = mu.examGroup,
                c = mu.c,
                majorsGroupName = mg.majors_group_name
            })
                            .Where(major => major.majorsGroupId == inputData.majorGroupId && major.examGroup == inputData.examGroup && major.location.Contains(inputData.location) && (major.benchmarks2019 <= inputData.score || major.benchmarks2020 <= inputData.score))
                            .OrderByDescending(major => major.c)
                            .Take(10)
                            .ToListAsync();

            return(Ok(ResultDSS));
        }
Beispiel #3
0
        public ActionResult Index(S1 s1, S2 s2, S3 s3, S4 s4, Agirlik a)
        {
            //Karar Matrisi
            double[,] KararMatris = new double[, ] {
                { s1.S1_K1, s1.S1_K2, s1.S1_K3, s1.S1_K4, s1.S1_K5, s1.S1_K6, s1.S1_K7 },
                { s2.S2_K1, s2.S2_K2, s2.S2_K3, s2.S2_K4, s2.S2_K5, s2.S2_K6, s2.S2_K7 },
                { s3.S3_K1, s3.S3_K2, s3.S3_K3, s3.S3_K4, s3.S3_K5, s3.S3_K6, s3.S3_K7 },
                { s4.S4_K1, s4.S4_K2, s4.S4_K3, s4.S4_K4, s4.S4_K5, s4.S4_K6, s4.S4_K7 },
            };

            // Seçenekler
            List <string> secenekler = new List <string>();

            secenekler.Add(s1.Sec1);
            secenekler.Add(s2.Sec2);
            secenekler.Add(s3.Sec3);
            secenekler.Add(s4.Sec4);
            TempData["Secenekler"] = secenekler;

            // Ağırlıklar
            double[] Agirliklar = new double[] {
                Convert.ToDouble(a.K1),
                Convert.ToDouble(a.K2),
                Convert.ToDouble(a.K3),
                Convert.ToDouble(a.K4),
                Convert.ToDouble(a.K5),
                Convert.ToDouble(a.K6),
                Convert.ToDouble(a.K7)
            };

            double top = 0;

            for (int i = 0; i < Agirliklar.Length; i++)
            {
                top = top + Agirliklar[i];
            }

            if (top > 1)
            {
                TempData["hata"] = "Agirlik değerlerinin toplamı 0 ile 1 arasında olmalıdır.";
                return(RedirectToAction("Index"));
            }

            Topsis topsis = new Topsis();

            // Karar Matrisi
            TempData["KararMatrisi"] = KararMatris;

            //1.Adım : Standart Karar Matrisi
            topsis.StandartKararMatrisiHazirla(KararMatris);
            double[,] StandartKararMatris    = topsis.StandartKararMatrisiGoster();
            TempData["StandartKararMatrisi"] = StandartKararMatris;

            //2.Adım : Ağırlıklı standart Karar Matrisi
            topsis.agirlikliStandartKararMatrisiHazirla(Agirliklar);
            double[,] agirlikliStandartKararMatrisi   = topsis.agirlikliStandartKararMatrisiGoster();
            TempData["agirlikliStandartKararMatrisi"] = agirlikliStandartKararMatrisi;

            //3.Adım : ideal ve negatif ideal çözüm setleri
            topsis.idealVeNegatifİdealCozumDegerleriHesapla();
            double[] IdealcozumDegerler         = topsis.idealCozumDegerleriGoster();
            double[] negatifİdealcozumDegerleri = topsis.negatifİdealcozumDegerleriGoster();
            TempData["IdealcozumDegerler"]         = IdealcozumDegerler;
            TempData["negatifİdealcozumDegerleri"] = negatifİdealcozumDegerleri;

            //4.Adım : ideal ve negatif ideal noktalara olan uzaklık - ideal ayrım
            topsis.uzakliklarinHesabi();
            double[] idealUzaklik        = topsis.idealUzaklik;
            double[] negatifİdealUzaklik = topsis.negatifİdealUzaklik;
            TempData["idealUzaklik"]        = idealUzaklik;
            TempData["negatifİdealUzaklik"] = negatifİdealUzaklik;

            //5.Adım : İdeal çözüme gerekli yakınlık değeri
            topsis.idealCozumHesabi();
            double[] idealCozumSirali = topsis.idealCozumSiralaVeGoster();
            double   idealCozum       = topsis.idealCozum;

            TempData["idealCozumSirali"] = idealCozumSirali;
            TempData["idealCozum"]       = idealCozum;

            // Secenek degerleri
            double S1 = topsis.s1;
            double S2 = topsis.s2;
            double S3 = topsis.s3;
            double S4 = topsis.s4;

            TempData["Ss1"] = S1;
            TempData["Ss2"] = S2;
            TempData["Ss3"] = S3;
            TempData["Ss4"] = S4;

            return(RedirectToAction("Result"));
        }