public static bool EqualsZero(Byte2 a)
{
var eq0high = EqualsZero(a.High);
var eq0low = EqualsZero(a.Low);
return(Gates.And(eq0high, eq0low));
}
/// <summary>
/// Sends a data bit to one of two output channels.
/// </summary>
/// <param name="s">Determines if the data bit is dispatched through c1 or c0</param>
/// <param name="data">Data</param>
public static Channels Do(bool s, bool data)
{
var invS = Gates.Invert(s);
var channel0 = Gates.And(invS, data);
var channel1 = Gates.And(s, data);
return(new Channels(channel0, channel1));
}
/// <summary>
/// A latch component stores and outputs a single bit.
/// When st(store) is 1, the value on d is stored and emitted.
/// When st is 0, the value of d is ignored, and the previously stored value is still emitted.
/// </summary>
/// <param name="st">Store: yes/no</param>
/// <param name="d">Data</param>
/// <param name="clock">Clock signal</param>
/// <returns>The previously stored value</returns>
public bool Do(bool st, bool d, bool clock)
{
var invertedCLock = Gates.Invert(clock);
var storeButNotClockTick = Gates.And(st, invertedCLock);
var output = _latch1.Do(storeButNotClockTick, d);
return(_latch2.Do(clock, output));
}
public static Bit2 Add(bool a, bool b, bool c)
{
var xorAb = Gates.Xor(a, b);
var xorAbc = Gates.Xor(xorAb, c);
var and = Gates.And(xorAb, c);
var andAb = Gates.And(a, b);
return(new Bit2(Gates.Or(and, andAb), xorAbc));
}
public void AndTest()
{
IEnumerable <bool> inputA;
IEnumerable <bool> inputB;
IEnumerable <bool> expected;
IEnumerable <bool> actual;
inputA = new bool[] { false, true, false, true };
inputB = new bool[] { false, false, true, true };
expected = new bool[] { false, false, false, true };
actual = Gates.And(inputA, inputB);
Assert.IsTrue(expected.SequenceEqual(actual));
}
public Byte2 Do(Nibble address, bool store, Byte2 data, bool clock)
{
var invertedAddress = Gates.Invert(address.Three);
var storeAtRam0 = Gates.And(invertedAddress, store);
var storeAtRam1 = Gates.And(address.Three, store);
var output0 = _ram0.Do(address, storeAtRam0, data, clock);
var output1 = _ram1.Do(address, storeAtRam1, data, clock);
var outputTotal = Select16.Do(address.Three,
output1,
output0);
return(outputTotal);
}
public Byte2 Do(bool address, bool store, Byte2 data, bool clock)
{
var storeAtBank1 = Gates.And(address, store);
var invertedAddress = Gates.Invert(address);
var storeAtBank0 = Gates.And(invertedAddress, store);
_output1 = _register1.Do(storeAtBank1, data, clock);
_output0 = _register0.Do(storeAtBank0, data, clock);
var outputTotal = Select16.Do(address,
_output1,
_output0);
return(outputTotal);
}
public static bool Evaluate(Condition condition, Byte2 data)
{
var isLessThanZero = Arithmetics.IsLessThanZero(data);
var andIsLessThanZero = Gates.And(condition.LessThanZero, isLessThanZero);
var equalsZero = Arithmetics.EqualsZero(data);
var andIsEqualToZero = Gates.And(condition.EqualToZero, equalsZero);
var isGreaterThanZero = Gates.And(condition.GreaterThanZero,
Gates.And(Gates.Invert(isLessThanZero),
Gates.Invert(equalsZero)));
var lessOrEqual = Gates.Or(andIsLessThanZero, andIsEqualToZero);
var lessOrEqualOrGreater = Gates.Or(lessOrEqual, isGreaterThanZero);
return(lessOrEqualOrGreater);
}
public void False_false_should_return_false()
{
var res = Gates.And(false, false);
res.Should().BeFalse();
}
public void True_true_should_return_true()
{
var res = Gates.And(true, true);
res.Should().BeTrue();
}
