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));
}
}
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 int chamarULAinteiro(bool[] f, int a, int b, int tamanho)
{
Conversor converter = new Conversor();
bool inverteu = false, complemento2A = false, complemento2B = false;
bool[] A, B;
int resposta;
if (b > a && (f[2] & !f[1] & f[0] || f[2] & !f[1] & !f[0])) //caso seja subtração e b > a ele inverte
{
inverteu = true;
int aux = a;
a = b;
b = aux;
}
//convertendo pra complemento 2 binario
if (a < 0)
{
a *= -1; complemento2A = true;
A = converter.complemento2(converter.InteiroParaBinario(tamanho, a));
}
else
{
A = converter.InteiroParaBinario(tamanho, a);
}
if (b < 0)
{
b *= -1; complemento2B = true;
B = converter.complemento2(converter.InteiroParaBinario(tamanho, b));
}
else
{
B = converter.InteiroParaBinario(tamanho, b);
}
if (f[2] & !f[1] & f[0]) //SE SUBTRAÇÃO
{
B = converter.complemento2(B);
}
bool overflowSoma;
bool[] resultado = new bool[tamanho];
if (tamanho == 8) //8 bits
{
UnidadeLogica8bits ula = new UnidadeLogica8bits();
overflowSoma = ula.ULA8Bits(A, B, f, resultado);
}
else //24 bits
{
UnidadeLogica24bits ula = new UnidadeLogica24bits();
overflowSoma = ula.ULA24Bits(A, B, f, resultado);
}
if (complemento2A || complemento2B)
{
resposta = converter.complemento2ParaDecimal(resultado);
}
else
{
resposta = converter.BinarioParaInteiro(resultado);
}
if (inverteu)
{
resposta *= -1;
}
return(resposta);
}
