[Back to MISC SWAG index] [Back to Main SWAG index] [Original]

    {
      unit Arit:  routine di calcolo numerico.
    }
    unit Arit;

    {$D-,L-,G+,N+}

    interface

    function Max(X,Y : integer) : integer;
      {- Restituisce il massimo tra A e B.}

    function Min(X,Y : integer) : integer;
      {- Restituisce il minimo tra A e B.}

    function LongMax(A,B : longint) : longint;
      {- Restituisce il massimo tra A e B (longint).}

    function LongMin(A,B : longint) : longint;
      {- Restituisce il minimo tra A e B (longint).}

    function InRange(V,A,B : integer) : boolean;
      {- Restituisce true se V Š compreso tra A e B (estrami inclusi).}

    function OutRange(V,A,B : integer) : boolean;
      {- Restituisce true se V non Š compreso tra A e B.}

    function LongInRange(V,A,B : longint) : boolean;
      {- Restituisce true se V Š compreso tra A e B (estrami inclusi).}

    function LongOutRange(V,A,B : longint) : boolean;
      {- Restituisce true se V non Š compreso tra A e B.}

    function LongToInt(V : longint) : integer;
      {- Converte da longinteger ad integer, restituendo MaxInt o -MaxInt nel caso
         V sia fuori dal range degli interi.}

    function IntToShort(V : integer) : shortint;
      {- Converte da integer ad shortint, restituendo 127 o -128 nel caso
         V sia fuori dal range degli shortint.}

    function CompToLongInt(V : Comp):longint;
      {- Converte da comp ad longint, restituendo MaxLongint o -MaxLongInt nel caso
         V sia fuori dal range dei longint.}

    function CompToInt(V : Comp):integer;
      {- Converte da comp ad longint, restituendo Maxint o -MaxInt nel caso
         V sia fuori dal range degli interi.}

    implementation {==============================================================}

    function Min(X,Y : integer) : integer; assembler;
    asm
      mov	ax,X
      cmp	ax,Y
      jle	@@1
      mov	ax,Y
    @@1:
    end;  { Min }

    function Max(X,Y : integer) : integer; assembler;
    asm
      mov	ax,X
      cmp	ax,Y
      jge	@@1
      mov	ax,Y
    @@1:
    end;  { Max }

    function LongMin(A,B : longint) : longint; assembler;
    asm
      mov   ax, word ptr [A]
      mov   dx, word ptr [A+2]
      mov   bx, word ptr [B]
      mov   cx, word ptr [B+2]
      cmp   dx,cx
      jl    @@1
      jg    @@2
      cmp   ax,bx
      jbe   @@1
    @@2:
      mov   ax,bx
      mov   dx,cx
    @@1:
    end;  { LongMin }

    function LongMax(A,B : longint) : longint; assembler;
    asm
      mov   ax, word ptr [A]
      mov   dx, word ptr [A+2]
      mov   bx, word ptr [B]
      mov   cx, word ptr [B+2]
      cmp   dx,cx
      jg    @@1
      jl    @@2
      cmp   ax,bx
      jae   @@1
    @@2:
      mov   ax,bx
      mov   dx,cx
    @@1:
    end;  { LongMax }

    function InRange(V,A,B : integer) : boolean; assembler;
    asm
      mov   ax,V
      cmp   ax,A
      jl    @1
      cmp   ax,B
      jg    @1
      mov   ax,1
      jmp   @2
    @1:
      xor   ax,ax
    @2:
    end; { InRange }

    function OutRange(V,A,B : integer) : boolean; assembler;
    asm
      mov   ax,V
      cmp   ax,A
      jl    @1
      cmp   ax,B
      jg    @1
      xor   ax,ax
      jmp   @2
    @1:
      mov   ax,1
    @2:
    end; { OutRange }

    function LongInRange(V,A,B : longint) : boolean;
    begin
      LongInRange := (V >= A) and (V <= B);
    end; { LongInRange }

    function LongOutRange(V,A,B : longint) : boolean;
    begin
      LongOutRange := (V < A) or (V > B);
    end; { LongOutRange }

    function LongToInt(V : longint) : integer;
    begin
      if V < -MaxInt then LongToInt := -MaxInt
      else if V > MaxInt then LongToInt := MaxInt
      else LongToInt := V;
    end; { LongToInt }

    function IntToShort(V : integer) : shortint;
    begin
      if V > 127 then IntToShort := 127
      else if V < -128 then IntToShort := -128
      else IntToShort := V;
    end; { IntToShort }

    function CompToLongInt(V : Comp):longint;
    var
      s : string[20];
      l : longint;
      e : integer;
    begin
      if V > MaxLongInt then l := MaxLongInt
      else if V < -MaxLongInt then l := -MaxLongInt
      else begin
        Str(V:20:0, S);
        val(s, l, e);
      end;
      CompToLongInt := l;
    end; { CompToLongInt }

    function CompToInt(V : Comp):integer;
    var
      s : string[20];
      i, e : integer;
    begin
      if V > MaxInt then i := MaxInt
      else if V < -MaxInt then i := -MaxInt
      else begin
        Str(V:20:0, S);
        val(s, i, e);
      end;
      CompToInt := i;
    end; { CompToInt }

    end. { unit Arit }

[Back to MISC SWAG index] [Back to Main SWAG index] [Original]