Esempio n. 1
0
        private void InitListRules(double HAR, double EDR)
        {
            //  AR - Atack Rate
            //  DR - Defence Rate
            //  D - Damage ["No","Low", "Minor", "Average", High]
            Rule temp = new Rule();

            //  if ("AR" is "Missing" and "DR" is "Missing") then ("D" is "Low")
            temp.Conditions.Add(new Condition("AR", MissingAR));
            temp.Conditions.Add(new Condition("DR", MissingDR));

            temp.Conclusions.Add(new SugenoConclusion("D", Low, 0, HAR, 0, EDR));
            this.Rules.Add(temp);
            temp = new Rule();

            //  if ("AR" is "Basic" and "DR" is "Missing") then ("D" is "Minor")
            temp.Conditions.Add(new Condition("AR", BasicAR));
            temp.Conditions.Add(new Condition("DR", MissingDR));

            temp.Conclusions.Add(new SugenoConclusion("D", Minor, 1.75, HAR, 0, EDR));
            this.Rules.Add(temp);
            temp = new Rule();

            //  if ("AR" is "Advance" and "DR" is "Missing") then ("D" is "Average")
            temp.Conditions.Add(new Condition("AR", AdvanceAR));
            temp.Conditions.Add(new Condition("DR", MissingDR));

            temp.Conclusions.Add(new SugenoConclusion("D", Average, 1.22, HAR, 0, EDR));
            this.Rules.Add(temp);
            temp = new Rule();

            //  if ("AR" is "Expert" and "DR" is "Missing") then ("D" is "High")
            temp.Conditions.Add(new Condition("AR", ExpertAR));
            temp.Conditions.Add(new Condition("DR", MissingDR));

            temp.Conclusions.Add(new SugenoConclusion("D", High, 1.197, HAR, 0, EDR));
            this.Rules.Add(temp);
            temp = new Rule();

            //  if ("AR" is "Missing" and "DR" is "Basic") then ("D" is "No")
            temp.Conditions.Add(new Condition("AR", MissingAR));
            temp.Conditions.Add(new Condition("DR", BasicDR));

            temp.Conclusions.Add(new SugenoConclusion("D", No, 0, HAR, 0, EDR));
            this.Rules.Add(temp);
            temp = new Rule();

            //  if ("AR" is "Basic" and "DR" is "Basic") then ("D" is "Low")
            temp.Conditions.Add(new Condition("AR", BasicAR));
            temp.Conditions.Add(new Condition("DR", BasicDR));

            temp.Conclusions.Add(new SugenoConclusion("D", Low, 1, HAR, 0.5, EDR));
            this.Rules.Add(temp);
            temp = new Rule();

            //  if ("AR" is "Advance" and "DR" is "Basic") then ("D" is "Minor")
            temp.Conditions.Add(new Condition("AR", AdvanceAR));
            temp.Conditions.Add(new Condition("DR", BasicDR));

            temp.Conclusions.Add(new SugenoConclusion("D", Minor, 1.2, HAR, 0.5, EDR));
            this.Rules.Add(temp);
            temp = new Rule();

            //  if ("AR" is "Expert" and "DR" is "Basic") then ("D" is "Average")
            temp.Conditions.Add(new Condition("AR", ExpertAR));
            temp.Conditions.Add(new Condition("DR", BasicDR));

            temp.Conclusions.Add(new SugenoConclusion("D", Average, 1.2, HAR, 0.4, EDR));
            this.Rules.Add(temp);
            temp = new Rule();

            //  if ("AR" is "Missing" and "DR" is "Advance") then ("D" is "No")
            temp.Conditions.Add(new Condition("AR", MissingAR));
            temp.Conditions.Add(new Condition("DR", AdvanceDR));

            temp.Conclusions.Add(new SugenoConclusion("D", No, 0, HAR, 0, EDR));
            this.Rules.Add(temp);
            temp = new Rule();

            //  if ("AR" is "Basic" and "DR" is "Advance") then ("D" is "No")
            temp.Conditions.Add(new Condition("AR", BasicAR));
            temp.Conditions.Add(new Condition("DR", AdvanceDR));

            temp.Conclusions.Add(new SugenoConclusion("D", No, 0, HAR, 0, EDR));
            this.Rules.Add(temp);
            temp = new Rule();

            //  if ("AR" is "Advance" and "DR" is "Advance") then ("D" is "Low")
            temp.Conditions.Add(new Condition("AR", AdvanceAR));
            temp.Conditions.Add(new Condition("DR", AdvanceDR));

            temp.Conclusions.Add(new SugenoConclusion("D", Low, 1, HAR, 0.8, EDR));
            this.Rules.Add(temp);
            temp = new Rule();

            //  if ("AR" is "Expert" and "DR" is "Advance") then ("D" is "Minor")
            temp.Conditions.Add(new Condition("AR", ExpertAR));
            temp.Conditions.Add(new Condition("DR", AdvanceDR));

            temp.Conclusions.Add(new SugenoConclusion("D", Minor, 1.2, HAR, 0.8, EDR));
            this.Rules.Add(temp);
            temp = new Rule();

            //  if ("AR" is "Missing" and "DR" is "Expert") then ("D" is "No")
            temp.Conditions.Add(new Condition("AR", MissingAR));
            temp.Conditions.Add(new Condition("DR", ExpertDR));

            temp.Conclusions.Add(new SugenoConclusion("D", No, 0, HAR, 0, EDR));
            this.Rules.Add(temp);
            temp = new Rule();

            //  if ("AR" is "Basic" and "DR" is "Expert") then ("D" is "No")
            temp.Conditions.Add(new Condition("AR", BasicAR));
            temp.Conditions.Add(new Condition("DR", ExpertDR));

            temp.Conclusions.Add(new SugenoConclusion("D", No, 0, HAR, 0, EDR));
            this.Rules.Add(temp);
            temp = new Rule();

            //  if ("AR" is "Advance" and "DR" is "Expert") then ("D" is "No")
            temp.Conditions.Add(new Condition("AR", AdvanceAR));
            temp.Conditions.Add(new Condition("DR", ExpertDR));

            temp.Conclusions.Add(new SugenoConclusion("D", No, 0, HAR, 0, EDR));
            this.Rules.Add(temp);
            temp = new Rule();

            //  if ("AR" is "Expert" and "DR" is "Expert") then ("D" is "Low")
            temp.Conditions.Add(new Condition("AR", ExpertAR));
            temp.Conditions.Add(new Condition("DR", ExpertDR));

            temp.Conclusions.Add(new SugenoConclusion("D", Low, 1.3, HAR, 1, EDR));
            this.Rules.Add(temp);
            temp = new Rule();
        }
Esempio n. 2
0
        private List <double> Aggregation(List <double> atackDirects, List <double> defenceDirects)
        {
            List <double> result = new List <double>();

            for (int I = 0; I < this.Rules.Count; I++)
            {
                double currentValue = Double.MaxValue;
                Rule   currentRule  = this.Rules[I];
                for (int J = 0; J < currentRule.Conditions.Count; J++)
                {
                    if (currentRule.Conditions[J].Variable.Id == "AR")
                    {
                        int index;
                        if (currentRule.Conditions[J].Term == MissingAR)
                        {
                            index = 0;
                        }
                        else if (currentRule.Conditions[J].Term == BasicAR)
                        {
                            index = 1;
                        }
                        else if (currentRule.Conditions[J].Term == AdvanceAR)
                        {
                            index = 2;
                        }
                        else if (currentRule.Conditions[J].Term == ExpertAR)
                        {
                            index = 3;
                        }
                        else
                        {
                            throw new Exception("Not exist current term");
                        }

                        currentValue = Math.Min(currentValue, atackDirects[index]);
                    }
                    else
                    {
                        int index;
                        if (currentRule.Conditions[J].Term == MissingDR)
                        {
                            index = 0;
                        }
                        else if (currentRule.Conditions[J].Term == BasicDR)
                        {
                            index = 1;
                        }
                        else if (currentRule.Conditions[J].Term == AdvanceDR)
                        {
                            index = 2;
                        }
                        else if (currentRule.Conditions[J].Term == ExpertDR)
                        {
                            index = 3;
                        }
                        else
                        {
                            throw new Exception("Not exist current term");
                        }

                        currentValue = Math.Min(currentValue, defenceDirects[index]);
                    }
                }
                result.Add(currentValue);
            }
            return(result);
        }