Exemplo n.º 1
0
 //iterates each bit of the 2 inputs and making or operation using "OR" gate - saves the output in Output
 public BitwiseAndGate(int iSize)
     : base(iSize)
 {
     for (int bit = 0; bit < iSize; bit++)
     {
         and_gate_per_bit = new AndGate();
         and_gate_per_bit.ConnectInput1(Input1[bit]);
         and_gate_per_bit.ConnectInput2(Input2[bit]);
         Output[bit].ConnectInput(and_gate_per_bit.Output);
     }
 }
Exemplo n.º 2
0
        private Wire calc(Wire input1, Wire input2, int wireNum)
        {
            andGate = new AndGate();
            andGate.ConnectInput1(input1);
            andGate.ConnectInput2(input2);

            if (wireNum < 0)
            {
                return(andGate.Output);
            }
            return(calc(andGate.Output, this.m_wsInput[wireNum], wireNum - 1));
        }
Exemplo n.º 3
0
 public HalfAdder()
 {
     //your code here
     ag  = new AndGate();
     xog = new XorGate();
     ag.ConnectInput1(Input1);
     ag.ConnectInput2(Input2);
     xog.ConnectInput1(Input1);
     xog.ConnectInput2(Input2);
     CarryOutput = ag.Output;
     Output      = xog.Output;
 }
Exemplo n.º 4
0
 public BitwiseAndGate(int iSize)
     : base(iSize)
 {
     BitwiseAnd = new AndGate[iSize];
     for (int i = 0; i < iSize; i++)
     {
         BitwiseAnd[i] = new AndGate();
         BitwiseAnd[i].ConnectInput1(Input1[i]);
         BitwiseAnd[i].ConnectInput2(Input2[i]);
         Output[i].ConnectInput(BitwiseAnd[i].Output);
     }
 }
Exemplo n.º 5
0
        //nand gate is defines as not-AND gate, the procedure is completed using the AND,NOT gates.
        public NAndGate()
        {
            and_input  = new AndGate();
            not_output = new NotGate();

            and_input.ConnectInput1(Input1);
            and_input.ConnectInput2(Input2);

            not_output.ConnectInput(and_input.Output);

            Output = not_output.Output;
        }
Exemplo n.º 6
0
 public HalfAdder()
 {
     CarryOutput = new Wire();
     and         = new AndGate();
     xor         = new XorGate();
     Input1      = and.Input1;
     Input2      = and.Input2;
     xor.ConnectInput1(Input1);
     xor.ConnectInput2(Input2);
     Output      = xor.Output;
     CarryOutput = and.Output;
 }
Exemplo n.º 7
0
        //your code here



        public HalfAdder()
        {
            //your code here
            XorGate xor = new XorGate();
            AndGate and = new AndGate();

            xor.ConnectInput1(Input1);
            xor.ConnectInput2(Input2);
            and.ConnectInput1(Input2);
            and.ConnectInput2(Input1);
            Output      = xor.Output;
            CarryOutput = and.Output;
        }
Exemplo n.º 8
0
        public HalfAdder()
        {
            CarryOutput = new Wire();
            m_xorGate   = new XorGate();
            m_andGate   = new AndGate();

            m_xorGate.Input1.ConnectInput(Input1);
            m_xorGate.Input2.ConnectInput(Input2);
            Output.ConnectInput(m_xorGate.Output);

            m_andGate.Input1.ConnectInput(Input1);
            m_andGate.Input2.ConnectInput(Input2);
            CarryOutput.ConnectInput(m_andGate.Output);
        }
Exemplo n.º 9
0
        public HalfAdder()
        {
            CarryOutput = new Wire();
            xor         = new XorGate();
            and         = new AndGate();

            xor.ConnectInput1(Input1);
            xor.ConnectInput2(Input2);
            and.ConnectInput1(Input1);
            and.ConnectInput2(Input2);

            CarryOutput.ConnectInput(and.Output);
            Output.ConnectInput(xor.Output);
        }
Exemplo n.º 10
0
        public BitwiseAndGate(int iSize)
            : base(iSize)
        {
            and = new AndGate();

            for (int i = 0; i < Size; i++)
            {
                and.ConnectInput1(Input1[i]);
                and.ConnectInput2(Input2[i]);

                Output[i].ConnectInput(and.Output);
                and = new AndGate();
            }
        }
Exemplo n.º 11
0
        public HalfAdder()
        {
            //your code here
            m_gXor = new XorGate();
            m_gAnd = new AndGate();

            m_gXor.ConnectInput1(Input1);
            m_gXor.ConnectInput2(Input2);
            Output.ConnectInput(m_gXor.Output);

            m_gAnd.ConnectInput1(Input1);
            m_gAnd.ConnectInput2(Input2);
            CarryOutput = new Wire();
            CarryOutput.ConnectInput(m_gAnd.Output);
        }
Exemplo n.º 12
0
        //making and operation for  2 consecutive bits(wires) until the  last bit. first bit is constant - 1
        public MultiBitAndGate(int iInputCount)
            : base(iInputCount)
        {
            size_of_wire = iInputCount;
            result       = new Wire();
            result.Value = 1;

            for (int bit = 0; bit < iInputCount; bit++)
            {
                and_operator = new AndGate();
                and_operator.ConnectInput1(result);
                and_operator.ConnectInput2(m_wsInput[bit]);
                result = and_operator.Output;
            }
            Output = result;
        }
Exemplo n.º 13
0
 public MultiBitAndGate(int iInputCount)
     : base(iInputCount)
 {
     //your code here
     and    = new AndGate[iInputCount - 1];
     and[0] = new AndGate();
     and[0].ConnectInput1(m_wsInput[0]);
     and[0].ConnectInput2(m_wsInput[1]);
     for (int i = 2; i < iInputCount; i++)
     {
         and[i - 1] = new AndGate();
         and[i - 1].ConnectInput1(and[i - 2].Output);
         and[i - 1].ConnectInput2(m_wsInput[i]);
     }
     Output.ConnectInput(and[iInputCount - 2].Output);
 }
Exemplo n.º 14
0
 public OrGate()
 {
     //init the gates
     m_gNot1 = new NotGate(); //outside the parentheses
     m_gNot2 = new NotGate(); //a
     m_gNot3 = new NotGate(); //b
     m_gAnd  = new AndGate();
     //connect the gates
     m_gAnd.ConnectInput1(m_gNot2.Output);
     m_gAnd.ConnectInput2(m_gNot3.Output);
     m_gNot1.ConnectInput(m_gAnd.Output);
     //set the inputs and the output of the or gate
     Output = m_gNot1.Output;
     Input1 = m_gNot2.Input;
     Input2 = m_gNot3.Input;
 }
Exemplo n.º 15
0
        //your code here

        public MultiBitAndGate(int iInputCount)
            : base(iInputCount)
        {
            AndGate[] and = new AndGate[iInputCount - 1]; // reminder - make the first one outside the for loop
            and[0] = new AndGate();
            and[0].ConnectInput1(m_wsInput[0]);           //assuming there are at least two bits
            and[0].ConnectInput2(m_wsInput[1]);

            for (int i = 1; i < iInputCount - 1; i++)
            {
                and[i] = new AndGate();
                and[i].ConnectInput1(and[i - 1].Output);
                and[i].ConnectInput2(m_wsInput[i + 1]);
            }
            Output.ConnectInput(and[iInputCount - 2].Output);
        }
Exemplo n.º 16
0
 public Demux()
 {
     Input = new Wire();
     //your code here
     Control = new Wire();
     m_gNot  = new NotGate();
     m_gAnd1 = new AndGate();
     m_gAnd2 = new AndGate();
     m_gNot.ConnectInput(Control);
     m_gAnd1.ConnectInput1(Input);
     m_gAnd1.ConnectInput2(m_gNot.Output);
     m_gAnd2.ConnectInput1(Control);
     m_gAnd2.ConnectInput2(Input);
     Output1 = m_gAnd1.Output;
     Output2 = m_gAnd2.Output;
 }
Exemplo n.º 17
0
        public HalfAdder()
        {
            CarryOutput = new Wire();

            var gXor = new XorGate();
            var gAnd = new AndGate();

            Input1 = gAnd.Input1;
            Input2 = gAnd.Input2;

            gXor.ConnectInput1(Input1);
            gXor.ConnectInput2(Input2);

            Output      = gXor.Output;
            CarryOutput = gAnd.Output;
        }
Exemplo n.º 18
0
        public XorGate()
        {
            or   = new OrGate();
            NAnd = new NAndGate();
            and  = new AndGate();



            Input1 = or.Input1;
            Input2 = or.Input2;

            NAnd.ConnectInput1(Input1);
            NAnd.ConnectInput2(Input2);
            and.ConnectInput1(or.Output);
            and.ConnectInput2(NAnd.Output);
            Output = and.Output;
        }
Exemplo n.º 19
0
        public MuxGate()
        {
            ControlInput = new Wire();

            m_gNot  = new NotGate();
            m_gAnd1 = new AndGate();
            m_gAnd2 = new AndGate();
            m_gOr   = new OrGate();
            m_gAnd1.ConnectInput1(m_gNot.Output);
            m_gOr.ConnectInput1(m_gAnd1.Output);
            m_gOr.ConnectInput2(m_gAnd2.Output);
            m_gNot.ConnectInput(ControlInput);
            m_gAnd2.ConnectInput1(ControlInput);
            Input1 = m_gAnd1.Input2;
            Input2 = m_gAnd2.Input2;
            Output = m_gOr.Output;
        }
Exemplo n.º 20
0
        public XorGate()
        {
            m_gNand = new NAndGate();
            m_gOr   = new OrGate();
            m_gAnd  = new AndGate();

            m_gOr.ConnectInput1(Input1);
            m_gOr.ConnectInput2(Input2);

            m_gNand.ConnectInput1(Input1);
            m_gNand.ConnectInput2(Input2);

            m_gAnd.ConnectInput1(m_gOr.Output);
            m_gAnd.ConnectInput2(m_gNand.Output);

            Output = m_gAnd.Output;
        }
Exemplo n.º 21
0
        //Xor gate is possible to get by combining with and gate the results of the nand and or gates.
        public XorGate()
        {
            nand_input = new NAndGate();
            or_input   = new OrGate();
            and_output = new AndGate();

            nand_input.ConnectInput1(Input1);
            nand_input.ConnectInput2(Input2);

            or_input.ConnectInput1(Input1);
            or_input.ConnectInput2(Input2);


            and_output.ConnectInput1(nand_input.Output);
            and_output.ConnectInput2(or_input.Output);

            Output = and_output.Output;
        }
Exemplo n.º 22
0
        public BitwiseAndGate(int iSize)
            : base(iSize)
        {
            m_gAnd = new AndGate[iSize];

            WireSet ws_resault = new WireSet(iSize);

            //your code here
            for (int i = 0; i < iSize; i++)
            {
                m_gAnd[i] = new AndGate();
                m_gAnd[i].ConnectInput1(Input1[i]);
                m_gAnd[i].ConnectInput2(Input2[i]);

                ws_resault[i].ConnectInput(m_gAnd[i].Output);
            }
            Output.ConnectInput(ws_resault);
        }
Exemplo n.º 23
0
        //your code here

        public Demux()
        {
            Input   = new Wire();
            Control = new Wire();

            //init
            AndGate and1 = new AndGate();
            AndGate and2 = new AndGate();
            NotGate not  = new NotGate();

            and1.ConnectInput1(Input);
            and2.ConnectInput2(Input);
            not.ConnectInput(Control);
            and1.ConnectInput2(not.Output);
            and2.ConnectInput1(Control);
            Output1 = and1.Output;
            Output2 = and2.Output;
        }
Exemplo n.º 24
0
        public MuxGate()
        {
            ControlInput = new Wire();
            m_gAndX      = new AndGate();
            m_gAndY      = new AndGate();
            m_gOr        = new OrGate();
            m_gNotC      = new NotGate();

            m_gAndY.ConnectInput1(ControlInput);
            m_gAndY.ConnectInput2(Input2);

            m_gNotC.ConnectInput(ControlInput);
            m_gAndX.ConnectInput2(m_gNotC.Output);
            m_gAndX.ConnectInput1(Input1);

            m_gOr.ConnectInput1(m_gAndX.Output);
            m_gOr.ConnectInput2(m_gAndY.Output);
            Output = m_gOr.Output;
        }
Exemplo n.º 25
0
        public XorGate()
        {
            //your code here
            m_gAnd  = new AndGate();
            m_gNand = new NAndGate();
            m_gOr   = new OrGate();

            m_gAnd.ConnectInput1(m_gNand.Output);
            m_gAnd.ConnectInput2(m_gOr.Output);


            Input1 = m_gOr.Input1;
            Input2 = m_gOr.Input2;

            m_gNand.ConnectInput1(Input1);
            m_gNand.ConnectInput2(Input2);

            Output = m_gAnd.Output;
        }
Exemplo n.º 26
0
        // creating the halfadder by using the "xor" and "and gates" for the output and the carry
        public HalfAdder()
        {
            // initilaize the gates
            CarryOutput = new Wire();
            xor_op      = new XorGate();
            and_op      = new AndGate();

            //xor operation for the sum output
            xor_op.ConnectInput1(Input1);
            xor_op.ConnectInput2(Input2);

            //and operation for the carry output
            and_op.ConnectInput1(Input1);
            and_op.ConnectInput2(Input2);

            //connecting outputs
            Output.ConnectInput(xor_op.Output);
            CarryOutput.ConnectInput(and_op.Output);
        }
Exemplo n.º 27
0
        public MultiBitAndGate(int iInputCount)
            : base(iInputCount)
        {
            m_AndGates = new AndGate[iInputCount - 1];
            for (int i = 0; i < m_AndGates.Length; i++)
            {
                m_AndGates[i] = new AndGate();
            }
            m_AndGates[0].ConnectInput1(m_wsInput[0]);
            m_AndGates[0].ConnectInput2(m_wsInput[1]);


            for (int i = 1; i < (iInputCount - 1); i++)
            {
                m_AndGates[i].ConnectInput1(m_AndGates[i - 1].Output);
                m_AndGates[i].ConnectInput2(m_wsInput[i + 1]);
            }

            Output = m_AndGates[iInputCount - 2].Output;
        }
Exemplo n.º 28
0
        public MultiBitAndGate(int iInputCount)
            : base(iInputCount)
        {
            and = new AndGate();
            and.ConnectInput1(m_wsInput[0]);
            and.ConnectInput2(m_wsInput[1]);
            Wire temp = and.Output;

            for (int i = 2; i < m_wsInput.Size; i++)
            {
                and = new AndGate();

                and.ConnectInput1(temp);
                and.ConnectInput2(m_wsInput[i]);

                temp = and.Output;
            }

            Output = temp;
        }
Exemplo n.º 29
0
        //your code here

        public Demux()
        {
            Input = new Wire();

            var mGAnd1 = new AndGate();
            var mGAnd2 = new AndGate();
            var mGNot1 = new NotGate();

            Control = new Wire();

            mGNot1.ConnectInput(Control);

            mGAnd2.ConnectInput1(Input);
            mGAnd2.ConnectInput2(Control);

            mGAnd1.ConnectInput1(Input);
            mGAnd1.ConnectInput2(mGNot1.Output);

            Output1 = mGAnd1.Output;
            Output2 = mGAnd2.Output;
        }
Exemplo n.º 30
0
        public MuxGate()
        {
            var mGAnd1 = new AndGate();
            var mGAnd2 = new AndGate();
            var mGNot1 = new NotGate();
            var mGOr   = new OrGate();

            ControlInput = new Wire();
            mGNot1.ConnectInput(ControlInput);

            mGAnd2.ConnectInput1(Input2);
            mGAnd2.ConnectInput2(ControlInput);

            mGAnd1.ConnectInput1(Input1);
            mGAnd1.ConnectInput2(mGNot1.Output);

            mGOr.ConnectInput1(mGAnd1.Output);
            mGOr.ConnectInput2(mGAnd2.Output);

            Output = mGOr.Output;
        }