private void StartCalculating() { var table = _data.GetTable(); var outcome = new List <IAsciiBasePropositionalOperator>(); foreach (var row in table) { if (row[row.Length - 1] == 1) { var list = new List <IAsciiBasePropositionalOperator>(); for (var x = 0; x < _names.Length; x++) { if (row[x] < 2) { list.Add(GetOperator(row[x], _names[x])); } } outcome.Add(list.Any() ? CombineOperators(list.ToArray(), '&') : new TruePropositionalOperator(_argumentManager)); } } _propositionalOperator = outcome.Any() ? CombineOperators(outcome.ToArray(), '|') : new FalsePropositionalOperator(_argumentManager); }
public TableuaxStep(IAsciiBasePropositionalOperator startOperator) { var propositional = startOperator; operators.Add(propositional); operatorIEnumerable = getNextParsingOperator(); }
public override void UpdateChild(int index, IAsciiBasePropositionalOperator baseOperator) { if (index > Operators.Count) { throw new ArgumentException(); } Operators[index] = baseOperator; }
public override void UpdateChild(int index, IAsciiBasePropositionalOperator baseOperator) { if (index != 0) { throw new NotImplementedException(); } _A = baseOperator; }
private bool FindOperator(char use) { _operator = _operatorFactory.GetOperator(use, _argumentManager); _ownOffset++; //The operatorfactory returns a operator if he finds it return(_operator != null); }
public SemanticTableauxParser(IAsciiBasePropositionalOperator baseOperator) { var not = new NotPropositionalOperator(baseOperator.GetArgumentsManager()); not.Instantiate(new [] { baseOperator.ToAndOrNot() }); Step = new TableuaxStep(not); HandleSteps(); }
private bool FindQuantifier(char use) { if (use == '@' || use == '!') { _operator = _operatorFactory.GetOperator(use, _argumentManager); _ownOffset++; return(true); } return(false); }
protected IAsciiBasePropositionalOperator SurroundWithNot(IAsciiBasePropositionalOperator baseOperator) { if (baseOperator is NotPropositionalOperator baseNot) { return(baseNot.GetChilds()[0]); } var not = new NotPropositionalOperator(_argumentManager); not.Instantiate(new [] { baseOperator }); return(not); }
private bool FindScalar(char use) { var regex = new Regex(@"[a-eg-su-z]"); var match = regex.Match(use.ToString()); if (match.Success) { _operator = _argumentManager.RequestOperator(use); return(true); } return(false); }
private void ParseArguments() { var arguments = new IAsciiBasePropositionalOperator[_operator.GetOperatorNeededArguments()]; for (var i = 0; i < _operator.GetOperatorNeededArguments(); i++) { while (!FindArgument()) { } arguments[i] = GetArgument(); } _operator.Instantiate(arguments); }
public static JsonModel CreateFromBaseOpeator(IAsciiBasePropositionalOperator baseOperator) { var json = new JsonModel(); var text = new TextModel(); text.title = baseOperator.ToName(); json.text = text; if (baseOperator.GetChilds() != null) { json.children = baseOperator.GetChilds().Where(x => x != null).Select(CreateFromBaseOpeator).ToList(); } return(json); }
private bool FindPredicate(char use) { var regex = new Regex(@"[A-EG-SU-Z]"); var match = regex.Match(use.ToString()); if (match.Success) { var predicate = new PredicateOperator(_argumentManager); predicate.SetName(use); _operator = predicate; return(true); } return(false); }
public override void UpdateChild(int index, IAsciiBasePropositionalOperator baseOperator) { switch (index) { case 0: _A = baseOperator; return; case 1: _B = baseOperator; return; } throw new NotImplementedException(); }
private bool AddOrChild(IAsciiBasePropositionalOperator baseOperator, IAsciiBasePropositionalOperator workChild) { List <IAsciiBasePropositionalOperator> list1 = operators.Where(x => x != baseOperator).ToList(); if (!list1.Contains(workChild)) { list1.Add(workChild); } var child1 = new TableuaxStep(list1, ExtensionalVariables); childs.Add(child1); return(true); }
private int NotCalcScore(IAsciiBasePropositionalOperator baseOperator) { switch (baseOperator) { case AndPropositionalOperator _: return(3); case NotPropositionalOperator _: return(CalcScore(baseOperator.GetChilds()[0])); case OrPropositionalOperator _: return(1); case ExtensionalQuantifierOperator _: return(5); case UniversalQuantifierOperator _: return(4); case AbstractConstantPropositionalOperator _: return(6); } throw new NotImplementedException(); }
private void AddChild(IAsciiBasePropositionalOperator baseOperator) { //Console.WriteLine("Child: "+ baseOperator.ToLogicString()); IAsciiBasePropositionalOperator work; if (baseOperator is NotPropositionalOperator) { var temp = baseOperator.GetChilds()[0].Negate(); work = temp; } else { work = baseOperator; } var stop = operatorsMadeIntoChilds.Contains(work) || operatorsMadeIntoChilds.Contains(baseOperator); operatorsMadeIntoChilds.Add(baseOperator); if (stop) { Console.WriteLine("STOP!"); return; } operatorsMadeIntoChilds.Add(work); if (work is OrPropositionalOperator) { AddOrChild(baseOperator, work.GetChilds()[0]); if (!work.GetChilds()[0].Equals(work.GetChilds()[1])) { AddOrChild(baseOperator, work.GetChilds()[1]); } return; } if (work is AndPropositionalOperator) { List <IAsciiBasePropositionalOperator> list = operators.Where(x => x != baseOperator).ToList(); var first = work.GetChilds()[0]; var second = work.GetChilds()[1]; if (!list.Contains(first)) { list.Add(first); } if (!list.Contains(second)) { list.Add(second); } var child = new TableuaxStep(list, ExtensionalVariables); childs.Add(child); return; } if (work is AbstractConstantPropositionalOperator) { List <IAsciiBasePropositionalOperator> list = operators.Where(x => x != baseOperator).ToList(); if (!list.Contains(work)) { list.Add(work); } var child = new TableuaxStep(list, ExtensionalVariables); childs.Add(child); return; } if (work is AbstractQuantifierOperator) { HandleQuantifierOperators(); return; } throw new NotImplementedException(); }
public override void Instantiate(IAsciiBasePropositionalOperator[] arg) { _A = arg[0]; _B = arg[1]; }
public abstract void UpdateChild(int index, IAsciiBasePropositionalOperator baseOperator);
public AbstractTrueTable(IAsciiBasePropositionalOperator oper) { _manager = oper.GetArgumentsManager(); _operator = oper; }
private IAsciiBasePropositionalOperator Process(IAsciiBasePropositionalOperator work) { var logic = work as IAsciiSinglePropositionalOperator; if (logic != null) { switch (logic.GetAsciiSymbol()) { case '>': var or = new OrPropositionalOperator(_manager); or.Instantiate(new [] { SurroundWithNot(logic.GetChilds()[0]), logic.GetChilds()[1] }); return(HandleOr(or)); case '=': var implication1 = new IfThenPropositionalOperator(_manager); implication1.Instantiate(new [] { logic.GetChilds()[0], logic.GetChilds()[1] }); var implication2 = new IfThenPropositionalOperator(_manager); implication2.Instantiate(new IAsciiBasePropositionalOperator[] { logic.GetChilds()[1], logic.GetChilds()[0] }); var and = new AndPropositionalOperator(_manager); and.Instantiate(new IAsciiBasePropositionalOperator[] { implication1, implication2 }); return(HandleAnd(and)); case '&': return(HandleAnd((AndPropositionalOperator)logic)); case '|': return(HandleOr((OrPropositionalOperator)logic)); case '~': return(logic); case '%': var nAnd = new AndPropositionalOperator(_manager); nAnd.Instantiate(logic.GetChilds()); return(SurroundWithNot(HandleAnd(nAnd))); case 'F': return(new TruePropositionalOperator(_manager)); case 'T': return(new FalsePropositionalOperator(_manager)); case '@': if (work is UniversalQuantifierOperator workUnversal) { var ext = new ExtensionalQuantifierOperator(_manager); ext.SetVariable(workUnversal.GetVariable()); ext.Instantiate(new[] { SurroundWithNot(logic.GetChilds()[0]) }); return(SurroundWithNot(ext)); } break; case '!': if (work is ExtensionalQuantifierOperator workExtensional) { var universal = new UniversalQuantifierOperator(_manager); universal.SetVariable(workExtensional.GetVariable()); universal.Instantiate(new[] { SurroundWithNot(logic.GetChilds()[0]) }); return(SurroundWithNot(universal)); } break; } } if (work is PredicateOperator predicate) { var result = new PredicateOperator(_manager); result.SetName(predicate.GetName()); foreach (var child in work.GetChilds()) { result.AddChild(Process(child)); } return(result); } if (work is ScalarPropositionalOperator scalar) { return(_manager.RequestOperator(scalar.GetName())); } throw new System.Exception("Operator not found"); }
public static IAsciiBasePropositionalOperator CloneOperator(IAsciiBasePropositionalOperator baseOperator) { var parser = new StringParser(baseOperator.ToString(), 0, baseOperator.GetArgumentsManager()); return(parser.GetOperator()); }
public NotifyDecorator(IAsciiBasePropositionalOperator oper, ArgumentsManager manager) { _manager = manager; _propositionalOperator = Process(oper); }
public void AddChild(IAsciiBasePropositionalOperator baseOperator) { Operators.Add(baseOperator); }
public override void UpdateChild(int index, IAsciiBasePropositionalOperator baseOperator) { throw new System.NotImplementedException(); }
public TruthTableCreator(IAsciiBasePropositionalOperator oper) : base(oper) { }