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)
{
}
