public void NandNode_11_Positive() { INode f1 = new FakeNode(true); INode f2 = new FakeNode(true); NandNode node = new NandNode("testName"); node.Inputs.Add(f1); node.Inputs.Add(f2); Assert.AreEqual(false, node.Process()[0]); }
public void NandNodeTest(bool input1, bool input2, bool expectedOutput) { var node = new NandNode(""); var states = new List <State> { new State(input1), new State(input2) }; node.Calculate(states.ToArray()); Assert.Equal(expectedOutput, node.CurrentState.LogicState); }
public void NandNodeOutputTest() { var a1 = new NandNode(); var a2 = new NandNode(); var a3 = new NandNode(); var a4 = new NandNode(); a1.Step(NodeCurrent.Low); a1.Step(NodeCurrent.Low); a2.Step(NodeCurrent.High); a2.Step(NodeCurrent.Low); a3.Step(NodeCurrent.Low); a3.Step(NodeCurrent.High); a4.Step(NodeCurrent.High); a4.Step(NodeCurrent.High); Assert.IsTrue(a1.Value == NodeCurrent.High); Assert.IsTrue(a2.Value == NodeCurrent.High); Assert.IsTrue(a3.Value == NodeCurrent.High); Assert.IsTrue(a4.Value == NodeCurrent.Low); }
public Node Nandify(Node tree) { /* * possible cases: * 1) implication * 2) bi-implication * 3) disjunction * 4) conjunction * 5) not * */ if (tree == null) { return(null); } var leftOfTree = tree.left; var rightOfTree = tree.right; var nandifiedLeftSubtree = Nandify(leftOfTree); var nandifiedRightSubtree = Nandify(rightOfTree); Node newTree; if (tree is ImplicationNode) { newTree = new NandNode(nandifiedLeftSubtree, new NandNode(nandifiedRightSubtree, DeepCopyTree(nandifiedRightSubtree))); } else if (tree is BiImplicationNode) { newTree = new NandNode( new NandNode( new NandNode(nandifiedLeftSubtree, DeepCopyTree(nandifiedLeftSubtree)), new NandNode(nandifiedRightSubtree, DeepCopyTree(nandifiedRightSubtree)) ), new NandNode(DeepCopyTree(nandifiedLeftSubtree), DeepCopyTree(nandifiedRightSubtree)) ); } else if (tree is DisjunctionNode) { newTree = new NandNode( new NandNode(nandifiedLeftSubtree, DeepCopyTree(nandifiedLeftSubtree)), new NandNode(nandifiedRightSubtree, DeepCopyTree(nandifiedRightSubtree)) ); } else if (tree is ConjunctionNode) { newTree = new NandNode( new NandNode(nandifiedLeftSubtree, DeepCopyTree(nandifiedRightSubtree)), new NandNode(DeepCopyTree(nandifiedLeftSubtree), nandifiedRightSubtree) ); } else if (tree is NotNode) { newTree = new NandNode(nandifiedLeftSubtree, DeepCopyTree(nandifiedLeftSubtree)); } else { newTree = tree; } return(newTree); }
/// <summary> /// A method that is called to actually build a tree from a given input. Is called from ProcessStringInput() /// </summary> /// <param name="input">input string</param> /// <param name="root">Node used in recursion for creating a binary tree</param> /// <exception cref="Exception"></exception> private void BuildTree(string input, Node root) { if (input == string.Empty) { return; } char first_character = input[0]; if (first_character == '~') { NotNode node = new NotNode(input, root); root.Insert(node); BuildTree(node.Value, node); } else if (first_character == '>') { ImplicationNode node = new ImplicationNode(input, root); root.Insert(node); BuildTree(node.Value, node); } else if (first_character == '=') { BiImplicationNode node = new BiImplicationNode(input, root); root.Insert(node); BuildTree(node.Value, node); } else if (first_character == '&') { ConjunctionNode node = new ConjunctionNode(input, root); root.Insert(node); BuildTree(node.Value, node); } else if (first_character == '|') { DisjunctionNode node = new DisjunctionNode(input, root); root.Insert(node); BuildTree(node.Value, node); } else if (first_character == '%') { NandNode node = new NandNode(input, root); root.Insert(node); BuildTree(node.Value, node); } else if (Char.IsUpper(first_character) && input[1] == '(') { /* predicate case */ /* P(x), Q(x) */ int closingBracketIndex = GetIndexOfClosingBracket(input, 1); var vars = QuantifierInputHandler.StringStartEndIndex(input, 2, closingBracketIndex - 1).Split(','); PredicateNode predicate = new PredicateNode(first_character); List <PropositionNode> propositions = new List <PropositionNode>(); foreach (var variable in vars) { propositions.Add(new PropositionNode(variable)); } predicate.Formulas = propositions; root.Insert(predicate); predicate.parent = root; input = input.Substring(closingBracketIndex + 1); BuildTree(input, predicate); } else if (first_character == '@' || first_character == '!') { string quantifierInput = QuantifierInputHandler.ParseOutInputForQuantifiers(input); QuantifierInputHandler quantifierInputHandler = new QuantifierInputHandler(quantifierInput); var node = quantifierInputHandler.Create(); node.parent = root; root.Insert(node); var newInput = input.Substring(IndexTillWhichStringAreSame(quantifierInput, input) + 1); BuildTree(newInput, node); } else if (first_character == ',') { if (root.parent == null) { throw new Exception("Error in your input"); } root = root.parent; input = input.Substring(1); BuildTree(input, root); } else if (Char.IsLetter(first_character)) { PropositionNode node = new PropositionNode(first_character.ToString(), input, root); root.Insert(node); BuildTree(node.Value, node); } else if (first_character == ')') { int numberOflevels = CalculateNumberOfLevelsToGoUp(input); for (int i = 0; i < numberOflevels; i++) { if (root.parent != null) { root = root.parent; } else { throw new Exception("Error in string input. Source: class Processor, method BuildTree, else if (')')"); } } input = input.Substring(numberOflevels); BuildTree(input, root); } else if (first_character == '(') { input = input.Substring(1); BuildTree(input, root); } }
public override Node CloneForFunctionCall(int clonedId, Node[] functionInputs) { if (_clonedId != clonedId) { _clonedId = clonedId; _cloned = new NandNode(_thisFunction, Left.CloneForFunctionCall(clonedId, functionInputs), Right.CloneForFunctionCall(clonedId, functionInputs)); } return _cloned; }
public int visit(NandNode NandNodeItem) { return((NandNodeItem.PropogationDelay) + 6); }