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 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));
}
}