Exemple #1
0
        private void circularButton_converter_Click(object sender, EventArgs e)
        {
            try
            {
                decimalA = float.Parse(textBoxNumero1.Text);
                decimalB = float.Parse(textBoxNumero2.Text);
            }
            catch
            {
                MessageBox.Show("Digite um número válido", "Erro", MessageBoxButtons.OK, MessageBoxIcon.Error);
            }

            bool[] A                = Conversores.PontoFlutuanteParaBinario(decimalA);
            string binarioA         = Conversores.BoolParaString(A);
            string hexaDecimalA     = Conversores.BinarioParaHexa(binarioA);
            string sinalA           = ManipularBinario.ObterSinal1Bit(A);
            string expoenteBinarioA = ManipularBinario.ObterExpoente8bit(A);
            int    expoenteA        = Conversores.BinarioParaDecimal(ManipularBinario.ObterExpoente8bit(A), 8) - 127;
            string mantissaA        = ManipularBinario.ObterMantissa23bit(A);

            bool[] B                = Conversores.PontoFlutuanteParaBinario(decimalB);
            string binarioB         = Conversores.BoolParaString(B);
            string hexaDecimalB     = Conversores.BinarioParaHexa(binarioB);
            string sinalB           = ManipularBinario.ObterSinal1Bit(B);
            string expoenteBinarioB = ManipularBinario.ObterExpoente8bit(B);
            int    expoenteB        = Conversores.BinarioParaDecimal(ManipularBinario.ObterExpoente8bit(B), 8) - 127;
            string mantissaB        = ManipularBinario.ObterMantissa23bit(B);

            textBoxSinal1.Text    = sinalA;
            textBoxExpoente1.Text = expoenteBinarioA;
            textBoxMantissa1.Text = mantissaA;
            textBoxHexa1.Text     = hexaDecimalA;

            textBoxSinal2.Text    = sinalB;
            textBoxExpoente2.Text = expoenteBinarioB;
            textBoxMantissa2.Text = mantissaB;
            textBoxHexa2.Text     = hexaDecimalB;
        }
Exemple #2
0
        // Converte um binário IEEE754 para decimal
        public static double BinarioFlutuanteParaDecimal(bool[] binario)
        {
            string sinal        = "";
            string expoente     = "";
            string mantissa     = "";
            double expoenteReal = 0;

            sinal        = ManipularBinario.ObterSinal1Bit(binario);
            expoente     = ManipularBinario.ObterExpoente8bit(binario);
            expoenteReal = Conversores.BinarioParaDecimal(expoente, 8) - 127;

            mantissa = ManipularBinario.ObterMantissa23bit(binario);

            double parteFlutuante = 0;

            for (double i = 0; i < mantissa.Length; i++)
            {
                if (mantissa[(int)i] == '0')
                {
                    parteFlutuante += 0 * Math.Pow(2.0, (i + 1) * (-1));
                }
                else
                {
                    parteFlutuante += 1 * Math.Pow(2.0, (i + 1) * (-1));
                }
            }

            if (sinal[0] == '0')
            {
                parteFlutuante = (1 + parteFlutuante) * Math.Pow(2.0, expoenteReal);
            }
            else
            {
                parteFlutuante = ((1 + parteFlutuante) * Math.Pow(2.0, expoenteReal) * -1);
            }

            return(parteFlutuante);
        }
Exemple #3
0
        public void Soma(float decimalA, float decimalB, bool soma, string sinal)
        {
            Somador32Bit somador32 = new Somador32Bit();
            Somador8Bit  somador8  = new Somador8Bit();



            bool overflow = false;

            bool[] A            = Conversores.PontoFlutuanteParaBinario(decimalA);
            string binarioA     = Conversores.BoolParaString(A);
            string hexaDecimalA = Conversores.BinarioParaHexa(binarioA);
            string sinalA       = ManipularBinario.ObterSinal1Bit(A);

            int    expoenteA     = Conversores.BinarioParaDecimal(ManipularBinario.ObterExpoente8bit(A), 8) - 127;
            string mantissaA     = ManipularBinario.ObterMantissa23bit(A);
            string expoenteFinal = "";
            int    deslocar      = 0;

            bool[] resultadoSomaMantisas = null;

            bool[] B            = Conversores.PontoFlutuanteParaBinario(decimalB);
            string binarioB     = Conversores.BoolParaString(B);
            string hexaDecimalB = Conversores.BinarioParaHexa(binarioB);
            string sinalB       = ManipularBinario.ObterSinal1Bit(B);
            int    expoenteB    = Conversores.BinarioParaDecimal(ManipularBinario.ObterExpoente8bit(B), 8) - 127;
            string mantissaB    = ManipularBinario.ObterMantissa23bit(B);

            // se os dois número forem iguais a zero
            if ((decimalA == decimalB) && (decimalA == 0))
            {
                textBoxResultadoNumero.Text = "0";
                textBoxSinalR.Text          = "0";
                textBoxExpoenteR.Text       = "00000000";
                textBoxMantissaR.Text       = "00000000000000000000000";
                textBoxHexa.Text            = "0x00000000";
            }
            else if (decimalA == 0)
            {
                textBoxResultadoNumero.Text = decimalB.ToString();
                textBoxSinalR.Text          = ManipularBinario.ObterSinal1Bit(B);
                textBoxExpoenteR.Text       = ManipularBinario.ObterExpoente8bit(B);
                textBoxMantissaR.Text       = ManipularBinario.ObterMantissa23bit(B);
                textBoxHexa.Text            = Conversores.BinarioParaHexa(binarioB);
            }
            else if (decimalB == 0)
            {
                textBoxResultadoNumero.Text = decimalA.ToString();
                textBoxSinalR.Text          = ManipularBinario.ObterSinal1Bit(A);
                textBoxExpoenteR.Text       = ManipularBinario.ObterExpoente8bit(A);
                textBoxMantissaR.Text       = ManipularBinario.ObterMantissa23bit(A);
                textBoxHexa.Text            = Conversores.BinarioParaHexa(binarioB);
            }
            else
            {
                mantissaA = ManipularBinario.Adicionar1(mantissaA);
                mantissaB = ManipularBinario.Adicionar1(mantissaB);

                if (expoenteB > expoenteA)
                {
                    expoenteFinal = ManipularBinario.ObterExpoente8bit(B);
                    deslocar      = Math.Abs(expoenteA - expoenteB);
                    mantissaA     = ManipularBinario.Deslocamento(mantissaA, deslocar);
                }
                else if (expoenteA > expoenteB)
                {
                    expoenteFinal = ManipularBinario.ObterExpoente8bit(A);
                    deslocar      = Math.Abs(expoenteB - expoenteA);
                    mantissaB     = ManipularBinario.Deslocamento(mantissaB, deslocar);
                }
                else if (expoenteA == expoenteB)
                {
                    expoenteFinal = ManipularBinario.ObterExpoente8bit(A);
                }

                if (soma == false)
                {
                    mantissaB = ManipularBinario.ComplementoDe2(mantissaB);
                }

                bool[] BinarioA = Conversores.StringParaBool(mantissaA, 24);
                bool[] BinarioB = Conversores.StringParaBool(mantissaB, 24);
                resultadoSomaMantisas = somador32.Somador(BinarioA, BinarioB, ref overflow, soma);

                string somaMantissas = Conversores.BoolParaString(resultadoSomaMantisas);
                //somaMantissas = ManipularBinario.AlinhaResultadoMantissa(somaMantissas);
                somaMantissas = ManipularBinario.Remover1(somaMantissas);

                if (overflow == true && soma == true)
                {
                    expoenteFinal = Conversores.BoolParaString(somador8.Somador(Conversores.StringParaBool(expoenteFinal, 8), Conversores.StringParaBool("00000001", 8), ref overflow));
                }
                else if (overflow == true && soma == false)
                {
                    //somaMantissas = ManipularBinario.NormalizarAposSoma(somaMantissas, ref expoenteFinal);
                }

                somaMantissas = ManipularBinario.ArredondarBinario(somaMantissas);

                string IEEE754_Binario = ManipularBinario.Gerar_IEEE754(sinal, expoenteFinal, somaMantissas);
                string IEEE754_Hexa    = Conversores.BinarioParaHexa(IEEE754_Binario);

                bool[] resultado = Conversores.StringParaBool(IEEE754_Binario, 32);

                sinal = ManipularBinario.ObterSinal1Bit(resultado);
                string expoente = ManipularBinario.ObterExpoente8bit(resultado);
                string mantissa = ManipularBinario.ObterMantissa23bit(resultado);

                textBoxResultadoNumero.Text = Conversores.BinarioFlutuanteParaDecimal(resultado).ToString();
                textBoxSinalR.Text          = sinal;
                textBoxExpoenteR.Text       = expoente;
                textBoxMantissaR.Text       = mantissa;
                textBoxHexa.Text            = IEEE754_Hexa;
            }
        }