Exemple #1
0
        static void Main(string[] args)
        {
            RuleInferenceEngine ruleInferenceEngine = new RuleInferenceEngine();

            Rule rule = new Rule("seo_hard_freelancer");

            rule.AddAntecedents(new GreaterEqualClause("experience", "4"));
            rule.AddAntecedents(new IsClause("type", "SEO"));
            rule.Consequent = new BaseClause("freelancer", "Oleg");
            ruleInferenceEngine.Rules.Add(rule);

            rule = new Rule("seo_easy_freelancer");
            rule.AddAntecedents(new LessClause("experience", "4"));
            rule.AddAntecedents(new IsClause("type", "SEO"));
            rule.Consequent = new BaseClause("freelancer", "Ivan");

            ruleInferenceEngine.Rules.Add(rule);

            List <BaseClause> unproved_conditions = new List <BaseClause>();

            Console.WriteLine("Write freencer experience:");

            ruleInferenceEngine.AddFact(new IsClause("type", Console.ReadLine()));
            ruleInferenceEngine.AddFact(new IsClause("experience", Console.ReadLine()));

            BaseClause conclusion = ruleInferenceEngine.Infer("freelancer", unproved_conditions);

            Console.WriteLine("Conclusion: " + conclusion);
        }
        public override void Init()
        {
            try
            {
                this.ClassName = this.ClassSpecifier.DeclaredName;

                this.AstState    = AstState.InClass;
                this.CurrentType = this.ClassName;

                BaseClause baseClause = this.ClassSpecifier.GetBaseClause();

                if (baseClause != null)
                {
                    foreach (BaseSpecifier baseNode in baseClause.BaseSpecifierNodes)
                    {
                        QualifiedBaseTypeReference baseReference = baseNode.QualifiedBaseTypeReferenceNode;

                        if (baseReference != null)
                        {
                            CppQualifiedName qualifiedName = baseReference.GetQualifiedName();

                            this.BaseClass = qualifiedName.GetNameStr();
                        }
                        else
                        {
                            LogManager.Self.Log("PenWebClassSpecifier() baseReference is null");
                        }
                    }
                }
                else
                {
                    LogManager.Self.Log("PenWebClassSpecifier() baseClause is null");
                }

                base.Init();

                this.CppFunctionCatagory = CppFunctionCatagory.ClassDef;

                if (!String.IsNullOrWhiteSpace(this.ClassName) && !String.IsNullOrWhiteSpace(this.BaseClass))
                {
                    this.SaveToJson = true;
                }

                IDeclaredElement declarationElement = this.ClassSpecifier.DeclaredElement;

                foreach (IDeclaration declaration in declarationElement.GetDeclarations())
                {
                }
            }
            catch (Exception e)
            {
                LogManager.Self.Log("PenWebClassSpecifier Exception", e);
            }

            this.ClassSpecifier = null;
        }
        public override IntersectionType Intersect(BaseClause clause)
        {
            //Then check numeric type
            if (double.TryParse(Value, out double currentClauseValue) && double.TryParse(clause.Value, out double innerClauseValue))
            {
                if (clause.Condition == ConditionType.Less)
                {
                    if (currentClauseValue >= innerClauseValue)
                    {
                        return(IntersectionType.Include);
                    }
                    else
                    {
                        return(IntersectionType.None);
                    }
                }

                if (clause.Condition == ConditionType.LessOrEqual)
                {
                    if (currentClauseValue >= innerClauseValue)
                    {
                        return(IntersectionType.Include);
                    }
                    else
                    {
                        return(IntersectionType.None);
                    }
                }

                if (clause.Condition == ConditionType.Equal)
                {
                    if (currentClauseValue >= innerClauseValue)
                    {
                        return(IntersectionType.Include);
                    }
                    else
                    {
                        return(IntersectionType.MutuallyExclude);
                    }
                }


                if (clause.Condition == ConditionType.Greater)
                {
                    if (currentClauseValue < innerClauseValue)
                    {
                        return(IntersectionType.MutuallyExclude);
                    }
                    else
                    {
                        return(IntersectionType.None);
                    }
                }

                if (clause.Condition == ConditionType.GreaterOrEqual)
                {
                    if (currentClauseValue <= innerClauseValue)
                    {
                        return(IntersectionType.MutuallyExclude);
                    }
                    else
                    {
                        return(IntersectionType.None);
                    }
                }
            }

            return(IntersectionType.None);
        }