Esempio n. 1
0
        private void btn_soma_Click(object sender, EventArgs e)
        {
            //SEPARAR DECIMAL E FRACIONARIO QUANDO CONVERTER PARA BINARIO

            Somador32Bit somador32     = new Somador32Bit();
            bool         overflow      = false;
            string       expoenteFinal = Decimal_Binario.DecimalParaBinario((numeroA + numeroB).ToString());

            vetorA = Conversões.Vetor_Booleano(valorBinario1_32);
            vetorB = Conversões.Vetor_Booleano(valorBinario2_32);
            expoente_simplificado_1 = Decimal_Binario.BinarioParaDecimal(expoente1) - 127;
            expoente_simplificado_2 = Decimal_Binario.BinarioParaDecimal(expoente2) - 127;
            int andar;

            if (expoente_simplificado_1 < expoente_simplificado_2)
            {
                expoenteFinal       = Conversões.Expoente(expoenteFinal);
                andar               = (expoente_simplificado_2 - expoente_simplificado_1) + 1;
                mantissa_A_igualada = Conversões.Andar(mantissa1, andar);
                mantissa_B_igualada = Conversões.Colocar1(mantissa2);
            }
            else if (expoente_simplificado_1 > expoente_simplificado_2)
            {
                expoenteFinal       = Conversões.Expoente(expoenteFinal);
                andar               = Math.Abs(expoente_simplificado_1 - expoente_simplificado_2) + 1;
                mantissa_B_igualada = Conversões.Andar(mantissa2, andar);
                mantissa_A_igualada = Conversões.Colocar1(mantissa1);
            }
            else if (expoente_simplificado_1 == expoente_simplificado_2)
            {
                expoenteFinal       = Conversões.Expoente(expoenteFinal);
                andar               = Math.Abs(expoente_simplificado_2 - expoente_simplificado_1);
                mantissa_B_igualada = Conversões.Andar(mantissa2, andar);
                mantissa_A_igualada = Conversões.Colocar1(mantissa1);
            }
            resultado_decimal    = num1 + num2;
            vetorA               = Conversões.Vetor_Booleano(mantissa_A_igualada);
            vetorB               = Conversões.Vetor_Booleano(mantissa_B_igualada);
            resultados_mantissas = somador32.Somador(vetorA, vetorB, ref overflow);
            mantissa_soma        = Conversões.Bool_Binario_string(resultados_mantissas);
            mantissa_soma        = Conversões.Retirar_1(mantissa_soma);
            mantissa_soma        = Conversões.Arr_bin(mantissa_soma);
            IEEE_final           = sinal_final + expoenteFinal + mantissa_soma;
            resultado_hexa       = Conversões.BinarioParaHexa(IEEE_final);
            lst_resultadosinal.Items.Clear();
            lst_resultadoexpoente.Items.Clear();
            lst_resultadoMantissa.Items.Clear();
            lst_resultadoHexa.Items.Clear();
            lst_resutadosomadecimal.Items.Clear();
            lst_resultadosinal.Items.Add(sinal_final);
            lst_resultadoexpoente.Items.Add(expoenteFinal);
            lst_resultadoMantissa.Items.Add(mantissa_soma);
            lst_resutadosomadecimal.Items.Add(resultado_decimal);
            lst_resultadoHexa.Items.Add(resultado_hexa);
        }
Esempio n. 2
0
        public static string Arr_bin(string binario)
        {
            if ((binario[binario.Length - 1] == '1') && (binario[binario.Length - 2] == '1'))
            {
                bool[] Binario    = Conversões.Vetor_Booleano(binario);
                bool[] arredondar = new bool[24];
                bool   overflow   = false;

                arredondar[22] = true;
                Somador32Bit somador   = new Somador32Bit();
                bool[]       resultado = somador.Somador(Binario, arredondar, ref overflow);
                return(Conversões.Bool_Binario_string(resultado).Substring(0, 23));
            }

            return(binario.Substring(0, 23));
        }
Esempio n. 3
0
        private void btn_multiplicar_Click(object sender, EventArgs e)
        {
            string mantissa_multiplicando = "";
            bool   erro = false;

            if (num1 % 1 != 0 && num2 % 1 != 0)
            {
                MessageBox.Show("Para multiplicar um dos dois fatores precisa ser inteiro", "Aviso", MessageBoxButtons.OK, MessageBoxIcon.Exclamation);
                erro = true;
            }
            else if (num1 % 1 != 0)
            {
                multiplicando          = num1;
                multiplicador          = num2;
                mantissa_multiplicando = mantissa1;
            }
            else if (num2 % 1 != 0)
            {
                multiplicando          = num2;
                multiplicador          = num1;
                mantissa_multiplicando = mantissa2;
            }
            else
            {
                if (num1 < num2)
                {
                    multiplicador          = num1;
                    multiplicando          = num2;
                    mantissa_multiplicando = mantissa2;
                }
                else if (num2 < num1)
                {
                    multiplicador          = num2;
                    multiplicando          = num1;
                    mantissa_multiplicando = mantissa1;
                }
                else
                {
                    multiplicador          = num1;
                    multiplicando          = num2;
                    mantissa_multiplicando = mantissa2;
                }
            }

            if (erro == false)
            {
                Somador32Bit somador32         = new Somador32Bit();
                double       num1_csinal       = double.Parse(txt_num1.Text);
                double       num2_csinal       = double.Parse(txt_num2.Text);
                double       resultado_decimal = num1 * num2;
                string       sinal_final       = "";
                if (num1_csinal < 0 && num2_csinal < 0)
                {
                    sinal_final = "0";
                }
                else if (num1_csinal < 0 || num2_csinal < 0)
                {
                    sinal_final = "1";
                }
                else
                {
                    sinal_final = "0";
                }
                string expoenteFinal = Decimal_Binario.DecimalParaBinario((numeroA * numeroB).ToString());
                expoenteFinal = Conversões.Expoente(expoenteFinal);
                bool   overflow = false;
                string mantissa_multiplicando_1 = Conversões.Colocar1(mantissa_multiplicando);
                bool[] multiplicando_vet_bool   = Conversões.Vetor_Booleano(mantissa_multiplicando_1);
                bool[] zero_bool = Conversões.Numero_zero();
                bool[] resultado = multiplicando_vet_bool;
                for (int i = 0; i < multiplicador; i++)
                {
                    resultado = somador32.Somador(resultado, zero_bool, ref overflow);
                }
                string resultado_binario = Conversões.Bool_Binario_string(resultado);
                resultado_binario = Conversões.Retirar_1(resultado_binario);
                //string mantissa_resultado = Conversões.Mantissa(resultado_binario);
                string mantissa_resultado = resultado_binario;
                IEEE_final     = sinal_final + expoenteFinal + mantissa_resultado;
                resultado_hexa = Conversões.BinarioParaHexa(IEEE_final);
                lst_resultadosinal.Items.Clear();
                lst_resultadoexpoente.Items.Clear();
                lst_resultadoMantissa.Items.Clear();
                lst_resultadoHexa.Items.Clear();
                lst_resutadosomadecimal.Items.Clear();
                lst_resultadosinal.Items.Add(sinal_final);
                lst_resultadoexpoente.Items.Add(expoenteFinal);
                lst_resultadoMantissa.Items.Add(mantissa_resultado);
                lst_resutadosomadecimal.Items.Add(resultado_decimal);
                lst_resultadoHexa.Items.Add(resultado_hexa);
            }
            else
            {
                MessageBox.Show("Operação não executada", "Aviso", MessageBoxButtons.OK, MessageBoxIcon.Exclamation);
            }
        }