Rhinemann
/
binaryCalculatorPrototype
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases 2 Wiki Activity
binaryCalculatorPrototype/README.md

512 lines
25 KiB
Markdown
Raw Normal View History

revert 0dc2bd39506b0d78bf7835371c96645746c8b283 revert Delete 'README.md'
2023-06-26 00:24:33 +03:00
# binaryCalculatorPrototype
README expanded.
2024-01-18 23:27:32 +02:00
This is a Python language prototype for a binary calculator to be used in Computer Arithmetics lab works for first-year students studying Computer Engineering at KPI.
revert 0dc2bd39506b0d78bf7835371c96645746c8b283 revert Delete 'README.md'
2023-06-26 00:24:33 +03:00
README.md added Ukrainian translation.
2024-01-19 21:34:00 +02:00
# English
## Requirements
README expanded.
2024-01-18 23:27:32 +02:00
The user must have installed:
- python 3 (for the calculator itself);
- git (to clone the repository for installation);
README.md added Ukrainian translation.
2024-01-19 21:34:00 +02:00
## Installation
README expanded.
2024-01-18 23:27:32 +02:00
To install the calculator just clone the repository locally:
```
README updated.
2024-01-18 23:41:43 +02:00
git clone -b master http://139.162.162.130:3000/Rhinemann/binaryCalculatorPrototype.git
README expanded.
2024-01-18 23:27:32 +02:00
```
README.md added Ukrainian translation.
2024-01-19 21:34:00 +02:00
## User instructions
README expanded.
2024-01-18 23:27:32 +02:00
Start the calculator using the following command:
```
python3 main.py
```
After that you must input the binary number as your first and second operands, as such:
```
Enter first operand: 110101
Enter second operand: 110
```
Note that you can't input any digit other than 0 or 1 into the operands:
```
Enter first operand: 234123
[ERROR] The first operand may contain only 1-s and 0-s!
Enter first operand: 12314
[ERROR] The first operand may contain only 1-s and 0-s!
Enter first operand: 1234123
[ERROR] The first operand may contain only 1-s and 0-s!
```
README.md fixed typos.
2024-01-19 21:03:47 +02:00
After inputting the operands properly, you will be presented with such prompt:
README expanded.
2024-01-18 23:27:32 +02:00
```
Choose the operation:
[a]ddition, [s]ubtraction, [m]ultiplication, [d]ivision, [q]uit
(110101 000110) >
```
README.md added Ukrainian translation.
2024-01-19 21:34:00 +02:00
`(110101 000110)` are the operands you have input.
README expanded.
2024-01-18 23:27:32 +02:00
README.md added Ukrainian translation.
2024-01-19 21:34:00 +02:00
You may now choose the operations performed on the operands as such:
README expanded.
2024-01-18 23:27:32 +02:00
```
Choose the operation:
[a]ddition, [s]ubtraction, [m]ultiplication, [d]ivision, [q]uit
(110101 000110) > a
Sum: 111011
Carry: 0
Choose the operation:
[a]ddition, [s]ubtraction, [m]ultiplication, [d]ivision, [q]uit
(110101 000110) > s
Subtraction: 101111
Carry: 1
Choose the operation:
[a]ddition, [s]ubtraction, [m]ultiplication, [d]ivision, [q]uit
(110101 000110) > m
Choose method to use (1-4):
(110101 000110) m > 1
Multiplication (method 1):
+------+--------+--------+--------+-----+----------------------+
| iter | RG1 | RG2 | RG3 | CT | MicroOperations |
+------+--------+--------+--------+-----+----------------------+
| 0 | 000000 | 110101 | 000110 | 110 | - |
+------+--------+--------+--------+-----+----------------------+
| 1 | 000110 | 110101 | 000110 | 110 | RG1 := RG1 + RG3 |
| 1 | 000011 | 011010 | 000110 | 101 | RG2 := RG1[1].r(RG2) |
| | | | | | RG1 := 0.r(RG1) |
| | | | | | CT := CT - 1 |
+------+--------+--------+--------+-----+----------------------+
| 2 | 000001 | 101101 | 000110 | 100 | RG2 := RG1[1].r(RG2) |
| | | | | | RG1 := 0.r(RG1) |
| | | | | | CT := CT - 1 |
+------+--------+--------+--------+-----+----------------------+
| 3 | 000111 | 101101 | 000110 | 100 | RG1 := RG1 + RG3 |
| 3 | 000011 | 110110 | 000110 | 011 | RG2 := RG1[1].r(RG2) |
| | | | | | RG1 := 0.r(RG1) |
| | | | | | CT := CT - 1 |
+------+--------+--------+--------+-----+----------------------+
| 4 | 000001 | 111011 | 000110 | 010 | RG2 := RG1[1].r(RG2) |
| | | | | | RG1 := 0.r(RG1) |
| | | | | | CT := CT - 1 |
+------+--------+--------+--------+-----+----------------------+
| 5 | 000111 | 111011 | 000110 | 010 | RG1 := RG1 + RG3 |
| 5 | 000011 | 111101 | 000110 | 001 | RG2 := RG1[1].r(RG2) |
| | | | | | RG1 := 0.r(RG1) |
| | | | | | CT := CT - 1 |
+------+--------+--------+--------+-----+----------------------+
| 6 | 001001 | 111101 | 000110 | 001 | RG1 := RG1 + RG3 |
| 6 | 000100 | 111110 | 000110 | 000 | RG2 := RG1[1].r(RG2) |
| | | | | | RG1 := 0.r(RG1) |
| | | | | | CT := CT - 1 |
+------+--------+--------+--------+-----+----------------------+
Result: 000100111110
Choose the operation:
[a]ddition, [s]ubtraction, [m]ultiplication, [d]ivision, [q]uit
(110101 000110) > d
Choose method to use (1-2):
(110101 000110) d > 1
Division (method 1):
+------+---------+----------+----------+-----------------------+
| iter | RG3 | RG2 | RG1 | MicroOperations |
+------+---------+----------+----------+-----------------------+
| 0 | 1111111 | 00110101 | 00000110 | - |
+------+---------+----------+----------+-----------------------+
| 1 | 1111111 | 00101111 | 00000110 | RG2 := RG2 - RG1 |
| 1 | 1111111 | 01011110 | 00000110 | RG3 := l(RG3).!RG2[8] |
| | | | | RG2 := l(RG2).0 |
+------+---------+----------+----------+-----------------------+
| 2 | 1111111 | 01011000 | 00000110 | RG2 := RG2 - RG1 |
| 2 | 1111111 | 10110000 | 00000110 | RG3 := l(RG3).!RG2[8] |
| | | | | RG2 := l(RG2).0 |
+------+---------+----------+----------+-----------------------+
| 3 | 1111111 | 10110110 | 00000110 | RG2 := RG2 + RG1 |
| 3 | 1111110 | 01101100 | 00000110 | RG3 := l(RG3).!RG2[8] |
| | | | | RG2 := l(RG2).0 |
+------+---------+----------+----------+-----------------------+
| 4 | 1111110 | 01100110 | 00000110 | RG2 := RG2 - RG1 |
| 4 | 1111101 | 11001100 | 00000110 | RG3 := l(RG3).!RG2[8] |
| | | | | RG2 := l(RG2).0 |
+------+---------+----------+----------+-----------------------+
| 5 | 1111101 | 11010010 | 00000110 | RG2 := RG2 + RG1 |
| 5 | 1111010 | 10100100 | 00000110 | RG3 := l(RG3).!RG2[8] |
| | | | | RG2 := l(RG2).0 |
+------+---------+----------+----------+-----------------------+
| 6 | 1111010 | 10101010 | 00000110 | RG2 := RG2 + RG1 |
| 6 | 1110100 | 01010100 | 00000110 | RG3 := l(RG3).!RG2[8] |
| | | | | RG2 := l(RG2).0 |
+------+---------+----------+----------+-----------------------+
| 7 | 1110100 | 01001110 | 00000110 | RG2 := RG2 - RG1 |
| 7 | 1101001 | 10011100 | 00000110 | RG3 := l(RG3).!RG2[8] |
| | | | | RG2 := l(RG2).0 |
+------+---------+----------+----------+-----------------------+
| 8 | 1101001 | 10100010 | 00000110 | RG2 := RG2 + RG1 |
| 8 | 1010010 | 01000100 | 00000110 | RG3 := l(RG3).!RG2[8] |
| | | | | RG2 := l(RG2).0 |
+------+---------+----------+----------+-----------------------+
| 9 | 1010010 | 00111110 | 00000110 | RG2 := RG2 - RG1 |
| 9 | 0100101 | 01111100 | 00000110 | RG3 := l(RG3).!RG2[8] |
| | | | | RG2 := l(RG2).0 |
+------+---------+----------+----------+-----------------------+
Result: 100101
```
README.md added Ukrainian translation.
2024-01-19 21:34:00 +02:00
The results of the operations will be displayed, and you will get prompted for the next operation to perform.
**Note** the results of previous operations don't impact the operands, therefore you can't plug your previous results into the calculator without restarting the program!
README expanded.
2024-01-18 23:27:32 +02:00
Also, as a quality of life feature, you can chain multiple operations in one prompt as such:
README.md added Ukrainian translation.
2024-01-19 21:34:00 +02:00
```
Choose the operation:
[a]ddition, [s]ubtraction, [m]ultiplication, [d]ivision, [q]uit
(110101 000110) > asm1d1
Sum: 111011
Carry: 0
Subtraction: 101111
Carry: 1
Multiplication (method 1):
+------+--------+--------+--------+-----+----------------------+
| iter | RG1 | RG2 | RG3 | CT | MicroOperations |
+------+--------+--------+--------+-----+----------------------+
| 0 | 000000 | 110101 | 000110 | 110 | - |
+------+--------+--------+--------+-----+----------------------+
| 1 | 000110 | 110101 | 000110 | 110 | RG1 := RG1 + RG3 |
| 1 | 000011 | 011010 | 000110 | 101 | RG2 := RG1[1].r(RG2) |
| | | | | | RG1 := 0.r(RG1) |
| | | | | | CT := CT - 1 |
+------+--------+--------+--------+-----+----------------------+
| 2 | 000001 | 101101 | 000110 | 100 | RG2 := RG1[1].r(RG2) |
| | | | | | RG1 := 0.r(RG1) |
| | | | | | CT := CT - 1 |
+------+--------+--------+--------+-----+----------------------+
| 3 | 000111 | 101101 | 000110 | 100 | RG1 := RG1 + RG3 |
| 3 | 000011 | 110110 | 000110 | 011 | RG2 := RG1[1].r(RG2) |
| | | | | | RG1 := 0.r(RG1) |
| | | | | | CT := CT - 1 |
+------+--------+--------+--------+-----+----------------------+
| 4 | 000001 | 111011 | 000110 | 010 | RG2 := RG1[1].r(RG2) |
| | | | | | RG1 := 0.r(RG1) |
| | | | | | CT := CT - 1 |
+------+--------+--------+--------+-----+----------------------+
| 5 | 000111 | 111011 | 000110 | 010 | RG1 := RG1 + RG3 |
| 5 | 000011 | 111101 | 000110 | 001 | RG2 := RG1[1].r(RG2) |
| | | | | | RG1 := 0.r(RG1) |
| | | | | | CT := CT - 1 |
+------+--------+--------+--------+-----+----------------------+
| 6 | 001001 | 111101 | 000110 | 001 | RG1 := RG1 + RG3 |
| 6 | 000100 | 111110 | 000110 | 000 | RG2 := RG1[1].r(RG2) |
| | | | | | RG1 := 0.r(RG1) |
| | | | | | CT := CT - 1 |
+------+--------+--------+--------+-----+----------------------+
Result: 000100111110
Division (method 1):
+------+---------+----------+----------+-----------------------+
| iter | RG3 | RG2 | RG1 | MicroOperations |
+------+---------+----------+----------+-----------------------+
| 0 | 1111111 | 00110101 | 00000110 | - |
+------+---------+----------+----------+-----------------------+
| 1 | 1111111 | 00101111 | 00000110 | RG2 := RG2 - RG1 |
| 1 | 1111111 | 01011110 | 00000110 | RG3 := l(RG3).!RG2[8] |
| | | | | RG2 := l(RG2).0 |
+------+---------+----------+----------+-----------------------+
| 2 | 1111111 | 01011000 | 00000110 | RG2 := RG2 - RG1 |
| 2 | 1111111 | 10110000 | 00000110 | RG3 := l(RG3).!RG2[8] |
| | | | | RG2 := l(RG2).0 |
+------+---------+----------+----------+-----------------------+
| 3 | 1111111 | 10110110 | 00000110 | RG2 := RG2 + RG1 |
| 3 | 1111110 | 01101100 | 00000110 | RG3 := l(RG3).!RG2[8] |
| | | | | RG2 := l(RG2).0 |
+------+---------+----------+----------+-----------------------+
| 4 | 1111110 | 01100110 | 00000110 | RG2 := RG2 - RG1 |
| 4 | 1111101 | 11001100 | 00000110 | RG3 := l(RG3).!RG2[8] |
| | | | | RG2 := l(RG2).0 |
+------+---------+----------+----------+-----------------------+
| 5 | 1111101 | 11010010 | 00000110 | RG2 := RG2 + RG1 |
| 5 | 1111010 | 10100100 | 00000110 | RG3 := l(RG3).!RG2[8] |
| | | | | RG2 := l(RG2).0 |
+------+---------+----------+----------+-----------------------+
| 6 | 1111010 | 10101010 | 00000110 | RG2 := RG2 + RG1 |
| 6 | 1110100 | 01010100 | 00000110 | RG3 := l(RG3).!RG2[8] |
| | | | | RG2 := l(RG2).0 |
+------+---------+----------+----------+-----------------------+
| 7 | 1110100 | 01001110 | 00000110 | RG2 := RG2 - RG1 |
| 7 | 1101001 | 10011100 | 00000110 | RG3 := l(RG3).!RG2[8] |
| | | | | RG2 := l(RG2).0 |
+------+---------+----------+----------+-----------------------+
| 8 | 1101001 | 10100010 | 00000110 | RG2 := RG2 + RG1 |
| 8 | 1010010 | 01000100 | 00000110 | RG3 := l(RG3).!RG2[8] |
| | | | | RG2 := l(RG2).0 |
+------+---------+----------+----------+-----------------------+
| 9 | 1010010 | 00111110 | 00000110 | RG2 := RG2 - RG1 |
| 9 | 0100101 | 01111100 | 00000110 | RG3 := l(RG3).!RG2[8] |
| | | | | RG2 := l(RG2).0 |
+------+---------+----------+----------+-----------------------+
Result: 100101
```
So that multiple operations are performed on the same operands without the need for multiple prompts.
# Українська
## Вимоги
Користувач мусить мати:
- python 3 (для роботи калькулятора);
- git (щоб встановити калькулятор);
## Завантаження
Щоб встановити калькулятор пропишіть цю команду:
```
git clone -b master http://139.162.162.130:3000/Rhinemann/binaryCalculatorPrototype.git
```
## Інструкція користувачам
Калькулятор запускається цією командою:
```
python3 main.py
```
Після цього користувач має ввести два операнди у двійковій системі, наприклад:
```
Enter first operand: 110101
Enter second operand: 110
```
Варто зауважити, що не можна ввести жодну цифру крім 0 чи 1 у значення операндів:
```
Enter first operand: 234123
[ERROR] The first operand may contain only 1-s and 0-s!
Enter first operand: 12314
[ERROR] The first operand may contain only 1-s and 0-s!
Enter first operand: 1234123
[ERROR] The first operand may contain only 1-s and 0-s!
```
Після коректного введення операндів користувач побачить такий запит:
```
Choose the operation:
[a]ddition, [s]ubtraction, [m]ultiplication, [d]ivision, [q]uit
(110101 000110) >
```
`(110101 000110)` - це операнди введені користувачем.
Користувач тепер може обрати операції що виконуватимуться:
```
Choose the operation:
[a]ddition, [s]ubtraction, [m]ultiplication, [d]ivision, [q]uit
(110101 000110) > a
Sum: 111011
Carry: 0
Choose the operation:
[a]ddition, [s]ubtraction, [m]ultiplication, [d]ivision, [q]uit
(110101 000110) > s
Subtraction: 101111
Carry: 1
Choose the operation:
[a]ddition, [s]ubtraction, [m]ultiplication, [d]ivision, [q]uit
(110101 000110) > m
Choose method to use (1-4):
(110101 000110) m > 1
Multiplication (method 1):
+------+--------+--------+--------+-----+----------------------+
| iter | RG1 | RG2 | RG3 | CT | MicroOperations |
+------+--------+--------+--------+-----+----------------------+
| 0 | 000000 | 110101 | 000110 | 110 | - |
+------+--------+--------+--------+-----+----------------------+
| 1 | 000110 | 110101 | 000110 | 110 | RG1 := RG1 + RG3 |
| 1 | 000011 | 011010 | 000110 | 101 | RG2 := RG1[1].r(RG2) |
| | | | | | RG1 := 0.r(RG1) |
| | | | | | CT := CT - 1 |
+------+--------+--------+--------+-----+----------------------+
| 2 | 000001 | 101101 | 000110 | 100 | RG2 := RG1[1].r(RG2) |
| | | | | | RG1 := 0.r(RG1) |
| | | | | | CT := CT - 1 |
+------+--------+--------+--------+-----+----------------------+
| 3 | 000111 | 101101 | 000110 | 100 | RG1 := RG1 + RG3 |
| 3 | 000011 | 110110 | 000110 | 011 | RG2 := RG1[1].r(RG2) |
| | | | | | RG1 := 0.r(RG1) |
| | | | | | CT := CT - 1 |
+------+--------+--------+--------+-----+----------------------+
| 4 | 000001 | 111011 | 000110 | 010 | RG2 := RG1[1].r(RG2) |
| | | | | | RG1 := 0.r(RG1) |
| | | | | | CT := CT - 1 |
+------+--------+--------+--------+-----+----------------------+
| 5 | 000111 | 111011 | 000110 | 010 | RG1 := RG1 + RG3 |
| 5 | 000011 | 111101 | 000110 | 001 | RG2 := RG1[1].r(RG2) |
| | | | | | RG1 := 0.r(RG1) |
| | | | | | CT := CT - 1 |
+------+--------+--------+--------+-----+----------------------+
| 6 | 001001 | 111101 | 000110 | 001 | RG1 := RG1 + RG3 |
| 6 | 000100 | 111110 | 000110 | 000 | RG2 := RG1[1].r(RG2) |
| | | | | | RG1 := 0.r(RG1) |
| | | | | | CT := CT - 1 |
+------+--------+--------+--------+-----+----------------------+
Result: 000100111110
Choose the operation:
[a]ddition, [s]ubtraction, [m]ultiplication, [d]ivision, [q]uit
(110101 000110) > d
Choose method to use (1-2):
(110101 000110) d > 1
Division (method 1):
+------+---------+----------+----------+-----------------------+
| iter | RG3 | RG2 | RG1 | MicroOperations |
+------+---------+----------+----------+-----------------------+
| 0 | 1111111 | 00110101 | 00000110 | - |
+------+---------+----------+----------+-----------------------+
| 1 | 1111111 | 00101111 | 00000110 | RG2 := RG2 - RG1 |
| 1 | 1111111 | 01011110 | 00000110 | RG3 := l(RG3).!RG2[8] |
| | | | | RG2 := l(RG2).0 |
+------+---------+----------+----------+-----------------------+
| 2 | 1111111 | 01011000 | 00000110 | RG2 := RG2 - RG1 |
| 2 | 1111111 | 10110000 | 00000110 | RG3 := l(RG3).!RG2[8] |
| | | | | RG2 := l(RG2).0 |
+------+---------+----------+----------+-----------------------+
| 3 | 1111111 | 10110110 | 00000110 | RG2 := RG2 + RG1 |
| 3 | 1111110 | 01101100 | 00000110 | RG3 := l(RG3).!RG2[8] |
| | | | | RG2 := l(RG2).0 |
+------+---------+----------+----------+-----------------------+
| 4 | 1111110 | 01100110 | 00000110 | RG2 := RG2 - RG1 |
| 4 | 1111101 | 11001100 | 00000110 | RG3 := l(RG3).!RG2[8] |
| | | | | RG2 := l(RG2).0 |
+------+---------+----------+----------+-----------------------+
| 5 | 1111101 | 11010010 | 00000110 | RG2 := RG2 + RG1 |
| 5 | 1111010 | 10100100 | 00000110 | RG3 := l(RG3).!RG2[8] |
| | | | | RG2 := l(RG2).0 |
+------+---------+----------+----------+-----------------------+
| 6 | 1111010 | 10101010 | 00000110 | RG2 := RG2 + RG1 |
| 6 | 1110100 | 01010100 | 00000110 | RG3 := l(RG3).!RG2[8] |
| | | | | RG2 := l(RG2).0 |
+------+---------+----------+----------+-----------------------+
| 7 | 1110100 | 01001110 | 00000110 | RG2 := RG2 - RG1 |
| 7 | 1101001 | 10011100 | 00000110 | RG3 := l(RG3).!RG2[8] |
| | | | | RG2 := l(RG2).0 |
+------+---------+----------+----------+-----------------------+
| 8 | 1101001 | 10100010 | 00000110 | RG2 := RG2 + RG1 |
| 8 | 1010010 | 01000100 | 00000110 | RG3 := l(RG3).!RG2[8] |
| | | | | RG2 := l(RG2).0 |
+------+---------+----------+----------+-----------------------+
| 9 | 1010010 | 00111110 | 00000110 | RG2 := RG2 - RG1 |
| 9 | 0100101 | 01111100 | 00000110 | RG3 := l(RG3).!RG2[8] |
| | | | | RG2 := l(RG2).0 |
+------+---------+----------+----------+-----------------------+
Result: 100101
```
Результати обчислень будуть виведені, а користувач отримає повторний запит операції.
**Увага** результати обчислень не змінюють операнди, тому їх неможливо використовувати у майбутніх обчисленнях без перезапуску програми!
README expanded.
2024-01-18 23:27:32 +02:00
README.md added Ukrainian translation.
2024-01-19 21:34:00 +02:00
Також, для зручності користувач може об'єднати декілька операцій у один запис:
README expanded.
2024-01-18 23:27:32 +02:00
```
Choose the operation:
[a]ddition, [s]ubtraction, [m]ultiplication, [d]ivision, [q]uit
(110101 000110) > asm1d1
Sum: 111011
Carry: 0
Subtraction: 101111
Carry: 1
Multiplication (method 1):
+------+--------+--------+--------+-----+----------------------+
| iter | RG1 | RG2 | RG3 | CT | MicroOperations |
+------+--------+--------+--------+-----+----------------------+
| 0 | 000000 | 110101 | 000110 | 110 | - |
+------+--------+--------+--------+-----+----------------------+
| 1 | 000110 | 110101 | 000110 | 110 | RG1 := RG1 + RG3 |
| 1 | 000011 | 011010 | 000110 | 101 | RG2 := RG1[1].r(RG2) |
| | | | | | RG1 := 0.r(RG1) |
| | | | | | CT := CT - 1 |
+------+--------+--------+--------+-----+----------------------+
| 2 | 000001 | 101101 | 000110 | 100 | RG2 := RG1[1].r(RG2) |
| | | | | | RG1 := 0.r(RG1) |
| | | | | | CT := CT - 1 |
+------+--------+--------+--------+-----+----------------------+
| 3 | 000111 | 101101 | 000110 | 100 | RG1 := RG1 + RG3 |
| 3 | 000011 | 110110 | 000110 | 011 | RG2 := RG1[1].r(RG2) |
| | | | | | RG1 := 0.r(RG1) |
| | | | | | CT := CT - 1 |
+------+--------+--------+--------+-----+----------------------+
| 4 | 000001 | 111011 | 000110 | 010 | RG2 := RG1[1].r(RG2) |
| | | | | | RG1 := 0.r(RG1) |
| | | | | | CT := CT - 1 |
+------+--------+--------+--------+-----+----------------------+
| 5 | 000111 | 111011 | 000110 | 010 | RG1 := RG1 + RG3 |
| 5 | 000011 | 111101 | 000110 | 001 | RG2 := RG1[1].r(RG2) |
| | | | | | RG1 := 0.r(RG1) |
| | | | | | CT := CT - 1 |
+------+--------+--------+--------+-----+----------------------+
| 6 | 001001 | 111101 | 000110 | 001 | RG1 := RG1 + RG3 |
| 6 | 000100 | 111110 | 000110 | 000 | RG2 := RG1[1].r(RG2) |
| | | | | | RG1 := 0.r(RG1) |
| | | | | | CT := CT - 1 |
+------+--------+--------+--------+-----+----------------------+
Result: 000100111110
Division (method 1):
+------+---------+----------+----------+-----------------------+
| iter | RG3 | RG2 | RG1 | MicroOperations |
+------+---------+----------+----------+-----------------------+
| 0 | 1111111 | 00110101 | 00000110 | - |
+------+---------+----------+----------+-----------------------+
| 1 | 1111111 | 00101111 | 00000110 | RG2 := RG2 - RG1 |
| 1 | 1111111 | 01011110 | 00000110 | RG3 := l(RG3).!RG2[8] |
| | | | | RG2 := l(RG2).0 |
+------+---------+----------+----------+-----------------------+
| 2 | 1111111 | 01011000 | 00000110 | RG2 := RG2 - RG1 |
| 2 | 1111111 | 10110000 | 00000110 | RG3 := l(RG3).!RG2[8] |
| | | | | RG2 := l(RG2).0 |
+------+---------+----------+----------+-----------------------+
| 3 | 1111111 | 10110110 | 00000110 | RG2 := RG2 + RG1 |
| 3 | 1111110 | 01101100 | 00000110 | RG3 := l(RG3).!RG2[8] |
| | | | | RG2 := l(RG2).0 |
+------+---------+----------+----------+-----------------------+
| 4 | 1111110 | 01100110 | 00000110 | RG2 := RG2 - RG1 |
| 4 | 1111101 | 11001100 | 00000110 | RG3 := l(RG3).!RG2[8] |
| | | | | RG2 := l(RG2).0 |
+------+---------+----------+----------+-----------------------+
| 5 | 1111101 | 11010010 | 00000110 | RG2 := RG2 + RG1 |
| 5 | 1111010 | 10100100 | 00000110 | RG3 := l(RG3).!RG2[8] |
| | | | | RG2 := l(RG2).0 |
+------+---------+----------+----------+-----------------------+
| 6 | 1111010 | 10101010 | 00000110 | RG2 := RG2 + RG1 |
| 6 | 1110100 | 01010100 | 00000110 | RG3 := l(RG3).!RG2[8] |
| | | | | RG2 := l(RG2).0 |
+------+---------+----------+----------+-----------------------+
| 7 | 1110100 | 01001110 | 00000110 | RG2 := RG2 - RG1 |
| 7 | 1101001 | 10011100 | 00000110 | RG3 := l(RG3).!RG2[8] |
| | | | | RG2 := l(RG2).0 |
+------+---------+----------+----------+-----------------------+
| 8 | 1101001 | 10100010 | 00000110 | RG2 := RG2 + RG1 |
| 8 | 1010010 | 01000100 | 00000110 | RG3 := l(RG3).!RG2[8] |
| | | | | RG2 := l(RG2).0 |
+------+---------+----------+----------+-----------------------+
| 9 | 1010010 | 00111110 | 00000110 | RG2 := RG2 - RG1 |
| 9 | 0100101 | 01111100 | 00000110 | RG3 := l(RG3).!RG2[8] |
| | | | | RG2 := l(RG2).0 |
+------+---------+----------+----------+-----------------------+
Result: 100101
```
README.md added Ukrainian translation.
2024-01-19 21:34:00 +02:00
Таким чином обчислення послідовно над операндами без потреби у декількох запитах.