Example #1
0
        //CHECKS IF THIS ROW IS A SUBSET OF THE GIVEN MAIN
        public bool isPartOfRow(TruthtableRow main)
        {
            if (main.arguments.Count != this.arguments.Count)
            {
                throw new Exception("Rows cannot be compared!");
            }
            bool isPart = true;

            if (main.RowValue != this.RowValue)
            {
                return(false);
            }

            for (int i = 0; i < main.Arguments.Count; i++)
            {
                if (main.Arguments[i].Argument == this.arguments[i].Argument) //same argument
                {
                    if (main.Arguments[i].Value != '*')                       //main arg is 1 or 0, thus this arg should be the same as main arg
                    {
                        if (main.Arguments[i].Value != this.arguments[i].Value)
                        {
                            isPart = false;
                            break;
                        }
                    }
                }
                else
                {
                    throw new Exception("Rows cannot be compared!");
                }
            }
            return(isPart);
        }
Example #2
0
        public override bool GetAnswer(TruthtableRow row)
        {
            bool leftAnswer  = con1.GetAnswer(row);
            bool rightAnswer = con2.GetAnswer(row);

            if (leftAnswer || rightAnswer)
            {
                return(true);
            }
            return(false);
        }
Example #3
0
        //CREATE TRUTHTABLE ROWS WITH ROW VALUES
        private void createTruthtableRows()
        {
            if (argumentsChar != null)
            {
                if (argumentsChar.Count > 0)
                {
                    //calculting row true/false swap time (when to print true and when to print false)
                    List <int> rowLenght = new List <int>();
                    for (int i = argumentsChar.Count - 1; i >= 0; i--)
                    {
                        rowLenght.Add((int)Math.Pow(2, i));
                    }

                    //creating all rows
                    TruthtableRow           tempRow;
                    TruthtableRowArgument   tempArg;
                    TruthtableRowArgument[] args = new TruthtableRowArgument[argumentsChar.Count];
                    for (int i = rowLenght[0] * 2 - 1; i >= 0; i--)   //going to next row
                    {
                        for (int j = 0; j < argumentsChar.Count; j++) //creating one row
                        {
                            int cal = i / rowLenght[j];
                            if (cal % 2 == 0)
                            {
                                tempArg = new TruthtableRowArgument(argumentsChar[j], '1');
                            }
                            else
                            {
                                tempArg = new TruthtableRowArgument(argumentsChar[j], '0');
                            }
                            args[j] = tempArg;
                        }
                        tempRow = new TruthtableRow(args.ToList());
                        rows.Add(tempRow);
                    }
                }
                else //Only 1 and/or 0 arguments
                {
                    rows.Add(new TruthtableRow(new List <TruthtableRowArgument>()));
                }
            }
            else
            {
                throw new NullReferenceException();
            }
        }
Example #4
0
 //CREATE SIMPLE TABLE WITH ROW VALUES
 public List <TruthtableRow> GetSimpleTable()
 {
     if (argumentsChar.Count == 0) //only 0 and/or 1 arguments
     {
         List <TruthtableRow> tempList = new List <TruthtableRow>();
         TruthtableRow        tempRow  = new TruthtableRow(new List <TruthtableRowArgument>());
         bool rowValue = conHolder.GetTruthtableRowAnswer(tempRow);
         if (rowValue)
         {
             tempRow.RowValue = '1';
         }
         else
         {
             tempRow.RowValue = '0';
         }
         tempList.Add(tempRow);
         return(tempList);
     }
     return(getSimpleTableRec(new List <TruthtableRowArgument>(), 0));
 }
 public override bool GetAnswer(TruthtableRow row)
 {
     if (argument == '1')
     {
         return(true);
     }
     else if (argument == '0')
     {
         return(false);
     }
     else if (row.GetValueForArgument(argument) == '1')
     {
         return(true);
     }
     else if (row.GetValueForArgument(argument) == '0')
     {
         return(false);
     }
     else
     {
         throw new Exception("Encountered invalid symbol value for argument " + argument);
     }
 }
Example #6
0
 public abstract bool GetAnswer(TruthtableRow row);
Example #7
0
 //GET TRUTHTABLE ROW VALUE
 public bool GetTruthtableRowAnswer(TruthtableRow row)
 {
     return(startConnective.GetAnswer(row));
 }
        //public override Connective Copy()
        //{
        //    throw new NotImplementedException();
        //}

        public override bool GetAnswer(TruthtableRow row)
        {
            throw new NotImplementedException();
        }
Example #9
0
        private static List <TruthtableRow> getSubrowsOfMainRowRec(TruthtableRow main, int argIndex)
        {
            if (argIndex == main.Arguments.Count)
            {
                return(new List <TruthtableRow>()
                {
                    main
                });
            }
            List <TruthtableRow> subsets = new List <TruthtableRow>();

            if (main.Arguments[argIndex].Value == '*')
            {
                //copy Main and adjust it
                List <TruthtableRowArgument> newMainArguments = new List <TruthtableRowArgument>();
                for (int i = 0; i < main.Arguments.Count; i++) //copy arguments, but change current argument (on index)
                {
                    if (i == argIndex)
                    {
                        newMainArguments.Add(new TruthtableRowArgument(main.Arguments[i].Argument, '1'));
                    }
                    else
                    {
                        newMainArguments.Add(main.Arguments[i]);
                    }
                }
                TruthtableRow newMain = new TruthtableRow(newMainArguments);
                newMain.RowValue = main.RowValue;
                //get subRows if current arg == '1'
                foreach (TruthtableRow r in getSubrowsOfMainRowRec(newMain, argIndex + 1))
                {
                    subsets.Add(r);
                }
                TruthtableRowArgument[] newMainArguments2 = new TruthtableRowArgument[newMainArguments.Count];
                newMainArguments.CopyTo(newMainArguments2);
                newMainArguments2[argIndex] = new TruthtableRowArgument(main.Arguments[argIndex].Argument, '0');
                TruthtableRow newMain2 = new TruthtableRow(newMainArguments2.ToList());
                newMain2.RowValue = main.RowValue;
                //get subRows if current arg == '0'
                foreach (TruthtableRow r in getSubrowsOfMainRowRec(newMain2, argIndex + 1))
                {
                    subsets.Add(r);
                }
            }
            else if (main.Arguments[argIndex].Value == '1')
            {
                foreach (TruthtableRow r in getSubrowsOfMainRowRec(main, argIndex + 1))
                {
                    subsets.Add(r);
                }
            }
            else if (main.Arguments[argIndex].Value == '0')
            {
                foreach (TruthtableRow r in getSubrowsOfMainRowRec(main, argIndex + 1))
                {
                    subsets.Add(r);
                }
            }
            else
            {
                throw new Exception("Unknown char");
            }
            return(subsets);
        }
Example #10
0
 //GIVE SIMPLE TRUTHTABLEROW (WITH * ARGUMENT VALUES) AND GET ALL NON SIMPLE TRUTHTABLE ROWS RETURNED (NO * ARGUMENT VALUES)
 public static List <TruthtableRow> GetSubrowsOfMainRow(TruthtableRow main)
 {
     return(getSubrowsOfMainRowRec(main, 0));
 }