Ejemplo n.º 1
0
        public bool[] complemento2(bool[] bin)
        {
            bool[] resultado = new bool[bin.Length];
            bool[] f         = new bool[3];

            if (bin.Length == 8) //8 bits
            {
                bool[]             um  = { false, false, false, false, false, false, false, true };
                UnidadeLogica8bits ula = new UnidadeLogica8bits();

                f[0] = true; f[1] = true; f[2] = false; //0  1  1  Not B
                ula.ULA8Bits(um, bin, f, resultado);

                bin = resultado;

                f[0] = false; f[1] = false; f[2] = true; //1  0  0  A + B
                ula.ULA8Bits(um, bin, f, resultado);
            }
            else //24 bits
            {
                UnidadeLogica24bits ula = new UnidadeLogica24bits();
                bool[] um = { false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, true };

                f[0] = true; f[1] = true; f[2] = false; //0  1  1  Not B
                ula.ULA24Bits(um, bin, f, resultado);

                bin = resultado;

                f[0] = false; f[1] = false; f[2] = true; //1  0  0  A + B
                ula.ULA24Bits(um, bin, f, resultado);
            }

            return(resultado);
        }
        private float chamarULAPontoFlutuante(bool f, float a, float b)
        {
            bool inverteu = false;

            if (b > a && f) //caso seja subtração e b seja > a ele inverte
            {
                inverteu = true;
                float aux = a;
                a = b;
                b = aux;
            }

            #region Variaveis, objetos e vetores
            //Objetos
            UnidadeLogica8bits  ula8  = new UnidadeLogica8bits();
            UnidadeLogica24bits ula24 = new UnidadeLogica24bits();
            Conversor           con   = new Conversor();

            //variaveis que indicam índice nos vetores
            int posExpoente;
            int posMantissa;

            //vetores
            bool[] expoenteUm = { false, false, false, false, false, false, false, true };

            //Ponto flutuante separado
            bool[] expoenteA = new bool[8], expoenteB = new bool[8];
            bool[] mantissaA = new bool[24], mantissaB = new bool[24];
            bool   sinalA, sinalB;

            //números convertidos
            bool[] NumeroA = con.PontoFlutuanteParaBinario(a);
            bool[] NumeroB = con.PontoFlutuanteParaBinario(b);

            //Vetor resultado
            bool[] resultadoFinal = new bool[32];
            #endregion

            #region Separando expoente e mantissa
            posExpoente = 0;
            sinalA      = NumeroA[0];
            for (int pos = 1; pos < 9; pos++)
            {
                expoenteA[posExpoente] = NumeroA[pos];
                expoenteB[posExpoente] = NumeroB[pos];
                posExpoente++;
            }

            posMantissa = 0;
            sinalB      = NumeroB[0];
            for (int pos = 9; pos < 32; pos++)
            {
                mantissaA[posMantissa] = NumeroA[pos];
                mantissaB[posMantissa] = NumeroB[pos];
                posMantissa++;
            }
            #endregion

            #region aparecer o bit implicito
            mantissaA = ShiftLogical.shiftRightLogical(mantissaA);
            ula8.ULA8Bits(expoenteA, expoenteUm, decodificadorSoma, expoenteA); //aumentar o expoente A em 1
            mantissaB = ShiftLogical.shiftRightLogical(mantissaB);
            ula8.ULA8Bits(expoenteB, expoenteUm, decodificadorSoma, expoenteB); //aumentar o expoente B em 1
            mantissaA[0] = true;
            mantissaB[0] = true;
            #endregion

            #region Evitar erro nas operações                                   // qual erro? overflow?
            mantissaA = ShiftLogical.shiftRightLogical(mantissaA);
            ula8.ULA8Bits(expoenteA, expoenteUm, decodificadorSoma, expoenteA); //aumentar o expoente A em 1
            mantissaB = ShiftLogical.shiftRightLogical(mantissaB);
            ula8.ULA8Bits(expoenteB, expoenteUm, decodificadorSoma, expoenteB); //aumentar o expoente B em 1
            #endregion

            #region igualar o expoente
            while (con.imprimirBinario(expoenteA) != con.imprimirBinario(expoenteB))
            {
                if (con.BinarioParaInteiro(expoenteB) < con.BinarioParaInteiro(expoenteA))
                {
                    mantissaB = ShiftLogical.shiftRightLogical(mantissaB);
                    ula8.ULA8Bits(expoenteB, expoenteUm, decodificadorSoma, expoenteB); //aumentar o expoente B em 1
                }
                else
                {
                    mantissaA = ShiftLogical.shiftRightLogical(mantissaA);
                    ula8.ULA8Bits(expoenteA, expoenteUm, decodificadorSoma, expoenteA); //aumentar o expoente A em 1
                }
            }
            #endregion

            #region Fazer soma ou subtração
            bool[] resultadoSomaMantissa = new bool[24];
            bool[] resultadoExpoente     = new bool[8];
            bool   resultadoSinal; //o que fazer com isso?

            if (!f)                //se falso, soma
            {
                ula24.ULA24Bits(mantissaA, mantissaB, decodificadorSoma, resultadoSomaMantissa);
                resultadoExpoente = expoenteA;
            }
            else //se verdadeiro, subtração
            {
                ula24.ULA24Bits(mantissaA, con.complemento2(mantissaB), decodificadorSubtracao, resultadoSomaMantissa);
                resultadoExpoente = expoenteA;
            }
            #endregion

            #region normalizar
            bool repetir = true, zero = false;

            if (con.imprimirBinario(resultadoSomaMantissa) == "000000000000000000000000")
            {
                repetir = false; zero = true;
                for (int pos = 0; pos < 8; pos++)
                {
                    resultadoExpoente[pos] = false;
                }
            }
            Console.WriteLine(con.imprimirBinario(resultadoSomaMantissa));
            while (repetir)
            {
                if (!resultadoSomaMantissa[0])
                {
                    resultadoSomaMantissa = ShiftLogical.shiftLeftLogical(resultadoSomaMantissa);
                    ula8.ULA8Bits(resultadoExpoente, con.complemento2(expoenteUm), decodificadorSubtracao, resultadoExpoente); //aumentar o expoente A em 1
                }
                else
                {
                    repetir = false;
                }
            }

            if (!zero)
            {
                resultadoSomaMantissa = ShiftLogical.shiftLeftLogical(resultadoSomaMantissa);
                ula8.ULA8Bits(resultadoExpoente, con.complemento2(expoenteUm), decodificadorSubtracao, resultadoExpoente); //aumentar o expoente A em 1
            }
            #endregion

            #region Reunir para o vetor resultado final
            posExpoente = 0;
            for (int pos = 1; pos < 9; pos++)
            {
                resultadoFinal[pos] = resultadoExpoente[posExpoente];
                posExpoente++;
            }

            posMantissa = 0;
            for (int pos = 9; pos < 32; pos++)
            {
                resultadoFinal[pos] = resultadoSomaMantissa[posMantissa];
                posMantissa++;
            }
            #endregion

            if (inverteu)
            {
                return(con.BinarioParaPontoFlutuante(resultadoFinal) * -1);
            }
            else
            {
                return(con.BinarioParaPontoFlutuante(resultadoFinal));
            }
        }
        private float novoPontoFlutuante(bool f, float a, float b)
        {
            bool inverteu = false;

            if (b > a && f) //caso seja subtração e b seja > a ele inverte
            {
                inverteu = true;
                float aux = a;
                a = b;
                b = aux;
            }

            #region Variaveis, objetos e vetores
            //Objetos
            UnidadeLogica8bits  ula8  = new UnidadeLogica8bits();
            UnidadeLogica24bits ula24 = new UnidadeLogica24bits();
            Conversor           con   = new Conversor();

            //variaveis que indicam índice nos vetores
            int posExpoente;
            int posMantissa;

            //vetores
            bool[] expoenteUm = { false, false, false, false, false, false, false, true };

            //Ponto flutuante separado
            bool[] expoenteA = new bool[8], expoenteB = new bool[8];
            bool[] mantissaA = new bool[24], mantissaB = new bool[24];
            bool   sinalA, sinalB;

            //números convertidos
            bool[] NumeroA = con.PontoFlutuanteParaBinario(a);
            bool[] NumeroB = con.PontoFlutuanteParaBinario(b);

            //Vetor resultado
            bool[] resultadoFinal = new bool[32];
            #endregion

            #region Separando expoente e mantissa
            sinalA = NumeroA[0];
            sinalB = NumeroB[0];

            posExpoente = 0;
            for (int pos = 1; pos < 9; pos++)
            {
                expoenteA[posExpoente] = NumeroA[pos];
                expoenteB[posExpoente] = NumeroB[pos];
                posExpoente++;
            }

            posMantissa = 0;
            for (int pos = 9; pos < 32; pos++)
            {
                mantissaA[posMantissa] = NumeroA[pos];
                mantissaB[posMantissa] = NumeroB[pos];
                posMantissa++;
            }
            #endregion

            if (a == 0)
            {
                return(con.BinarioParaPontoFlutuante(NumeroB));
            }

            else if (b == 0)
            {
                return(con.BinarioParaPontoFlutuante(NumeroA));
            }

            else
            {
                Console.WriteLine("RECEBIDO DO CONVERSOR");
                Console.Write(con.imprimirBinario(expoenteB) + " - ");
                Console.WriteLine(con.imprimirBinario(mantissaB));

                Console.Write(con.imprimirBinario(expoenteA) + " - ");
                Console.WriteLine(con.imprimirBinario(mantissaA));

                Console.WriteLine("+++++++++++++++++++++++++++++++++++++++++++++++");

                #region aparecer o bit implicito
                mantissaA = ShiftLogical.shiftRightLogical(mantissaA);
                ula8.ULA8Bits(expoenteA, expoenteUm, decodificadorSoma, expoenteA); //aumentar o expoente A em 1
                mantissaB    = ShiftLogical.shiftRightLogical(mantissaB);
                mantissaA[0] = true;
                mantissaB[0] = true;
                #endregion

                #region Evitar erro nas operações
                ula8.ULA8Bits(expoenteB, expoenteUm, decodificadorSoma, expoenteB); //aumentar o expoente B em 1
                mantissaA = ShiftLogical.shiftRightLogical(mantissaA);
                ula8.ULA8Bits(expoenteA, expoenteUm, decodificadorSoma, expoenteA); //aumentar o expoente A em 1
                mantissaB = ShiftLogical.shiftRightLogical(mantissaB);
                ula8.ULA8Bits(expoenteB, expoenteUm, decodificadorSoma, expoenteB); //aumentar o expoente B em 1
                #endregion

                Console.WriteLine("BIT IMPLICITO + 1 CASA");
                Console.Write(con.imprimirBinario(expoenteB) + " - ");
                Console.WriteLine(con.imprimirBinario(mantissaB));

                Console.Write(con.imprimirBinario(expoenteA) + " - ");
                Console.WriteLine(con.imprimirBinario(mantissaA));

                Console.WriteLine("+++++++++++++++++++++++++++++++++++++++++++++++");

                #region igualar o expoente
                while (con.imprimirBinario(expoenteA) != con.imprimirBinario(expoenteB))
                {
                    if (con.BinarioParaInteiro(expoenteB) < con.BinarioParaInteiro(expoenteA))
                    {
                        mantissaB = ShiftLogical.shiftRightLogical(mantissaB);
                        ula8.ULA8Bits(expoenteB, expoenteUm, decodificadorSoma, expoenteB); //aumentar o expoente B em 1
                    }
                    else
                    {
                        mantissaA = ShiftLogical.shiftRightLogical(mantissaA);
                        ula8.ULA8Bits(expoenteA, expoenteUm, decodificadorSoma, expoenteA); //aumentar o expoente A em 1
                    }

                    if (con.BinarioParaInteiro(mantissaB) == 0)
                    {
                        return(con.BinarioParaPontoFlutuante(NumeroA));
                    }
                    else if (con.BinarioParaInteiro(mantissaB) == 0)
                    {
                        return(con.BinarioParaPontoFlutuante(NumeroB));
                    }
                }
                #endregion

                Console.WriteLine("EXPOENTES IGUALADOS");
                Console.Write(con.imprimirBinario(expoenteB) + " - ");
                Console.WriteLine(con.imprimirBinario(mantissaB));

                Console.Write(con.imprimirBinario(expoenteA) + " - ");
                Console.WriteLine(con.imprimirBinario(mantissaA));

                #region tratando o sinal
                //feito de forma didatica
                if (f)
                {
                    //se for subtração
                    if (!sinalA)     //se A for positivo
                    {
                        if (!sinalB) //se B for positivo
                        {
                            // +a - (+b)
                            mantissaB = con.complemento2(mantissaB);
                        }
                        else
                        {//deu errado
                         // +a - (-b) = a + b
                         //não faz nada
                        }
                    }
                    else
                    {
                        if (!sinalB) //se for positivo
                        {
                            // -a - (+b) = b - (-a) = b + a
                            //não faz nada, foi tratado por causa do inverteu
                            inverteu = true;
                        }
                        else
                        {
                            // -a - (-b) = -a + b
                            mantissaA = con.complemento2(mantissaA);
                        }
                    }
                }
                else
                {
                    //se for soma
                    if (!sinalA)
                    {
                        if (!sinalB) //se for positivo
                        {
                            //+a + (+b) = a + b
                            //nao fazer nada
                        }
                        else
                        {
                            //+a + (-b) = a - b
                            mantissaB = con.complemento2(mantissaB);
                        }
                    }
                    else
                    {
                        if (!sinalB) //se for positivo
                        {
                            //-a + (+b) = +b + (-a) = b - a
                            //fazer complemento2 no A, foi tratado por causa do inverteu
                            mantissaA = con.complemento2(mantissaA);
                        }
                        else //funciona
                        {
                            //-a + (-b) = -a - b
                            //somar e dizer que inverteu
                            inverteu = true;
                        }
                    }
                }
                #endregion

                Console.WriteLine("SINAL");
                Console.Write(con.imprimirBinario(expoenteB) + " - ");
                Console.WriteLine(con.imprimirBinario(mantissaB));

                Console.Write(con.imprimirBinario(expoenteA) + " - ");
                Console.WriteLine(con.imprimirBinario(mantissaA));

                #region Fazer soma ou subtração
                bool[] resultadoSomaMantissa = new bool[24];
                bool[] resultadoExpoente     = new bool[8];
                bool   resultadoSinal; //o que fazer com isso?

                if (!f)
                {
                    ula24.ULA24Bits(mantissaA, mantissaB, decodificadorSubtracao, resultadoSomaMantissa);
                    resultadoExpoente = expoenteA;
                }
                else
                {
                    ula24.ULA24Bits(mantissaA, mantissaB, decodificadorSubtracao, resultadoSomaMantissa);
                    resultadoExpoente = expoenteA;
                }
                #endregion

                Console.WriteLine("++++++++++++++++++++++++++++++++++++");
                Console.WriteLine("resultado da soma");
                Console.Write(con.imprimirBinario(resultadoExpoente) + " - ");
                Console.WriteLine(con.imprimirBinario(resultadoSomaMantissa));

                #region normalizar
                bool repetir = true, overflow = false;
                while (repetir)
                {
                    if (con.BinarioParaInteiro(resultadoExpoente) > 0)
                    {
                        if (!resultadoSomaMantissa[0])
                        {
                            resultadoSomaMantissa = ShiftLogical.shiftLeftLogical(resultadoSomaMantissa);
                            ula8.ULA8Bits(resultadoExpoente, con.complemento2(expoenteUm), decodificadorSubtracao, resultadoExpoente); //aumentar o expoente A em 1
                        }
                        else
                        {
                            repetir = false;
                        }
                    }
                    else
                    {
                        repetir  = false;
                        overflow = true;
                    }
                }
                if (!overflow)
                {
                    resultadoSomaMantissa = ShiftLogical.shiftLeftLogical(resultadoSomaMantissa);
                    ula8.ULA8Bits(resultadoExpoente, con.complemento2(expoenteUm), decodificadorSubtracao, resultadoExpoente); //aumentar o expoente A em 1
                }
                #endregion

                Console.WriteLine("++++++++++++++++++++++++++++++++++++");
                Console.WriteLine("normalizado");
                Console.Write(con.imprimirBinario(resultadoExpoente) + " - ");
                Console.WriteLine(con.imprimirBinario(resultadoSomaMantissa));

                #region Reunir para o vetor resultado final
                posExpoente = 0;
                for (int pos = 1; pos < 9; pos++)
                {
                    resultadoFinal[pos] = resultadoExpoente[posExpoente];
                    posExpoente++;
                }

                posMantissa = 0;
                for (int pos = 9; pos < 32; pos++)
                {
                    resultadoFinal[pos] = resultadoSomaMantissa[posMantissa];
                    posMantissa++;
                }
                #endregion

                Console.WriteLine("\n\nFIM");
                if (inverteu)
                {
                    return(con.BinarioParaPontoFlutuante(resultadoFinal) * -1);
                }
                else
                {
                    return(con.BinarioParaPontoFlutuante(resultadoFinal));
                }
            }
        }
        private int chamarULAinteiro(bool[] f, int a, int b, int tamanho)
        {
            Conversor converter = new Conversor();
            bool      inverteu = false, complemento2A = false, complemento2B = false;

            bool[] A, B;
            int    resposta;

            if (b > a && (f[2] & !f[1] & f[0] || f[2] & !f[1] & !f[0])) //caso seja subtração e b > a ele inverte
            {
                inverteu = true;
                int aux = a;
                a = b;
                b = aux;
            }

            //convertendo pra complemento 2 binario
            if (a < 0)
            {
                a *= -1; complemento2A = true;
                A  = converter.complemento2(converter.InteiroParaBinario(tamanho, a));
            }
            else
            {
                A = converter.InteiroParaBinario(tamanho, a);
            }
            if (b < 0)
            {
                b *= -1; complemento2B = true;
                B  = converter.complemento2(converter.InteiroParaBinario(tamanho, b));
            }
            else
            {
                B = converter.InteiroParaBinario(tamanho, b);
            }

            if (f[2] & !f[1] & f[0]) //SE SUBTRAÇÃO
            {
                B = converter.complemento2(B);
            }


            bool overflowSoma;

            bool[] resultado = new bool[tamanho];

            if (tamanho == 8) //8 bits
            {
                UnidadeLogica8bits ula = new UnidadeLogica8bits();
                overflowSoma = ula.ULA8Bits(A, B, f, resultado);
            }
            else //24 bits
            {
                UnidadeLogica24bits ula = new UnidadeLogica24bits();
                overflowSoma = ula.ULA24Bits(A, B, f, resultado);
            }


            if (complemento2A || complemento2B)
            {
                resposta = converter.complemento2ParaDecimal(resultado);
            }
            else
            {
                resposta = converter.BinarioParaInteiro(resultado);
            }


            if (inverteu)
            {
                resposta *= -1;
            }

            return(resposta);
        }