private Node Xor()
{
var node = And();
while (_lexer.TryReadChar('^'))
{
node = new XorNode(node, And());
}
return(node);
}
private void Initialize()
{
_prototypes["AND"] = new AndNode();
_prototypes["NOT"] = new NotNode();
_prototypes["NAND"] = new NotAndNode();
_prototypes["NOR"] = new NotOrNode();
_prototypes["OR"] = new OrNode();
_prototypes["PROBE"] = new OutputNode();
_prototypes["INPUT"] = new InputNode();
_prototypes["XOR"] = new XorNode();
_prototypes["NODE"] = new Node();
}
public void Visit(XorNode visitee)
{
_cumulativeDelay += (visitee.EndTime - visitee.StartTime);
_outputHandler.SendNodeValues(
visitee.Name,
"XorNode",
visitee.Inputs,
visitee.Result,
(visitee.EndTime - visitee.StartTime)
);
}
public void XorNodeTest(bool input1, bool input2, bool expectedOutput)
{
var node = new XorNode("");
var states = new List <State>
{
new State(input1),
new State(input2)
};
node.Calculate(states.ToArray());
Assert.Equal(expectedOutput, node.CurrentState.LogicState);
}
public void ShouldSerialiseXorCorrectly()
{
// arrange
var node = new XorNode
{
LeftChildNode = new TrueNode(),
RightChildNode = new FalseNode()
};
var doc = new XmlDocument();
var snf = new StalkNodeFactory(this.phabExternalMock.Object);
// act
var result = snf.ToXml(doc, node);
// assert
Assert.AreEqual("<xor><true /><false /></xor>", result.OuterXml);
}
private IStalkNode NewDoubleChildNode(XmlElement fragment)
{
DoubleChildLogicalNode node;
switch (fragment.Name)
{
case "xor":
node = new XorNode();
break;
default:
throw new XmlException("Unknown element " + fragment.Name);
}
var left = this.NewFromXmlFragment((XmlElement)fragment.ChildNodes[0]);
var right = this.NewFromXmlFragment((XmlElement)fragment.ChildNodes[1]);
node.LeftChildNode = left;
node.RightChildNode = right;
return(node);
}
public void ToMultilayerNetworkClassifier_XorSample_ClassifiesAsExpected()
{
int i = 0;
var xor1 = new XorNode() { X = true, Y = false };
var xor2 = new XorNode() { X = false, Y = false };
var xor3 = new XorNode() { X = true, Y = true };
var xor4 = new XorNode() { X = false, Y = true };
var samples = new[] { xor1, xor2, xor3, xor4 };
var pipeline = samples.AsQueryable().CreatePipeline();
var classifier = pipeline
.ToMultilayerNetworkClassifier(x => x.Output, 0.3f)
.ExecuteUntil(f =>
{
i++;
if (i > 200) return true;
return
f.Classify(xor1).First().ClassType == xor1.Output
&& f.Classify(xor2).First().ClassType == xor2.Output
&& f.Classify(xor3).First().ClassType == xor3.Output
&& f.Classify(xor4).First().ClassType == xor4.Output;
});
var classResults1 = classifier.Classify(xor1).First();
var classResults2 = classifier.Classify(xor2).First();
var classResults3 = classifier.Classify(xor3).First();
var classResults4 = classifier.Classify(xor4).First();
Assert.That(classResults1.ClassType == xor1.Output);
Assert.That(classResults2.ClassType == xor2.Output);
Assert.That(classResults3.ClassType == xor3.Output);
Assert.That(classResults4.ClassType == xor4.Output);
}
public void XorNodeOutputTest()
{
var a1 = new XorNode();
var a2 = new XorNode();
var a3 = new XorNode();
var a4 = new XorNode();
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.Low);
Assert.IsTrue(a3.Value == NodeCurrent.Low);
Assert.IsTrue(a4.Value == NodeCurrent.High);
}
public void Visit(XorNode node)
{
VisitChildren(node);
builder.AppendLine("\t\txor");
}
public Type Visit(XorNode node)
{
VisitBinaryOperator(node, Type.BOOL);
return(Type.BOOL);
}
public void Visit(XorNode visitee)
{
HasNextNode(visitee);
WillBeAbleToCalculate(visitee);
}
public void Visit(XorNode visitee)
{
SendOutput(visitee.Name, "XorNode", GetConnectionsString(visitee));
}
public int visit(XorNode XorNodeItem)
{
return((XorNodeItem.PropogationDelay) + 3);
}
