private double distance2(Case a, Case b) // the distance between two points
{
EuclideanSimilarity sim = new EuclideanSimilarity(); // the Pythagorean theorem we calculate the distance between two points
// return sim.Compare(a, b); // vyzvraschaem distance 1/distance
return(sim.Similarity(a, b));
}
public void EuclideanSimilarityTest()
{
EuclideanSimilarity sim = new EuclideanSimilarity();
// Assert.Throws<ArgumentException>(() => sim.GetSimilarityScore(p0, q4));
double result = sim.GetSimilarityScore(p0, q0);
Assert.AreEqual(result, 0.58578, 0.00001);
result = sim.GetSimilarityScore(p1, q1);
Assert.AreEqual(result, 0.47213, 0.00001);
result = sim.GetSimilarityScore(p2, q2);
Assert.AreEqual(result, 1);
result = sim.GetSimilarityScore(p3, q3);
Assert.AreEqual(result, 1);
result = sim.GetSimilarityScore(p4, q4);
Assert.AreEqual(result, 0.2943, 0.00001);
result = sim.GetSimilarityScore(p5, q5);
Assert.AreEqual(result, 0.19074, 0.00001);
}
/// <summary>
/// Euclidean distance between two points in a two dimensional space.
/// </summary>
/// <param name="p1">Point 1</param>
/// <param name="p2">Point 2</param>
/// <returns>The distance</returns>
public static double Distance(this Case p1, Case p2)
{
// call eucladian distance beteen tow cases
EuclideanSimilarity sim = new EuclideanSimilarity();
return(sim.Similarity(p1, p2));
}
/// <summary>
/// Simple Euclidean distance
/// cf. http://en.wikipedia.org/wiki/Euclidean_distance
/// Consider also: Manhattan, Chebyshev & Minkowski distances
/// </summary>
/// <param name="P1"></param>
/// <param name="P2"></param>
/// <returns></returns>
private double GetEuclideanD(Case P1, Case P2)
{
EuclideanSimilarity sim = new EuclideanSimilarity(); // the Pythagorean theorem we calculate the distance between two points
return(sim.Dissimilarity(P1, P2)); // vyzvraschaem distance
//return sim.Compare(P1, P2); // vyzvraschaem distance
}
private void button13_Click_2(object sender, EventArgs e)
{
int c;
double[] ranks;
int dG_With = 0;
ahp_sol_no_clustering = new MyAHPModel(CriteriaArr.GetLength(0), mybestchoice.Cases.Count);
ahp_sol_no_clustering.AddCriteria(CriteriaArr);
ahp_sol_no_clustering.AddCriterionRatedChoices(ChoicesArr_Non);
if (ahp_sol_no_clustering.CalculatedCriteria())
{
ranks = ahp_sol_no_clustering.CalculatedChoices(out c);
if (c != -1)
{
MessageBox.Show("عدم تناسق في تفضيلات البدائل المدخلة للمعيار رقم" + c.ToString());
return;
}
}
else
{
MessageBox.Show("عدم تناسق في تفضيلات المعايير المدخلة");
return;
}
dg_results_no_clustering.Columns.Add("SolutionID", "Solution ID");
dg_results_no_clustering.Columns.Add("SolutionWeight", "Solution Weight");
dg_results_no_clustering.Columns.Add("SolutionSim", "Solution Similarity");
for (int i = 0; i < ranks.Length; i++)
{
dg_results_no_clustering.Rows.Add();
dg_results_no_clustering.Rows[dG_With].Cells[0].Value = mybestchoice.Cases[i].GetFeature("id").GetFeatureValue().ToString();
dg_results_no_clustering.Rows[dG_With].Cells[1].Value = Math.Round(ranks[i] * 100, 2);
EuclideanSimilarity s = new EuclideanSimilarity();
List <Case> sols = Db.get_cases_condition(mybestchoice.Tablename_Standardization, mybestchoice.CaseName);
dg_results_no_clustering.Rows[dG_With].Cells[2].Value = Math.Round(s.Similarity(sols[i], mybestchoice.StandrizeProblem) * 100, 2);
dG_With++;
}
dg_results_no_clustering.Sort(dg_results_no_clustering.Columns["SolutionWeight"], ListSortDirection.Descending);
}
private void button3_Click_1(object sender, EventArgs e)
{
if (add_file())
{
List <Case> centroids = new List <Case>();
centroids = Db.get_Centroids(choice.Tablename_Standardization, choice.CaseName);
for (int i = 0; i < ListCases.Count; i++)
{
// Case s_case = new Case(0, ListCases[0].GetCaseName(), ListCases[0].GetCaseDescription());
List <Case> restandrize_array = choice.Re_standrize(ListCases[i]);//, out s_case);
Case s_case = restandrize_array.Last();
Case result_centroid = choice.Updated_cluster_Min_Centroid(s_case, centroids, restandrize_array);
if (result_centroid != null)
{
Feature f = (Feature)result_centroid.GetFeatures()[0];
s_case.GetFeature("cluster").SetFeatureValue(f.GetFeatureValue()); // اسناد العنقود المناسب للعنصر الجديد
Db.update_cluster(choice.Tablename_Standardization, s_case.GetFeature("id").GetFeatureValue().ToString(), Convert.ToInt32(f.GetFeatureValue()));
Db.update_cluster(choice.TableName, s_case.GetFeature("id").GetFeatureValue().ToString(), Convert.ToInt32(f.GetFeatureValue()));
double ess = 0;
// من ضمن الداتا سيت المقييسة يتم حساب المراكز لجميع العناقيد
for (int k = 0; k < Convert.ToInt32(choice.Clusters_Num); k++)
{
List <Case> S_Arr_Cluster = Db.get_cases_condition_cluster(choice.Tablename_Standardization, choice.CaseName, "cluster", k.ToString());
Feature cen = S_Arr_Cluster[0].GetFeature("cluster");
Case new_centroid = Kmeans.ReCalcCentroid(S_Arr_Cluster, Convert.ToInt32(cen.GetFeatureValue()));
Db.insert_case_to_table(new_centroid, choice.Tablename_Standardization);
EuclideanSimilarity es = new EuclideanSimilarity();
double d = 0;
foreach (Case c in S_Arr_Cluster)
{
d += es.Dissimilarity(c, new_centroid);
}
ess += d;
}
MessageBox.Show(ess.ToString());
}
}
dataGridView_old.DataSource = Db.get_table_contetnt(choice.TableName);
}
}
private void button1_Click_1(object sender, EventArgs e)
{
textBox1.Text = Db.Get_CostFunction(listBox1.SelectedValue.ToString()).ToString();
string t = listBox1.SelectedValue.ToString().ToString();
double sse = 0;
EuclideanSimilarity sim = new EuclideanSimilarity();
string c = listBox1.Text;
List <Case> cases = Db.get_cases_condition(Db.get_standriazation(t), c);
List <Case> centroids = Db.get_Centroids(Db.get_standriazation(t), c);
foreach (Case a in cases)
{
foreach (Case ce in centroids)
{
if (a.GetFeature("cluster").GetFeatureValue().ToString() == ce.GetFeature("id").GetFeatureValue().ToString())
{
sse += sim.Dissimilarity(a, ce); break;
}
}
}
textBox1.Text = sse.ToString();
}
private void button2_Click_1(object sender, EventArgs e)
{
if (add_file())
{
List <Case> centroids = new List <Case>();
centroids = Db.get_Centroids(choice.Tablename_Standardization, choice.CaseName);
List <string> Ids = new List <string>();
for (int i = 0; i < ListCases.Count; i++)
{
//Case s_case = new Case(0, ListCases[0].GetCaseName(), ListCases[0].GetCaseDescription());
// تقييس الداتا سيت بناءا على العنصر الجديد
var watch = System.Diagnostics.Stopwatch.StartNew();
List <Case> restandrize_array = choice.Re_standrize(ListCases[i]);
// العنصر الجديد بعد التقييس
Case s_case = restandrize_array.Last();
// نرى إلى أي عنقود ستمم اضافته
Case result_centroid = choice.Updated_cluster(s_case, centroids, restandrize_array);
watch.Stop();
var elapsedMs = watch.ElapsedMilliseconds;
label2.Text = "with clustring time " + elapsedMs.ToString();
// سيتم انضمامه لعنقود موجود
if (result_centroid != null)
{
Feature f = (Feature)result_centroid.GetFeatures()[0];
s_case.GetFeature("cluster").SetFeatureValue(f.GetFeatureValue()); // اسناد العنقود المناسب للعنصر الجديد
Db.update_cluster(choice.Tablename_Standardization, s_case.GetFeature("id").GetFeatureValue().ToString(), Convert.ToInt32(f.GetFeatureValue()));
Db.update_cluster(choice.TableName, s_case.GetFeature("id").GetFeatureValue().ToString(), Convert.ToInt32(f.GetFeatureValue()));
Ids.Add(f.GetFeatureValue().ToString());
} // end if
else // عنقود جديد
{
int k = Convert.ToInt32(choice.Clusters_Num) + 1;
// اضافة عنقود جديد
Db.update_cluster(choice.Tablename_Standardization, s_case.GetFeature("id").GetFeatureValue().ToString(), k);
Db.update_cluster(choice.TableName, s_case.GetFeature("id").GetFeatureValue().ToString(), k);
Case new_centroid = s_case;
new_centroid.GetFeature("cluster").SetFeatureValue(-1);
Db.insert_case_to_table(new_centroid, choice.Tablename_Standardization);
choice.Clusters_Num = k.ToString();
Db.update_clusterNum(choice.CaseName, k);
}
} // end for all new cases
if (Ids != null)
{
Db.del_centroids(choice.Tablename_Standardization, Ids);
double ess = 0;
// من ضمن الداتا سيت المقييسة يتم حساب المراكز لجميع العناقيد
foreach (string id in Ids)
{
List <Case> S_Arr_Cluster = Db.get_cases_condition_cluster(choice.Tablename_Standardization, choice.CaseName, "cluster", id);
Feature cen = S_Arr_Cluster[0].GetFeature("cluster");
Case new_centroid = Kmeans.ReCalcCentroid(S_Arr_Cluster, Convert.ToInt32(cen.GetFeatureValue()));
EuclideanSimilarity es = new EuclideanSimilarity();
double d = 0;
foreach (Case c in S_Arr_Cluster)
{
d += es.Dissimilarity(c, new_centroid);
}
ess += d;
Db.insert_case_to_table(new_centroid, choice.Tablename_Standardization);
}
// حساب distorion error
MessageBox.Show(ess.ToString());
}
dataGridView_old.DataSource = Db.get_table_contetnt(choice.TableName);
}
}
//---------------------------------------------------------------------------------------
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
private void button21_Click(object sender, EventArgs e)
{
// display
int dG_WithR = 0;
dG_With.Columns.Clear();
//dG_Non.Columns.Add("Porblem No ", "Porblem No ");
dG_With.Columns.Add("SolNum", "Sol Num ");
dG_With.Columns.Add("Weight ", "Weight ");
dG_With.Columns.Add("Sim ", "Sim ");
List <Case> solutions = statistics.FindAlternative_WithClustering(statistics.exp_random_cases[problem_num]);
// call method
listBox1.Items.Add("Finding Alternatices by specifying best cluster");
double[] ranks;
Dictionary <int, double[, ]> choices;
double[,] criteriaarr;
MyFuzzyAHP myfahp = new MyFuzzyAHP(statistics.count_citeria, solutions.Count);
criteriaarr = GenerateComparison.CriteriaComparisonMatrix;
myfahp.AddCriteria(criteriaarr);
myfahp.CalculatedCriteria();
choices = GenerateComparison.Create_All_Criteria_Choice_Comparison_Array(solutions);
myfahp.AddCriterionRatedChoices(choices);
ranks = myfahp.CalculatedChoices();
for (int i = 0; i < ranks.Length; i++)
{
dG_With.Rows.Add();
dG_With.Rows[dG_WithR].Cells[0].Value = solutions[i].GetFeature("id").GetFeatureValue().ToString();
dG_With.Rows[dG_WithR].Cells[1].Value = Math.Round(ranks[i] * 100, 2);
EuclideanSimilarity s = new EuclideanSimilarity();
dG_With.Rows[dG_WithR].Cells[2].Value = Math.Round(s.Similarity(solutions[i], statistics.exp_random_cases[problem_num]) * 100, 2);
dG_WithR++;
}
dG_With.Sort(dG_With.Columns[1], ListSortDirection.Descending);
if (dG_Prob.Columns.Count == 0)
{
dG_Prob.Columns.Add("Criteria", " Criteria ");
dG_Prob.Columns.Add("AHP", "AHP");
dG_Prob.Columns.Add("FuzzyAHP", "Fuzzy AHP");
for (int i = 1; i < solutions[0].GetFeatures().Count - 1; i++)
{
dG_Prob.Rows.Add();
Feature f = (Feature)solutions[0].GetFeatures()[i];
dG_Prob.Rows[i - 1].Cells[0].Value = f.GetFeatureName().ToString();
dG_Prob.Rows[i - 1].Cells[2].Value = Math.Round(myfahp.CriteriaWeights[i - 1] * 100, 2);
}
}
else
{
for (int i = 1; i < solutions[0].GetFeatures().Count - 1; i++)
{
Feature f = (Feature)solutions[0].GetFeatures()[i];
dG_Prob.Rows[i - 1].Cells[2].Value = Math.Round(myfahp.CriteriaWeights[i - 1] * 100, 2);
}
}
dG_Prob.AutoResizeColumns();
dG_Prob.AutoSizeColumnsMode = DataGridViewAutoSizeColumnsMode.AllCells;
dG_With.AutoResizeColumns();
dG_With.AutoSizeColumnsMode = DataGridViewAutoSizeColumnsMode.AllCells;
// display
}
//------------------------------------------------------------------------------------------
public void implement_ahp()
{
// call method
statistics.FindSolutions_FuzzyAHP();
// display
int dG_R = 0;
int DG_cri = 0;
dg_With_stat.Columns.Clear();
dg_With_stat.Columns.Add("Porblem No ", "Porblem No ");
dg_With_stat.Columns.Add("SolNum", "Sol No ");
dg_With_stat.Columns.Add("Weight", "Weight");
dg_With_stat.Columns.Add("Sol sim with problem ", "Sol sim with problem ");
dg_Non_stat.Columns.Clear();
dg_Non_stat.Columns.Add("Porblem No ", "Porblem No ");
dg_Non_stat.Columns.Add("SolNum", "Sol Num ");
dg_Non_stat.Columns.Add("Weight", "Weight");
dg_Non_stat.Columns.Add("Sol sim with problem ", "Sol sim with problem ");
dg_criteria.Columns.Clear();
dg_criteria.Columns.Add("Porblem No", "Porblem No ");
for (int i = 1; i < statistics.exp_random_cases[0].GetFeatures().Count - 1; i++)
{
Feature f = (Feature)statistics.exp_random_cases[0].GetFeatures()[i];
dg_criteria.Columns.Add(f.GetFeatureName(), f.GetFeatureName());
}
listBox1.Items.Add("خطوة2: إيجاد حلول لكل حالة دراسة");
listBox1.Items.Add("الأنسب ايجاد بدائل العنقود");
listBox1.Items.Add("AHP خطوة 3: تطبيق");
listBox1.Items.Add("خطوة 1.3 توليد المقارنات الزوجية للمعاير وللبدائل");
foreach (Case c in statistics.exp_random_cases)
{
dg_Non_stat.Rows.Add();
dg_With_stat.Rows.Add();
// ahp
dg_Non_stat.Rows[dG_R].Cells[0].Value = c.GetFeature("id").GetFeatureValue().ToString();
dg_Non_stat.Rows[dG_R].Cells[1].Value = statistics.AllAhpResults[c][0, 0]; // first sol
dg_Non_stat.Rows[dG_R].Cells[2].Value = Math.Round(statistics.AllAhpResults[c][0, 1], 2).ToString();
int sol_id = Convert.ToInt32(statistics.AllAhpResults[c][0, 0]);
EuclideanSimilarity s = new EuclideanSimilarity();
dg_Non_stat.Rows[dG_R].Cells[3].Value = Math.Round(s.Similarity(c, mybestchoice.Cases[sol_id]) * 100, 2).ToString();
// fuzzy ahp
dg_With_stat.Rows[dG_R].Cells[0].Value = c.GetFeature("id").GetFeatureValue().ToString();
dg_With_stat.Rows[dG_R].Cells[1].Value = statistics.AllFuzzyAhpResults[c][0, 0]; // first sol
sol_id = Convert.ToInt32(statistics.AllFuzzyAhpResults[c][0, 0]);
dg_With_stat.Rows[dG_R].Cells[2].Value = Math.Round(statistics.AllFuzzyAhpResults[c][0, 1], 2);
s = new EuclideanSimilarity();
dg_With_stat.Rows[dG_R].Cells[3].Value = Math.Round(s.Similarity(c, mybestchoice.Cases[sol_id]) * 100, 2).ToString();
dG_R++;
//criteria
dg_criteria.Rows.Add(2);
dg_criteria.Rows[DG_cri].Cells[0].Value = c.GetFeature("id").GetFeatureValue().ToString();
dg_criteria.Rows[DG_cri + 1].Cells[0].Value = c.GetFeature("id").GetFeatureValue().ToString();
for (int i = 0; i < statistics.exp_random_cases[0].GetFeatures().Count - 2; i++)
{
dg_criteria.Rows[DG_cri].Cells[i + 1].Value = Math.Round(statistics.AllAhpCriteria[c][i] * 100, 2).ToString() + "%";
dg_criteria.Rows[DG_cri + 1].Cells[i + 1].Value = Math.Round(statistics.AllFAhpCriteria[c][i] * 100, 2).ToString() + "%";
}
DG_cri += 2;
}
dg_With_stat.AutoResizeColumns();
dg_Non_stat.AutoResizeColumns();
dg_With_stat.AutoSizeColumnsMode =
DataGridViewAutoSizeColumnsMode.AllCells;
dg_Non_stat.AutoSizeColumnsMode =
DataGridViewAutoSizeColumnsMode.AllCells;
}
public void calc_matching()
{
listBox1.Items.Add("خطوة 4: اظهر نتائج تطابق الطريقتين");
diff_fuzzy_bigger = new List <int[]>();
diff_fuzzy_smaller = new List <int[]>();
diff_fuzzy_equal = new List <int[]>();
diff_fuzzy_bigger_sim = new List <double[]>();
diff_fuzzy_smaller_sim = new List <double[]>();
diff_fuzzy_equal_sim = new List <double[]> ();
// display
dg_result.Columns.Clear();
dg_result.Columns.Add("Cases_numbers", "Cases_numbers");
dg_result.Columns.Add("Similarity", "Similarity");
double[,] fuzzyAhp_pair, ahp_pair;
//---------------------------------------------------------------------------------
// display
foreach (Case c in statistics.exp_random_cases)
{
ahp_pair = statistics.AllAhpResults[c];
fuzzyAhp_pair = statistics.AllFuzzyAhpResults[c];
EuclideanSimilarity s = new EuclideanSimilarity();
int num1 = Convert.ToInt32(fuzzyAhp_pair[0, 0]);
int num2 = Convert.ToInt32(ahp_pair[0, 0]);
int sol_id = Convert.ToInt32(c.GetFeature("id").GetFeatureValue());
double sim1 = Math.Round(s.Similarity(mybestchoice.Cases[num1], c) * 100, 2); // fuzzy
double sim2 = Math.Round(s.Similarity(mybestchoice.Cases[num2], c) * 100, 2); // ahp
int[] te = new int [3];
double[] tee = new double[2];
if (ahp_pair[0, 0] == fuzzyAhp_pair[0, 0])
{
te[0] = sol_id;
te[1] = num1;
te[2] = num2;
tee[0] = sim1;
tee[1] = sim2;
diff_fuzzy_equal.Add(te);
diff_fuzzy_equal_sim.Add(tee);
}
else
{
// fuzzy > ahp
if (sim1 > sim2)
{
te[0] = sol_id;
te[1] = num1;
te[2] = num2;
tee[0] = sim1;
tee[1] = sim2;
diff_fuzzy_bigger.Add(te);
diff_fuzzy_bigger_sim.Add(tee);
}
else // fuzz < ahp
{
te[0] = sol_id;
te[1] = num1;
te[2] = num2;
tee[0] = sim1;
tee[1] = sim2;
diff_fuzzy_smaller.Add(te);
diff_fuzzy_smaller_sim.Add(tee);
}
}
}
int h = 0;
dg_result.Rows.Add();
dg_result.Rows[h].Cells[0].Value = "Fuzzy AHP = AHP";
dg_result.Rows[h].Cells[1].Value = diff_fuzzy_equal.Count;
h++;
for (int i = 0; i < diff_fuzzy_equal.Count; i++)
{
dg_result.Rows.Add();
dg_result.Rows[h].Cells[0].Value = diff_fuzzy_equal[i][0] + "[ " + diff_fuzzy_equal[i][1] + "," + diff_fuzzy_equal[i][2] + " ]";
dg_result.Rows[h].Cells[1].Value = diff_fuzzy_equal_sim[i][0] + " , " + diff_fuzzy_equal_sim[i][1];
h++;
}
dg_result.Rows.Add();
dg_result.Rows[h].Cells[0].Value = "Fuzzy AHP Sim> AHP Sim";
dg_result.Rows[h].Cells[1].Value = diff_fuzzy_bigger.Count;
h++;
for (int i = 0; i < diff_fuzzy_bigger.Count; i++)
{
dg_result.Rows.Add();
dg_result.Rows[h].Cells[0].Value = diff_fuzzy_bigger[i][0] + " [ " + diff_fuzzy_bigger[i][1] + " , " + diff_fuzzy_bigger[i][2] + " ] ";
dg_result.Rows[h].Cells[1].Value = diff_fuzzy_bigger_sim[i][0] + ", " + diff_fuzzy_bigger_sim[i][1];
h++;
}
dg_result.Rows.Add();
dg_result.Rows[h].Cells[0].Value = "Fuzzy AHP Sim < AHP Sim";
dg_result.Rows[h].Cells[1].Value = diff_fuzzy_smaller.Count;
h++;
for (int i = 0; i < diff_fuzzy_smaller.Count; i++)
{
dg_result.Rows.Add();
dg_result.Rows[h].Cells[0].Value = diff_fuzzy_smaller[i][0] + " [ " + diff_fuzzy_smaller[i][1] + " , " + diff_fuzzy_smaller[i][2] + " ] ";
dg_result.Rows[h].Cells[1].Value = diff_fuzzy_smaller_sim[i][0] + ", " + diff_fuzzy_smaller_sim[i][1];
h++;
}
dg_result.AutoResizeColumns();
dg_result.AutoSizeColumnsMode = DataGridViewAutoSizeColumnsMode.AllCells;
}
