/**
* 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()));
}
