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(); }