public Nand(AsciiFormula leftFormula, AsciiFormula rightFormula)
 {
     LeftFormula  = leftFormula;
     RightFormula = rightFormula;
 }
 public BiImplication(AsciiFormula leftFormula, AsciiFormula rightFormula)
 {
     LeftFormula  = leftFormula;
     RightFormula = rightFormula;
 }
 public Disjunction(AsciiFormula leftFormula, AsciiFormula rightFormula)
 {
     LeftFormula  = leftFormula;
     RightFormula = rightFormula;
 }
        public AsciiFormula FindNandifiedForm()
        {
            AsciiFormula result = MainFormula.Nandify();

            return(result);
        }
        private AsciiFormula AnalyzeFormula(string mainFormula)
        {
            AsciiFormula singleFormula;
            AsciiFormula leftFormula;
            AsciiFormula rightFormula;

            Variables = new List <Variable>();

            for (int i = mainFormula.Length - 1; i >= 0; i--)
            {
                char toBeChecked = mainFormula[i];
                if (!_toBeIgnoredChars.Contains(toBeChecked))
                {
                    switch (toBeChecked)
                    {
                    case '=':
                        leftFormula  = _stack.Pop();
                        rightFormula = _stack.Pop();
                        _stack.Push(new BiImplication(leftFormula, rightFormula));
                        break;

                    case '&':
                        leftFormula  = _stack.Pop();
                        rightFormula = _stack.Pop();
                        _stack.Push(new Conjunction(leftFormula, rightFormula));
                        break;

                    case '|':
                        leftFormula  = _stack.Pop();
                        rightFormula = _stack.Pop();
                        _stack.Push(new Disjunction(leftFormula, rightFormula));
                        break;

                    case '~':
                        singleFormula = _stack.Pop();
                        _stack.Push(new Negation(singleFormula));
                        break;

                    case '>':
                        leftFormula  = _stack.Pop();
                        rightFormula = _stack.Pop();
                        _stack.Push(new Implication(leftFormula, rightFormula));
                        break;

                    case char proposition when char.IsUpper(proposition):
                        Variable upperChar = CheckExistVariable(proposition);

                        if (upperChar == null)
                        {
                            upperChar = new Variable(proposition);
                            Variables.Add(upperChar);
                        }

                        _stack.Push(upperChar);
                        break;

                    case char proposition when char.IsLower(proposition):
                        Variable lowerChar = CheckExistVariable(proposition);

                        if (lowerChar == null)
                        {
                            lowerChar = new Variable(proposition);
                            Variables.Add(lowerChar);
                        }

                        _stack.Push(lowerChar);
                        break;

                    case '%':
                        leftFormula  = _stack.Pop();
                        rightFormula = _stack.Pop();
                        _stack.Push(new Nand(leftFormula, rightFormula));
                        break;

                    default:
                        return(null);
                    }
                }
            }

            if (_stack.Count > 0)
            {
                AsciiFormula resultFormula = _stack.Pop();
                resultFormula.Variables = Variables;
                resultFormula.Variables.Sort();
                return(resultFormula);
            }

            return(null);
        }
Exemple #6
0
 public TruthTable(AsciiFormula mainFormula, List <Variable> variables)
 {
     Variables   = variables;
     MainFormula = mainFormula;
 }