Обчислення квадратного кореня 8-бітного двійкового числа

Я шукав спосіб обчислити квадратний корінь заданого 8-бітного числа, використовуючи лише цифрову комбінацію або послідовну логіку. Це можливо?

Один із способів може бути просто використовувати таблицю пошуку, оскільки я взагалі не розглядаю дробові частини (так ), але має бути кращий спосіб, ніж цей. Чи може хтось вказати мені на це?$\sqrt{10} \simeq 3$

У коментарях згадуються таблиці пошуку. Є два підходи.

Швидко
Створіть довгу таблицю на 256 байт, при кожному наступному значенні - квадратний корінь відповідного індексу. Це швидко, оскільки ви використовуєте аргумент як індекс для прямого доступу до потрібного значення. Недолік полягає в тому, що йому потрібна довга таблиця з великою кількістю повторюваних значень.

Як сказано компактно , 8-бітове ціле число може мати значення лише від 0 до 255, а відповідні квадратні корені - від 0 до 16 (округлі). Побудуйте таблицю 16 записів (на основі нуля) з n-го запису максимальним значенням аргументу, для якого квадратний корінь є n. Таблиця виглядатиме так:

 0  
 2  
 6  
12  
20
etc.

Ви проходите по таблиці та зупиняєтесь, коли стикаєтесь із значенням, що перевищує або дорівнює вашому аргументу. Приклад: квадратний корінь 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

Хоча таблиця швидкого пошуку має фіксований час виконання (лише один пошук), тут для виконання аргументів більш високого значення довше час виконання.

Для обох методів виходить, що, вибираючи різні значення для таблиці, ви можете вибрати округлене або усічене значення для квадратного кореня.

Працюючи в 8 бітах, ви в основному обмежені цілими рішеннями. Якщо вам потрібен квадратний корінь X, найближчим ви можете отримати найбільше ціле число, квадрат якого менше або дорівнює X. Наприклад, для sqrt (50) ви отримаєте 7, оскільки 8 * 8 було б більше, ніж 50.

Тож ось хитрість для цього: підрахуйте, скільки непарних чисел, починаючи з 1, ви можете відняти від X. Ви можете це зробити за такою логікою: 8-бітний регістр R1 містить робоче значення, 7-бітний лічильник R2 утримує (більшість) непарне число, а результат має 4-бітний лічильник R3. Після скидання R1 завантажується зі значенням X, R2 очищається до нуля, а R3 - до нуля. 8-бітова схема віднімання подається R1 на вхід 'A', а значення R2 поєднується з LSB, зафіксованим на '1' (через підтягування) для входу 'B'. Віднімання виводить 8-бітну різницю AB і біт позики. Щоразу, якщо біт позики зрозумілий, R1 завантажується з виходом віднімання, R2 збільшується, а R3 збільшується. Якщо біт позики встановлений, R1 не завантажується, а R2, R3 не збільшуються, b / c результат вже готовий у R3.

АЛЬТЕРНАТИВНО

Є лише 16 можливих вихідних значень, тому відповідь - чотирибітове число. По суті, у вас є чотири однобітні функції з 8 вхідних бітів. Зараз я не можу намалювати 8-мірну карту Карнау, але в принципі ви могли просто створити комбінаторну схему для кожного біта відповіді. Візьміть результати цих чотирьох комбінаторних схем разом і інтерпретуйте їх як чотирибітну відповідь. Вуаля. Ні годин, ні реєстрів, достатньо лише купки NAND та NOR.

Я не знаю, чи це якась допомога, але є геніально простий спосіб обчислити квадратний корінь:

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

Я мало знаю про те, що можна, а що не можна зробити в послідовній логіці, але оскільки цей алгоритм закінчується всього в 4 петлі, ви зможете реалізувати його в 4 етапи.

$2^8$

    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;