public ReducedBooleanExpression(ExpandedBooleanExpression bexpr)
{
_sortedVariables = bexpr.GetAllVariables();
ushort index = 0;
foreach (char c in _sortedVariables)
{
_alphabet[c] = index;
index++;
}
Implicant i = null;
foreach (string factor in bexpr.AsString.Split('+'))
{
i = new Implicant(this, factor);
if ((i == null) || (i.IsContradiction))
{
continue;
}
_implicants.Add(i);
}
//
CalculatePrimeImplicants();
BuildMintermToPrimeImplicantTable();
_mintermCount = _primeImplicantTable.Count();
PickFinalImplicants();
}
public static bool CheckEqual(Implicant gic1, Implicant sic2)
{
bool restult = true;
foreach (Minterm minterm in sic2.Minterms)
{
if (!gic1.Minterms.Contains(minterm))
{
restult = false;
}
}
return(restult);
}
private void PickFinalImplicants()
{
HashSet <uint> mintermsCovered = new HashSet <uint>();
foreach (var kv in _primeImplicantTable)
{
if (kv.Value.Count == 1)
{
Implicant i = kv.Value[0];
mintermsCovered.UnionWith(i.minterms);
_finalImplicants.Add(i);
}
}
//
if (mintermsCovered.Count < _mintermCount)
{
// if not all minterms are covered, apply the following heuristic:
// from the list of implicants belonging to uncovered minterms
// greedily add the implicants that cover the largest number of minterms
// until all minterms are covered.
//
// the minimum expression is not guaranteed, but f**k it
// I'm not implementing Petrick's method.
foreach (var kv in _primeImplicantTable)
{
if (mintermsCovered.Contains(kv.Key))
{
continue;
}
int maxTersmCovered = 0;
Implicant toAdd = null;
foreach (Implicant i in kv.Value)
{
if (i.minterms.Count > maxTersmCovered)
{
toAdd = i;
maxTersmCovered = i.minterms.Count;
}
}
_finalImplicants.Add(toAdd);
mintermsCovered.UnionWith(toAdd.minterms);
if (mintermsCovered.Count == _mintermCount)
{
break;
}
}
}
}
private void CalculatePrimeImplicants()
{
List <Implicant> startingSet;
List <Implicant> iterationPrimes = new List <Implicant>();
List <Implicant> nextSet = _implicants;
do
{
startingSet = nextSet;
startingSet.AddRange(iterationPrimes);
startingSet.Sort();
nextSet = new List <Implicant>();
iterationPrimes = new List <Implicant>();
for (int currIndex = 0; currIndex < startingSet.Count; currIndex++)
{
Implicant current = startingSet[currIndex];
bool combined = false;
for (int nextIndex = currIndex + 1; nextIndex < startingSet.Count; nextIndex++)
{
Implicant next = startingSet[nextIndex];
if (Math.Abs(current.Ones - next.Ones) > 1)
{
break;
}
Implicant mergedImplicant = current.Merge(next);
if (mergedImplicant != null)
{
combined = true;
nextSet.Add(mergedImplicant);
}
}
//
if (!combined)
{
iterationPrimes.Add(current);
}
}
} while (nextSet.Count > 0);
//
startingSet.AddRange(iterationPrimes);
_primeImplicants = new SortedSet <Implicant>(startingSet);
}
private void BtnSimplify_Click(object sender, RoutedEventArgs e)
{
if (ComboBoxVariableCount.SelectedIndex == 0)
{
MessageBox.Show("Error");
return;
}
List <Minterm> minterms = _mintermButtons
.Where(b =>
b.IsEnabled &&
(b.Content.Equals("1") ||
b.Content.Equals("D")))
.Select(b =>
new Minterm(Regex.Match(b.Name, @"\d+").Value))
.ToList();
if (ComboBoxVariableCount.SelectedIndex == 1)
{
try
{
Minterm minterm4 = minterms.First(m => m.Number == "4");
minterms.Remove(minterm4);
minterms.Add(new Minterm("2"));
}
catch (InvalidOperationException invalidOperationException)
{
Console.WriteLine(invalidOperationException);
}
try
{
Minterm minterm5 = minterms.First(m => m.Number == "5");
minterms.Remove(minterm5);
minterms.Add(new Minterm("3"));
}
catch (InvalidOperationException invalidOperationException)
{
Console.WriteLine(invalidOperationException);
}
}
new Thread(() =>
{
List <Minterm> orginMinterms = minterms;
List <int> numberOfOne = new List <int>();
foreach (Minterm minterm in minterms)
{
numberOfOne.Add(minterm.NumberofOnes);
}
int maxNumberOfOne = numberOfOne.Max();
foreach (Minterm minterm in minterms)
{
while (minterm.BinaryCode.Length < VariableCount)
{
minterm.BinaryCode = '0' + minterm.BinaryCode;
}
}
TruthTable groupTruthTable = new TruthTable(maxNumberOfOne);
groupTruthTable.GroupLists(minterms);
List <List <Implicant> > firstPrimeImplicants = new List <List <Implicant> >();
List <Implicant> implicants = (from mintermList in groupTruthTable.TruthTabales
from minterm in mintermList
select new Implicant(new List <Minterm>()
{
minterm
})).ToList();
firstPrimeImplicants.Add(implicants);
TruthTable gpTruthTable = groupTruthTable;
bool x = true;
while (true)
{
TruthTable gp;
if (x)
{
gp = GroupMintermCreate(gpTruthTable, true);
x = false;
}
else
{
gp = GroupMintermCreate(gpTruthTable, false);
}
gp.SortGroupList();
if (gp.TruthTabales.Length == 0)
{
break;
}
List <Implicant> implicantsInWhileList = new List <Implicant>();
foreach (List <Minterm> mintrms in gp.TruthTabales)
{
List <Minterm> implicantMinterms = new List <Minterm>();
foreach (Minterm minterm in mintrms)
{
implicantMinterms.Add(minterm);
}
Implicant implicant = new Implicant(implicantMinterms);
implicantsInWhileList.Add(implicant);
}
firstPrimeImplicants.Add(implicantsInWhileList);
gpTruthTable = gp;
}
for (int i = firstPrimeImplicants.Count - 1; i >= 0; i--)
{
for (int j = 0; j < firstPrimeImplicants[i].Count; j++)
{
if (firstPrimeImplicants[i][j].Status)
{
for (int k = 0; k < i; k++)
{
for (int l = 0; l < firstPrimeImplicants[k].Count; l++)
{
if (CheckEqual(firstPrimeImplicants[i][j], firstPrimeImplicants[k][l]))
{
firstPrimeImplicants[k][l].Status = false;
}
}
}
}
}
}
List <Implicant> primeImplicants = new List <Implicant>();
foreach (List <Implicant> implicantList in firstPrimeImplicants)
{
foreach (Implicant implicant in implicantList)
{
if (implicant.Status)
{
primeImplicants.Add(implicant);
}
}
}
List <Implicant> finalImplicants = new List <Implicant>();
bool[] mintermsUse = new bool[orginMinterms.Count];
for (int i = 0; i < mintermsUse.Length; i++)
{
mintermsUse[i] = false;
}
bool[,] implicantsTable = new bool[primeImplicants.Count, orginMinterms.Count];
for (int i = 0; i < orginMinterms.Count; i++)
{
for (int j = 0; j < primeImplicants.Count; j++)
{
if (primeImplicants[j].Minterms.Contains(orginMinterms[i]))
{
implicantsTable[j, i] = true;
}
else
{
implicantsTable[j, i] = false;
}
}
}
while (!CheckMinterUse(mintermsUse))
{
List <int> essentialList = new List <int>();
for (int i = 0; i < implicantsTable.GetLength(1); i++)
{
if (CheckEssentialImplicants(implicantsTable, i))
{
essentialList.Add(SendIndexOfEssential(implicantsTable, i));
}
}
foreach (int essential in essentialList)
{
for (int j = 0; j < orginMinterms.Count; j++)
{
if (primeImplicants[essential].Minterms.Contains(orginMinterms[j]))
{
mintermsUse[j] = true;
}
}
finalImplicants.Add(primeImplicants[essential]);
}
if (essentialList.Count > 0)
{
implicantsTable = UpdateImplicantsTable(implicantsTable, essentialList);
continue;
}
for (int i = 0; i < implicantsTable.GetLength(1); i++)
{
for (int j = 0; j < implicantsTable.GetLength(1); j++)
{
if (NumberOfDifferences(implicantsTable, i, j, false) == 1)
{
implicantsTable = UpdateImplicantsTable(implicantsTable,
NumberOfTrue(implicantsTable, i, false) > NumberOfTrue(implicantsTable, j, false)
? i
: j, false);
}
}
}
for (int i = 0; i < implicantsTable.GetLength(0); i++)
{
for (int j = 0; j < implicantsTable.GetLength(0); j++)
{
if (i == j)
{
continue;
}
if (NumberOfDifferences(implicantsTable, i, j, true) == 1)
{
implicantsTable = UpdateImplicantsTable(implicantsTable,
NumberOfTrue(implicantsTable, i, true) > NumberOfTrue(implicantsTable, j, true) ? j : i,
true);
}
else if (NumberOfDifferences(implicantsTable, i, j, true) == 0)
{
implicantsTable = UpdateImplicantsTable(implicantsTable, j, true);
}
}
}
}
List <Implicant> finalImplicantSorted = new List <Implicant>();
foreach (Implicant implicant in finalImplicants)
{
if (!finalImplicantSorted.Contains(implicant))
{
finalImplicantSorted.Add(implicant);
}
}
string result = "";
for (int i = 0; i < finalImplicantSorted.Count; i++)
{
result += finalImplicantSorted[i].ToString();
if (i % 10 == 0 && i != 0)
{
result += "\n";
}
}
Dispatcher.Invoke(() => { LblOutput.Content = result.Remove(result.Length - 1); });
}).Start();
}
