деление. Как разделить число А на степень 10ки ?

САБЖ
Нужно без div/idiv
разделить число на 10, 100.... 10^n

В общем на степень 10.
Как это сделать проще всего?

 

Может быть, так?

Код (Text):

1. MOV EDX, EAX;
2. SHR EDX, 5;
3. SHR EAX, 6;
4. ADD EAX, EDX;

Правда, этот алгос не обеспечит нужной точности =(
Это будет не 0.1*ЕАХ, а всего 0.09375*ЕАХ.
А вообще, задачка интересная. Будем думать дальше

 

Если число -- дворд, то можно так:
разделить на 2,
умножить результат на (0хСССССССD)^n mod 2^32 и взять старший дворд из edx, т.к. 0хСССССССD = 1/5 mod 2^32
вру, но не пойму почему не так...

сорри, работает только для нечетных, и брать нужно результат из eax

 

x/10 = exp(ln(x)-ln(10))

 

GoldFinch

на асме нужно
и чем проще тем лучше

 

логарифмы вычисляет только FPU, причём делает это в среднем медленнее чем CPU - деление. Тем более неизбежно возникнут потери при переводе целых чисел в формат регистра FPU и обратно.
Но если уж заговорили мы о сопре, то может тупо пользовать

?

 

Насчёт замены (целочисленного) деления (целочисленным) умножением:
http://wasm.ru/baixado.php?mode=tool&id=203
http://www.amd.com/us-en/assets/content_type/white_papers_and_tech_docs/22007.pdf (самое начало главы 8) - там больше вариантов, знаковое и беззнаковое деления
А о том, почему всё это работает, и всевозможных случаях, очень подробно написано в книге Уоррена "Алгоритмические трюки для программистов", книгу очень рекомендую.

 

ну оть как просто, доступно и понятно оптимизируют си-шные компили
сие выражение

Код (Text):

1. int div10 (int a)
2. {
3.  return a / 10;
4. }
5.  
6. в асемблерный вид

Код (Text):

1.                  public _div10
2.  _div10          proc near               ;
3.  
4.  arg_0           = dword ptr  4
5.  
6.           mov   ecx, [esp+arg_0]
7.           mov   eax, 66666667h
8.           imul   ecx
9.           mov  eax, ecx
10.           sar    eax, 1Fh
11.           sar    edx, 2
12.           sub    edx, eax
13.           imul   eax, edx, 0Ah
14.           sub    ecx, eax
15.           mov    eax, edx
16.           mov    edx, ecx
17.           retn
18. _div10 endp

 

bugaga, что за компилятор?
VS2005 на

Код (Text):

1. int div10(int a)
2. {
3.     return a / 10;
4. }

выдаёт

Код (Text):

1. mov ecx, [esp+arg_0]
2. mov eax, 66666667h
3. imul ecx
4. sar edx, 2
5. mov eax, edx
6. shr eax, 1Fh
7. add eax, edx
8. retn

а на

Код (Text):

1. unsigned div10(unsigned a)
2. {
3.     return a / 10;
4. }

соответственно

Код (Text):

1. mov eax, 0CCCCCCCDh
2. mul [esp+arg_0]
3. shr edx, 3
4. mov eax, edx
5. retn

 

Код (Text):

1. int div10(int x)
2. {
3.     return x/10;
4. }

Visual C++ 6.0 Professional

Код (Text):

1.     mov ecx, DWORD PTR _x$[esp-4]
2.     mov eax, 1717986919             ; 66666667H
3.     imul    ecx
4.     mov eax, edx
5.     sar eax, 2
6.     mov ecx, eax
7.     shr ecx, 31                 ; 0000001fH
8.     add eax, ecx
9.     ret 0

Intel C++ Compiler v10

Код (Text):

1.     mov ecx, DWORD PTR [esp+4]  ;1.5
2.     mov eax, 1717986919     ;3.11
3.     imul    ecx         ;3.11
4.     sar ecx, 31         ;3.11
5.     sar edx, 2          ;3.11
6.     sub edx, ecx        ;3.11
7.     mov eax, edx        ;3.11
8.     ret             ;3.11

Не понятно зачем в коде bugaga второе умножение понадобилось.
Да и умножение на десять можно побыстрее сделать.
Вместо

Код (Text):

1. imul   eax, edx, 0Ah

быстрее будет

Код (Text):

1. lea eax,[edx*8+edx]
2. add eax,edx

Кстати, а в сети есть где-нибудь подробное описание почему работает замена деления на умножение?
В смысле как оно работает, выбор магического числа и т.д.

 

Остаток от деления зачем-то вычисляет

Насчет сети не знаю, в манах у Фога и AMD есть. Общий смысл простой - множитель берется равным round(2^n/10) и затем результат edx:eax сдвигается вправо на n бит (при n >= 32 это эквивалентно сдвигу edx на 32-n)

 

Я так подозреваю что компилятор решил div заэмулировать
При делении ведь получается целая часть и остаток, вот компилятор и через умножение то же вычисляет.
И пофиг ему что остаток никому не нужен

Угу, это понятно.
А как именно степень выбирается?
В смысле все компиляторы константу генерируют одну и ту же.
По идее чем больше n тем меньше будет погрешность.
В мануалах AMD я видел, но там по-моему как-то не расписано.
Типа делай так и будет тебе счастье. А почему так - не расписано.
К примеру n можно взять 32, и тогда edx вообще двигать не надо.
Но так почему-то не делают...

 

Это вычисления с целыми числами. Никакой погрешности быть не может, иначе получилась бы неэквивалентная замена, и её нужно было бы выбросить подальше.
На "магическое число" и n есть два условия: первое - вычисления должны быть всегда точными (это даёт ограничение снизу на n), второе - "магическое число" таки должно влезать в 32 бита (это даёт ограничение сверху на n). И то - это не всегда возможно, и для беззнакового деления иногда точная замена получается только начиная с 33 бит (например, для делителя 7). Подробно о том, почему замена точная и как нужно выбирать числа и почему именно так, написано в уже упомянутой книге Уоррена, и написано довольно много (в имеющемся у меня издании глава 10 называется "Целое деление на константы" и занимает 42 страницы).

 

перевести двоичное A в десятичную систему и сдвинуть результат вправо.
ИМХО не стоило приводить задачу к такому условию, деление на 10 реализуется на сопроцессоре.

 

Digital Mars Compiler 8.53.

угу. а если сапра нет то его нада эмулить

 

cppasm

Ты видать ман АМД невнимательно читал (см.Simpler Code for Restricted Dividend)
n=32 можно юзать только для чисел меньших 40000005h

 

Код (Text):

1. mov eax,Твое_число
2. mov ebx,10 ; буду делить на 10
3. xor ecx,ecx
4. lab0:
5. sub eax,ebx
6. jc exit
7. inc ecx
8. jmp lab0
9. exit: