/* * Selects the smallest group of implicants which satisfy the equation from the matrix. */ private static ImplicantCollection SelectImplicants(ImplicantCollection implicants, int[] inputs) { List <int> lstToRemove = new List <int>(inputs); ImplicantCollection final = new ImplicantCollection(); while (lstToRemove.Count != 0) { //Implicant[] weightedTerms = WeightImplicants(implicants, final, lstToRemove); foreach (Implicant m in implicants) { bool add = false; foreach (int i in m.Minterms) { if (lstToRemove.Contains(i)) { add = true; } } if (add) { final.Add(m); foreach (int r in m.Minterms) { lstToRemove.Remove(r); } break; } } } return(final); }
/* * Selects the smallest group of implicants which satisfy the equation from the matrix. */ private static ImplicantCollection SelectImplicants(ImplicantCollection implicants, int[] inputs) { var lstToRemove = new List <int>(inputs); var final = new ImplicantCollection(); int runnumber = 0; while (lstToRemove.Count != 0) { //Implicant[] weightedTerms = WeightImplicants(implicants, final, lstToRemove); foreach (var m in implicants) { bool add = false; if (ContainsSubList(lstToRemove, m.Minterms)) { add = true; if (lstToRemove.Count < m.Minterms.Count) { break; } } else { add = false; } if (((lstToRemove.Count <= m.Minterms.Count) && add == false) || runnumber > 5) { if (ContainsAtleastOne(lstToRemove, m.Minterms) && runnumber > 5) { add = true; } } if (add) { final.Add(m); foreach (int r in m.Minterms) { lstToRemove.Remove(r); } } } foreach (var item in final) { implicants.Remove(item); //ami benne van már 1x, az még 1x ne } ++runnumber; } return(final); }
public static string GetSimplified(IEnumerable <LogicItem> List, int variables, bool hazardsafe = false, bool lsba = false, bool negate = false) { var implicants = new ImplicantCollection(); var items = (from i in List where i.Checked == true || i.Checked == null orderby i.Index ascending select i.Index).ToArray(); var careminterms = (from i in List where i.Checked == true orderby i.Index ascending select i.Index).ToArray(); foreach (var item in items) { var m = new Implicant(); m.Mask = LogicItem.GetBinaryValue(item, variables); m.Minterms.Add(item); implicants.Add(m); } //int count = 0; while (Simplify(ref implicants)) { //Populate a matrix. bool[,] matrix = new bool[implicants.Count, items.Length]; //x, y PopulateMatrix(ref matrix, implicants, items); } ImplicantCollection selected; if (hazardsafe) { selected = implicants; } else { selected = SelectImplicants(implicants, careminterms); } return(GetFinalExpression(selected, lsba, negate)); }
/* * Entry point. */ public static void Main(string[] args) { int[] input = null; Console.WriteLine("Michael Landi\t\tComp. Architecture."); Console.WriteLine("Boolean Simplification Program"); Console.WriteLine(); Console.Write("ENTER MINTERMS: "); string[] minterms = Console.ReadLine().Split(' '); Console.WriteLine(); //Parse and validate input. try { input = new int[minterms.Length]; for (int i = 0; i < input.Length; i++) { input[i] = -1; //That way we can check for duplicate zeroes. } //Empty string passed. if (minterms.Length == 0 || minterms[0].Trim() == string.Empty) { throw new Exception("No input."); } for (int i = 0; i < minterms.Length; i++) { int check = Int32.Parse(minterms[i]); if (check < 0) { throw new Exception("Input cannot be less than zero."); } if (input.Contains(check)) { throw new Exception("Input cannot contain the same minterm twice."); } input[i] = check; } Array.Sort(input); } catch (Exception ex) { Console.WriteLine("ERROR: " + ex.Message); Environment.Exit(-1); } //Create initial list of minterms. ImplicantCollection implicants = new ImplicantCollection(); foreach (int i in input) { Implicant m = new Implicant(); m.Mask = Convert.ToString(i, 2); m.Minterms.Add(i); implicants.Add(m); } //Simplify expressions. int count = 0; while (Simplify(ref implicants)) { //Populate a matrix. bool[,] matrix = new bool[implicants.Count, input.Length]; //x, y PopulateMatrix(ref matrix, implicants, input); PrintMatrix(matrix, input, ++count); } //Select implicants. ImplicantCollection selected = SelectImplicants(implicants, input); string strFinal = GetFinalExpression(selected); Console.WriteLine(); Console.WriteLine("SIMPLIFIED EXPRESSION: "); Console.WriteLine(strFinal); Console.ReadKey(); }
/* * Simplifies a givenset of implicants. */ private static bool Simplify(ref ImplicantCollection implicants) { /* * Group by number of 1's and determine relationships by comparing. */ ImplicantGroup group = Group(implicants); ImplicantRelationshipCollection relationships = new ImplicantRelationshipCollection(); for (int i = 0; i < group.Keys.Count; i++) { if (i == (group.Keys.Count - 1)) { break; } ImplicantCollection thisGroup = group[group.Keys.ElementAt(i)]; ImplicantCollection nextGroup = group[group.Keys.ElementAt(i + 1)]; foreach (Implicant a in thisGroup) { foreach (Implicant b in nextGroup) { if (GetDifferences(a.Mask, b.Mask) == 1) { relationships.Add(new ImplicantRelationship(a, b)); } } } } /* * For each relationship, find the affected minterms and remove them. * Then add a new implicant which simplifies the affected minterms. */ foreach (ImplicantRelationship r in relationships) { ImplicantCollection rmList = new ImplicantCollection(); foreach (Implicant m in implicants) { if (r.a.Equals(m) || r.b.Equals(m)) { rmList.Add(m); } } foreach (Implicant m in rmList) { implicants.Remove(m); } Implicant newImplicant = new Implicant(); newImplicant.Mask = GetMask(r.a.Mask, r.b.Mask); newImplicant.Minterms.AddRange(r.a.Minterms); newImplicant.Minterms.AddRange(r.b.Minterms); bool exist = false; foreach (Implicant m in implicants) { if (m.Mask == newImplicant.Mask) { exist = true; } } if (!exist) //Why am I getting dupes? { implicants.Add(newImplicant); } } //Return true if simplification occurred, false otherwise. return(!(relationships.Count == 0)); }
/* * Simplifies a givenset of implicants. */ private static bool Simplify(ref ImplicantCollection implicants) { /* * Group by number of 1's and determine relationships by comparing. */ var groups = (from i in Group(implicants) orderby i.Key select i).ToDictionary(i => i.Key, i => i.Value); var relationships = new ImplicantRelationshipCollection(); for (int i = 0; i < groups.Keys.Count; i++) { if (i == (groups.Keys.Count - 1)) { break; } var thisGroup = groups[groups.Keys.ElementAt(i)]; var nextGroup = groups[groups.Keys.ElementAt(i + 1)]; var q = from a in thisGroup from b in nextGroup where GetDifferences(a.Mask, b.Mask) == 1 select new ImplicantRelationship(a, b); relationships.AddRange(q); } /* * For each relationship, find the affected minterms and remove them. * Then add a new implicant which simplifies the affected minterms. */ foreach (ImplicantRelationship r in relationships) { var rmList = new ImplicantCollection(); foreach (Implicant m in implicants) { if (r.a.Equals(m) || r.b.Equals(m)) { rmList.Add(m); } } foreach (Implicant m in rmList) { implicants.Remove(m); } var newImplicant = new Implicant(); newImplicant.Mask = GetMask(r.a.Mask, r.b.Mask); newImplicant.Minterms.AddRange(r.a.Minterms); newImplicant.Minterms.AddRange(r.b.Minterms); bool exist = false; foreach (Implicant m in implicants) { if (m.Mask == newImplicant.Mask) { exist = true; } } if (!exist) //Why am I getting dupes? { implicants.Add(newImplicant); } } //Return true if simplification occurred, false otherwise. return(!(relationships.Count == 0)); }