private string imprimirTelaHexa(string numero, bool hexa)
        {
            Conversor con      = new Conversor();
            string    resposta = null;

            //resultado
            if (hexa)
            {
                return("0x" + con.BinarioParaHexadecimal(con.PontoFlutuanteParaBinario(float.Parse(numero))));
            }
            else
            {
                int num = Convert.ToInt32(numero);
                if (num < 0)
                {
                    num     *= -1;
                    resposta = "-";
                }

                if (num > 255)
                {
                    return(resposta + con.BinarioParaHexadecimal(con.InteiroParaBinario(24, num)));
                }
                else
                {
                    return(resposta + con.BinarioParaHexadecimal(con.InteiroParaBinario(8, num)));
                }
            }
        }
        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));
                }
            }
        }
        public void calcularArquivo()
        {
            string path = "operandos.txt";
            string OperandoA, OperandoB;

            //Tabela inteiro
            // F2 F1 F0 Saída
            // 0  0  0  A and B
            // 0  0  1  A or B
            // 0  1  0  Not A
            // 0  1  1  Not B
            // 1  0  0  A + B
            // 1  0  1  A - B
            // 1  1  0    -
            // 1  1  1    -

            try
            {
                if (File.Exists(path))
                {
                    string[]     linha;
                    StreamReader arquivo = new StreamReader(path);          //Stream de leitura do arquivo contendo os operandos

                    StreamWriter arqui = new StreamWriter("resultado.txt"); //Stream de escrita do arquivo com os resultados das operações com os operandos

                    Conversor conv = new Conversor();

                    //escrever novo arquivo
                    for (int pos = 0; !arquivo.EndOfStream; pos++)
                    {
                        linha     = arquivo.ReadLine().Split(';'); //Lê uma linha do arquivo e separa pelo separador ';' no vetor linha
                        OperandoA = linha[0];                      //atribui a primeira posição do vetor linha
                        OperandoB = linha[1];                      ////atribui a segunda posição do vetor linha

                        //Executa os cálculos e salva os resultados no arquivo "resultado.txt"
                        arqui.WriteLine("Operando A: {0}, Operando B: {1}", OperandoA, OperandoB);
                        arqui.WriteLine("\tDECIMAL: ");
                        arqui.Write("AND: ");
                        //0  0  0  A and B
                        arqui.WriteLine((encaminhaULA(decodificadorAnd, OperandoA, OperandoB)));

                        arqui.Write("OR: ");
                        arqui.WriteLine((encaminhaULA(decodificadorOr, OperandoA, OperandoB)));

                        arqui.Write("NOT A: ");
                        arqui.WriteLine((encaminhaULA(decodificadorNotA, OperandoA, OperandoB)));

                        arqui.Write("NOT B: ");
                        arqui.WriteLine((encaminhaULA(decodificadorNotB, OperandoA, OperandoB)));

                        arqui.Write("SOMA: ");
                        arqui.WriteLine((encaminhaULA(decodificadorSoma, OperandoA, OperandoB)));

                        arqui.Write("SUBTRAÇÃO: ");
                        arqui.WriteLine((encaminhaULA(decodificadorSubtracao, OperandoA, OperandoB)));

                        arqui.WriteLine("\tHEXADECIMAL: ");
                        arqui.Write("AND: ");
                        arqui.WriteLine(conv.BinarioParaHexadecimal(conv.PontoFlutuanteParaBinario(encaminhaULA(decodificadorAnd, OperandoA, OperandoB))));

                        arqui.Write("OR: ");
                        arqui.WriteLine(conv.BinarioParaHexadecimal(conv.PontoFlutuanteParaBinario(encaminhaULA(decodificadorOr, OperandoA, OperandoB))));

                        arqui.Write("NOT A: ");
                        arqui.WriteLine(conv.BinarioParaHexadecimal(conv.PontoFlutuanteParaBinario(encaminhaULA(decodificadorNotA, OperandoA, OperandoB))));

                        arqui.Write("NOT B: ");
                        arqui.WriteLine(conv.BinarioParaHexadecimal(conv.PontoFlutuanteParaBinario(encaminhaULA(decodificadorNotB, OperandoA, OperandoB))));

                        arqui.Write("SOMA: ");
                        arqui.WriteLine(conv.BinarioParaHexadecimal(conv.PontoFlutuanteParaBinario(encaminhaULA(decodificadorSoma, OperandoA, OperandoB))));

                        arqui.Write("SUBTRAÇÃO:");
                        arqui.WriteLine(conv.BinarioParaHexadecimal(conv.PontoFlutuanteParaBinario(encaminhaULA(decodificadorSubtracao, OperandoA, OperandoB))));

                        arqui.WriteLine();
                        arqui.WriteLine();
                        arqui.WriteLine();
                    }
                    arqui.Close();
                    arquivo.Close();
                    MessageBox.Show("De acordo com o arquivo operandos.txt foi gerado um novo arquivo com os resultados chamado resultado.txt", "Sucesso", MessageBoxButton.OK, MessageBoxImage.Information);
                }
                else
                {
                    MessageBox.Show("arquivo inexistente");
                }
            }
            catch (Exception e)
            {
                MessageBox.Show("Erro: " + e.Message);
            }
        }
        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));
            }
        }