Reactive Extensions Logic Circuit 1

RxLogicCircuit1.md

Reactive Extension Logic Circuit 1

Summary

This Gist is my experimental code of explanation for logic circuit with C#.
I think, using Reactive Extension, we can write more smart code for circuit(not only logical one).

Files

LogicSignal.cs

This class means logic wire. Logic gate elements are also provided.
For IObservalble<bool> instances with default value, factory method "CreateWithDefault" is exist.
"CheckOut" method is getting IObservable stream. If i don't use operator override, LogicSignal is same as IObservable<bool>

Circuit.cs

This shows how to use.
Using normaly, statements in 4 Subscribe methods will be Console.WriteLine method for value watching.

Circuit.cs

using System;

using System.Reactive.Linq;

namespace LogicCircuit
{
	using L = LogicSignal;

	public class Circuit
	{
		public void Run()
		{
			var portA = L.CreateWithDefault(false, Observable.Interval(TimeSpan.FromSeconds(2.0)).TakeWhile(i => i < 8).Select(i => i % 2 == 0));
			var portB = L.CreateWithDefault(false, Observable.Interval(TimeSpan.FromSeconds(1.0)).TakeWhile(i => i < 16).Select(i => i % 2 == 0));

			string A = string.Empty;
			string B = string.Empty;
			string A_and_B = string.Empty;
			string A_or_B = string.Empty;
			string not_A = string.Empty;
			string A_xor_B = string.Empty;

			portA.CheckOut().Subscribe(value => { A = "portA: " + value; });
			portB.CheckOut().Subscribe(value => { B = "portB: " + value; });


			L.And(portA, portB).CheckOut().Subscribe(value => { A_and_B = "A&B : " + value; });
			L.Or(portA, portB).CheckOut().Subscribe(value => { A_or_B = "A|B : " + value; });
			L.Not(portA).CheckOut().Subscribe(value => { not_A = " !A : " + value; });
			L.Xor(portA, portB).CheckOut().Subscribe(value => { A_xor_B = "A^B : " + value; });

			Observable.Merge(portA.CheckOut(), portB.CheckOut())
				.Delay(TimeSpan.FromMilliseconds(100.0)).Throttle(TimeSpan.FromMilliseconds(100.0))
				.Subscribe(_ =>
			{
				Console.Clear();

				Console.WriteLine(A);
				Console.WriteLine(B);
				Console.WriteLine(A_and_B);
				Console.WriteLine(A_or_B);
				Console.WriteLine(not_A);
				Console.WriteLine(A_xor_B);

			}, () => Console.WriteLine("End."));

			Console.Read();
		}
	}
}

LogicSignal.cs

using System;

using System.Reactive.Linq;

namespace LogicCircuit
{
	using Signal = IObservable<bool>;

	class LogicSignal
	{
		Signal value;
		public LogicSignal(Signal s)
		{
			this.value = s;
		}
		public Signal CheckOut()
		{
			return this.value;
		}

		static public LogicSignal CreateWithDefault(bool def, IObservable<bool> stream)
		{
			return new LogicSignal(stream.StartWith(def));
		}

		#region AND
		static public LogicSignal And(LogicSignal a, LogicSignal b)
		{
			return new LogicSignal(a.value.CombineLatest(b.value, (left, right) => left && right));
		}
		static public LogicSignal operator *(LogicSignal a, LogicSignal b)
		{
			return And(a, b);
		}
		#endregion

		#region OR
		static public LogicSignal Or(LogicSignal a, LogicSignal b)
		{
			return new LogicSignal(a.value.CombineLatest(b.value, (left, right) => left || right));
		}
		static public LogicSignal operator +(LogicSignal a, LogicSignal b)
		{
			return Or(a, b);
		}
		#endregion

		#region NOT
		static public LogicSignal Not(LogicSignal a)
		{
			return new LogicSignal(a.value.Select(value => !value));
		}
		static public LogicSignal operator ~(LogicSignal a)
		{
			return Not(a);
		}
		#endregion

		#region XOR
		static public LogicSignal Xor(LogicSignal a, LogicSignal b)
		{
			return new LogicSignal(a.value.CombineLatest(b.value, (left, right) => left != right));
		}
		#endregion
	}
}