Вычисление корня "вручную"

[Kronos913]

Вроде как работает.

Function Sqrt64(var a:Int64):LongWord;
asm
  push ebx
  push edi
  push esi

  mov edi, [eax]
  mov esi, [eax+4] {Çàãðóçèëè íà÷àëüíîå ÷èñëî}

  push ebp

  mov ebx, 2147483648
  mov ebp, 0

  @Begin1:
    mov ecx, ebp
    add ecx, ebx
    mov eax, ecx
    mov edx, 0

    mul ecx

    cmp edx, esi
      ja @Big1
      jb @Go1

    cmp eax, edi
      ja @Big1

    @Go1:
    add ebp, ebx

    @Big1:
    shr ebx, 1

    cmp ebx, 0
      ja @Begin1

  mov eax, ebp

  pop ebp
  pop esi
  pop edi
  pop ebx
end;

Параметр var - использовал потому что иначе asm код не работает.

Остаётся понять, оптимален ли этот код?

[northener]

Сообщение от Kronos913

Я открыл system но там его не нашел

function Sqrt(const X: Extended): Extended;
asm
        FLD     X
        FSQRT
        FWAIT
end;

[Kronos913]

Что будет быстрее работать? Мой алгоритм, или

trunc(sqrt(x))

[NetSpace]

сделай цикл в миллион шагов и пусть считает корни от 1 до миллиона или все одинаковые бери. засеки время по таймеру.
потом trunc(sqrt(x)) в цикл запихни тот же и снова время засекай.
так в сравнительном анализе и узнаешь, что быстрее.

[Kronos913]

Пришлось даже 100 миллионов раз выполнить каждую функцию, чтобы был нормальный результат
И да - моя алгоритм сработал почти в 2 раза быстрее

[Kronos913]

Сделал больше тестов. И вот что заметил: если число меньше 2^32 - то быстрее работает мой алгоритм
А если больше - то уже быстрее trunc(sqrt)

Но правда я код который выше еще модернизировал как раз на то чтобы было меньше итераций если число небольшое

[northener]

Сообщение от Kronos913

Сделал больше тестов. И вот что заметил: если число меньше 2^32 - то быстрее работает мой алгоритм
А если больше - то уже быстрее trunc(sqrt)

Извините, не верю без доказательств.

[Kronos913]

Моя функция Sqrt64 подгружается с юнита. А вот код тестирования

Суммирование корней я сделал потому что не знаю как именно работает оптимизация кода компилятором, потому сделал так чтобы эти данные использовались куда-то - следовательно точно не сокращались при оптимизации.
Так же, Int64 не хотел использоваться как счётчик цикла, потому пришлось его "вручную" прибавлять

Итог (на картинке): с числами до 2^32 мой код работает быстрее, а вот с числами после 2^32 - медленнее

Function StandartSqrt(const a:int64):LongWord;
begin
  Result:=Trunc(Sqrt(a*1.0));
end;

procedure TForm1.Button1Click(Sender: TObject);
var
  a1, a2, b1, b2: Int64;
  d1, d2, d3, i, j, k: longWord;
begin
  b1:=0;
  b2:=0;

  a1:=0;
  a2:=0;

  d1:=GetTickCount;
  For i:=1 to 10000000 do begin
    inc(a1);
    k:=StandartSqrt(a1);
    b1:=b1+k;
  end;
  d2:=GetTickCount;
  For i:=1 to 10000000 do begin
    inc(a2);
    k:=Sqrt64(a2);
    b2:=b2+k;
  end;
  d3:=GetTickCount;
  Label1.Caption:=IntToStr(d2-d1);
  Label2.Caption:=IntToStr(d3-d2);
  Form1.Refresh;

  a1:=4294967296;
  a2:=4294967296;

  d1:=GetTickCount;
  For i:=1 to 10000000 do begin
    inc(a1);
    k:=StandartSqrt(a1);
    b1:=b1+k;
  end;
  d2:=GetTickCount;
  For i:=1 to 10000000 do begin
    inc(a2);
    k:=Sqrt64(a2);
    b2:=b2+k;
  end;
  d3:=GetTickCount;
  Label3.Caption:=IntToStr(d2-d1);
  Label4.Caption:=IntToStr(d3-d2);
  Form1.Refresh;

  Memo1.Clear;
  Memo1.Lines.Add(IntToStr(b1));
  Memo1.Lines.Add(IntToStr(b2));
end;

[NetSpace]

теперь запили отдельную библиотеку *.pas и скинь всем в тему. пусть используют, кто занимается расчётами.
и кстати, эту строки b:=b+k; тоже можно сделать через inc() - быстрее будет, там надо через запятую параметр k написать.

[digitalis]

Сообщение от NetSpace

b:=b+k; тоже можно сделать через inc() - быстрее будет

Не думаю, что компилятор делает различие между двумя описаниями одного и того же действия. Анализировать сгенерированный код лень, конечно. По логике, там даже не будет вызова процедуры, а in-line вставка. Да и от версии компилятора зависит, видимо.