( TCH | 2021. 06. 23., sze – 22:41 )

Én valamit nem értek az összeadó/kivonó kapcsán. Ugye írod, hogy

sajnos a kivonás a három logikai alap-kapuval (és, vagy, nem) már bajosabban lenne kivitelezhető

Kérdem én, hogy mennyivel bajosabb és miért bajosabb? A 3-bites összeadó (egyik bemenet (A), másik bemenet (B), előző átviteli bemenet (C)) igazságtáblája a következő:

A|B|X|Y|C
-+-+-+-+-
0|0|0|0|0
-+-+-+-+-
0|0|1|1|0
-+-+-+-+-
0|1|0|1|0
-+-+-+-+-
0|1|1|0|1
-+-+-+-+-
1|0|0|1|0
-+-+-+-+-
1|0|1|0|1
-+-+-+-+-
1|1|0|0|1
-+-+-+-+-
1|1|1|1|1

Látszik belőle, hogy az eredmény (Y) akkor magas, ha páratlan számú bemenet magas, tehát elég végig XOR-olni őket egymással (A ^ B ^ C), illetve, hogy átvitel akkor keletkezik, ha legalább kettő magas, azaz két-két-két AND kapcsolat össze OR-olva (A & B) | (A & C) | (B & C), de ebből a három műveletből kettőt össze lehet vonni úgy, hogy a közös elemük AND-elve a két különböző elem XOR-jával (((A ^ B) & C)), mert ugye VAGY az egyik, VAGY a másik magas (ez itt kizáró vagy), ÉS a harmadik is és így egy OR kaput megspórolunk.

Azaz képletben:

Y = (A ^ B) ^ C
X = (A & B) | ((A ^ B) & C)

Namármost, mivel az A ^ B mindkét képletben szerepel, így még egy XOR kaput megspórolunk, valahogy így:

              *=======*
A ========+===|       |           *=======*
          |   |   ^   |=+=========|       |
B =+======)===|       | |         |   ^   |=================== Y
   |      |   *=======* |       *=|       |
   |      |             |       | *=======*
   |      |             |       |
   |      |             |       |
C =)======)=============)=======+
   |      |             |       |
   |      |             |       |
   |      |             |       |
   |      |             |       |
   |      |             |       |
   |      |             |       | *=======* 
   |      |             |       *=|       |     *=======* 
   |      |             |         |   &   |=====|       |
   |      |             *=========|       |     |   |   |===== X
   |      |   *=======*           *=======*  *==|       |
   |      *===|       |                      |  *=======*
   |          |   &   |======================*
   *==========|       |
              *=======*

(Az ASCII-"art"-ért én kívánok elnézést, de képeket nem szabad beszúrni.)

A 3-bites kivonó (identikus A, B, C bemenetekkel) a következő igazságtáblával bír:

A|B|C|Y|X
-+-+-+-+-
0|0|0|0|0
-+-+-+-+-
0|0|1|1|1
-+-+-+-+-
0|1|0|1|1
-+-+-+-+-
0|1|1|0|1
-+-+-+-+-
1|0|0|1|0
-+-+-+-+-
1|0|1|0|0
-+-+-+-+-
1|1|0|0|0
-+-+-+-+-
1|1|1|1|1

Ebből rögtön kiviláglik, hogy az eredmény (Y) pontosan ugyanúgy jön létre, mint az összeadónál. Az átvitel már kissé bonyolultabb; az úgy jön ki, hogy ha 0-ból vonunk ki valahol egyet, azaz alacsony A-ból magas B-t, vagy C-t vonunk ki, (azaz AND-eljük vele), vagy alacsony B-ből vonunk ki magas C-t, úgy, hogy előtte nem történt kivonás, mert A is alacsony volt ((!A & B) | (!A & C) | (!A & !B & C)), de ebből az előző átviteli rész kiegyszerűsíthető úgy, hogy nem kell külön megvizsgálni az első bemenetre, ill. a másodikra, hanem csak az első két bemenet egyezését (invertált kizáró vagy kapcsolat) és az előző átvitel magas állapotát nézzük meg ((!(A ^ B) & C)).

Azaz képletben:

Y = A ^ B ^ C
X = (!A & B) | (!(A ^ B) & C)

A két képlet amit kaptunk, kvázi ugyanazt a kapcsolást eredményezi, annyi különbséggel, hogy a kivonónál az átvitelben A-t, valamint A és B különbségét (értsd: nem egyezőségét) invertálni kell:

              *=======*
A ========+===|       |           *=======*
          |   |   ^   |=+=========|       |
B =+======)===|       | |         |   ^   |=================== Y
   |      |   *=======* |       *=|       |
   |      |             |       | *=======*
   |      |             |       |
   |      |             |       |
C =)======)=============)=======+
   |      |             |       |
   |      |             |       |
   |  *=======*     *=======*   |
   |  |       |     |       |   |
   |  |   !   |     |   !   |   |
   |  |       |     |       |   | *=======* 
   |  *=======*     *=======*   *=|       |     *=======* 
   |      |             |         |   &   |=====|       |
   |      |             *=========|       |     |   |   |===== X
   |      |   *=======*           *=======*  *==|       |
   |      *===|       |                      |  *=======*
   |          |   &   |======================*
   *==========|       |
              *=======*

Miért lett volna ez bajosabban kivitelezhető? Csak két kapuval van benne több; ha soros a kivonó az ALU-ban, akkor összesen ennyi, ha párhuzamos, akkor annyiszor kettő, ahány biten végzi a műveletet.

De, ha nagyon spórolni akarok, akkor akár össze is vonhatom a két műveletet egy áramkörbe, ugyanis az invertereket kiválthatom egy-egy XOR kapuval, ami annak függvényében invertálja A-t, ill. A XOR B-t, hogy a másik lába magas-e, lévén (0 ^ X) == X && (1 ^ X) == !X.

              *=======*
A ======+=====|       |           *=======*
        |     |   ^   |===+=======|       |
B =+====)=====|       |   |       |   ^   |=================== Y
   |    |     *=======*   |     *=|       |
   |    |                 |     | *=======*
F =)====)===+=========*   |     |
   |    |   |         |   |     |
C =)====)===)=========)===)=====+
   |    |   |         |   |     |
   |    |   |         |   |     |
   |  *=======*     *=======*   |
   |  |       |     |       |   |
   |  |   ^   |     |   ^   |   |
   |  |       |     |       |   | *=======* 
   |  *=======*     *=======*   *=|       |     *=======* 
   |      |             |         |   &   |=====|       |
   |      |             *=========|       |     |   |   |===== X
   |      |   *=======*           *=======*  *==|       |
   |      *===|       |                      |  *=======*
   |          |   &   |======================*
   *==========|       |
              *=======*

És így egy funkcióbittel (F) még azt is el tudom dönteni, hogy összeadni, vagy kivonni akarok és így gyakorlatilag két kapu áráért cserébe a kivonóáramkör összes többi része megspórolódott és cserébe még komplemenseket sem kell számolgatni (pre-invertálás, pre-inkrementálás).

Szóval tényleg nem értem, hogy miért lett volna ez bajosabb, pontosan ugyanazok az elemi kapuk szerepelnek benne, mint ami a 3-bites összeadóban van (AND, OR, XOR).