// creating counter by using one multibit register and 1 full addr to increment by 1
// using mux to decide if to increment or to get new input
public Counter(int iSize)
{
Size = iSize;
Input = new WireSet(Size);
Output = new WireSet(Size);
Load = new Wire();
val = new WireSet(Size);
val.SetValue(1);
mux_op = new BitwiseMux(Size);
adder = new MultiBitAdder(Size);
register = new MultiBitRegister(Size);
register.Load.Value = 1;
mux_op.ConnectControl(Load);
mux_op.ConnectInput1(adder.Output);
mux_op.ConnectInput2(Input);
register.ConnectInput(mux_op.Output);
Output.ConnectInput(register.Output);
adder.ConnectInput1(register.Output);
adder.ConnectInput2(val);
}
public BitwiseMultiwayMux(int iSize, int cControlBits)
{
Size = iSize;
Output = new WireSet(Size);
Control = new WireSet(cControlBits);
Inputs = new WireSet[(int)Math.Pow(2, cControlBits)];
for (int i = 0; i < Inputs.Length; i++)
{
Inputs[i] = new WireSet(Size);
}
int numOfInputs = Inputs.Length;
m_gBitwiseMux = new BitwiseMux[numOfInputs - 1];
for (int i = 0; i < m_gBitwiseMux.Length; i++)
{
m_gBitwiseMux[i] = new BitwiseMux(Size);
}
int currInputsToConnect = 0;
int currGateToConnect = 0;
int level = 1;
int currNumOfGates = numOfInputs / 2;
for (int j = 0; j < currNumOfGates; j++) //connecting all the inputs to gates
{
m_gBitwiseMux[currGateToConnect].ConnectInput1(Inputs[currInputsToConnect]);
m_gBitwiseMux[currGateToConnect].ConnectInput2(Inputs[currInputsToConnect + 1]);
m_gBitwiseMux[currGateToConnect].ConnectControl(Control[level - 1]);
currGateToConnect++;
currInputsToConnect += 2;
}
int previousGatesIndex = 0;
for (level = 2; level <= numOfInputs; level++) // connectig gates' outputs to next level gates' inputs
{
currNumOfGates = currNumOfGates / 2;
for (int j = 0; j < currNumOfGates; j++)
{
m_gBitwiseMux[currGateToConnect].ConnectInput1(m_gBitwiseMux[previousGatesIndex].Output);
m_gBitwiseMux[currGateToConnect].ConnectInput2(m_gBitwiseMux[previousGatesIndex + 1].Output);
m_gBitwiseMux[currGateToConnect].ConnectControl(Control[level - 1]);
currGateToConnect++;
previousGatesIndex += 2;
}
}
Output.ConnectInput(m_gBitwiseMux[currGateToConnect - 1].Output);
}
public BitwiseMultiwayMux(int iSize, int cControlBits)
{
Size = iSize;
Output = new WireSet(Size);
Control = new WireSet(cControlBits);
Inputs = new WireSet[(int)Math.Pow(2, cControlBits)];
for (int i = 0; i < Inputs.Length; i++)
{
Inputs[i] = new WireSet(Size);
}
bwmx = new BitwiseMux[(int)Math.Pow(2, cControlBits) - 1];
for (int i = 0; i < bwmx.Length; i++)
{
bwmx[i] = new BitwiseMux(iSize);
}
//Level
int j = 0;
for (int i = 0; 2 * i + 2 < bwmx.Length; i++)
{
bwmx[i].ConnectInput1(bwmx[2 * i + 1].Output);
bwmx[i].ConnectInput2(bwmx[2 * i + 2].Output);
j = i + 1;
}
for (int i = 0; i < Inputs.Length; i = i + 2)
{
bwmx[j].ConnectInput1(Inputs[i]);
bwmx[j].ConnectInput2(Inputs[i + 1]);
j++;
}
int k = 0;
for (int i = 0; i < bwmx.Length; i++)
{
if (i == (int)Math.Pow(2, k + 1) - 1)
{
k++;
}
bwmx[i].ConnectControl(Control[Control.Size - k - 1]);
}
Output.ConnectInput(bwmx[0].Output);
}
// in order to find the right input, for each level of inputs making mux operation with the corresponding control bit
// for all inputs in that level, after that repeat the procedure for the results of the muxes.
// to accomplish that I made array of bitwise mux , in the size of Inputs -1 , because there always be 1 less mux than the inputs
public BitwiseMultiwayMux(int iSize, int cControlBits)
{
//initilaize
Size = iSize;
ControlBits = cControlBits;
Output = new WireSet(Size);
Control = new WireSet(cControlBits);
Inputs = new WireSet[(int)Math.Pow(2, cControlBits)];
bitwise_mux_operation = new BitwiseMux[Inputs.Length - 1];
for (int i = 0; i < Inputs.Length; i++)
{
Inputs[i] = new WireSet(Size);
}
for (int i = 0; i < bitwise_mux_operation.Length; i++)
{
bitwise_mux_operation[i] = new BitwiseMux(Size);
}
// make mux operation on the first level of inputs with the first control bit
// so that the results will be stored in the first half of bitwise gates
for (int i = 0; i < bitwise_mux_operation.Length / 2 + 1; i++)
{
bitwise_mux_operation[i].ConnectControl(Control[0]);
bitwise_mux_operation[i].ConnectInput1(Inputs[i * 2]);
bitwise_mux_operation[i].ConnectInput2(Inputs[(i * 2) + 1]);
}
// iterates for each control bit (starting from the second) and saves each pair of outputs in inputs of bitwise mux
// so that the end result is in the last bitwisemux
int start_of_input = 0, end_of_input = bitwise_mux_operation.Length / 2 + 1, counter = 0;
for (int contol_bit = 1; contol_bit < cControlBits; contol_bit++)
{
for (int out_bit = start_of_input; out_bit < end_of_input; out_bit = out_bit + 2)
{
bitwise_mux_operation[counter + end_of_input].ConnectControl(Control[contol_bit]);
bitwise_mux_operation[counter + end_of_input].ConnectInput1(bitwise_mux_operation[out_bit].Output);
bitwise_mux_operation[counter + end_of_input].ConnectInput2(bitwise_mux_operation[out_bit + 1].Output);
counter++;
}
counter = 0;
start_of_input = end_of_input;
end_of_input = (end_of_input + (bitwise_mux_operation.Length - end_of_input) / 2) + 1;
}
// connect the output
Output.ConnectInput(bitwise_mux_operation[bitwise_mux_operation.Length - 1].Output);
}
public override bool TestGate()
{
try
{
for (int k = 1; k >= 0; k--)
{
ControlInput.Value = k;
for (int i = 0; i < Math.Pow(2, Size); i++)
{
for (int j = 0; j < Math.Pow(2, Size); j++)
{
BitwiseMux mgMux = new BitwiseMux(Size);
WireSet ws2 = new WireSet(Size);
WireSet ws1 = new WireSet(Size);
ws1.SetValue(i);
ws2.SetValue(j);
mgMux.ConnectInput1(ws1);
mgMux.ConnectInput2(ws2);
mgMux.ConnectControl(ControlInput);
for (int f = Size - 1; f >= 0; f--)
{
if (k == 0)
{
if (mgMux.Output[f].Value == ws1[f].Value)
{
continue;
}
return(false);
}
else if (mgMux.Output[f].Value != ws2[f].Value)
{
return(false);
}
}
}
}
}
}
catch (Exception e)
{
Console.WriteLine(e);
}
return(true);
}
//your code here
public BitwiseMultiwayMux(int iSize, int cControlBits)
{
Size = iSize;
Output = new WireSet(Size);
Control = new WireSet(cControlBits);
Inputs = new WireSet[(int)Math.Pow(2, cControlBits)];
WireSet[] wires = new WireSet[Inputs.Length];
BitwiseMux[] mux = new BitwiseMux[Inputs.Length - 1];
int muxIn = 0;
for (int i = wires.Length - 1; i >= 0; i--)
{
Inputs[i] = new WireSet(Size);
wires[i] = new WireSet(Size);
wires[i] = Inputs[i];
}
try
{
for (int currentControl = 0, wiresLength = wires.Length; wiresLength >= 2; wiresLength /= 2, currentControl++)
{
int outIN = 0;
for (int i = 0; i < wiresLength; i += 2)
{
mux[muxIn] = new BitwiseMux(Size);
if (currentControl <= cControlBits)
{
mux[muxIn].ConnectInput1(wires[i]);
mux[muxIn].ConnectInput2(wires[i + 1]);
mux[muxIn].ConnectControl(Control[currentControl]);
wires[outIN] = mux[muxIn].Output;
outIN++;
muxIn++;
}
}
}
Output.ConnectInput(mux[muxIn - 1].Output);
}
catch (Exception e)
{
Console.WriteLine(e);
}
}
//your code here
public BitwiseMultiwayMux(int iSize, int cControlBits)
{
Size = iSize;
Output = new WireSet(Size);
Control = new WireSet(cControlBits);
Inputs = new WireSet[(int)Math.Pow(2, cControlBits)];
for (int i = 0; i < Inputs.Length; i++)
{
Inputs[i] = new WireSet(Size);
}
BitwiseMux[] mux = new BitwiseMux[(int)Math.Pow(2, cControlBits) - 1];
WireSet[] wires = new WireSet[(int)Math.Pow(2, cControlBits)];
int wiresLength = wires.Length;
int currentMux = 0;
int toSave = 0;
int currentControl = 0;
for (int i = 0; i < wires.Length; i++)
{
wires[i] = Inputs[i];
}
while (wiresLength >= 2)
{
for (int i = 0; i < wiresLength; i = i + 2)
{
mux[currentMux] = new BitwiseMux(Size);
mux[currentMux].ConnectInput1(wires[i]);
mux[currentMux].ConnectInput2(wires[i + 1]);
mux[currentMux].ConnectControl(Control[currentControl]);
wires[toSave] = mux[currentMux].Output;
toSave++;
currentMux++;
}
wiresLength = wiresLength / 2;
toSave = 0;
currentControl++;
}
Output.ConnectInput(mux[currentMux - 1].Output);
}
public BitwiseMultiwayMux(int iSize, int cControlBits)
{
Size = iSize;
Output = new WireSet(Size);
Control = new WireSet(cControlBits);
Inputs = new WireSet[(int)Math.Pow(2, cControlBits)];
muxOutputs = new WireSet[Inputs.Length];
mux = new BitwiseMux[Inputs.Length];
int freeMux = 0;
for (int i = 0; i < Inputs.Length; i++)
{
Inputs[i] = new WireSet(Size);
muxOutputs[i] = new WireSet(Size);
mux[i] = new BitwiseMux(Size);
if (i % 2 == 1)
{
mux[freeMux].ConnectInput1(Inputs[i - 1]);
mux[freeMux].ConnectInput2(Inputs[i]);
mux[freeMux].ConnectControl(Control[0]);
muxOutputs[freeMux].ConnectInput(mux[freeMux].Output);
freeMux++;
}
}
int muxNum = freeMux / 2, whereToStart = 0, whereToEnd = freeMux;
for (int j = 1; j < cControlBits; j++)
{
for (int k = whereToStart; k < whereToEnd; k += 2)
{
mux[freeMux].ConnectInput1(muxOutputs[whereToStart]);
mux[freeMux].ConnectInput2(muxOutputs[whereToStart + 1]);
mux[freeMux].ConnectControl(Control[j]);
muxOutputs[freeMux].ConnectInput(mux[freeMux].Output);
freeMux++;
whereToStart += 2;
}
whereToEnd = freeMux;
}
Output.ConnectInput(muxOutputs[freeMux - 1]);
}
public override bool TestGate()
{
BitwiseMux bwmx;
MuxGate m_gLocalMux;
Wire w_local = new Wire();
for (int l = 0; l < 2; l++)
{
w_local.Value = l;
for (int j = 0; j < Math.Pow(2, Size); j++)
{
bwmx = new BitwiseMux(Size);
bwmx.ConnectInput1(InitTestVariables(j));
bwmx.ConnectInput2(InitRandTestVar(Size));
bwmx.ConnectControl(w_local);
for (int i = 0; i < Size; i++)
{
m_gLocalMux = new MuxGate();
m_gLocalMux.ConnectInput1(bwmx.Input1[i]);
m_gLocalMux.ConnectInput2(bwmx.Input2[i]);
m_gLocalMux.ConnectControl(w_local);
if (bwmx.Input1[i].Value == bwmx.Input2[i].Value && bwmx.Input2[i].Value == 1)
{
if (m_gLocalMux.Output.Value != bwmx.Output[i].Value)
{
return(false);
}
}
}
// UNCOMMENT THIS LINES TO SEE THE DEBUG PRINT
//System.Console.WriteLine(" Testing input1 " + " -> " + WStoString(bwmx.Input1));
//System.Console.WriteLine(" Testing input2 " + " -> " + WStoString(bwmx.Input2));
//System.Console.WriteLine(" Testing control" + " -> " + bwmx.ControlInput);
//System.Console.WriteLine(" Testing output " + " -> " + WStoString(bwmx.Output));
}
}
return(true);
}
static void Main(string[] args)
{
OrGate or = new OrGate();
XorGate xor = new XorGate();
AndGate and = new AndGate();
MuxGate mux = new MuxGate();
Demux demux = new Demux();
HalfAdder halfAdder = new HalfAdder();
FullAdder fullAdder = new FullAdder();
WireSet wireSet = new WireSet(9);
BitwiseAndGate bwag = new BitwiseAndGate(2);
BitwiseNotGate bwng = new BitwiseNotGate(3);
BitwiseOrGate bwog = new BitwiseOrGate(2);
BitwiseMux bwm = new BitwiseMux(2);
BitwiseDemux bwd = new BitwiseDemux(2);
MultiBitAndGate mbag = new MultiBitAndGate(4);
MultiBitAdder mba = new MultiBitAdder(3);
BitwiseMultiwayMux bwmwm = new BitwiseMultiwayMux(5, 4);
BitwiseMultiwayDemux bwmwd = new BitwiseMultiwayDemux(4, 4);
SingleBitRegister sbr = new SingleBitRegister();
MultiBitRegister mbr = new MultiBitRegister(4);
if (!sbr.TestGate())
{
Console.WriteLine("SingleBitRegisterbugbug");
}
if (!mbr.TestGate())
{
Console.WriteLine("MultiBitRegisterbugbug");
}
ALU alu = new ALU(4);
if (!alu.TestGate())
{
Console.WriteLine("ALUbugbug");
}
if (!bwmwd.TestGate())
{
Console.WriteLine("BitwiseMultiwayDemuxbugbug");
}
if (!bwmwm.TestGate())
{
Console.WriteLine("BitwiseMultiwayMuxbugbug");
}
if (!mba.TestGate())
{
Console.WriteLine("MultiBitAdderbugbug");
}
if (!mbag.TestGate())
{
Console.WriteLine("MultiBitAndGatebugbug");
}
if (!bwd.TestGate())
{
Console.WriteLine("BitWiseDemuxbugbug");
}
if (!bwm.TestGate())
{
Console.WriteLine("BitWiseMuxbugbug");
}
if (!bwog.TestGate())
{
Console.WriteLine("BitWiseOrGatebugbug");
}
if (!bwng.TestGate())
{
Console.WriteLine("BitWiseNotGatebugbug");
}
if (!bwag.TestGate())
{
Console.WriteLine("BitWiseAndGatebugbug");
}
wireSet.SetValue(137);
wireSet.Set2sComplement(-32);
if (!and.TestGate())
{
Console.WriteLine("andbugbug");
}
if (!or.TestGate())
{
Console.WriteLine("orbugbug");
}
if (!xor.TestGate())
{
Console.WriteLine("xorbugbug");
}
if (!mux.TestGate())
{
Console.WriteLine("muxbugbug");
}
if (!demux.TestGate())
{
Console.WriteLine("demuxbugbug");
}
if (!halfAdder.TestGate())
{
Console.WriteLine("HAbugbug");
}
if (!fullAdder.TestGate())
{
Console.WriteLine("FAbugbug");
}
Memory memory = new Memory(2, 6);
if (!memory.TestGate())
{
Console.WriteLine("Membugbug");
}
Console.WriteLine("done");
Console.ReadLine();
}
static void Main(string[] args)
{
AndGate and = new AndGate();
OrGate or = new OrGate();
XorGate xor = new XorGate();
MuxGate mux = new MuxGate();
Demux demux = new Demux();
HalfAdder ha = new HalfAdder();
FullAdder fa = new FullAdder();
if (!and.TestGate())
{
Console.WriteLine("bugbug");
}
Console.WriteLine("done And");
if (!or.TestGate())
{
Console.WriteLine("bugbug");
}
Console.WriteLine("done Or");
if (!xor.TestGate())
{
Console.WriteLine("bugbug");
}
Console.WriteLine("done Xor");
if (!mux.TestGate())
{
Console.WriteLine("bugbug");
}
Console.WriteLine("done Mux");
if (!demux.TestGate())
{
Console.WriteLine("bugbug");
}
Console.WriteLine("done Demux");
if (!ha.TestGate())
{
Console.WriteLine("bugbug");
}
Console.WriteLine("done HalfAdder");
if (!fa.TestGate())
{
Console.WriteLine("bugbug");
}
Console.WriteLine("done FullAdder");
WireSet num = new WireSet(4);
num.SetValue(6);
Console.WriteLine(num.ToString());
Console.WriteLine(num.GetValue());
Console.WriteLine("trying 2's complement");
WireSet num2 = new WireSet(4);
num2.Set2sComplement(6);
Console.WriteLine(num2.Get2sComplement());
WireSet num3 = new WireSet(4);
num3.Set2sComplement(-2);
Console.WriteLine(num3.Get2sComplement());
BitwiseAndGate BWAnd = new BitwiseAndGate(3);
BWAnd.TestGate();
BitwiseNotGate BWNot = new BitwiseNotGate(3);
BWNot.TestGate();
BitwiseOrGate BWOr = new BitwiseOrGate(3);
BWOr.TestGate();
BitwiseMux BWMux = new BitwiseMux(3);
BWMux.TestGate();
BitwiseDemux BWDemux = new BitwiseDemux(3);
BWDemux.TestGate();
MultiBitAndGate multiAnd = new MultiBitAndGate(3);
multiAnd.TestGate();
MultiBitAdder multiAdd = new MultiBitAdder(5);
multiAdd.TestGate();
BitwiseMultiwayMux multimux = new BitwiseMultiwayMux(8, 2);
WireSet[] inp = new WireSet[4];
inp[0] = new WireSet(8);
inp[0].Set2sComplement(1);
multimux.ConnectInput(0, inp[0]);
inp[1] = new WireSet(8);
inp[1].Set2sComplement(2);
multimux.ConnectInput(1, inp[1]);
inp[2] = new WireSet(8);
inp[2].Set2sComplement(3);
multimux.ConnectInput(2, inp[2]);
inp[3] = new WireSet(8);
inp[3].Set2sComplement(4);
multimux.ConnectInput(3, inp[3]);
WireSet control = new WireSet(2);
control.Set2sComplement(3);
multimux.ConnectControl(control);
multimux.TestGate();
BitwiseMultiwayDemux multidemux = new BitwiseMultiwayDemux(8, 1);
ALU alu = new ALU(16);
alu.TestGate();
SingleBitRegister sbr = new SingleBitRegister();
if (sbr.TestGate())
{
Console.WriteLine("sbr IS OK");
}
MultiBitRegister mbr = new MultiBitRegister(8);
if (mbr.TestGate())
{
Console.WriteLine("mbr IS OK");
}
Memory mem = new Memory(3, 6);
if (mem.TestGate())
{
Console.WriteLine("mem IS OK");
}
Console.ReadLine();
}
static void Main(string[] args)
{
//This is an example of a testing code that you should run for all the gates that you create
//
// //Create a gate
// AndGate and = new AndGate();
// //Test that the unit testing works properly
// if (!and.TestGate())
// Console.WriteLine("bugbug");
//
// //test or gate
// OrGate or = new OrGate();
// if (or.TestGate())
// Console.WriteLine("done or");
//
//test xor gate
// XorGate xor = new XorGate();
// if (xor.TestGate())
// Console.WriteLine("done xor");
//
// MultiBitAndGate mbaGate = new MultiBitAndGate(4);
// if (mbaGate.TestGate())
// Console.WriteLine("done mba");
//
// MultiBitOrGate mboGate = new MultiBitOrGate(4);
// if (mboGate.TestGate())
// Console.WriteLine("done mbo");
//
// MuxGate mux = new MuxGate();
// if (mux.TestGate())
// Console.WriteLine("done mux");
//
// Demux demux = new Demux();
// if (demux.TestGate())
// Console.WriteLine("done demux");
//
// BitwiseAndGate bwAg = new BitwiseAndGate(4);
// if (bwAg.TestGate())
// Console.WriteLine("done bwAg");
//
// BitwiseNotGate bwNg = new BitwiseNotGate(4);
// if (bwNg.TestGate())
// Console.WriteLine("done bwNg");
////
// BitwiseOrGate bwOg = new BitwiseOrGate(4);
// if (bwOg.TestGate())
// Console.WriteLine("done bwOg");
//
//
// WireSet ws = new WireSet(4);
// ws.SetValue(8);
// Console.WriteLine(ws.ToString());
////
// BitwiseMux bwMux = new BitwiseMux(4);
// if (bwMux.TestGate())
// Console.WriteLine("done bwMux");
//
// BitwiseDemux bwDemux = new BitwiseDemux(4);
// if (bwDemux.TestGate())
// Console.WriteLine("done bwDemux");
//
// BitwiseMultiwayMux bwMwMux = new BitwiseMultiwayMux(3,3);
// if (bwMwMux.TestGate())
// Console.WriteLine("done bwMwMux");
OrGate or = new OrGate();
XorGate xor = new XorGate();
AndGate and = new AndGate();
MuxGate mux = new MuxGate();
Demux demux = new Demux();
HalfAdder halfAdder = new HalfAdder();
FullAdder fullAdder = new FullAdder();
WireSet wireSet = new WireSet(9);
BitwiseAndGate bwag = new BitwiseAndGate(2);
BitwiseNotGate bwng = new BitwiseNotGate(3);
BitwiseOrGate bwog = new BitwiseOrGate(2);
BitwiseMux bwm = new BitwiseMux(2);
BitwiseDemux bwd = new BitwiseDemux(2);
MultiBitAndGate mbag = new MultiBitAndGate(4);
MultiBitAdder mba = new MultiBitAdder(3);
BitwiseMultiwayMux bwmwm = new BitwiseMultiwayMux(5, 4);
BitwiseMultiwayDemux bwmwd = new BitwiseMultiwayDemux(4, 4);
SingleBitRegister sbr = new SingleBitRegister();
MultiBitRegister mbr = new MultiBitRegister(4);
wireSet.SetValue(137);
wireSet.Set2sComplement(-32);
if (halfAdder.TestGate())
{
Console.WriteLine("HAbugbug");
}
if (fullAdder.TestGate())
{
Console.WriteLine("FAbugbug");
}
if (mba.TestGate())
{
Console.WriteLine("MultiBitAdderbugbug");
}
ALU alu = new ALU(16);
if (alu.TestGate())
{
Console.WriteLine("ALU bugbug");
}
Console.WriteLine("FINISH HIM");
}
public BitwiseMultiwayMux(int iSize, int cControlBits)
{
Size = iSize;
Output = new WireSet(Size);
Control = new WireSet(cControlBits);
Inputs = new WireSet[(int)Math.Pow(2, cControlBits)];
for (int i = 0; i < Inputs.Length; i++)
{
Inputs[i] = new WireSet(Size);
}
WireSet[] temp;
temp = new WireSet[Inputs.Length / 2];
int tempPointer = 0;
int controlindex = 0;
for (int i = 0; i + 1 < Inputs.Length; i += 2)
{
bitwiseMux = new BitwiseMux(iSize);
bitwiseMux.ConnectControl(Control[controlindex]);
bitwiseMux.ConnectInput1(Inputs[i]);
bitwiseMux.ConnectInput2(Inputs[i + 1]);
temp[tempPointer] = bitwiseMux.Output;
tempPointer++;
}
controlindex++;
int limit = temp.Length;
while (limit != 0)
{
tempPointer = 0;
for (int i = 0; i + 1 < limit; i += 2)
{
bitwiseMux = new BitwiseMux(iSize);
bitwiseMux.ConnectControl(Control[controlindex]);
bitwiseMux.ConnectInput1(temp[i]);
bitwiseMux.ConnectInput2(temp[i + 1]);
temp[tempPointer] = bitwiseMux.Output;
tempPointer++;
}
controlindex++;
limit /= 2;
}
Output.ConnectInput(temp[0]);
/* Queue<WireSet> temp1 = new Queue<WireSet>();
* Queue<WireSet> temp2 = new Queue<WireSet>();
*
* int controlindex = Control.Size-1;
*
* for (int i = 0; i < Inputs.Length ; i=i+2)
* {
* bitwiseMux = new BitwiseMux(iSize);
* bitwiseMux.ConnectControl(Control[controlindex]);
* bitwiseMux.ConnectInput1(Inputs[i]);
* bitwiseMux.ConnectInput2(Inputs[i]);
* temp1.Enqueue(bitwiseMux.Output);
*
* }
* controlindex--;
*
* int level = controlindex;
* while (level != -1)
* {
*
* if (temp2.Count == 0)
* {
* while (temp1.Count >= 2)
* {
* bitwiseMux = new BitwiseMux(iSize);
* bitwiseMux.ConnectControl(Control[controlindex]);
* bitwiseMux.ConnectInput1(temp1.Dequeue());
* bitwiseMux.ConnectInput2(temp1.Dequeue());
* temp2.Enqueue(bitwiseMux.Output);
*
* }
* }
* else if (temp1.Count == 0)
* {
* while (temp2.Count >= 2) {
* bitwiseMux = new BitwiseMux(iSize);
* bitwiseMux.ConnectControl(Control[controlindex]);
* bitwiseMux.ConnectInput1(temp2.Dequeue());
* bitwiseMux.ConnectInput2(temp2.Dequeue());
* temp1.Enqueue(bitwiseMux.Output);
* }
* }
* controlindex--;
* level--;
* }
*
* if (temp1.Count != 0)
* Output.ConnectInput( temp1.Dequeue());
* else
* Output.ConnectInput( temp2.Dequeue());
*
*/
/* WireSet[] temp;
* temp = new WireSet[Inputs.Length/2];
*
*
* for (int i =0;i+1<Inputs.Length ; i+=2) {
* bitwiseMux = new BitwiseMux(iSize);
* bitwiseMux.ConnectControl(Control[controlindex]);
* bitwiseMux.ConnectInput1(Inputs[i]);
* bitwiseMux.ConnectInput2(Inputs[i+1]);
*
* temp[tempPointer] = bitwiseMux.Output;
* tempPointer++;
* }
* controlindex--;
*
* int limit = temp.Length;
*
* while (limit != -1) {
*
* tempPointer = 0;
* for (int i = 0; i+1 < limit ;i+=2) {
* bitwiseMux = new BitwiseMux(iSize);
* bitwiseMux.ConnectControl(Control[controlindex]);
*
* bitwiseMux.ConnectInput1(temp[i]);
* bitwiseMux.ConnectInput2(temp[i+1]);
* temp[tempPointer] = bitwiseMux.Output;
* tempPointer++;
* }
*
* controlindex--;
* if (limit == 0) break;
* limit /= 2;
* }
*
* Output = temp[0];*/
}
public ALU(int iSize)
{
Size = iSize;
InputX = new WireSet(Size);
InputY = new WireSet(Size);
ZeroX = new Wire();
ZeroY = new Wire();
NotX = new Wire();
NotY = new Wire();
F = new Wire();
NotOutput = new Wire();
Negative = new Wire();
Zero = new Wire();
//Create and connect all the internal components
//init the muxes
Zx = new BitwiseMux(iSize);
Zy = new BitwiseMux(iSize);
nX = new BitwiseMux(iSize);
nY = new BitwiseMux(iSize);
f = new BitwiseMux(iSize);
nO = new BitwiseMux(iSize);
notX = new BitwiseNotGate(iSize);
notY = new BitwiseNotGate(iSize);
notOutput = new BitwiseNotGate(iSize);
and = new BitwiseAndGate(iSize);
fullAdder = new FullAdder();
WireSet zeros = new WireSet(iSize);
for (int i = 0; i < zeros.Size; i++)
{
zeros[i].ConnectInput(Zero);
}
Zx.ConnectInput1(InputX);
Zx.ConnectInput2(zeros);
Zx.ConnectControl(ZeroX);
/*for (int i = 0; i < zeros.Size; i++)
* {
* zeros[i].ConnectInput(Zero);
* }*/
Zy.ConnectInput1(InputY);
Zy.ConnectInput2(zeros);
Zy.ConnectControl(ZeroY);
nX.ConnectInput1(Zx.Output);
notX.ConnectInput(Zx.Output);
nX.ConnectInput2(notX.Output);
nX.ConnectControl(NotX);
nY.ConnectInput1(Zy.Output);
notY.ConnectInput(Zy.Output);
nY.ConnectInput2(notY.Output);
nY.ConnectControl(NotY);
and.ConnectInput1(nX.Output);
and.ConnectInput2(nY.Output);
WireSet addResult = new WireSet(iSize);
fullAdder.ConnectInput1(nX.Output[0]);
fullAdder.ConnectInput2(nY.Output[0]);
Wire Co = fullAdder.CarryOutput;
addResult[0].ConnectInput(fullAdder.Output);
for (int i = 1; i < iSize; i++)
{
fullAdder = new FullAdder();
fullAdder.ConnectInput1(nX.Output[i]);
fullAdder.ConnectInput2(nY.Output[i]);
fullAdder.CarryInput.ConnectInput(Co);
Co = new Wire();
Co.ConnectInput(fullAdder.CarryOutput);
addResult[i].ConnectInput(fullAdder.Output);
}
f.ConnectInput1(and.Output);
f.ConnectInput2(addResult);
f.ConnectControl(F);
nO.ConnectInput1(f.Output);
notOutput.ConnectInput(f.Output);
nO.ConnectInput2(notOutput.Output);
nO.ConnectControl(NotOutput);
Output = nO.Output;
}
//your code here
public ALU(int iSize)
{
Size = iSize;
InputX = new WireSet(Size);
InputY = new WireSet(Size);
ZeroX = new Wire();
ZeroY = new Wire();
NotX = new Wire();
NotY = new Wire();
F = new Wire();
NotOutput = new Wire();
Negative = new Wire();
Zero = new Wire();
//Create and connect all the internal components
Output = new WireSet(Size);
BitwiseMux m_gZX = new BitwiseMux(Size);
BitwiseMux m_gZY = new BitwiseMux(Size);
WireSet zeroForXY = new WireSet(Size);
zeroForXY.Set2sComplement(0);
BitwiseNotGate m_gNotX = new BitwiseNotGate(Size); // reverse X
BitwiseNotGate m_gNotY = new BitwiseNotGate(Size); // reverse Y
BitwiseMux m_gNX = new BitwiseMux(Size);
BitwiseMux m_gNY = new BitwiseMux(Size);
BitwiseAndGate m_gBAnd = new BitwiseAndGate(Size); // X & Y
MultiBitAdder mbAdder = new MultiBitAdder(Size); // X + Y
BitwiseMux m_gF = new BitwiseMux(Size);
BitwiseNotGate m_gNotFOut = new BitwiseNotGate(Size); // reverse F output
BitwiseMux m_gN = new BitwiseMux(Size);
MultiBitAndGate m_gZeroAnd = new MultiBitAndGate(Size);
BitwiseNotGate m_gZeroNot = new BitwiseNotGate(Size);
// connect inputX and input0 to ZX, connect ZXControl
m_gZX.ConnectInput1(InputX);
m_gZX.ConnectInput2(zeroForXY);
m_gZX.ConnectControl(ZeroX);
// connect bitwiseNotXIn to ZX output, connect ZXOut to NXIn1, connect bitwiseNotOut to NXIn2
m_gNotX.ConnectInput(m_gZX.Output);
m_gNX.ConnectInput1(m_gZX.Output);
m_gNX.ConnectInput2(m_gNotX.Output);
m_gNX.ConnectControl(NotX);
// connect inputY and input0 to ZY, connect ZYControl
m_gZY.ConnectInput1(InputY);
m_gZY.ConnectInput2(zeroForXY);
m_gZY.ConnectControl(ZeroY);
// connect bitwiseNotYIn to ZY output, connect ZYOut to NYIn1, connect bitwiseNotYOut to NYIn2
m_gNotY.ConnectInput(m_gZY.Output);
m_gNY.ConnectInput1(m_gZY.Output);
m_gNY.ConnectInput2(m_gNotY.Output);
m_gNY.ConnectControl(NotY);
// connect NXOut to bitwiseAndIn1, connect NYOut to bitwiseAndIn2
m_gBAnd.ConnectInput1(m_gNX.Output);
m_gBAnd.ConnectInput2(m_gNY.Output);
// connect NXOut to mbAdderIn1, connect NYOut to mbAdderIn2
mbAdder.ConnectInput1(m_gNX.Output);
mbAdder.ConnectInput2(m_gNY.Output);
// connect bitwiseAndOut to F_In1, connect mbAdderOut to F_In2
m_gF.ConnectInput1(m_gBAnd.Output);
m_gF.ConnectInput2(mbAdder.Output);
m_gF.ConnectControl(F);
//connect F_Out to bitwiseNotFIn
m_gNotFOut.ConnectInput(m_gF.Output);
// connect F_Out to N_In1, connect bitwiseNotFOut to N_In2
m_gN.ConnectInput1(m_gF.Output);
m_gN.ConnectInput2(m_gNotFOut.Output);
m_gN.ConnectControl(NotOutput);
// connect N_Out to Output
Output.ConnectInput(m_gN.Output);
// connect negativeIndicator to last Output wire
Negative.ConnectInput(Output[Size - 1]);
// connect ZeroIndicator depending on zeroNot and zeroAnd concatenation
m_gZeroNot.ConnectInput(Output);
m_gZeroAnd.ConnectInput(m_gZeroNot.Output);
Zero.ConnectInput(m_gZeroAnd.Output);
}
public ALU(int iSize)
{
Size = iSize;
InputX = new WireSet(Size);
InputY = new WireSet(Size);
ZeroX = new Wire();
ZeroY = new Wire();
NotX = new Wire();
NotY = new Wire();
F = new Wire();
NotOutput = new Wire();
Negative = new Wire();
Zero = new Wire();
Output = new WireSet(iSize);
muxZx = new BitwiseMux(iSize);
muxZy = new BitwiseMux(iSize);
muxNx = new BitwiseMux(iSize);
muxNy = new BitwiseMux(iSize);
muxF = new BitwiseMux(iSize);
muxNo = new BitwiseMux(iSize);
notNx = new BitwiseNotGate(iSize);
notNy = new BitwiseNotGate(iSize);
notNo = new BitwiseNotGate(iSize);
andF = new BitwiseAndGate(iSize);
adderF = new MultiBitAdder(iSize);
wireX0 = new WireSet(iSize);
wireX0.Set2sComplement(0);
wireY0 = new WireSet(iSize);
wireY0.Set2sComplement(0);
isZeroNot = new BitwiseNotGate(iSize);
isZeroMultiAnd = new MultiBitAndGate(iSize);
muxZx.ConnectInput1(InputX);
muxZx.ConnectInput2(wireX0);
muxZx.ConnectControl(ZeroX);
muxNx.ConnectInput1(muxZx.Output);
notNx.ConnectInput(muxZx.Output);
muxNx.ConnectInput2(notNx.Output);
muxNx.ConnectControl(NotX);
andF.ConnectInput1(muxNx.Output);
adderF.ConnectInput1(muxNx.Output);
muxZy.ConnectInput1(InputY);
muxZy.ConnectInput2(wireY0);
muxZy.ConnectControl(ZeroY);
muxNy.ConnectInput1(muxZy.Output);
notNy.ConnectInput(muxZy.Output);
muxNy.ConnectInput2(notNy.Output);
muxNy.ConnectControl(NotY);
andF.ConnectInput2(muxNy.Output);
adderF.ConnectInput2(muxNy.Output);
//now from muxF
muxF.ConnectInput1(andF.Output);
muxF.ConnectInput2(adderF.Output);
muxF.ConnectControl(F);
muxNo.ConnectInput1(muxF.Output);
notNo.ConnectInput(muxF.Output);
muxNo.ConnectInput2(notNo.Output);
muxNo.ConnectControl(NotOutput);
Output.ConnectInput(muxNo.Output);
Negative.ConnectInput(muxNo.Output[iSize - 1]);
isZeroNot.ConnectInput(muxNo.Output);
isZeroMultiAnd.ConnectInput(isZeroNot.Output);
Zero.ConnectInput(isZeroMultiAnd.Output);
}
public ALU(int iSize)
{
Size = iSize;
InputX = new WireSet(Size);
InputY = new WireSet(Size);
ZeroX = new Wire();
ZeroY = new Wire();
NotX = new Wire();
NotY = new Wire();
F = new Wire();
NotOutput = new Wire();
Negative = new Wire();
Zero = new Wire();
Output = new WireSet(Size);
zx = new BitwiseMux(Size);
zy = new BitwiseMux(Size);
nx = new BitwiseMux(Size);
ny = new BitwiseMux(Size);
fx = new BitwiseMux(Size);
nOut = new BitwiseMux(Size);
notX = new BitwiseNotGate(Size);
notY = new BitwiseNotGate(Size);
notOut = new BitwiseNotGate(Size);
notCheckzero = new BitwiseNotGate(Size);
fAdder = new MultiBitAdder(Size);
fAnd = new BitwiseAndGate(Size);
negCheck = new MultiBitAdder(Size);
zeroCheck = new MultiBitAndGate(Size);
//zx//
WireSet zeroXWire = new WireSet(Size);
zx.ConnectInput1(InputX);
zx.ConnectInput2(zeroXWire);
zx.ConnectControl(ZeroX);
//nx//
nx.ConnectInput1(zx.Output);
notX.ConnectInput(zx.Output);
nx.ConnectInput2(notX.Output);
nx.ConnectControl(NotX);
//zy//
WireSet zeroYWire = new WireSet(Size);
zy.ConnectInput1(InputY);
zy.ConnectInput2(zeroYWire);
zy.ConnectControl(ZeroY);
//ny//
ny.ConnectInput1(zy.Output);
notY.ConnectInput(zy.Output);
ny.ConnectInput2(notY.Output);
ny.ConnectControl(NotY);
//f//
fAnd.ConnectInput1(nx.Output);
fAnd.ConnectInput2(ny.Output);
fAdder.ConnectInput1(nx.Output);
fAdder.ConnectInput2(ny.Output);
fx.ConnectInput1(fAnd.Output);
fx.ConnectInput2(fAdder.Output);
fx.ConnectControl(F);
//not Outpot
nOut.ConnectInput1(fx.Output);
notOut.ConnectInput(fx.Output);
nOut.ConnectInput2(notOut.Output);
nOut.ConnectControl(NotOutput);
Output = nOut.Output;
//negative number check
negCheck.ConnectInput1(nOut.Output);
negCheck.ConnectInput2(nOut.Output);
Negative = negCheck.Overflow;
//Zero number check
notCheckzero.ConnectInput(nOut.Output);
zeroCheck.ConnectInput(notCheckzero.Output);
Zero = zeroCheck.Output;
}
public ALU(int iSize)
{
Size = iSize;
InputX = new WireSet(Size);
InputY = new WireSet(Size);
ZeroX = new Wire();
ZeroY = new Wire();
NotX = new Wire();
NotY = new Wire();
F = new Wire();
NotOutput = new Wire();
Negative = new Wire();
Zero = new Wire();
Output = new WireSet(Size);
var fx = new BitwiseMux(Size);
var fAdder = new MultiBitAdder(Size);
var fAnd = new BitwiseAndGate(Size);
var notX = new BitwiseNotGate(Size);
var notY = new BitwiseNotGate(Size);
var notCheckzero = new BitwiseNotGate(Size);
var zeroCheck = new MultiBitAndGate(Size);
var nOut = new BitwiseMux(Size);
var notOut = new BitwiseNotGate(Size);
var nx = new BitwiseMux(Size);
var ny = new BitwiseMux(Size);
var zx = new BitwiseMux(Size);
var zy = new BitwiseMux(Size);
var wireX0 = new WireSet(iSize);
var wireY0 = new WireSet(iSize);
wireX0.Set2sComplement(0);
wireY0.Set2sComplement(0);
try
{
//zx//
var zeroXWire = new WireSet(Size);
zeroXWire.Set2sComplement(0);
zx.ConnectInput1(InputX);
zx.ConnectInput2(zeroXWire);
zx.ConnectControl(ZeroX);
}
catch (Exception e)
{
Console.WriteLine("zx exp" + e.Message);
}
try
{
//nx//
nx.ConnectInput1(zx.Output);
notX.ConnectInput(zx.Output);
nx.ConnectInput2(notX.Output);
nx.ConnectControl(NotX);
}
catch (Exception e)
{
Console.WriteLine("nx exp" + e.Message);
}
try
{
//zy//
var zeroYWire = new WireSet(Size);
zeroYWire.Set2sComplement(0);
zy.ConnectInput1(InputY);
zy.ConnectInput2(zeroYWire);
zy.ConnectControl(ZeroY);
}
catch (Exception e)
{
Console.WriteLine("zy exp" + e.Message);
}
try
{
//ny//
ny.ConnectInput1(zy.Output);
notY.ConnectInput(zy.Output);
ny.ConnectInput2(notY.Output);
ny.ConnectControl(NotY);
}
catch (Exception e)
{
Console.WriteLine("ny exp" + e.Message);
}
try
{
//f//
fAdder.ConnectInput1(nx.Output);
fAdder.ConnectInput2(ny.Output);
fAnd.ConnectInput1(nx.Output);
fAnd.ConnectInput2(ny.Output);
fx.ConnectInput1(fAnd.Output);
fx.ConnectInput2(fAdder.Output);
fx.ConnectControl(F);
}
catch (Exception e)
{
Console.WriteLine("f exp" + e.Message);
throw;
}
try
{
notOut.ConnectInput(fx.Output);
nOut.ConnectInput1(fx.Output);
nOut.ConnectInput2(notOut.Output);
nOut.ConnectControl(NotOutput);
/*********************************/
Output = nOut.Output;
/*********************************/
}
catch (Exception e)
{
Console.WriteLine("not Output exp" + e.Message);
}
try
{
//negative number check
Negative = Output[Size - 1];
//Zero number check
notCheckzero.ConnectInput(nOut.Output);
zeroCheck.ConnectInput(notCheckzero.Output);
Zero.ConnectInput(zeroCheck.Output);
}
catch (Exception e)
{
Console.WriteLine("Output info exp" + e.Message);
throw;
}
}
public ALU(int iSize)
{
Size = iSize;
InputX = new WireSet(Size);
InputY = new WireSet(Size);
ZeroX = new Wire();
ZeroY = new Wire();
NotX = new Wire();
NotY = new Wire();
F = new Wire();
NotOutput = new Wire();
Negative = new Wire();
Zero = new Wire();
//Create and connect all the internal components
muxZeroX = new BitwiseMux(Size);
muxZeroY = new BitwiseMux(Size);
muxNegX = new BitwiseMux(Size);
muxNegY = new BitwiseMux(Size);
muxFunc = new BitwiseMux(Size);
muxNegOut = new BitwiseMux(Size);
mbAdder = new MultiBitAdder(Size);
bwAnd = new BitwiseAndGate(Size);
mbOr = new MultiBitOrGate(Size);
bwNot1 = new BitwiseNotGate(Size);
bwNot2 = new BitwiseNotGate(Size);
bwNot3 = new BitwiseNotGate(Size);
zeroWS = new WireSet(Size);
negAnd = new AndGate();
notBit = new Wire();
not1 = new NotGate();
// Zero X
muxZeroX.Input1.ConnectInput(InputX);
muxZeroX.Input2.ConnectInput(zeroWS);
muxZeroX.ConnectControl(ZeroX);
// Not X
bwNot1.ConnectInput(muxZeroX.Output);
muxNegX.Input1.ConnectInput(muxZeroX.Output);
muxNegX.Input2.ConnectInput(bwNot1.Output);
muxNegX.ConnectControl(NotX);
// Zero Y
muxZeroY.Input1.ConnectInput(InputY);
muxZeroY.Input2.ConnectInput(zeroWS);
muxZeroY.ConnectControl(ZeroY);
// Not Y
bwNot2.ConnectInput(muxZeroY.Output);
muxNegY.Input1.ConnectInput(muxZeroY.Output);
muxNegY.Input2.ConnectInput(bwNot2.Output);
muxNegY.ConnectControl(NotY);
// Func
mbAdder.ConnectInput1(muxNegX.Output);
mbAdder.ConnectInput2(muxNegY.Output);
bwAnd.Input1.ConnectInput(muxNegX.Output);
bwAnd.Input2.ConnectInput(muxNegY.Output);
muxFunc.Input1.ConnectInput(bwAnd.Output);
muxFunc.Input2.ConnectInput(mbAdder.Output);
muxFunc.ConnectControl(F);
// Not Output
bwNot3.ConnectInput(muxFunc.Output);
muxNegOut.Input1.ConnectInput(muxFunc.Output);
muxNegOut.Input2.ConnectInput(bwNot3.Output);
muxNegOut.ConnectControl(NotOutput);
// Zero
mbOr.ConnectInput(muxNegOut.Output);
not1.ConnectInput(mbOr.Output);
Zero.Value = not1.Output.Value;
// Negative
notBit.Value = 1;
negAnd.Input1.ConnectInput(notBit);
negAnd.Input2.ConnectInput(muxNegOut.Output[muxNegOut.Size - 1]);
// Output
//Output = bwAnd.Output;
Output = muxNegOut.Output;
}