Calcolo della radice quadrata del numero binario a 8 bit

Stavo cercando un modo per calcolare la radice quadrata di un dato numero di 8 bit usando solo la combinazione digitale o la logica sequenziale. È possibile?

Un modo potrebbe essere quello di usare solo una tabella di ricerca poiché non sto prendendo in considerazione parti frazionarie (quindi ) ma ci deve essere un modo migliore di questo. Qualcuno può indicarmi questo?$\sqrt{10} \simeq 3$

Le tabelle di ricerca sono state menzionate nei commenti. Esistono due approcci.

Crea velocemente una tabella lunga 256 byte, con ogni valore successivo la radice quadrata dell'indice corrispondente. Questo è veloce poiché usi l'argomento come indice per accedere direttamente al giusto valore. Lo svantaggio è che ha bisogno di una tabella lunga, con molti valori duplicati.

Compatto
Come detto, un numero intero a 8 bit può avere solo valori da 0 a 255 e le radici quadrate corrispondenti sono da 0 a 16 (arrotondate). Costruire una tabella di 16 voci (in base zero) con l'n-esima voce il valore massimo per l'argomento per il quale la radice quadrata è n. La tabella sarebbe simile a questa:

 0  
 2  
 6  
12  
20
etc.

Cammini attraverso la tabella e ti fermi quando incontri un valore maggiore o uguale al tuo argomento. Esempio: radice quadrata di 18

set index to 0
value[0] = 0, is less than 18, go to the next entry  
value[1] = 2, is less than 18, go to the next entry  
value[2] = 6, is less than 18, go to the next entry  
value[3] = 12, is less than 18, go to the next entry
value[4] = 20, is greater than or equal to 18, so sqrt(18) = 4

Mentre la tabella di ricerca rapida ha un tempo di esecuzione fisso (solo una ricerca), qui il tempo di esecuzione è più lungo per argomenti di valore più elevato.

Per entrambi i metodi, scegliendo diversi valori per la tabella, è possibile selezionare un valore arrotondato o troncato per la radice quadrata.

Lavorando in 8 bit, sei sostanzialmente vincolato a soluzioni intere. Se hai bisogno della radice quadrata di X, il più vicino che puoi ottenere è il numero intero più grande il cui quadrato è minore o uguale a X. Ad esempio, per sqrt (50) otterrai 7, poiché 8 * 8 sarebbe maggiore di 50.

Quindi, ecco un trucco per farlo: conta quanti numeri dispari, a partire da 1, puoi sottrarre da X. Puoi farlo con la logica in questo modo: un registro R1 a 8 bit contiene il valore di lavoro, un contatore R2 a 7 bit R2 contiene (la maggior parte) del numero dispari e un contatore a 4 bit R3 contiene il risultato. Al ripristino, R1 viene caricato con il valore di X, R2 viene azzerato e R3 viene azzerato. Un circuito di sottrazione a 8 bit viene alimentato R1 per l'ingresso 'A' e il valore di R2 combinato con un LSB fissato su '1' (tramite pull-up) per l'ingresso 'B'. Il sottrattore emette una differenza di 8 bit AB e un bit di prestito. Ad ogni clock, se il bit di prestito è chiaro, R1 viene caricato con l'uscita del sottrattore, R2 viene incrementato e R3 viene incrementato. Se il bit di prestito è impostato, R1 non viene caricato e R2, R3 non viene incrementato, b / c il risultato è ora pronto in R3.

IN ALTERNATIVA

Esistono solo 16 valori di output possibili, quindi la risposta è un numero di quattro bit. In sostanza, hai quattro funzioni a bit singolo degli 8 bit di ingresso. Ora, non riesco a disegnare una mappa di Karnaugh a 8 dimensioni, ma in linea di principio potresti creare un circuito combinatorio per ogni bit della risposta. Prendi le uscite di quei quattro circuiti combinatori insieme e interpretali come la risposta a quattro bit. Ecco. Niente orologi, niente registri, basterebbe solo un mucchio di NAND e NOR.

Non so se questo sia di aiuto, ma esiste un modo ingegnosamente semplice per calcolare una radice quadrata:

unsigned char sqrt(unsigned char num)
{
    unsigned char op  = num;
    unsigned char res = 0;
    unsigned char one = 0x40;

    while (one > op)
        one >>= 2;

    while (one != 0)
    {
        if (op >= res + one)
        {
            op -= res + one;
            res = (res >> 1) + one;
        }
        else
        {
            res >>= 1;
        }

        one >>= 2;
    }
    return res;
}

Non so molto di ciò che può e non può essere fatto nella logica sequenziale, ma poiché questo algoritmo termina in soli 4 loop, potresti essere in grado di implementarlo in 4 fasi.

Ho eseguito le tabelle di verità per la radice quadrata intera da 0-255 attraverso un minimizzatore logico Quine-McCluskey. La radice quadrata intera può essere eseguita solo con la logica combinatoria, ma anche per una dimensione di input relativamente piccola di$2^8$possibili valori, la risposta non è per i deboli di cuore. Viene ordinato quanto segue da MSB A a LSB D dell'uscita, in termini di abcdefgh come input, da MSB a LSB:

    A =     a
     or     b;

    B =     a and     b
     or not b and     c
     or not b and     d;

    C =     a and     b and     c
     or     a and     b and     d
     or     a and not b and not c and not d
     or     a and not c and not d and     e
     or     a and not c and not d and     f
     or not a and     c and     d
     or not a and     c and     e
     or not a and     c and     f
     or not a and not b and not d and     e
     or not a and not b and not d and     f;

     D =     a and     b and     c and     e
     or     a and     b and     c and     f
     or     a and     c and     d
     or     a and not b and not c and not d
     or     a and not b and not d and     e and     f
     or     a and not b and not d and     e and     g
     or     a and not b and not d and     e and     h
     or     a and not c and not d and not e and not f
     or     b and     c and not d and not e and not f and     g
     or     b and     c and not d and not e and not f and     h
     or not a and     b and not c and     d and     e
     or not a and     b and not c and     d and     f
     or not a and     b and not c and     d and     g
     or not a and     b and not c and     d and     h
     or not a and     c and not d and not e and not f
     or not a and     d and     e and     f
     or not a and     d and     e and     g
     or not a and     d and     e and     h
     or not a and not b and     c and not e and not f and     g
     or not a and not b and     c and not e and not f and     h
     or not a and not b and not c and     e and     f
     or not b and     c and     d and     e
     or not b and     c and     d and     f
     or not b and not c and not d and not f and     g
     or not b and not c and not d and not f and     h;