Ejemplo n.º 1
0
        public override bool TestGate()
        {
            var ws1 = new WireSet(Size);

            for (int i = 0; i < Math.Pow(2, Size); i++)
            {
                ws1.SetValue(i);
                for (int j = 0; j < Math.Pow(2, Size); j++)
                {
                    var mgAnd = new BitwiseAndGate(Size);
                    var ws2   = new WireSet(Size);
                    ws2.SetValue(j);
                    mgAnd.ConnectInput1(ws1);
                    mgAnd.ConnectInput2(ws2);
                    for (int k = 0; k < ws2.Size; k++)
                    {
                        if (mgAnd.Output[k].Value != (ws1[k].Value & ws2[k].Value))
                        {
                            return(false);
                        }
                    }
                }
            }
            return(true);
        }
Ejemplo n.º 2
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;
        }
Ejemplo n.º 3
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();
            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;
        }
Ejemplo n.º 4
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();
            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);
        }
Ejemplo n.º 5
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();
            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;
            }
        }
Ejemplo n.º 6
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
            Output = new WireSet(Size);

            m_wsZero = new WireSet(Size);
            for (int i = 0; i < Size; i++)
            {
                m_wsZero[i].Value = 0;
            }

            m_gZxMux = new BitwiseMultiwayMux(Size, 1);
            m_gZxMux.ConnectInput(0, InputX);
            m_gZxMux.ConnectInput(1, m_wsZero);
            m_gZxMux.Control[0].ConnectInput(ZeroX);

            m_gNxNot = new BitwiseNotGate(Size);
            m_gNxNot.ConnectInput(m_gZxMux.Output);
            m_gNxMux = new BitwiseMultiwayMux(Size, 1);
            m_gNxMux.ConnectInput(0, m_gZxMux.Output);
            m_gNxMux.ConnectInput(1, m_gNxNot.Output);
            m_gNxMux.Control[0].ConnectInput(NotX);

            m_gZyMux = new BitwiseMultiwayMux(Size, 1);
            m_gZyMux.ConnectInput(0, InputY);
            m_gZyMux.ConnectInput(1, m_wsZero);
            m_gZyMux.Control[0].ConnectInput(ZeroY);

            m_gNyNot = new BitwiseNotGate(Size);
            m_gNyNot.ConnectInput(m_gZyMux.Output);
            m_gNyMux = new BitwiseMultiwayMux(Size, 1);
            m_gNyMux.ConnectInput(0, m_gZyMux.Output);
            m_gNyMux.ConnectInput(1, m_gNyNot.Output);
            m_gNyMux.Control[0].ConnectInput(NotY);

            m_gFAdder = new MultiBitAdder(Size);
            m_gFAdder.ConnectInput1(m_gNxMux.Output);
            m_gFAdder.ConnectInput2(m_gNyMux.Output);
            m_gFAnd = new BitwiseAndGate(Size);
            m_gFAnd.ConnectInput1(m_gNxMux.Output);
            m_gFAnd.ConnectInput2(m_gNyMux.Output);
            m_gFMux = new BitwiseMultiwayMux(Size, 1);
            m_gFMux.ConnectInput(0, m_gFAnd.Output);
            m_gFMux.ConnectInput(1, m_gFAdder.Output);
            m_gFMux.Control[0].ConnectInput(F);

            m_gNoNot = new BitwiseNotGate(Size);
            m_gNoNot.ConnectInput(m_gFMux.Output);
            m_gNoMux = new BitwiseMultiwayMux(Size, 1);
            m_gNoMux.ConnectInput(0, m_gFMux.Output);
            m_gNoMux.ConnectInput(1, m_gNoNot.Output);
            m_gNoMux.Control[0].ConnectInput(NotOutput);

            Output.ConnectInput(m_gNoMux.Output);

            m_gZrOr = new MultiBitOrGate(Size);
            m_gZrOr.ConnectInput(Output);
            m_gZrNot = new NotGate();
            m_gZrNot.ConnectInput(m_gZrOr.Output);

            Zero.ConnectInput(m_gZrNot.Output);
            Negative.ConnectInput(Output[Size - 1]);
        }
Ejemplo n.º 7
0
        public override bool TestGate()
        {
            ALU al;

            WireSet[] inputs   = new WireSet[2];
            WireSet[] solution = new WireSet[18];
            WireSet[] all      = new WireSet[6];

            for (int i = 0; i < all.Length; i++)
            {
                all[i] = new WireSet(18);
            }


            WireSet wsTemp  = new WireSet(18);
            WireSet wsTemp2 = new WireSet(Size);

            wsTemp.SetValue(240288);
            all[0].ConnectInput(wsTemp);
            wsTemp = new WireSet(18);
            wsTemp.SetValue(109481);
            all[1].ConnectInput(wsTemp);
            wsTemp = new WireSet(18);
            wsTemp.SetValue(251200);
            all[2].ConnectInput(wsTemp);
            wsTemp = new WireSet(18);
            wsTemp.SetValue(87493);
            all[3].ConnectInput(wsTemp);
            wsTemp = new WireSet(18);
            wsTemp.SetValue(231420);
            all[4].ConnectInput(wsTemp);
            wsTemp = new WireSet(18);
            wsTemp.SetValue(73613);
            all[5].ConnectInput(wsTemp);

            for (int i = 0; i < Size; i++)
            {
                for (int j = 0; j < Size; j++)
                {
                    for (int f = 0; f < solution.Length; f++)
                    {
                        solution[f] = new WireSet(Size);
                    }

                    inputs[0] = new WireSet(Size);
                    inputs[1] = new WireSet(Size);
                    inputs[0].SetValue(i);
                    inputs[1].SetValue(j);

                    wsTemp2 = new WireSet(Size);
                    wsTemp2.SetValue(0);
                    solution[0].ConnectInput(wsTemp2);
                    wsTemp2 = new WireSet(Size);
                    wsTemp2.SetValue(1);
                    solution[1].ConnectInput(wsTemp2);
                    wsTemp2 = new WireSet(Size);
                    wsTemp2.Set2sComplement(-1);
                    solution[2].ConnectInput(wsTemp2);
                    solution[3].ConnectInput(inputs[0]);
                    solution[4].ConnectInput(inputs[1]);

                    BitwiseNotGate bwng = new BitwiseNotGate(Size);
                    bwng.ConnectInput(inputs[0]);

                    solution[5].ConnectInput(bwng.Output);
                    bwng = new BitwiseNotGate(Size);
                    bwng.ConnectInput(inputs[1]);
                    solution[6].ConnectInput(bwng.Output);
                    wsTemp2 = new WireSet(Size);

                    wsTemp2.SetValue(inputs[0].GetValue() * -1);
                    solution[7].ConnectInput(wsTemp2);
                    wsTemp2 = new WireSet(Size);
                    wsTemp2.SetValue(inputs[1].GetValue() * -1);
                    solution[8].ConnectInput(wsTemp2);
                    wsTemp2 = new WireSet(Size);
                    wsTemp2.SetValue(inputs[0].GetValue() + 1);
                    solution[9].ConnectInput(wsTemp2);
                    wsTemp2 = new WireSet(Size);
                    wsTemp2.SetValue(inputs[1].GetValue() + 1);
                    solution[10].ConnectInput(wsTemp2);
                    wsTemp2 = new WireSet(Size);
                    wsTemp2.SetValue(inputs[0].GetValue() - 1);
                    solution[11].ConnectInput(wsTemp2);
                    wsTemp2 = new WireSet(Size);
                    wsTemp2.SetValue(inputs[1].GetValue() - 1);
                    solution[12].ConnectInput(wsTemp2);
                    wsTemp2 = new WireSet(Size);
                    wsTemp2.SetValue(inputs[0].GetValue() + inputs[1].GetValue());
                    solution[13].ConnectInput(wsTemp2);
                    wsTemp2 = new WireSet(Size);
                    wsTemp2.SetValue(inputs[0].GetValue() - inputs[1].GetValue());
                    solution[14].ConnectInput(wsTemp2);
                    wsTemp2 = new WireSet(Size);
                    wsTemp2.SetValue(inputs[1].GetValue() - inputs[0].GetValue());
                    solution[15].ConnectInput(wsTemp2);

                    BitwiseOrGate  bwog = new BitwiseOrGate(Size);
                    BitwiseAndGate bwag = new BitwiseAndGate(Size);
                    bwog.ConnectInput1(inputs[0]);
                    bwog.ConnectInput2(inputs[1]);
                    bwag.ConnectInput1(inputs[0]);
                    bwag.ConnectInput2(inputs[1]);
                    solution[16].ConnectInput(bwag.Output);
                    solution[17].ConnectInput(bwog.Output);

                    for (int k = 0; k < 18; k++)
                    {
                        al = new ALU(Size);
                        al.InputX.ConnectInput(inputs[0]);
                        al.InputY.ConnectInput(inputs[1]);
                        al.ZeroX.Value     = all[0][17 - k].Value;
                        al.NotX.Value      = all[1][17 - k].Value;
                        al.ZeroY.Value     = all[2][17 - k].Value;
                        al.NotY.Value      = all[3][17 - k].Value;
                        al.F.Value         = all[4][17 - k].Value;
                        al.NotOutput.Value = all[5][17 - k].Value;

                        if (al.Output.ToString() != solution[k].ToString())
                        {
                            return(false);
                        }
                    }
                }
            }
            return(true);
        }
Ejemplo n.º 8
0
        //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);
        }
Ejemplo n.º 9
0
        public override bool TestGate()
        {
            int[] arrZX = new int[] { 1, 1, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 0, 0, 0, 0 };
            int[] arrNX = new int[] { 0, 1, 1, 0, 1, 0, 1, 0, 1, 1, 1, 0, 1, 0, 1, 0, 0, 1 };
            int[] arrZY = new int[] { 1, 1, 1, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 0, 0, 0, 0, 0 };
            int[] arrNY = new int[] { 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 1, 1, 0, 0, 0, 1, 0, 1 };
            int[] arrF  = new int[] { 1, 1, 1, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0 };
            int[] arrNO = new int[] { 0, 1, 0, 0, 0, 1, 1, 1, 1, 1, 1, 0, 0, 0, 1, 1, 0, 1 };

            InputX = new WireSet(Size);
            InputY = new WireSet(Size);
            Random rand = new Random();

            WireSet[] answer = new WireSet[arrZX.Length];
            for (int i = 0; i < answer.Length; i++)
            {
                answer[i] = new WireSet(Size);
            }
            answer[0].Set2sComplement(0);
            answer[1].Set2sComplement(1);
            answer[2].Set2sComplement(-1);

            for (int i = 0; i < arrZX.Length; i++)
            {
                int num1 = rand.Next((-(int)Math.Pow(2, Size - 1)), ((int)Math.Pow(2, Size - 1) - 1) + 1);
                int num2 = rand.Next((-(int)Math.Pow(2, Size - 1)), ((int)Math.Pow(2, Size - 1) - 1) + 1);
                InputX.Set2sComplement(num1);
                InputY.Set2sComplement(num2);

                ZeroX.Value     = arrZX[i];
                NotX.Value      = arrNX[i];
                ZeroY.Value     = arrZY[i];
                NotY.Value      = arrNY[i];
                F.Value         = arrF[i];
                NotOutput.Value = arrNO[i];

                if (Negative.Value != Output[Size - 1].Value)
                {
                    return(false);
                }
                if (Output.Get2sComplement() == 0 && Zero.Value != 1)
                {
                    return(false);
                }
                if (Output.Get2sComplement() != 0 && Zero.Value != 0)
                {
                    return(false);
                }


                answer[3].Set2sComplement(num1);
                answer[4].Set2sComplement(num2);
                BitwiseNotGate tempGX = new BitwiseNotGate(Size);
                tempGX.ConnectInput(InputX);
                answer[5].ConnectInput(tempGX.Output);
                BitwiseNotGate tempGY = new BitwiseNotGate(Size);
                tempGY.ConnectInput(InputY);
                answer[6].ConnectInput(tempGY.Output);
                answer[7].Set2sComplement(-num1);
                answer[8].Set2sComplement(-num2);
                answer[9].Set2sComplement(num1 + 1);
                answer[10].Set2sComplement(num2 + 1);
                answer[11].Set2sComplement(num1 - 1);
                answer[12].Set2sComplement(num2 - 1);
                answer[13].Set2sComplement(num1 + num2);
                answer[14].Set2sComplement(num1 - num2);
                answer[15].Set2sComplement(num2 - num1);
                BitwiseAndGate tempGAnd = new BitwiseAndGate(Size);
                tempGAnd.ConnectInput1(InputX);
                tempGAnd.ConnectInput2(InputY);
                answer[16].ConnectInput(tempGAnd.Output);
                answer[17].ConnectInput(Output);

                for (int j = 0; j < Size; j++)
                {
                    if (answer[i][j].Value != Output[j].Value)
                    {
                        return(false);
                    }
                }
            }
            return(true);
        }