Добро пожаловать Гаджи. Не ответив на вопрос, будешь удалён из чата

есть у кого алгоритм на асме?мне надо число грузить в генератор частоты. Его получаю умножением. Желаемой частоты в килогерцах на 10734 это я округлил еще до целого

а мк 8битный

в столбик перемножу, чет я посмотрел на Карацубы алгоритм ничего не понял))

нет времени разбиратся)

круто же писать калькулятор, тоже зарядка для мозгов огого :) а вот еще написать чтобы больше выводил чем микрософтовский! Спасибо кстати за поле а то я гадал еще как туда значение вывести, оставлял на потом а терь будет! :)

это кстати фасмовский сэмпл оконный я там в 48 строке вообще ничего не трогал потому что не знаю как там что работает толком, поубирал кое что лишнее только

как же мне раньше нравился мой 8разрядный мк

пока я на нем  двойные слова складывать не начал

пора на стм переходить походу

ты мне скажи как умножить если разрядности не хватает?
Не множителя не множитель в разрядность не влазят

дизассемблер в помощь, 32х битные проекты считаю умножения и деления преобразуя множители и делитель, делимое в qwordы, дизасм этих функций и покажет алгоритм. Ну и в сети алгоритм наверное есть.

наверное алгоритм как умножение в столбик и потом поразрядно в память писать результат

.text:010122B0 ; LARGE_INTEGER __stdcall Quad_multiply(LARGE_INTEGER mul1, LARGE_INTEGER mul2)
.text:010122B0 Quad_multiply   proc near               ; CODE XREF: CPerfPage__DrawMEMMeter+87 p
.text:010122B0                                         ; CPerfPage__DrawMEMMeter+FF p ...
.text:010122B0
.text:010122B0 mul1            = _LARGE_INTEGER::$837407842DC9087486FDFA5FEB63B74E ptr  4
.text:010122B0 mul2            = _LARGE_INTEGER::$837407842DC9087486FDFA5FEB63B74E ptr  0Ch
.text:010122B0
.text:010122B0                 mov     eax, [esp+mul1.HighPart]
.text:010122B4                 mov     ecx, [esp+mul2.HighPart]
.text:010122B8                 or      ecx, eax
.text:010122BA                 mov     ecx, [esp+mul2.LowPart]
.text:010122BE                 jnz     short loc_10122C9
.text:010122C0                 mov     eax, [esp+mul1.LowPart]
.text:010122C4                 mul     ecx
.text:010122C6                 retn    10h
.text:010122C9 ; ---------------------------------------------------------------------------
.text:010122C9
.text:010122C9 loc_10122C9:                            ; CODE XREF: Quad_multiply+E j
.text:010122C9                 push    ebx
.text:010122CA                 mul     ecx
.text:010122CC                 mov     ebx, eax
.text:010122CE                 mov     eax, [esp+4+mul1.LowPart]
.text:010122D2                 mul     [esp+4+mul2.HighPart]
.text:010122D6                 add     ebx, eax
.text:010122D8                 mov     eax, [esp+4+mul1.LowPart]
.text:010122DC                 mul     ecx
.text:010122DE                 add     edx, ebx
.text:010122E0                 pop     ebx
.text:010122E1                 retn    10h
.text:010122E1 Quad_multiply   endp

.text:010122F0 ; LARGE_INTEGER __stdcall Quad_division(LARGE_INTEGER dividend, LARGE_INTEGER divider)
.text:010122F0 Quad_division   proc near               ; CODE XREF: CAdapter__AdjustLinkSpeed+86 p
.text:010122F0                                         ; CAdapter__AdjustLinkSpeed+175 p ...
.text:010122F0
.text:010122F0 dividend        = _LARGE_INTEGER::$837407842DC9087486FDFA5FEB63B74E ptr  4
.text:010122F0 divider         = _LARGE_INTEGER::$837407842DC9087486FDFA5FEB63B74E ptr  0Ch
.text:010122F0
.text:010122F0                 push    ebx
.text:010122F1                 push    esi
.text:010122F2                 mov     eax, [esp+8+divider.HighPart]
.text:010122F6                 or      eax, eax
.text:010122F8                 jnz     short loc_1012312
.text:010122FA                 mov     ecx, [esp+8+divider.LowPart]
.text:010122FE                 mov     eax, [esp+8+dividend.HighPart]
.text:01012302                 xor     edx, edx
.text:01012304                 div     ecx
.text:01012306                 mov     ebx, eax
.text:01012308                 mov     eax, [esp+8+dividend.LowPart]
.text:0101230C                 div     ecx
.text:0101230E                 mov     edx, ebx
.text:01012310                 jmp     short loc_1012353
.text:01012312 ; ---------------------------------------------------------------------------
.text:01012312
.text:01012312 loc_1012312:                            ; CODE XREF: Quad_division+8 j
.text:01012312                 mov     ecx, eax
.text:01012314                 mov     ebx, [esp+8+divider.LowPart]
.text:01012318                 mov     edx, [esp+8+dividend.HighPart]
.text:0101231C                 mov     eax, [esp+8+dividend.LowPart]
.text:01012320
.text:01012320 loc_1012320:                            ; CODE XREF: Quad_division+3A j
.text:01012320                 shr     ecx, 1
.text:01012322                 rcr     ebx, 1
.text:01012324                 shr     edx, 1
.text:01012326                 rcr     eax, 1
.text:01012328                 or      ecx, ecx
.text:0101232A                 jnz     short loc_1012320
.text:0101232C                 div     ebx
.text:0101232E                 mov     esi, eax
.text:01012330                 mul     [esp+8+divider.HighPart]
.text:01012334                 mov     ecx, eax
.text:01012336                 mov     eax, [esp+8+divider.LowPart]
.text:0101233A                 mul     esi
.text:0101233C                 add     edx, ecx
.text:0101233E                 jb      short loc_101234E
.text:01012340                 cmp     edx, [esp+8+dividend.HighPart]
.text:01012344                 ja      short loc_101234E
.text:01012346                 jb      short loc_101234F
.text:01012348                 cmp     eax, [esp+8+dividend.LowPart]
.text:0101234C                 jbe     short loc_101234F
.text:0101234E
.text:0101234E loc_101234E:                            ; CODE XREF: Quad_division+4E j
.text:0101234E                                         ; Quad_division+54 j
.text:0101234E                 dec     esi
.text:0101234F
.text:0101234F loc_101234F:                            ; CODE XREF: Quad_division+56 j
.text:0101234F                                         ; Quad_division+5C j
.text:0101234F                 xor     edx, edx
.text:01012351                 mov     eax, esi
.text:01012353
.text:01012353 loc_1012353:                            ; CODE XREF: Quad_division+20 j
.text:01012353                 pop     esi
.text:01012354                 pop     ebx
.text:01012355                 retn    10h
.text:01012355 Quad_division   endp

.text:01012200 ; LARGE_INTEGER __stdcall Quad_division_alt(LARGE_INTEGER dividend, LARGE_INTEGER divider)
.text:01012200 Quad_division_alt proc near             ; CODE XREF: UpdateStatusBar+AA p
.text:01012200                                         ; UpdateStatusBar+C4 p ...
.text:01012200
.text:01012200 dividend        = LARGE_INTEGER ptr  4
.text:01012200 divider         = LARGE_INTEGER ptr  0Ch
.text:01012200
.text:01012200                 push    edi
.text:01012201                 push    esi
.text:01012202                 push    ebx
.text:01012203                 xor     edi, edi
.text:01012205                 mov     eax, dword ptr [esp+0Ch+dividend+4]
.text:01012209                 or      eax, eax
.text:0101220B                 jge     short loc_1012221
.text:0101220D                 inc     edi
.text:0101220E                 mov     edx, dword ptr [esp+0Ch+dividend]
.text:01012212                 neg     eax
.text:01012214                 neg     edx
.text:01012216                 sbb     eax, 0
.text:01012219                 mov     dword ptr [esp+0Ch+dividend+4], eax
.text:0101221D                 mov     dword ptr [esp+0Ch+dividend], edx
.text:01012221
.text:01012221 loc_1012221:                            ; CODE XREF: Quad_division_alt+B j
.text:01012221                 mov     eax, dword ptr [esp+0Ch+divider+4]
.text:01012225                 or      eax, eax
.text:01012227                 jge     short loc_101223D
.text:01012229                 inc     edi
.text:0101222A                 mov     edx, dword ptr [esp+0Ch+divider]
.text:0101222E                 neg     eax
.text:01012230                 neg     edx
.text:01012232                 sbb     eax, 0
.text:01012235                 mov     dword ptr [esp+0Ch+divider+4], eax
.text:01012239                 mov     dword ptr [esp+0Ch+divider], edx
.text:0101223D
.text:0101223D loc_101223D:                            ; CODE XREF: Quad_division_alt+27 j
.text:0101223D                 or      eax, eax
.text:0101223F                 jnz     short loc_1012259
.text:01012241                 mov     ecx, dword ptr [esp+0Ch+divider]
.text:01012245                 mov     eax, dword ptr [esp+0Ch+dividend+4]
.text:01012249                 xor     edx, edx
.text:0101224B                 div     ecx
.text:0101224D                 mov     ebx, eax
.text:0101224F                 mov     eax, dword ptr [esp+0Ch+dividend]

.text:01012200 ; LARGE_INTEGER __stdcall Quad_division_alt(LARGE_INTEGER dividend, LARGE_INTEGER divider)
.text:01012200 Quad_division_alt proc near             ; CODE XREF: UpdateStatusBar+AA p
.text:01012200                                         ; UpdateStatusBar+C4 p ...
.text:01012200
.text:01012200 dividend        = LARGE_INTEGER ptr  4
.text:01012200 divider         = LARGE_INTEGER ptr  0Ch
.text:01012200
.text:01012200                 push    edi
.text:01012201                 push    esi
.text:01012202                 push    ebx
.text:01012203                 xor     edi, edi
.text:01012205                 mov     eax, dword ptr [esp+0Ch+dividend+4]
.text:01012209                 or      eax, eax
.text:0101220B                 jge     short loc_1012221
.text:0101220D                 inc     edi
.text:0101220E                 mov     edx, dword ptr [esp+0Ch+dividend]
.text:01012212                 neg     eax
.text:01012214                 neg     edx
.text:01012216                 sbb     eax, 0
.text:01012219                 mov     dword ptr [esp+0Ch+dividend+4], eax
.text:0101221D                 mov     dword ptr [esp+0Ch+dividend], edx
.text:01012221
.text:01012221 loc_1012221:                            ; CODE XREF: Quad_division_alt+B j
.text:01012221                 mov     eax, dword ptr [esp+0Ch+divider+4]
.text:01012225                 or      eax, eax
.text:01012227                 jge     short loc_101223D
.text:01012229                 inc     edi
.text:0101222A                 mov     edx, dword ptr [esp+0Ch+divider]
.text:0101222E                 neg     eax
.text:01012230                 neg     edx
.text:01012232                 sbb     eax, 0
.text:01012235                 mov     dword ptr [esp+0Ch+divider+4], eax
.text:01012239                 mov     dword ptr [esp+0Ch+divider], edx
.text:0101223D
.text:0101223D loc_101223D:                            ; CODE XREF: Quad_division_alt+27 j
.text:0101223D                 or      eax, eax
.text:0101223F                 jnz     short loc_1012259
.text:01012241                 mov     ecx, dword ptr [esp+0Ch+divider]
.text:01012245                 mov     eax, dword ptr [esp+0Ch+dividend+4]
.text:01012249                 xor     edx, edx
.text:0101224B                 div     ecx
.text:0101224D                 mov     ebx, eax
.text:0101224F                 mov     eax, dword ptr [esp+0Ch+dividend]
.text:01012253                 div     ecx
.text:01012255                 mov     edx, ebx
.text:01012257                 jmp     short loc_101229A
.text:01012259 ; ---------------------------------------------------------------------------
.text:01012259
.text:01012259 loc_1012259:                            ; CODE XREF: Quad_division_alt+3F j
.text:01012259                 mov     ebx, eax
.text:0101225B                 mov     ecx, dword ptr [esp+0Ch+divider]
.text:0101225F                 mov     edx, dword ptr [esp+0Ch+dividend+4]
.text:01012263                 mov     eax, dword ptr [esp+0Ch+dividend]
.text:01012267
.text:01012267 loc_1012267:                            ; CODE XREF: Quad_division_alt+71 j
.text:01012267                 shr     ebx, 1
.text:01012269                 rcr     ecx, 1
.text:0101226B                 shr     edx, 1
.text:0101226D                 rcr     eax, 1
.text:0101226F                 or      ebx, ebx
.text:01012271                 jnz     short loc_1012267
.text:01012273                 div     ecx
.text:01012275                 mov     esi, eax
.text:01012277                 mul     dword ptr [esp+0Ch+divider+4]
.text:0101227B                 mov     ecx, eax
.text:0101227D                 mov     eax, dword ptr [esp+0Ch+divider]
.text:01012281                 mul     esi
.text:01012283                 add     edx, ecx
.text:01012285                 jb      short loc_1012295
.text:01012287                 cmp     edx, dword ptr [esp+0Ch+dividend+4]
.text:0101228B                 ja      short loc_1012295
.text:0101228D                 jb      short loc_1012296
.text:0101228F                 cmp     eax, dword pt

r [esp+0Ch+dividend]
.text:01012293                 jbe     short loc_1012296
.text:01012295
.text:01012295 loc_1012295:                            ; CODE XREF: Quad_division_alt+85 j
.text:01012295                                         ; Quad_division_alt+8B j
.text:01012295                 dec     esi
.text:01012296
.text:01012296 loc_1012296:                            ; CODE XREF: Quad_division_alt+8D j
.text:01012296                                         ; Quad_division_alt+93 j
.text:01012296                 xor     edx, edx
.text:01012298                 mov     eax, esi
.text:0101229A
.text:0101229A loc_101229A:                            ; CODE XREF: Quad_division_alt+57 j
.text:0101229A                 dec     edi
.text:0101229B                 jnz     short loc_10122A4
.text:0101229D                 neg     edx
.text:0101229F                 neg     eax
.text:010122A1                 sbb     edx, 0
.text:010122A4
.text:010122A4 loc_10122A4:                            ; CODE XREF: Quad_division_alt+9B j
.text:010122A4                 pop     ebx
.text:010122A5                 pop     esi
.text:010122A6                 pop     edi
.text:010122A7                 retn    10h
.text:010122A7 Quad_division_alt endp

разбирайся, хлл часто лишнее городит, но общий принцип достать можно.

По-моему ты просто не вник в выше предложенный код.
Можно и 8-ми битными регистрами обойтись, если хватит памяти для вычислений.
Алгоритм следующий:
1. Нужно посчитать где находится младший включённый бит в первом множителе (или во втором, как удобнее), в твоём случае пройтись по ячейкам памяти в которых лежит твоё большое число;
2. Сдвинуть в сторону старшинства побитово другой множитель на такое количество бит, на котором ранее был замечен крайний включённый бит и сбросить его в 0.
Т.е. опять таки пройтись последовательно по ячейкам памяти и через CF сдвигать биты (подготовь заранее место из нескольких 0 под сдвиги);
3. То что получилось побайтно сложить с буфером (тут отдельно потренеруйся как будешь складывать длинные числа с использованием 3-х 8-ми битных регистров).
4. Восстановить тот множитель, который двигали и повторять с 1 пункта пока все биты не окажутся выключенными.