public static string ObterExpoente8bit(bool[] binario)
{
string binarioS = "";
string expoente = "";
binarioS = Conversores.BoolParaString(binario);
expoente = binarioS.Substring(1, 8);
return(expoente);
}
public static string ObterMantissa23bit(bool[] binario)
{
string binarioS = "";
string mantissa = "";
binarioS = Conversores.BoolParaString(binario);
mantissa = binarioS.Substring(9, 23);
return(mantissa);
}
public static string ObterSinal1Bit(bool[] binario)
{
string binarioS = "";
string sinal = "";
binarioS = Conversores.BoolParaString(binario);
sinal = binarioS.Substring(0, 1);
return(sinal);
}
// arredontar binário somando 1 a mantissa
public static string ArredondarBinario(string binario)
{
if ((binario[binario.Length - 1] == '1') && (binario[binario.Length - 2] == '1'))
{
bool[] Binario = Conversores.StringParaBool(binario, 24);
bool[] arredondar = new bool[24];
bool overflow = false;
arredondar[22] = true;
Somador32Bit somador = new Somador32Bit();
bool[] resultado = somador.Somador(Binario, arredondar, ref overflow, false);
return(Conversores.BoolParaString(resultado).Substring(0, 23));
}
return(binario.Substring(0, 23));
}
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;
}
// 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);
}
public static string ComplementoDe2(string mantissa)
{
ComplementoDe2 complemento = new ComplementoDe2();
bool overflow = false;
bool[] mantissaBool = Conversores.StringParaBool(mantissa, 24);
bool[] Um = Conversores.StringParaBool("00000000000000000000001", 24);
for (int i = 0; i < mantissaBool.Length; i++)
{
if (mantissaBool[i] == true)
{
mantissaBool[i] = false;
}
else
{
mantissaBool[i] = true;
}
}
mantissaBool = complemento.complemento2(mantissaBool, Um, ref overflow);
return(Conversores.BoolParaString(mantissaBool).PadRight(24, '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;
}
}
// converte um número float para binário no formato IEEE754
public static bool[] PontoFlutuanteParaBinario(float flutuante)
{
// .TrimStart(new Char[] { '0' } remove zeros a esquerda da string
float numeroF = 0;
int parteInteira = 0;
float parteFlutuante = 0;
char sinal;
string binarioInteiro = "";
string binarioFlutuante = "";
int expoente = 0;
int expoentePolarizado = 0;
string expoentePolarizadoBinario = "";
string mantissa = "";
string flutuanteNormalizado = "";
string binarioFinal = "";
numeroF = flutuante;
if (numeroF < 0)
{
sinal = '1';
numeroF *= -1;
}
else
{
sinal = '0';
}
parteInteira = (int)numeroF;
parteFlutuante = numeroF - parteInteira;
binarioInteiro = Conversores.InteiroParaBinario(parteInteira, 32).TrimStart(new Char[] { '0' });
if (parteFlutuante > 0)
{
binarioFlutuante = Conversores.FlutuanteParaBinario(parteFlutuante);
}
if (parteInteira > 0)
{
expoente = binarioInteiro.Length - 1;
expoentePolarizado = (binarioInteiro.Length - 1) + 127;
mantissa = (binarioInteiro + binarioFlutuante).Remove(0, 1);
}
else if (parteInteira == 0 && parteFlutuante == 0)
{
expoentePolarizado = 0;
}
else
{
flutuanteNormalizado = binarioFlutuante.TrimStart(new Char[] { '0' });
flutuanteNormalizado = flutuanteNormalizado.Remove(0, 1);
expoente = -(binarioFlutuante.Length - flutuanteNormalizado.Length);
expoentePolarizado = (127 - (binarioFlutuante.Length - flutuanteNormalizado.Length));
mantissa = flutuanteNormalizado;
}
expoentePolarizadoBinario = Conversores.InteiroParaBinario(expoentePolarizado, 8);
binarioFinal = sinal + expoentePolarizadoBinario + mantissa;
bool[] IEEE754 = Conversores.StringParaBool(binarioFinal, 32);
return(IEEE754);
}