Есть лаба - возвести число X в 32 степень.
Из команд можно использовать только умножение не более пяти раз. Окей, пять раз перемножить число само на себя много ума не надо, и как раз получается 32 степень, но что делать с ебучим переполнением? Можно как-то использовать несколько регистров в качестве одной переменной?
Если использовать тупой подход, то нужна переменная размером 8 байт хотя бы, но таких, вроде бы, нет.
Может какие-то хитрые алгоритмы есть?
Короче, спасайте, это пиздец какой-то. У всех остальных задачки вроде «посчитать число сотен в числе» или «найти объем куба со стороной X», а мне такой вот хардкор достался.
Блять, двач, я должен решить эту херню на чистом ассемблере, встроенном в C++, хотя бы ради того, чтобы не чувствовать себя говном.
В общем, решаем всем двачом двумя вариантами:
1. Законно: с использованием только умножения не более пяти раз, можно изменять и баловаться только с регистрами.
2. На похуях: любые варианты, лишь бы работало.
>Окей, пять раз перемножить число само на себя много ума не надо, и как раз получается 32 степень
Нифига новости.
Цикл зопели, дегенерат блять.
Бля, ну ты дурак, смотри, возьмём X = 2;
2 2 = 4;
4 4 = 16;
16 16 = 256;
256 256 = 65536;
65536 * 65336 = 4294967296;
232 = 294967296;
Для этого как раз подходит команда MUL, она делает то, что нужно, но ебучее переполнение всё портит.
Да какой нахуй цикл, когда проблема в ПЕРЕПОЛНЕНИИ, а не в алгоритме.
>232 = 4294967296;
быстрофикс
Круть. Не догадался.
SHL SHR
Прикол ещё в том, что 2 - самое малое значение X уже вызывает переполнение, а как тогда считать, например, 9532?
>SHL SHR
Окей, но как внести переменную long long в __asm? Как здесь быть, если long long - 8 байт, а eax - 4 байт?
Нихуя не понимаю, что там и как это использовать. Я, блять, с ассемблером первый раз в жизни встретился.
>>258915491
И как его там смотреть-то, блять?
Вывожу по-отдельности eax, ebx, edx и там числа что-то вроде 24473687, 0 и 9, а что это значит, я не представляю.
типа блять, что мне с пикрилом делать?
Бамп
Ну и что дальше-то, блять?
А мой хуй у тебя за щекой находится.
Ну блин, я не буду ради тебя масм ставить. Что-то вроде
mov ax, [num1]
mov bx, [num2]
mul bx
mov [mulResult],ax
mov [mulResult+2],dx
mov eax,[mulResult]
>А мой хуй у тебя за щекой находится
Ясно. Удачи.
Какой толк от кода, если я его не понимаю?
Я хочу понять, а не тупо скопипастить ответ, тем более он не работает.
Окей, но как внести переменную long long в __asm? Как здесь быть, если long long - 8 байт, а eax - 4 байт?
Он в сдвиги не шарит. Выше кинули идею - хуй отдуплил.
Использовать несколько регистров для одного числа. В инете можно найти примеры умножения огромных чисел, там так и организовано. Также использовать флаг переполнения в качестве детектора.
А, ну тогда хз. По-другому я не знаю.
Блять, какой смысл от сдвига, если результат некуда записать?
Блять, какой смысл от сдвига, если результат некуда записать?
Ничего, голову поломает пару дней, станет повежливее, и поумнее. Поймет важность деталей. Ему только на пользу.
> Может какие-то хитрые алгоритмы есть?
Использовать 64-битные команды, дурачок.
Это не умножение на степень двойки, это возведение в степень. Здесь сдвиги не помогут.
5х5 = 25
Где здесь сдвиги? Ему нужно умножить как здесь >>258915091 только нужно увидеть, что переполнения там нет нигде, кроме последнего умножения.
x, y: 64-bit integer
x_h/x_l: higher/lower 32 bits of x
y_h/y_l: higher/lower 32 bits of y
xy = ((x_h2^32 + x_l)(y_h2^32 + y_l)) mod 2^64
= (x_hy_h2^64 + x_ly_l + x_hy_l2^32 + x_ly_h2^32) mod 2^64
= x_ly_l + (x_hy_l + x_ly_h)2^32
Now from the equation you can see that only 3(not 4) multiplication needed.
movl 16(%ebp), %esi ; get y_l
movl 12(%ebp), %eax ; get x_l
movl %eax, %edx
sarl $31, %edx ; get x_h, (x >>a 31), higher 32 bits of sign-extension of x
movl 20(%ebp), %ecx ; get y_h
imull %eax, %ecx ; compute s: x_ly_h
movl %edx, %ebx
imull %esi, %ebx ; compute t: x_hy_l
addl %ebx, %ecx ; compute s + t
mull %esi ; compute u: x_ly_l
leal (%ecx,%edx), %edx ; u_h += (s + t), result is u
movl 8(%ebp), %ecx
movl %eax, (%ecx)
movl %edx, 4(%ecx)
Бля, я учился лет 15 назад, ассемблер решал всей параллели, щас конечно уже не вспомню. Эхх надо было пограмистом идти, а щас уж все мозги пропил.
>>258917344
Ну, вот, блять, юзаю сдвиги.
Сдвиг на 10 бит - окей, ибо нет переполнения.
Сдвиг на 15 бит - окей, ибо опять нет переполнения.
Сдвиг на 31 бит - всё, пиздец, переполнили 4 ебучих байта.
Какие детали я должен понять?
тут решение
>>258917888
Формула для умножения части чисел в регистрах.
Число с плавающей точкой, мат. сопроцесор, возводишь число в квадрат, повторить 5 раз, удачи
Было бы заебись, если бы можно было бы два 4-байтовых регистра в один 8-байтовых, но нельзя, потому что архитектура x32, а не x64, если я правильно понимаю.
>>258917787
Например какие?
>>258917827
Верхняя граница - 4294967295, если я правильно понял.
Ты охуеешь насколько это большое число, ОЗУ на всех пекарнях в мире не хватит чтобы его сохранить, а ОП тролль
>>258918186
Решение приведено на GNU ASSEMBLER, а FASM не поддержииват 95% из этого.
ты нахуя пользуешься 32-битным eax, когда есть 64-битный rax?
Да нет, спокойно считается и сохраняется, всего то 1.9371148e+63
Банка сгущёнки, твоя жопа, вставляешь банку сгущёнки в жопу, повторить 5 раз, удачи
умножение на 2 эквивалентно сдвигу слево на оди разряд.
Для 32 бит:
mov esi, y_low
mov eax, x
mov edx, eax
sar edx, 31
mov ecx, y_high
imul ecx, eax ; ecx = y_high {signed} x
mov ebx, edx
imul ebx, esi ; ebx = sign_extension(x) {signed} y_low
add ecx, ebx ; ecx = y_high {signed} x_low + x_high {signed} y_low
mul esi ; edx:eax = x_low {unsigned} y_low
lea edx, [ecx + edx] ; edx = high(x_low {unsigned} y_low + y_high {signed} x_low + x_high {signed} y_low)
mov ecx, dest
mov [ecx], eax
mov [ecx + 4], edx
настоящий_русский.жпег
Опять же какой мне смысл от готовой программы, если я её, блять, не понимаю?
Я даже не могу её запустить.
Берёшь и спрашиваешь препода, надо ли учитывать переполнение. Решаешь только если сказал да и нет возможносьи взять другое задание/препода.
>>258918857
Ну, смотри. Соль тут уже просто в том, чтобы найти способ, решить это говно.
До появления 64-битной архитектуры каким-то же образом должны были считать большие числа ассемблером.
Алсо скажу, что переполнение возникает уже на числе 2.
То есть без переполнения можно посчитать только единицу и нуль.
Умножение на себя удваивает число разрядов. Так что опу понадобится 32 байта если исходное число один байт.
А если там инт32, то 4х32 = 128 байт.
Так что опу нужна плавающая запятая. Там можно читать и писать через поинтер 32, 64 и 80 бит.
>каким-то же образом
Так не за 5 уножений же.
Не, ну можно 0 умножений сделать, заменить умножение на сложение в цикле, но это будет костыль страшный.
ввод x
a=xx // 2 степень
x=aa // 4 степень
a=xx // 8 степень
x=aa // 16 степень
a=x*x // 32 степень
Или я не прав?
Тред выше не читал
> сложение в цикле
Всё равно переполнение никуда не уйдет
Может возможно как-нибудь части числа раскидать по разным регистрам, но как потом собрать их в кучу и вывести результат?
В первом же посте то же самое написано, долбоёб
Так используй rax регистр в х64 лол
Всё проще. Тебе даден асс-эмблер, а ты пытаешься применить на нём что-то из высокоровневых языков. Используй сдвиг.
переполнение
Ну так разбей результат и запиши в верхнем и нижнем регистрах. Асс-эмблер позволяет работать с любыми числами, на сколько хватит ячеек памяти.
>как раз
>Ну так разбей результат и запиши в верхнем и нижнем регистрах
Каким образом? Каким образом потом продолжать двигать регистры? Каким образом вывести результат во внешнюю переменную?
Алгоритм я тебе скинул на Википедии. Сдвиги не нужны, не слушай даунов. Тебе придется для честного решения ворочать массивы на ассемблере и объявлять подпрограммы.
И определись, ты на fasm или на вставках ищешь решение? Фасм это отдельный от си проект.
Определись, какой размер входной переменной. Определись, используешь ты плавающую запятую или длинную арифметику.
Можешь оба варианта сделать, раз уж собрался выебнуться перед преподом.
Да, спасибо за статью и за исправление.
Нужно всё сделать на вставках си.
Думаю, придётся ворочать массивы и объявлять подпрограммы.
Больше всего меня напрягает вывод данных. Я не представляю как собрать данные разных регистров во внешней 64-битной переменной.
Скорее всего придётся писать новый класс, а это снова отход от принципа, что на языке должен выполняться только ввод и вывод данных, а вся логика внутри ассемблера.
Или использовать массив BCD (https://ru.m.wikipedia.org/wiki/Двоично-десятичный_код)
Размер переменных хотелось бы, конечно 8 байт, но вставки в C++ поддерживают только 4 байта, так что буду брать их.
Скорее всего буду работать с длинной математикой.
О, двоично-десятичный код, судя по всему, классная штука.
Буду брать её.
Тогда начни с того, что объяви массив unsigned int и передай его по ссылке в ассемблер и попробуй что-нибудь с ним сделать, увеличить на единицу все элементы, например.
Это нужно чтобы понять формат хранения массива, который сделает компилятор.
Для 4 байт на входе будет 128 байт на выходе. В любом случае передавать нужно будет ссылку на число, а не само число. Так что не важно, что он там поддерживает.