"Zeichen" im Integer

[3_of_8]

Ich nehme mal an, auch mit Assembler wird es nicht recht viel schneller gehen. Das einzige, was man hier ausnutzen kann, ist diese Schweinerei mit cdq, bringt aber auch nicht recht viel, wenn überhaupt was.

Delphi-Quellcode:

function NumberLength(x: Integer): Integer;
asm
  push ebx
  mov ebx, 10
  cdq
  mov ecx, edx
  and ecx, 1
  xor eax, edx
  sub eax, edx
  @loop:
  and eax, eax
  jz @endloop
  mov edx, 0
  div ebx
  add ecx, 1
  jmp @loop
  @endloop:
  mov eax, ecx
  pop ebx
end;

[JasonDX]

Ich wuerde sagen, die staendige Division ist eine unnoetige Bremse, die man nicht zwingend braucht.
Algorithmisch gesehen sollte das die schnellste Variante sein:

Delphi-Quellcode:

function DecIntLength(x: integer): byte;
const
  m: packed array[0..9] of integer = ($A, $64, $3E8, $2710, $186A0, $F4240, $989680, $5F5E100, $3B9ACA00, $0);
asm
   MOV EAX, x
   MOV ESI, m
   CDQ
   XOR EAX, EDX
   AND EDX, 1
   ADD EAX, EDX
@@loopstart:
   INC DL
   MOV EBX, [ESI]
   TEST EBX, EBX
   JZ loopend
   CMP EBX, EAX
   JA loopend
   ADD ESI, 4
   JMP loopstart
@@loopend: 
   MOV AL, DL
end;

Ich hab leider keinen Delphicompiler installiert, aber ich sehe eigentlich keinen grund, warums nich laufen sollte

greetz
Mike

[Edit] and is schneller als sets, also her damit
[Edit2] und den test brauchma auch ned... hoff ich zumindest mal *g*

[xZise]

Und das ganze jetzt für den Int64

Ein Problem in deinem Code

Zitat:

[Pascal Fehler] uMain.pas(6): E2107 Operandengröße stimmt nicht überein

MOV ESI, m

[3_of_8]

Jason, warum schreibst du statt $A, $64,... nicht einfach 10, 100,...? Zur Verwirrung?

[JasonDX]

Zitat von 3_of_8:

Jason, warum schreibst du statt $A, $64,... nicht einfach 10, 100,...? Zur Verwirrung?

Nein, weil ich das array eigentlich mal in den Code-Block schieben wollte, damit ich nicht auf ein Sprach-abhaengiges array zurueckgreifen haette muessen. Hat aber nicht zu ganz geklappt, und hab aus Gewohnheit die Hex-Werte kopiert... Wenn ich Leute Verwirren will, sieht das anders aus
Na ja, das mit dem Array hatte dann auch zur folge, dass dann das geschriebene nichmehr kompiliert... warum auch immer Delphi was dagegen hat, nen Zeiger in ein 32-Bit-Register zu schreiben

Egal, es geht auch ohne assembler:

Delphi-Quellcode:

function DecIntLength(x: integer): byte; 
const 
  m: packed array[0..9] of integer = (10, 100, 1000, 10000, 100000, 1000000, 10000000, 100000000, 1000000000, 0); 
var
  i: byte;
begin
  result := 0;
  i := 0;
  if (x < 0) then
  begin
    inc(result);
    x := -x;
  end;
  repeat
    inc(i);
  until ((m[i] = 0) or (m[i] > x))
  inc(result, i);
end;

Zitat von xZise:

Und das ganze jetzt für den Int64

Einfach alle integers durch int64 ersetzen, und folgendes fuer m nehmen:
m: packed array[0..17] of integer = (10, 100, 1000, 10000, 100000, 1000000, 10000000, 100000000, 1000000000, 10000000000, 100000000000, 1000000000000, 10000000000000, 100000000000000, 1000000000000000, 10000000000000000, 100000000000000000, 0); Wie gesagt: nicht probiert...

greetz
Mike

[jmd anders]

ich hab mal ein bißchen rumgetestet, auch mit assembler, bisher aber nur für 32bit integer.

Delphi-Quellcode:

function InlineAsm(x:integer) : integer;
const e=1;
      z=10;
      h=100;
      t=1000;
     zt=10000;
     ht=100000;
      m=1000000;
     zm=10000000;
     hm=100000000;
     md=1000000000;
    zmd=10000000000;
asm
  MOV EDX, EAX
  JMP @Ret1

  @Ret1            :
    CMP EDX,z
    JAE @Ret10
    MOV EAX, 1
    JMP @Ende;
  @Ret10           :
    CMP EDX,h
    JAE @Ret100
    MOV EAX, 2
    JMP @Ende;
  @Ret100          :
    CMP EDX,t
    JAE @Ret1000
    MOV EAX, 3
    JMP @Ende;
  @Ret1000         :
    CMP EDX,zt
    JAE @Ret10000
    MOV EAX, 4
    JMP @Ende;
  @Ret10000       :
    CMP EDX,ht
    JAE @Ret100000;
    MOV EAX, 5
    JMP @Ende;
  @Ret100000       :
    CMP EDX,m
    JAE @Ret1000000
    MOV EAX, 6
    JMP @Ende;
  @Ret1000000      :
    CMP EDX,zm
    JAE @Ret10000000
    MOV EAX, 7
    JMP @Ende;
  @Ret10000000     :
    CMP EDX,hm
    JAE @Ret100000000
    MOV EAX, 8
    JMP @Ende;
  @Ret100000000    :
    CMP EDX,md
    JAE @Ret100000000
    MOV EAX, 9
    JMP @Ende;
  @Ret1000000000    :
    MOV EAX, 10
    JMP @Ende;

 @Ende :
end;

das ist dabei rausgekommen, sehr ähnlich zu jason's asm funktion, nur ohne irgendwelche schleifen.
ich hab jason's asm funktion nicht getestet, aber seine delphi funktion, die war extrem schnell(7-8mal schneller als die asm funktion von 3_of_8).
ich hatte das gefühl, dass meine funktion einen tick schneller ist als die delphi funktion von jason(ich glaub nicht mal 1%)