Calculadora

SamuelRodriguesC
(usa Linux Mint)

Enviado em 25/05/2017 - 16:25h

Pessoal como fazer calculadora que calcula as quatro operações de bit a bit sem usar operadores aritméticos ?

paulo1205
(usa Ubuntu)

Enviado em 26/05/2017 - 01:50h

Usando os operadores lógicos.

Para cada bit a ser somado, por exemplo, você tem duas tabelas verdade, com três variáveis de entrada em cada uma.

Soma do n-ésimo bit (S[n]):

Entradas: n-ésimo bit de A, n-ésimo bit de B, e o vai-um do [n-1]-ésimo bit da soma (V)



    +------------------+-----+-----+-----+-----+

    | V[n-1]\A[n],B[n] | 0,0 | 0,1 | 1,1 | 1,0 |

    +------------------+-----+-----+-----+-----+

    |      0           |  0  |  1  |  0  |  1  |

    +------------------+-----+-----+-----+-----+

    |      1           |  1  |  0  |  1  |  0  |

    +------------------+-----+-----+-----+-----+



S[n]=(A[n]&B[n]&V[n-1])|(A[n]&~B[n]&~V[n-1])|(~A[n]&~B[n]&V[n-1])|(~A[n]&B[n]&~V[n-1])

    ou

S[n]=A[n]^B[n]^V[n-1]  (O sinal “^” é o operador ou-exclusivo bit a bit do C.) 

Vai-um do n-ésimo bit (V[n]):

Entradas: n-ésimo bit de A, n-ésimo bit de B, e o vai-um do [n-1]-ésimo bit da soma (V)



    +------------------+-----+-----+-----+-----+

    | V[n-1]\A[n],B[n] | 0,0 | 0,1 | 1,1 | 1,0 |

    +------------------+-----+-----+-----+-----+

    |      0           |  0  |  0  |  1  |  0  |

    +------------------+-----+-----+-----+-----+

    |      1           |  0  |  1  |  1  |  1  |

    +------------------+-----+-----+-----+-----+

        

V[n]=(A[n]&B[n])|(A[n]&V[n-1])|(B[n]&V[n-1])

    ou

V[n]=(A[n]&B[n])|(V[n-1]&(A[n]|B[n])) 

Como você tem a fórmula de um V[n] qualquer, e tanto S[n] quanto V[n] dependem de V[n-1], você pode expandir esse V[n-1].

V[n]=(A[n]&B[n])|(((A[n-1]&B[n-1])|(V[n-2]&(A[n-1]|B[n-1])))&(A[n]|B[n]))

S[n]=A[n]^B[n]^((A[n-1]&B[n-1])|(V[n-2]&(A[n-1]|B[n-1]))) 

Essa expansão pode ser repetida até que você só tenha como componentes os bits de A e de B. Quando n=0, A[n-1]=B[n-1]=V[n-1]=0.

Alternativamente, em lugar da expansão, você poderia usar um laço de repetição, e ir operando um bit de cada vez.

SamuelRodriguesC
(usa Linux Mint)

Enviado em 26/05/2017 - 06:58h

Sim sim mais como eu escrevo um código assim? Tem como vc dar um exemplo na linguagem em c?

paulo1205
(usa Ubuntu)

Enviado em 26/05/2017 - 15:43h

Não tem como dar um exemplo sem entregar a resposta (ou pelo menos uma boa parte dela). Espero que você entenda que não seria ético fazer isso.

uilianries
(usa Linux Mint)

Enviado em 26/05/2017 - 20:58h

As respostas do Paulo são mais ricas do que muito material encontrado nos livros utilizados durante os cursos da área.
Cada post é quase uma aula.

SamuelRodriguesC
(usa Linux Mint)

Enviado em 31/05/2017 - 09:50h

Mesmo assim não consegui escrever o código, tem como você mandar parte do programa feito, pois eu só preciso entender como funciona não tem nada você entregar a resposta so precisa estar de forma bem clara para que eu entenda como funciona?

paulo1205
(usa Ubuntu)

Enviado em 31/05/2017 - 17:22h

Ai, ai... Vamos lá. Vou mostrar a soma para dados do tipo unit8_t (equivalente a unsigned char nos nossos PCs).

uint8_t a, b, aEb, aOUb, s, v;

a=123;  // Primeira parcela.

b=99;   // Segunda parcela.

aEb=a&b;

aOUb=a|b;

v=aEb;           // bit 0 de v

v|=(v<<1)&aOUb;  // bit 1 de v (usa valor do bit 0, levando-o para a esquerda (v<<1) mas preservando o original (|=))

v|=(v<<1)&aOUb;  // bit 2 de v (usa valor dos bit 0-1, levando-os para a esquerda (v<<1) mas preservando os originais (|=))

v|=(v<<1)&aOUb;  // bit 3 de v (usa valor dos bit 0-2, levando-os para a esquerda (v<<1) mas preservando os originais (|=))

v|=(v<<1)&aOUb;  // bit 4 de v (usa valor dos bit 0-3, levando-os para a esquerda (v<<1) mas preservando os originais (|=))

v|=(v<<1)&aOUb;  // bit 5 de v (usa valor dos bit 0-4, levando-os para a esquerda (v<<1) mas preservando os originais (|=))

v|=(v<<1)&aOUb;  // bit 6 de v (usa valor dos bit 0-5, levando-os para a esquerda (v<<1) mas preservando os originais (|=))

v|=(v<<1)&aOUb;  // bit 7 de v (usa valor dos bit 0-6, levando-os para a esquerda (v<<1) mas preservando os originais (|=))

s=a^b^(v<<1); 

TarcisioSilva
(usa Ubuntu)

Enviado em 31/05/2017 - 17:49h

Boa Tarde meu amigo!

fiz uma hoje mas na gambiarra hahaha, o que posso dizer pra você é que usando o operador bit a bit (&) faz pra você, só dar uma lida sobre que vai abrir sua mente ai com o que absorver você tenta alinhar a sua qualidade na linguagem.

Tarcisio Silva