// ----------------------------------------------------------------------------------- public Dictionary <Case, double[, ]> AHP(List <Case> Cases) { double[,] Non_Results; Dictionary <Case, double[, ]> Results = new Dictionary <Case, double[, ]>(); for (int u = 0; u < exp_random_cases.Count; u++) { Case _problem = exp_random_cases[u]; // Criteria Comparsions------------------------ MyAHPModel model = new MyAHPModel(); double[,] cri_arr = model.Create_Criteria_Comparison_Array(count_citeria); MyAHPModel model1 = new MyAHPModel(count_citeria, Cases.Count); model1.AddCriteria(cri_arr); model1.CalculatedCriteria(); // Choices Comparsions------------------------ bool consistency = false; double[] choices = new double[Cases.Count]; double[] tempresult = new double[Cases.Count]; for (int uu = 0; uu < count_citeria; uu++) { double[,] comp_choice = model1.CreateOne_CeiteriaChoiceComp(uu, Cases); while (!consistency) { tempresult = model1.Calculated_One__Choic(out consistency, model1.CriteriaWeights[uu], comp_choice); } for (int h = 0; h < tempresult.GetLength(0); h++) { choices[h] += tempresult[h]; } } int ii = 0; Non_Results = new double[Cases.Count, 2]; foreach (Case c in Cases) { Non_Results[ii, 0] = Convert.ToDouble(c.GetFeature("id").GetFeatureValue()); Non_Results[ii, 1] = choices[ii] * 100; ii++; } // sort Clustered for (int i = 0; i < Non_Results.GetLength(0) - 1; i++) { for (int j = 0; j < Non_Results.GetLength(0) - i - 1; j++) { if (Non_Results[j, 1] < Non_Results[j + 1, 1]) { double temp = Non_Results[j, 1]; Non_Results[j, 1] = Non_Results[j + 1, 1]; Non_Results[j + 1, 1] = temp; temp = Non_Results[j, 0]; Non_Results[j, 0] = Non_Results[j + 1, 0]; Non_Results[j + 1, 0] = temp; } } } Results.Add(exp_random_cases[u], Non_Results); } return(Results); }
//--------------------------------------------------------------------------------------- public void FindSolutions_FuzzyAHP() { bool consistency; double[] choices; double[] tempresult; AllAhpCriteria = new Dictionary <Case, double[]>(); AllFAhpCriteria = new Dictionary <Case, double[]>(); AllAhpResults = new Dictionary <Case, double[, ]>(); AllFuzzyAhpResults = new Dictionary <Case, double[, ]>(); List <double[, ]> tempahp; List <double[, ]> tempfahp; List <Case> AhpArrCases; double[,] Ahp_Results; double[,] Fahp_Results; //--------------------------------------------------------------------------------- for (int u = 0; u < exp_random_cases.Count; u++) { Case _problem = exp_random_cases[u]; // Criteria Comparsions------------------------ MyAHPModel model = new MyAHPModel(count_citeria); tempahp = new List <double[, ]>(); tempfahp = new List <double[, ]>(); double[,] cri_arr = model.Create_Criteria_Comparison_Array(count_citeria); //-------Criteria Weights---------------------------------------------------------------- model.AddCriteria(cri_arr); double[] cri_wgh = new double[count_citeria]; bool res = false; while (!res) { if (model.CalculatedCriteria()) { res = true; } } cri_wgh = model.CriteriaWeights; //-------------------------------AHP-------------------------------------------------- AhpArrCases = FindAlternative_WithClustering(_problem); if (AhpArrCases.Count != 0) { // non clustering MyAHPModel model1 = new MyAHPModel(count_citeria, AhpArrCases.Count); model1.AddCriteria(cri_arr); model1.CalculatedCriteria(); AllAhpCriteria.Add(exp_random_cases[u], model1.CriteriaWeights); // Choices Comparsions------------------------ consistency = false; choices = new double[AhpArrCases.Count]; tempresult = new double[AhpArrCases.Count]; for (int uu = 0; uu < count_citeria; uu++) { double[,] comp_choice = model1.CreateOne_CeiteriaChoiceComp(uu, AhpArrCases); while (!consistency) { tempresult = model1.Calculated_One__Choic(out consistency, model1.CriteriaWeights[uu], comp_choice); } consistency = false; for (int h = 0; h < tempresult.GetLength(0); h++) { choices[h] += tempresult[h]; } } int ii = 0; Ahp_Results = new double[AhpArrCases.Count, 2]; foreach (Case cc in AhpArrCases) { Ahp_Results[ii, 0] = Convert.ToDouble(cc.GetFeature("id").GetFeatureValue()); Ahp_Results[ii, 1] = choices[ii] * 100; ii++; } // sort Clustered for (int i = 0; i < Ahp_Results.GetLength(0) - 1; i++) { for (int j = 0; j < Ahp_Results.GetLength(0) - i - 1; j++) { if (Ahp_Results[j, 1] < Ahp_Results[j + 1, 1]) { double temp = Ahp_Results[j, 1]; Ahp_Results[j, 1] = Ahp_Results[j + 1, 1]; Ahp_Results[j + 1, 1] = temp; temp = Ahp_Results[j, 0]; Ahp_Results[j, 0] = Ahp_Results[j + 1, 0]; Ahp_Results[j + 1, 0] = temp; } else if (Ahp_Results[j, 1] == Ahp_Results[j + 1, 1]) { EuclideanSimilarity s = new EuclideanSimilarity(); int num1 = Convert.ToInt32(Ahp_Results[j, 0]); int num2 = Convert.ToInt32(Ahp_Results[j + 1, 0]); double sim1 = s.Similarity(AhpArrCases[num1], _problem); double sim2 = s.Similarity(AhpArrCases[num2], _problem); if (sim2 > sim1) { double temp = Ahp_Results[j, 1]; Ahp_Results[j, 1] = Ahp_Results[j + 1, 1]; Ahp_Results[j + 1, 1] = temp; temp = Ahp_Results[j, 0]; Ahp_Results[j, 0] = Ahp_Results[j + 1, 0]; Ahp_Results[j + 1, 0] = temp; } } } } // Fuzzy MyFuzzyAHP model2 = new MyFuzzyAHP(count_citeria, AhpArrCases.Count); model2.AddCriteria(cri_arr); model2.CalculatedCriteria(); AllFAhpCriteria.Add(exp_random_cases[u], model2.CriteriaWeights); // Choices Comparsions------------------------ consistency = false; choices = new double[AhpArrCases.Count]; tempresult = new double[AhpArrCases.Count]; for (int uu = 0; uu < count_citeria; uu++) { double[,] comp_choice = model2.CreateOne_CeiteriaChoiceComp(uu, AhpArrCases); while (!consistency) { tempresult = model2.Calculated_One__Choice(out consistency, model2.CriteriaWeights[uu], comp_choice); } consistency = false; for (int h = 0; h < tempresult.GetLength(0); h++) { choices[h] += tempresult[h]; } } ii = 0; Fahp_Results = new double[AhpArrCases.Count, 2]; foreach (Case cc in AhpArrCases) { Fahp_Results[ii, 0] = Convert.ToDouble(cc.GetFeature("id").GetFeatureValue()); Fahp_Results[ii, 1] = choices[ii] * 100; ii++; } // sort Clustered for (int i = 0; i < Fahp_Results.GetLength(0) - 1; i++) { for (int j = 0; j < Fahp_Results.GetLength(0) - i - 1; j++) { if (Fahp_Results[j, 1] < Fahp_Results[j + 1, 1]) { double temp = Fahp_Results[j, 1]; Fahp_Results[j, 1] = Fahp_Results[j + 1, 1]; Fahp_Results[j + 1, 1] = temp; temp = Fahp_Results[j, 0]; Fahp_Results[j, 0] = Fahp_Results[j + 1, 0]; Fahp_Results[j + 1, 0] = temp; } } } AllAhpResults.Add(exp_random_cases[u], Ahp_Results); AllFuzzyAhpResults.Add(exp_random_cases[u], Fahp_Results); } } //end if } // end for
//======================================================================================================================= public void FindSolutions_AHP() { bool consistency; double[] choices; double[] tempresult; AllNonClusterdResults = new Dictionary <Case, Dictionary <double, double[, ]> >(); AllClusterdResults = new Dictionary <Case, Dictionary <double, double[, ]> >(); criteria_weights = new Dictionary <Case, double[]>(); Dictionary <string, double> cri_dic; Dictionary <double, double[, ]> tempNon; Dictionary <double, double[, ]> tempWith; List <Case> ClusterdArrCases; List <Case> NonClusterdArrCases; double[,] Non_Results; double[,] With_Results; ArrayList current_cases_partial = new ArrayList(); //List<Case> centroids = new List<Case>(); Kmeans kmeans = new Kmeans(); Dictionary <int, List <Case> > cases_by_centroids = new Dictionary <int, List <Case> >(); // get centroids for case for (int i = 0; i < centroids.Count; i++) { int k = Convert.ToInt32(centroids[i].GetFeature("id").GetFeatureValue()); cases_by_centroids.Add(k, Db.get_cases_condition_cluster(tablename, casename, "cluster", k.ToString())); } //--------------------------------------------------------------------------------- for (int u = 0; u < exp_random_cases.Count; u++) { cri_dic = new Dictionary <string, double>(); double sim = Math.Round(0.10, 2); Case _problem = exp_random_cases[u]; // Criteria Comparsions------------------------ MyAHPModel model = new MyAHPModel(count_citeria); tempNon = new Dictionary <double, double[, ]> (); tempWith = new Dictionary <double, double[, ]>(); double[,] cri_arr = model.Create_Criteria_Comparison_Array(count_citeria); //-------Criteria Weights---------------------------------------------------------------- model.AddCriteria(cri_arr); double[] cri_wgh = new double[count_citeria]; List <string> criteria_names = Db.get_criteria(casename); bool res = false; while (!res) { if (model.CalculatedCriteria()) { res = true; } } cri_wgh = model.CriteriaWeights; criteria_weights.Add(_problem, model.CriteriaWeights); //-------------------------------AHP-------------------------------------------------- while (sim < 1) { NonClusterdArrCases = FindAlternative_NonClustering(_problem, sim.ToString()); ClusterdArrCases = FindAlternative_WithClustering(_problem, sim.ToString()); if (NonClusterdArrCases.Count != 0) { // non clustering MyAHPModel model1 = new MyAHPModel(count_citeria, NonClusterdArrCases.Count); model1.AddCriteria(cri_arr); model1.CalculatedCriteria(); // Choices Comparsions------------------------ consistency = false; choices = new double[NonClusterdArrCases.Count]; tempresult = new double[NonClusterdArrCases.Count]; for (int uu = 0; uu < count_citeria; uu++) { double[,] comp_choice = model1.CreateOne_CeiteriaChoiceComp(uu, NonClusterdArrCases); while (!consistency) { tempresult = model1.Calculated_One__Choic(out consistency, model1.CriteriaWeights[uu], comp_choice); } consistency = false; for (int h = 0; h < tempresult.GetLength(0); h++) { choices[h] += tempresult[h]; } } int ii = 0; Non_Results = new double[NonClusterdArrCases.Count, 2]; foreach (Case cc in NonClusterdArrCases) { Non_Results[ii, 0] = Convert.ToDouble(cc.GetFeature("id").GetFeatureValue()); Non_Results[ii, 1] = choices[ii] * 100; ii++; } // sort Clustered for (int i = 0; i < Non_Results.GetLength(0) - 1; i++) { for (int j = 0; j < Non_Results.GetLength(0) - i - 1; j++) { if (Non_Results[j, 1] < Non_Results[j + 1, 1]) { double temp = Non_Results[j, 1]; Non_Results[j, 1] = Non_Results[j + 1, 1]; Non_Results[j + 1, 1] = temp; temp = Non_Results[j, 0]; Non_Results[j, 0] = Non_Results[j + 1, 0]; Non_Results[j + 1, 0] = temp; } } } tempNon.Add(sim, Non_Results); } if (ClusterdArrCases.Count != 0) { // Clustering MyAHPModel model2 = new MyAHPModel(count_citeria, ClusterdArrCases.Count); model2.AddCriteria(cri_arr); model2.CalculatedCriteria(); // Choices Comparsions------------------------ consistency = false; choices = new double[ClusterdArrCases.Count]; tempresult = new double[ClusterdArrCases.Count]; for (int uu = 0; uu < count_citeria; uu++) { double[,] comp_choice = model2.CreateOne_CeiteriaChoiceComp(uu, ClusterdArrCases); while (!consistency) { tempresult = model2.Calculated_One__Choic(out consistency, model2.CriteriaWeights[uu], comp_choice); } consistency = false; for (int h = 0; h < tempresult.GetLength(0); h++) { choices[h] += tempresult[h]; } } int ii = 0; With_Results = new double[ClusterdArrCases.Count, 2]; foreach (Case cc in ClusterdArrCases) { With_Results[ii, 0] = Convert.ToDouble(cc.GetFeature("id").GetFeatureValue()); With_Results[ii, 1] = choices[ii] * 100; ii++; } // sort Clustered for (int i = 0; i < With_Results.GetLength(0) - 1; i++) { for (int j = 0; j < With_Results.GetLength(0) - i - 1; j++) { if (With_Results[j, 1] < With_Results[j + 1, 1]) { double temp = With_Results[j, 1]; With_Results[j, 1] = With_Results[j + 1, 1]; With_Results[j + 1, 1] = temp; temp = With_Results[j, 0]; With_Results[j, 0] = With_Results[j + 1, 0]; With_Results[j + 1, 0] = temp; } } } tempWith.Add(sim, With_Results); } // end if sim += Math.Round(0.05, 2); sim = Math.Round(sim, 2); } // end sim AllNonClusterdResults.Add(exp_random_cases[u], tempNon); AllClusterdResults.Add(exp_random_cases[u], tempWith); } // end for }