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