divisioni binarie

[Donbabbeo]

Non è esattamente un discorso di programmazione, più che altro sarebbe un'implementazione di divisore binario con 3 bit di dividendo e divisore.
Ovviamente l'output sono sia quoziente che resto.
Io le operazioni le ho fatte e vengono, ma il risultato in alcune soluzioni non ha alcun senso... aiutatemi please :(
Il problema che ho è questo:
supponendo che io abbia una divisione
001 / 110
avrei come risultato
000 con 001 di resto, perchè da verifica
DIVIDENDO = DIVISORE x RISULTATO + RESTO...

ma di consequenza, qualsiasi operazione con dividendo < divisore ha come risultato 000 con resto = dividendo? :confused:

[DanieleC88]

Be', direi proprio di sì... Cosa stai facendo, un circuito combinatorio?

[Donbabbeo]

Esattamente, sto implementando un circuito per una calcolatrice binaria con operandi a 4 bit.
Addizione/sottrazione e moltiplicazione sono operazioni banali, il problema viene nella divisione...

Comunque la prima parte dell'errore è stata trovata... in realtà dovrei ottenere come risultato anche i numeri dopo la virgola, invece di ottenere quoziente più resto... Ho buttato giù una tabellina riassuntiva dei risultati e degli scarti dal valore corretto, ha operandi a 3 bit perchè a 4 veniva troppo lunga e non c'avevo voglia :asd:

OP1 OP2 RISULTATO DECIM. SCARTO
----------------------------------------------
001 001 001.0000 1 0
001 010 000.1000 0.5 0
001 011 000.0101 0.3333 0.0208
001 100 000.0100 0.25 0
001 101 000.0011 0.2 0.0125
001 110 000.0010 0.1667 0.0417
001 111 000.0010 0.1428 0.0178
----------------------------------------------
010 001 010.0000 2 0
010 010 001.0000 1 0
010 011 000.1010 0.6667 0.0417
010 100 000.1000 0.5 0
010 101 000.0110 0.4 0.025
010 110 000.0101 0.3333 0.0208
010 111 000.0100 0.2857 0.0375
----------------------------------------------
011 001 011.0000 3 0
011 010 001.1000 1.5 0
011 011 001.0000 1 0
011 100 000.1100 0.75 0
011 101 000.1001 0.6 0.0375
011 110 000.1000 0.5 0
011 111 000.0110 0.4286 0.0536
----------------------------------------------
100 001 100.0000 4 0
100 010 010.0000 2 0
100 011 001.0101 1.333 0.0208
100 100 001.0000 1 0
100 101 000.1100 0.8 0.05
100 110 000.1010 0.6667 0.0417
100 111 000.1001 0.5714 0.0089
----------------------------------------------
101 001 101.0000 5 0
101 010 010.1000 2.5 0
101 011 001.1010 1.6667 0.0417
101 100 001.0100 1.25 0
101 101 001.0000 1 0
101 110 000.1101 0.8333 0.0208
101 111 000.1011 0.7143 0.0268
----------------------------------------------
110 001 110.0000 6 0
110 010 011.0000 3 0
110 011 010.0000 2 0
110 100 001.1000 1.5 0
110 101 001.0011 1.2 0.0125
110 110 001.0000 1 0
110 111 000.1101 0.8571 0.0446
----------------------------------------------
111 001 111.0000 7 0
111 010 011.1000 3.5 0
111 011 010.0101 2.3333 0.0208
111 100 001.1100 1.75 0
111 101 001.0110 1.4 0.025
111 110 001.0010 1.1667 0.0417
111 111 001.0000 1 0
----------------------------------------------

Il circuito ha come output 9 display a segmenti (Uno per il segno nella sottrazione, gli altri 8 per i valori binari)... Di conseguenza nella divisione invece di avere come risultato 4 display per il quoziente e 4 per il resto devo usare 8 display per il risultato, 4 sopra la virgola e 4 sotto...:muro:

[DanieleC88]

Ho buttato giù una tabellina riassuntiva dei risultati e degli scarti dal valore corretto, ha operandi a 3 bit perchè a 4 veniva troppo lunga e non c'avevo voglia :asd:
In effetti uscirebbe un tabellone enorme, hai fatto bene a tralasciarlo... :D
In caso di divisione per zero invece che risultato dai? Vedo che l'hai omesso dai possibili input. :)

Ma una curiosità: lo stai facendo per hobby/studio o è una cosa più seria? Perché se è la seconda, non ho certo l'esperienza per permettermi anche solo di consigliarti... :stordita:

[gugoXX]

ma di consequenza, qualsiasi operazione con dividendo < divisore ha come risultato 000 con resto = dividendo? :confused:

Certo.
E' cosi' in qualsiasi base (giustamente i risultati delle operazioni sono indipendenti dalla base)

45/60 = 0 resto 45
5/9 = 0 resto 5
3/4 = 0 resto 3


Esattamente, sto implementando un circuito per una calcolatrice binaria con operandi a 4 bit.


Comunque, se devi fare il calcolo della divisione in circuito combinatorio, ti consiglio di fare proprio l'algoritmo della divisione.
Ripassa quello che ci veniva insegnato alle elementari. Quello della calcolatrice e' identico, se non che e' in base 2 (che e' ancora piu' semplice della base 10).
Ovviamente la strada di memorizzarsi tutte le possibili combinazioni funziona... ma solo fino ad un certo punto.
Se invece di 3 bit fosse a 16 bit, dovresti memorizzare 4GB di dati, per la sola divisione a 16bit.
Pensa la 32bit...

[DanieleC88]

Non serve effettivamente memorizzare quei dati, ma avendo un circuito che presenta 8 bit in input sugli ingressi (4+4 dei due operandi) puoi farti un bel tabellone e poi implementare un circuito che codifichi le funzioni booleane di tutti e 8 i bit da presentare in output... ma non so fino a che punto convenga un lavoraccio così. :boh:

[Donbabbeo]

Difatti la tabella era solo per avere un'idea di base sui vari risultati e capire bene o male come dovevo comportarmi.
In realtà come ho detto la divisione l'ho già implementata, ma i risultati han poco senso.

dividendo/(valore > dividendo) da come risultato sempre 0 e resto dividendo, che sebbene voi diciate sia corretto è in ogni caso un risultato poco significativo... Se io faccio 1/2 ed 1/3 i risultati sono diversi, mentre io ottengo il medesimo risultato.

Ho pensato perciò di ottenere 4 bit di risultato intero e 4 bit di risultato dopo la virgola, così da ottenere un risultato significativo e diverso per ogni divisione.

Qualche idea? E' meglio lasciar perdere? Come potrei impostare il circuito?
:D

[gugoXX]

Difatti la tabella era solo per avere un'idea di base sui vari risultati e capire bene o male come dovevo comportarmi.
In realtà come ho detto la divisione l'ho già implementata, ma i risultati han poco senso.

dividendo/(valore > dividendo) da come risultato sempre 0 e resto dividendo, che sebbene voi diciate sia corretto è in ogni caso un risultato poco significativo... Se io faccio 1/2 ed 1/3 i risultati sono diversi, mentre io ottengo il medesimo risultato.

Ho pensato perciò di ottenere 4 bit di risultato intero e 4 bit di risultato dopo la virgola, così da ottenere un risultato significativo e diverso per ogni divisione.

Qualche idea? E' meglio lasciar perdere? Come potrei impostare il circuito?
:D

1/2 e 1/3 danno entrambi 0, se si considera la matematica degli interi.
Se invece vuoi le virgole, allora di nuovo ti consiglio di studiare l'algoritmo della divisione delle elementari, che e' quello usato anche dai nostri processori.

[Donbabbeo]

Comincio a capirci qualcosa... In pratica io avrei implementato (senza neanche saperlo :sofico: ) la divisione Euclidea...

Ho reinventato la divisione :eek:

A parte gli scherzi, proverò ad implementare la divisione trasformando il risultato in numero reale, ma non credo di fare in tempo per la consegna...

Proverò a contattare il professore e sentire un suo parere.

In ogni caso ogni consiglio è bene accetto e grazie ad entrambi :D

[Donbabbeo]

Potreste semplificarmi questa equazione? Sono un caprone :cry:

ABC+AB'C'D'+A'B'CD'+A'BC'+BD = E

vorrei utilizzare pure xor, nor xnor o quello che è, non sono stato capace io :help:

[DanieleC88]

Non credo sia ulteriormente semplificabile, non mi sembra che ci siano termini a distanza di Hamming unitaria. :(

[Donbabbeo]

Grazie mille, ho già implementato tutto, ma risulta un pò complessa da decifrare :muro:
So che quello che ho fatto "dovrebbe" permettermi di calcolare la sottrazione su singolo bit, ma sebbene sia corretto non mi tornano i conti :muro:

[DanieleC88]

E allora non è corretto. :D
Il problema è che se ti scappa una connessione sbagliata salta tutto. :(

[Donbabbeo]

scemo :muro: scemo :muro: scemo :muro:
Ehm... era tutto corretto quello che avevo già fatto, se non fosse che avevo invertito gli ingressi due volte e quindi alla fine tornava, ma prendendoli singolarmente non tornavano i conti :rolleyes:
Comunque finito, consegnato e ricevuto i complimenti dal professore per il bel lavoro.

:D

Volevo uppare lo schema qua, ma non posso allegarlo perchè troppo pesante, casomai qualcuno fosse interessato (:rolleyes: ) mi invii un pvt che glielo mando.

PS: grazie dell'aiuto ad entrambi :D