public void Solve()
{
TList min;
Format output = new Format();
bool no_ones = checkNoOnes();
bool no_zeros = checkNoZeros();
if (no_ones && no_zeros)
{
Solution = "1 or 0";
}
else if (no_zeros)
{
Solution = "1";
}
else if (no_ones)
{
Solution = "0";
}
else
{
if (LogicPadParser.IsMinimizationActive)
{
fillTable();
min = minimize(table);
min = smoosh(min);
//Convert TruthTable Data Structure to InterTree
InterTree temp = null;
solution = output.formatOutput(
values,
min.getValues(),
min.getSubs(),
terms_names,
sum_of_products_or_product_of_sums,
one_sol_or_all_possible, ref temp
);
InterTree root = new InterTree(InterTree.LogicOperator.EQUAL);
root.LeftNode = new InterTree(this.CurrentTruthTable.outputName);
root.RightNode = temp;
LogicPadParser.truthTable = root;
}
else
{
//TODO without minimization
}
}
}
public static void TraverseTreeInOrder(InterTree root)
{
if (root.IsOperator)
{
//builder.Append("(");
if (root.LeftNode != null) TraverseTreeInOrder(root.LeftNode);
if (root.Operator == LogicOperator.AND)
{
//replaced "." with empty string
builder.Append("");
}
else if (root.Operator == LogicOperator.OR)
{
builder.Append("+");
}
else if(root.Operator == LogicOperator.EQUAL)
{
builder.Append("=");
}
else if (root.Operator == LogicOperator.NOT)
{
builder.Append("'");
}
else if (root.Operator == LogicOperator.XOR)
{
builder.Append("*");
}
if (root.RightNode != null) TraverseTreeInOrder(root.RightNode);
//builder.Append(")");
}
else
{
if (root.LeftNode != null) TraverseTreeInOrder(root.LeftNode);
builder.Append(root.Head);
if (root.RightNode != null) TraverseTreeInOrder(root.RightNode);
}
}
public static void ParseInterTreeToInterTreeList(ref InterTree root, ref List<InterTree> treeList)
{
if (root == null) return;
if (root.IsOperator)
{
if (root.Operator == LogicOperator.OR)
{
#region OR Gate
if (root.LeftNode != null)
{
if (root.LeftNode.IsOperator && root.LeftNode.Operator == LogicOperator.AND)
{
treeList.Add(root.LeftNode);
}
else if (!root.LeftNode.IsOperator)
{
treeList.Add(root.LeftNode);
}
else
{
ParseInterTreeToInterTreeList( ref root._leftNode, ref treeList);
}
}
if (root.RightNode != null)
{
if (root.RightNode.IsOperator && root.RightNode.Operator == LogicOperator.AND)
{
treeList.Add(root.RightNode);
}
else if (!root.RightNode.IsOperator)
{
treeList.Add(root.RightNode);
}
else
{
ParseInterTreeToInterTreeList(ref root._rightNode, ref treeList);
}
}
#endregion
}
else if(root.Operator == LogicOperator.AND)
{
#region And Gate
treeList.Add(root);
#endregion
}
else if (root.Operator == LogicOperator.XOR)
{
#region XOR Gate
//TODO
#endregion
}
else if (root.Operator == LogicOperator.NOT)
{
#region OR Gate
treeList.Add(root);
#endregion
}
return;
}
else {
treeList.Add(root);
return;
}
}
//Used for Calculating Tokens
public static void ParseInterTreeTokens(InterTree root, ref List<String> tokens)
{
if (root == null)
{
return;
}
if (root.IsOperator)
{
ParseInterTreeTokens(root.LeftNode, ref tokens);
ParseInterTreeTokens(root.RightNode, ref tokens);
}else {
if (!tokens.Contains(root.Head))
{
tokens.Add(root.Head);
}
return;
}
}
public static bool MatchTwoInterTree(InterTree tree1, InterTree tree2)
{
return MatchInternalTwoInterTree(tree1.RightNode, tree2.RightNode);
}
public static string ParseExpressionToString(InterTree root)
{
builder = new StringBuilder();
builder.Append(root.LeftNode.Head);
builder.Append(" = ");
TraverseTreeInOrder(root.RightNode);
return builder.ToString();
}
public static void ReformulateInterTree(ref InterTree root)
{
if (root == null)
{
return;
}
if (!root.IsOperator)
{
return;
}
else {
if (root.Operator == LogicOperator.OR)
{
}
else if(root.Operator == LogicOperator.AND){
if (root.LeftNode != null && root.LeftNode.IsOperator && root.LeftNode.Operator == LogicOperator.OR)
{
InterTree orTree = new InterTree(LogicOperator.OR);
InterTree duplicateOR = new InterTree(LogicOperator.AND);
InterTree rightNode = root.RightNode.MemberwiseClone() as InterTree;
duplicateOR.RightNode = rightNode;
rightNode.ParentNode = duplicateOR;
duplicateOR.LeftNode = root.LeftNode.RightNode;
root.LeftNode.RightNode.ParentNode = duplicateOR;
orTree.RightNode = duplicateOR;
InterTree duplicateOR2 = new InterTree(LogicOperator.AND);
duplicateOR2.RightNode = root.RightNode;
root.RightNode.ParentNode = duplicateOR2;
duplicateOR2.LeftNode = root.LeftNode.LeftNode;
root.LeftNode.LeftNode.ParentNode = duplicateOR2;
orTree.LeftNode = duplicateOR2;
root = orTree;
}
if (root.RightNode != null && root.RightNode.IsOperator && root.RightNode.Operator == LogicOperator.OR)
{
InterTree orTree = new InterTree(LogicOperator.OR);
InterTree duplicateOR = new InterTree(LogicOperator.AND);
InterTree leftNode = root.LeftNode.MemberwiseClone() as InterTree;
duplicateOR.LeftNode = leftNode;
leftNode.ParentNode = duplicateOR;
duplicateOR.RightNode = root.RightNode.LeftNode;
root.RightNode.LeftNode.ParentNode = duplicateOR;
orTree.LeftNode = duplicateOR;
InterTree duplicateOR2 = new InterTree(LogicOperator.AND);
duplicateOR2.LeftNode = root.LeftNode;
root.LeftNode.ParentNode = duplicateOR2;
duplicateOR2.RightNode = root.RightNode.RightNode;
root.RightNode.RightNode.ParentNode = duplicateOR2;
orTree.RightNode = duplicateOR2;
root = orTree;
}
}
else if (root.Operator == LogicOperator.XOR)
{
InterTree OrTree = new InterTree(LogicOperator.OR);
OrTree.LeftNode = new InterTree(LogicOperator.AND);
OrTree.RightNode = new InterTree(LogicOperator.AND);
OrTree.LeftNode.LeftNode = new InterTree(root.LeftNode);
OrTree.LeftNode.RightNode = new InterTree(LogicOperator.NOT);
OrTree.LeftNode.RightNode.LeftNode = new InterTree(root.RightNode);
OrTree.RightNode.LeftNode = new InterTree(LogicOperator.NOT);
OrTree.RightNode.LeftNode.LeftNode = new InterTree(root.LeftNode);
OrTree.RightNode.RightNode = new InterTree(root.RightNode);
root = OrTree;
}
if (root.LeftNode != null) { ReformulateInterTree(ref root._leftNode); }
if (root.RightNode != null) { ReformulateInterTree(ref root._rightNode); }
}
}
public static void CheckDominationLaw(ref InterTree tree)
{
if (tree != null)
{
if (tree._leftNode != null) CheckDominationLaw(ref tree._leftNode);
if (tree._rightNode != null) CheckDominationLaw(ref tree._rightNode);
}else return;
if (!tree.IsOperator)
{
return;
}
else
{
if (tree.Operator == LogicOperator.AND)
{
if (tree.LeftNode == null || tree.RightNode == null)
{
tree = null;
}
}
}
}
public static void AddParentToInterTree(ref InterTree tree)
{
InterTree temp;
if (tree == null)
{
return;
}
if (!tree.IsOperator)
{
return;
}
else {
if (tree.LeftNode != null)
{
tree.LeftNode.ParentNode = tree;
temp = tree.LeftNode;
AddParentToInterTree(ref temp);
}
if (tree.RightNode != null)
{
tree.RightNode.ParentNode = tree;
temp = tree.RightNode;
AddParentToInterTree(ref temp);
}
}
}
private XElement ConvertInterTreeToXElement(ref XElement gates, ref XElement wires, InterTree tree, DPoint parentPos)
{
if (tree.IsOperator)
{
#region
XElement gate = CheckInterTreeHead(ref gates, tree.Operator, new DPoint(parentPos.X - Rand(), parentPos.Y));
int toGateID = int.Parse(gate.Attribute("ID").Value);
if (tree.Operator == InterTree.LogicOperator.NOT)
{
//Not gate
XElement fromGate = ConvertInterTreeToXElement(ref gates, ref wires, tree.LeftNode, new DPoint(parentPos.X - Rand(), parentPos.Y));
int fromGateID = int.Parse(fromGate.Attribute("ID").Value);
XElement wire = new XElement("Wire", new XElement("From"), new XElement("To"));
wire.Element("From").SetAttributeValue("ID", fromGateID);
wire.Element("From").SetAttributeValue("Port", 0);
wire.Element("To").SetAttributeValue("ID", toGateID);
wire.Element("To").SetAttributeValue("Port", 0);
wires.Add(wire);
}
else {
//Left Child
XElement fromGate = ConvertInterTreeToXElement(ref gates, ref wires, tree.LeftNode, new DPoint(parentPos.X - Rand(), parentPos.Y - Rand()));
int fromGateID = int.Parse(fromGate.Attribute("ID").Value);
XElement wire = new XElement("Wire", new XElement("From"), new XElement("To"));
wire.Element("From").SetAttributeValue("ID", fromGateID);
wire.Element("From").SetAttributeValue("Port", 0);
wire.Element("To").SetAttributeValue("ID", toGateID);
wire.Element("To").SetAttributeValue("Port", 1);
wires.Add(wire);
//Right Child
fromGate = ConvertInterTreeToXElement(ref gates, ref wires, tree.RightNode, new DPoint(parentPos.X - Rand(), parentPos.Y + Rand()));
fromGateID = int.Parse(fromGate.Attribute("ID").Value);
wire = new XElement("Wire", new XElement("From"), new XElement("To"));
wire.Element("From").SetAttributeValue("ID", fromGateID);
wire.Element("From").SetAttributeValue("Port", 0);
wire.Element("To").SetAttributeValue("ID", toGateID);
wire.Element("To").SetAttributeValue("Port", 0);
wires.Add(wire);
}
return gate;
#endregion
}
else
{
#region
//Header So it is the input, add inputGate and relative Comment
string letter = tree.Head;
if (!addedInputGate.Keys.Contains(letter))
{
//Create one UserInput with Comment
XElement gt = new XElement("Gate");
gt.SetAttributeValue("Type", "UserInput");
gt.SetAttributeValue("Name", letter);
gt.SetAttributeValue("ID", cid);
gt.Add(new XElement("Point"));
gt.Element("Point").SetAttributeValue("X", parentPos.X - Rand());
gt.Element("Point").SetAttributeValue("Y", parentPos.Y);
gt.Element("Point").SetAttributeValue("Angle", 0.0f);
gates.Add(gt);
addedInputGate.Add(letter, gt);
cid++;
//iniX -= 80;
gt = new XElement("Gate");
gt.SetAttributeValue("Type", "Comment");
gt.SetAttributeValue("Name", letter);
gt.SetAttributeValue("ID", cid);
gt.Add(new XElement("Point"));
gt.Element("Point").SetAttributeValue("X", parentPos.X - 2 * Rand());
gt.Element("Point").SetAttributeValue("Y", parentPos.Y);
gt.Element("Point").SetAttributeValue("Angle", 0.0f);
gt.Add(new XElement("Comment", letter));
gates.Add(gt);
cid++;
//iniY += 80;
}
return addedInputGate[letter];
#endregion
}
}
//Expression
public string ParseExpressionXElement(XElement root)
{
LogicPadParser.expression = ParseXElement(root);
if (LogicPadParser.expression != null)
{
return InterTree.ParseExpressionToString(LogicPadParser.expression);
}
else
{
return null;
}
}
//Diagram
public string ParseDiagramXElement(XElement root)
{
LogicPadParser.diagram = ParseXElement(root);
if (LogicPadParser.diagram != null)
{
return InterTree.ParseDiagramToString(LogicPadParser.diagram);
}
else
{
return null;
}
}
//TruthTable
public void ParseInterTreeToTruthTable(InterTree tree,
out int number_of_term, out string[] term_names,
out int[] fvalue, out string outputName)
{
List<String> termList = new List<String>();
if (tree == null)
{
number_of_term = -1;
term_names = null;
fvalue = null;
outputName = null;
return;
}
outputName = tree.LeftNode.Head;
InterTree.ParseInterTreeTokens(tree.RightNode, ref termList);
term_names = termList.ToArray();
Array.Sort(term_names);
number_of_term = termList.Count;
//Add Parent pointer to each node
InterTree.AddParentToInterTree(ref tree._rightNode);
//Change Not Gate
InterTree.FilterNotGate(ref tree._rightNode);
//Change XOR and change Product to Summation
InterTree.ReformulateInterTree(ref tree._rightNode);
//Check Complement Law
//InterTree.CheckComplement(ref tree._rightNode);
//Check Domination Law
//InterTree.CheckDominationLaw(ref tree._rightNode);
/*
if (tree._rightNode == null)
{
number_of_term = 0;
term_names = null;
fvalue = null;
outputName = null;
return;
}
*/
TruthTable truthTable = new TruthTable(number_of_term);
truthTable.Terms_names = term_names;
truthTable.OutputName = outputName;
Dictionary<int, string[]> truthTableRows = truthTable.ConstructTruthTableRowList();
//Initialization
int row = (int)Math.Pow(2, number_of_term);
Dictionary<int, int> truthTableResults = new Dictionary<int, int>(row);
for (int index = 0; index < row; index++)
{
truthTableResults.Add(index, 0);
}
//Segement InterTree to InterTreeList
List<InterTree> interTreeList = new List<InterTree>();
InterTree.ParseInterTreeToInterTreeList(ref tree._rightNode, ref interTreeList);
List<List<string>> stringArray = new List<List<string>>();
InterTree.ParseInterTreeListToStringArray(interTreeList, ref stringArray, term_names);
if (stringArray.Count == 0)
{
number_of_term = 0;
term_names = null;
fvalue = null;
outputName = null;
return;
}
InterTree.MatchInterTreeToTruthTable(stringArray, truthTableRows, ref truthTableResults, row);
fvalue = truthTableResults.Values.ToArray();
}
//TruthTable
public XElement ParseTruthTable(InterTree rootTree)
{
Reset();
XElement root = new XElement("CircuitGroup");
root.SetAttributeValue("Version", "1.2");
XElement circuit = new XElement("Circuit");
XElement gates = new XElement("Gates");
XElement wires = new XElement("Wires");
XElement gt = new XElement("Gate");
gt.SetAttributeValue("Type", "Comment");
gt.SetAttributeValue("Name", rootTree.LeftNode.Head);
gt.SetAttributeValue("ID", cid);
gt.Add(new XElement("Point"));
gt.Element("Point").SetAttributeValue("X", dPoint.X);
gt.Element("Point").SetAttributeValue("Y", dPoint.Y);
gt.Element("Point").SetAttributeValue("Angle", 0.0f);
gt.Add(new XElement("Comment", rootTree.LeftNode.Head));
gates.Add(gt);
cid++;
//iniX -= 80;
gt = new XElement("Gate");
gt.SetAttributeValue("Type", "UserOutput");
gt.SetAttributeValue("Name", rootTree.LeftNode.Head);
gt.SetAttributeValue("ID", cid);
gt.Add(new XElement("Point"));
gt.Element("Point").SetAttributeValue("X", dPoint.X - deltaX);
gt.Element("Point").SetAttributeValue("Y", dPoint.Y);
gt.Element("Point").SetAttributeValue("Angle", 0.0f);
gates.Add(gt);
cid++;
//iniX -= 80;
XElement wire = new XElement("Wire", new XElement("From"), new XElement("To"));
wire.Element("From").SetAttributeValue("ID", 3);
wire.Element("From").SetAttributeValue("Port", 0);
wire.Element("To").SetAttributeValue("ID", 2);
wire.Element("To").SetAttributeValue("Port", 0);
wires.Add(wire);
ConvertInterTreeToXElement(ref gates, ref wires, rootTree.RightNode, new DPoint(dPoint.X - deltaX, dPoint.Y));
circuit.Add(gates);
circuit.Add(wires);
root.Add(circuit);
return root;
}
private static bool MatchInternalTwoInterTree(InterTree tree1, InterTree tree2)
{
if (tree1.IsOperator && tree2.IsOperator)
{
//Compare the head operator
if (tree1.Operator != tree2.Operator)
{
return false;
}
if (tree1.Operator != InterTree.LogicOperator.NOT)
{
//Compare two left node
if (tree1.LeftNode != null && tree2.RightNode != null)
{
if (!MatchInternalTwoInterTree(tree1.LeftNode, tree2.RightNode))
{
return false;
}
}
else if (tree1.LeftNode == null && tree2.RightNode == null)
{
//doing nothing,continue to comparee
return true;
}
else
{
return false;
}
//Compare two right node
if (tree1.RightNode != null && tree2.LeftNode != null)
{
if (!MatchInternalTwoInterTree(tree1.RightNode, tree2.LeftNode))
{
return false;
}
}
else if (tree1.RightNode == null && tree2.LeftNode == null)
{
//doing nothing, continue to compare
return true;
}
else
{
return false;
}
return true;
}
else
{
//Not Operator
//Compare two left node
if (tree1.LeftNode != null && tree2.LeftNode != null)
{
if (!MatchInternalTwoInterTree(tree1.LeftNode, tree2.LeftNode))
{
return false;
}
}
else if (tree1.LeftNode == null && tree2.LeftNode == null)
{
//doing nothing,continue to comparee
return true;
}
else
{
return false;
}
return true;
}
}
else if (!tree1.IsOperator && !tree2.IsOperator)
{
//Two Letters
return true;
}
else
{
//one Letter, one operator
return false;
}
}
private static String SearchForNode(InterTree root, String token)
{
String temp = null;
bool positive = false, negative = false;
if (root == null)
{
return null;
}
if (root.IsOperator)
{
if (root.Operator == LogicOperator.NOT)
{
if (root.LeftNode.Head.Equals(token))
{
negative = true;
}
}
else {
temp = SearchForNode(root.LeftNode, token);
if (temp != null)
{
if (temp.Equals(token))
positive = true;
if (temp.Equals(token + "'"))
negative = true;
if (temp.Equals("flag"))
{
positive = true;
negative = true;
}
}
temp = SearchForNode(root.RightNode, token);
if (temp != null)
{
if (temp.Equals(token))
positive = true;
if (temp.Equals(token + "'"))
negative = true;
if (temp.Equals("flag"))
{
positive = true;
negative = true;
}
}
}
}else
{
if (token.Equals(root.Head))
{
positive = true;
}
}
if (positive && negative)
return "flag";
else if (positive)
return token;
else if (negative)
return token + "'";
return null;
}
private XElement CheckInterTreeHead(ref XElement gates, InterTree.LogicOperator oper, DPoint point)
{
XElement gt = null;
//TODO: XOR Gate and Not Gate
if (oper == InterTree.LogicOperator.OR)
{
gt = new XElement("Gate");
gt.SetAttributeValue("Type", "Or");
gt.SetAttributeValue("Name", "Or");
gt.SetAttributeValue("ID", cid);
gt.SetAttributeValue("NumInputs", 2);
gt.Add(new XElement("Point"));
gt.Element("Point").SetAttributeValue("X", point.X);
gt.Element("Point").SetAttributeValue("Y", point.Y);
gt.Element("Point").SetAttributeValue("Angle", 0.0f);
gates.Add(gt);
cid++;
//iniX -= 80;
//iniY += 80;
}
else if (oper == InterTree.LogicOperator.AND)
{
gt = new XElement("Gate");
gt.SetAttributeValue("Type", "And");
gt.SetAttributeValue("Name", "And");
gt.SetAttributeValue("ID", cid);
gt.SetAttributeValue("NumInputs", 2);
gt.Add(new XElement("Point"));
gt.Element("Point").SetAttributeValue("X", point.X);
gt.Element("Point").SetAttributeValue("Y", point.Y);
gt.Element("Point").SetAttributeValue("Angle", 0.0f);
gates.Add(gt);
cid++;
//iniX -= 80;
//iniY += 80;
}
else if (oper == InterTree.LogicOperator.NOT)
{
gt = new XElement("Gate");
gt.SetAttributeValue("Type", "Not");
gt.SetAttributeValue("Name", "Not");
gt.SetAttributeValue("ID", cid);
gt.SetAttributeValue("NumInputs", 2);
gt.Add(new XElement("Point"));
gt.Element("Point").SetAttributeValue("X", point.X);
gt.Element("Point").SetAttributeValue("Y", point.Y);
gt.Element("Point").SetAttributeValue("Angle", 0.0f);
gates.Add(gt);
cid++;
}
return gt;
}
public static void FilterNotGate(ref InterTree tree)
{
if(tree == null)
{
return;
}
if (!tree.IsOperator)
{
return;
}
else
{
if (tree.Operator == LogicOperator.NOT)
{
if (tree.LeftNode != null && tree.LeftNode.IsOperator)
{
if (tree.LeftNode.Operator == LogicOperator.AND)
{
InterTree notLeftTree = new InterTree(LogicOperator.NOT);
InterTree notRightTree = new InterTree(LogicOperator.NOT);
InterTree orTree = new InterTree(LogicOperator.OR);
orTree.LeftNode = notLeftTree;
orTree.RightNode = notRightTree;
orTree.ParentNode = tree.ParentNode;
notLeftTree.LeftNode = tree.LeftNode.LeftNode;
notRightTree.LeftNode = tree.LeftNode.RightNode;
tree = orTree;
}
else if (tree.LeftNode.Operator == LogicOperator.OR)
{
InterTree notLeftTree = new InterTree(LogicOperator.NOT);
InterTree notRightTree = new InterTree(LogicOperator.NOT);
InterTree andTree = new InterTree(LogicOperator.AND);
andTree.LeftNode = notLeftTree;
andTree.RightNode = notRightTree;
andTree.ParentNode = tree.ParentNode;
notLeftTree.LeftNode = tree.LeftNode.LeftNode;
notRightTree.LeftNode = tree.LeftNode.RightNode;
tree = andTree;
}
}
}
FilterNotGate(ref tree._leftNode);
FilterNotGate(ref tree._rightNode);
}
}
public InterTree ParseXElement(XElement root)
{
parsedWires.Clear();
diagramGid.Clear();
XElement circuit = root.Element("Circuit");
//Like load XElement
if (root.Attribute("Version") != null && root.Attribute("Version").Value != "1.2")
throw new Exception("Unsupport version " + root.Attribute("Version").Value);
Gates.Circuit c = new Gates.Circuit();
XElement outputGate = null;
foreach (XElement gate in circuit.Element("Gates").Elements())
{
Gates.AbstractGate abgate = this.CreateGate(gate);
if (gate.Attribute("Type").Value == "UserOutput")
{
outputGate = gate;
}
c.Add(abgate);
int gateIDTest = int.Parse(gate.Attribute("ID").Value);
diagramGid.Add(int.Parse(gate.Attribute("ID").Value), abgate);
}
if(outputGate == null)
return null;
char letter = outputGate.Attribute("Name").Value[0];
InterTree rootInterTree = new InterTree(InterTree.LogicOperator.EQUAL);
rootInterTree.LeftNode = new InterTree(letter.ToString());
int gateID = int.Parse(outputGate.Attribute("ID").Value);
ConvertXElementToInterTree(gateID, ref rootInterTree, circuit);
return rootInterTree;
}
public static void CheckComplement(ref InterTree tree)
{
if (tree == null)
{
return;
}
if (!tree.IsOperator)
{
return;
}
else
{
if (tree.Operator == LogicOperator.AND)
{
if (tree.LeftNode != null && tree.LeftNode.IsOperator)
{
if (tree.LeftNode.Operator == LogicOperator.NOT)
{
if (tree.RightNode != null && tree.LeftNode.LeftNode != null && !tree.RightNode.IsOperator && !tree.LeftNode.LeftNode.IsOperator && tree.LeftNode.LeftNode.Head == tree.RightNode.Head)
{
tree = null;
}
}
}
else if (tree.RightNode != null && tree.RightNode.IsOperator)
{
if (tree.RightNode.Operator == LogicOperator.NOT)
{
if (tree.LeftNode != null && tree.RightNode.LeftNode != null && !tree.LeftNode.IsOperator && !tree.RightNode.LeftNode.IsOperator && tree.RightNode.LeftNode.Head == tree.LeftNode.Head)
{
tree = null;
//tree.LeftNode = null;
//tree.RightNode = null;
}
}
}
}
if (tree != null)
{
CheckComplement(ref tree._leftNode);
CheckComplement(ref tree._rightNode);
}
}
}
/*
* formatOutput format the answer to a readable string
*/
public String formatOutput(
int[] values,
List<int> mini_vals,
List<int> mini_subs,
String[] terms_names,
int sum_of_products_or_product_of_sums,
int one_sol_or_all_possible, ref InterTree truthTableInterTree)
{
PrimeImplicantsChartTable prime_implicant_chart =
new PrimeImplicantsChartTable(values, mini_vals, mini_subs, one_sol_or_all_possible);
List<int> essential_primes_indexs =
prime_implicant_chart.Essential_primes_indexs;
List<List<int>> minimume_compination_of_non_essential_table =
prime_implicant_chart.Minimume_compination_of_non_essential_table;
List<String> essential_primes_st_v = new List<String>();
String essential_primes_st = System.String.Empty;
List<String> non_essential_st_v = new List<String>();
List<InterTree> essential_interTree = new List<InterTree>();
InterTree tempInterTree = null;
for (int i = 0; i < essential_primes_indexs.Count; i++)
{
essential_primes_st_v.Add(
formatPrime(
mini_vals[essential_primes_indexs[i]],
mini_subs[essential_primes_indexs[i]],
terms_names,
sum_of_products_or_product_of_sums, ref tempInterTree));
essential_interTree.Add(tempInterTree);
}
if (essential_primes_st_v.Count > 0)
{
essential_primes_st =
addFormatedPrimes(essential_primes_st_v, sum_of_products_or_product_of_sums);
tempInterTree = addInterTreePrimes(essential_interTree, sum_of_products_or_product_of_sums);
truthTableInterTree = tempInterTree;
}
for (int i = 0; i < minimume_compination_of_non_essential_table.Count; i++)
{
List<int> temp = minimume_compination_of_non_essential_table[i];
List<String> temp_st = new List<String>();
for (int j = 0; j < temp.Count; j++)
temp_st.Add(
formatPrime(
mini_vals[temp[j]],
mini_subs[temp[j]],
terms_names,
sum_of_products_or_product_of_sums));
non_essential_st_v.Add(addFormatedPrimes(temp_st, sum_of_products_or_product_of_sums));
}
String final_answer = null;
if (!non_essential_st_v.Any())
{
final_answer = essential_primes_st;
}
else
{
for (int i = 0; i < non_essential_st_v.Count; i++)
final_answer += essential_primes_st +
((essential_primes_st.Length > 0) ?
//replaced "." with empty String
((sum_of_products_or_product_of_sums == 0) ? " + " : " . ") : "");
}
return final_answer;
}
public InterTree(InterTree tree)
{
if (tree.IsOperator)
{
this.IsOperator = true;
this.Operator = tree.Operator;
this.LeftNode = tree.LeftNode;
this.RightNode = tree.RightNode;
this.ParentNode = tree.ParentNode;
}
else {
this.Head = tree.Head;
this.IsOperator = false;
this.ParentNode = tree.ParentNode;
}
}
private InterTree addInterTreePrimes(List<InterTree> essential_interTree_list, int format)
{
InterTree result = null, gate;
result = essential_interTree_list[0];
for (int i = 1; i < essential_interTree_list.Count; i++)
{
if (format == 0)
{
//OR Gate
gate = new InterTree(InterTree.LogicOperator.OR);
}
else {
//AND Gate
gate = new InterTree(InterTree.LogicOperator.AND);
}
gate.LeftNode = essential_interTree_list[i];
gate.RightNode = result;
result = gate;
}
return result;
}
private String formatPrime(int value, int sub, String[] terms_names, int format, ref InterTree rootTree)
{
String answer = null;
bool check = false;
InterTree temp = null, gate = null;
for (int i = (terms_names.Length - 1); i >= 0; i--)
{
if ((sub % 2) == 0)
{
if (((value % 2) == 0 && format == 0) || ((value % 2) == 1 && format == 1))
{
if (check)
{
if (format == 0)
{
gate = new InterTree(InterTree.LogicOperator.AND);
}
else
{
gate = new InterTree(InterTree.LogicOperator.OR);
}
}
InterTree notGate = new InterTree(InterTree.LogicOperator.NOT);
notGate.LeftNode = new InterTree(terms_names[i].ToString());
if (check)
{
gate.LeftNode = notGate;
gate.RightNode = temp;
temp = gate;
}
else {
temp = notGate;
}
//replaced "." with empty String
answer = terms_names[i] + "'" + ((check) ? ((format == 0) ? "" : "+") : "") + answer;
}
else
{
if (!check)
{
//Only Letters
temp = new InterTree(terms_names[i].ToString());
}
else {
if (format == 0)
{
gate = new InterTree(InterTree.LogicOperator.AND);
}
else {
gate = new InterTree(InterTree.LogicOperator.OR);
}
gate.LeftNode = new InterTree(terms_names[i].ToString());
gate.RightNode = temp;
temp = gate;
}
answer = terms_names[i] + " " + ((check) ? ((format == 0) ? "" : "+") : "") + answer;
}
answer = " " + answer;
check = true;
}
sub /= 2;
value /= 2;
}
answer = "(" + answer + ")";
rootTree = temp;
return answer;
}
private void ConvertXElementToInterTree(int ID, ref InterTree root, XElement circuit)
{
InterTree tree = null;
foreach (XElement wire in circuit.Element("Wires").Elements())
{
int wireToGateID = int.Parse(wire.Element("To").Attribute("ID").Value);
if (wireToGateID == ID && !parsedWires.Contains(wire))
{
parsedWires.Add(wire);
//Retrieve the fromGateID
int wireFromGateID = int.Parse(wire.Element("From").Attribute("ID").Value);
Gates.AbstractGate fromGate = diagramGid[wireFromGateID];
if (fromGate is Gates.IOGates.UserInput)
{
string inputGateName = (fromGate as Gates.IOGates.UserInput).Name;
tree = new InterTree(inputGateName);
tree.LeftNode = null;
tree.RightNode = null;
}
else if (fromGate is Gates.BasicGates.And)
{
tree = new InterTree(InterTree.LogicOperator.AND);
}
else if (fromGate is Gates.BasicGates.Or)
{
tree = new InterTree(InterTree.LogicOperator.OR);
}
else if (fromGate is Gates.BasicGates.Xor)
{
tree = new InterTree(InterTree.LogicOperator.XOR);
}
else if (fromGate is Gates.BasicGates.Not)
{
tree = new InterTree(InterTree.LogicOperator.NOT);
}
else {
tree = new InterTree(InterTree.LogicOperator.OTHER);
}
if (root.LeftNode == null)
{
root.LeftNode = tree;
}
else
{
root.RightNode = tree;
}
ConvertXElementToInterTree(wireFromGateID, ref tree, circuit);
}
}
}
