/** * This static function is used in the QuineColumn function and the general Quine algorithm to simplify boolean functions * its general putpose is to combine the parents arrays, not in any particular order, and then find the difference and add a null alue */ public static Implicant Combine(Implicant implicant1, Implicant implicant2) { bool[] newBitValue = new bool[implicant1.Length]; int[] newParents = new int[implicant2.parents.Length + implicant1.parents.Length]; bool[] newNullValue = new bool[implicant1.nullValue.Length]; for (int i = 0; i < implicant1.Length; i++) { if (implicant1.bitValue[i] != implicant2.bitValue[i] || implicant1.nullValue[i] == true || implicant2.nullValue[i] == true) { newBitValue[i] = false; newNullValue[i] = true; } else { newBitValue[i] = implicant1.bitValue[i]; } } for (int i = 0; i < implicant1.parents.Length; i++) { newParents[i] = implicant1.parentAt(i); } for (int i = implicant1.parents.Length; i < implicant1.parents.Length + implicant2.parents.Length; i++) { newParents[i] = implicant2.parentAt(i - implicant1.parents.Length); } return(new Implicant(newBitValue, newParents, newNullValue)); }
//returns the simplest form of this quine in booleanexpression format as a string public String ExpressionString() { if (!this.fullySimplified) { this.simplify(); } return(Implicant.ConvertToExpression(this.essentialImplicants)); }
/** * Simplifies the function first by finding the prime minterms and them the essential prime imlicants */ public List <Implicant> simplify() { this.findPrimeImplicants(); //System.Console.WriteLine(this.primeImplicantString()); //this.getImplicantChartString(); this.primeImplicantMapping = new ImplicantChart(this.primeImplicants); this.essentialImplicants.AddRange(this.primeImplicantMapping.findEssential()); this.fullySimplified = true; this.essentialImplicants = Implicant.RemoveDuplicatesInList(this.essentialImplicants); return(this.essentialImplicants); }
/** * Simplifies a list and removes any dublicates */ public static Tuple <QuineColumn, List <Implicant> > ColumnSimplify(QuineColumn column) { List <List <Implicant> > newColumn = new List <List <Implicant> >(); List <Implicant> unusedImplcants = buildUnusedList(column.implicants); for (int i = 0; i <= column.implicantLength; i++) { newColumn.Add(new List <Implicant>()); } for (int i = 0; i < column.implicants.Count - 1; i++) // Loops through the super list which sorts sublists based on the number of ones { for (int j = 0; j < column.implicants[i].Count; j++) // one column looping through { for (int m = 0; m < column.implicants[i + 1].Count; m++) // Lopp through next column looking for a match { if (Implicant.CanCombine(column.implicants[i][j], column.implicants[i + 1][m])) { //Console.WriteLine($"Trying to combine: {column[i][j].ToString()} {column[i + 1][m].ToString()}"); //Console.WriteLine($"These can combine: {Implicant.CanCombine(column[i][j], column[i+1][m])}"); Implicant newImp = Implicant.Combine(column.implicants[i][j], column.implicants[i + 1][m]); //Console.WriteLine($"Num Ones: {newImp.numOnes}"); //Console.WriteLine($"{newImp.ToString()}"); newColumn[newImp.numOnes].Add(newImp); if (unusedImplcants.Contains(column.implicants[i][j])) // Checks if either implucant is in the unused column, if unused removes and updates unused list { unusedImplcants.Remove(column.implicants[i][j]); } if (unusedImplcants.Contains(column.implicants[i + 1][m])) { unusedImplcants.Remove(column.implicants[i + 1][m]); } } } } } newColumn = QuineColumn.removeDublicates(newColumn); QuineColumn nextColumn = new QuineColumn(column.implicantLength, newColumn); return(Tuple.Create(nextColumn, unusedImplcants)); }
public void implicantTest() { BooleanAlgebra.Implicant imp1 = new BooleanAlgebra.Implicant(0, 5); BooleanAlgebra.Implicant imp2 = new BooleanAlgebra.Implicant(1, 5); BooleanAlgebra.Implicant imp3 = new BooleanAlgebra.Implicant(8, 5); BooleanAlgebra.Implicant imp4 = new BooleanAlgebra.Implicant(9, 5); System.Console.WriteLine($"{BooleanAlgebra.Implicant.CanCombine(imp1, imp2)}"); // true System.Console.WriteLine($"{BooleanAlgebra.Implicant.CanCombine(imp1, imp3)}"); // false BooleanAlgebra.Implicant imp1_2 = BooleanAlgebra.Implicant.Combine(imp1, imp2); Console.WriteLine($"{imp1_2.numOnes}"); BooleanAlgebra.Implicant imp3_4 = BooleanAlgebra.Implicant.Combine(imp3, imp4); Console.WriteLine(imp1_2.ToString()); Console.WriteLine(imp1_2.ToExpression()); Console.WriteLine(imp3_4.ToString()); Console.WriteLine(imp3_4.ToExpression()); Console.WriteLine($"{BooleanAlgebra.Implicant.CanCombine(imp1_2, imp3_4)}"); BooleanAlgebra.Implicant imp5 = BooleanAlgebra.Implicant.Combine(imp1_2, imp3_4); Console.WriteLine(imp5.ToString()); Console.WriteLine(imp5.ToExpression()); }
/* * Simplifies an expression and makes sure the same previous variables are used again in the new expression that is returned */ public BooleanExpression simplify() { if (!this.hasTruthTable()) { this.GenerateTruthTable(); } Quine simplifiedExpression = new Quine(this.truthTable.minterms.ToArray(), this.Variables.Count); List <Implicant> essentialImplicants = simplifiedExpression.simplify(); StringBuilder newExpression = new StringBuilder(Implicant.ConvertToExpression(essentialImplicants)); //Console.WriteLine("Intermediate expression: " + newExpression.ToString()); for (int i = 0; i < this.VariableNodes.Keys.Count; i++) { newExpression.Replace($"{(char)('A' + i)}", this.VariableNodes.Keys.ElementAt(i).ToLower()); //Console.WriteLine("Replacing " + $"{(char)('A' + i)}" + " with " + this.VariableNodes.Keys.ElementAt(i)); } return(new BooleanExpression(newExpression.ToString())); }
public static void implicantTest() { Implicant imp1 = new Implicant(0, 5); Implicant imp2 = new Implicant(1, 5); Implicant imp3 = new Implicant(8, 5); Implicant imp4 = new Implicant(9, 5); System.Console.WriteLine($"{Implicant.CanCombine(imp1, imp2)}"); // true System.Console.WriteLine($"{Implicant.CanCombine(imp1, imp3)}"); // false Implicant imp1_2 = Implicant.Combine(imp1, imp2); Console.WriteLine($"{imp1_2.numOnes}"); Implicant imp3_4 = Implicant.Combine(imp3, imp4); Console.WriteLine(imp1_2.ToString()); Console.WriteLine(imp3_4.ToString()); Console.WriteLine($"{Implicant.CanCombine(imp1_2, imp3_4)}"); Implicant imp5 = Implicant.Combine(imp1_2, imp3_4); Console.WriteLine(imp5.ToString()); }
/** * Checks to see if two implicants can be conbimed and returns true if thats the case * this is true if there is only one diffence between the implicants from the null values and the bit array */ public static bool CanCombine(Implicant imp1, Implicant imp2) { if (imp1.Length != imp1.Length) { return(false); } int differenceCounter = 0; for (int i = 0; i < imp1.Length; i++) { if (imp1.bitValue[i] != imp2.bitValue[i] || imp1.nullValue[i] != imp2.nullValue[i]) { differenceCounter += 1; } } if (differenceCounter != 1) { return(false); } else { return(true); } }
/* * This is a copy constructor, cheifly for use in the implicant chart class */ public Implicant(Implicant imp) : base(imp.bitValue) { this.nullValue = imp.nullValue; this.parents = imp.parents; this.numOnes = imp.numOnes; }
/** * A value is the same if the bitarray values and the null values are the same * parents isnt included because the equals function in the remove duplicates function in QUINE column is likely sensative to order */ public override bool Equals(object obj) { Implicant implicant = (Implicant)obj; return(base.Equals(obj) && System.Linq.Enumerable.SequenceEqual(this.nullValue, implicant.nullValue)); //&& System.Linq.Enumerable.SequenceEqual(implicant.parents, this.parents); }
//Gets the simplest Expression representing this kmap public String getSimpleExpression() { Quine tempQuine = new Quine(this.minterms); return(Implicant.ConvertToExpression(tempQuine.simplify())); }