Hw3Small

; Hw3Small.asm

    .MODEL SMALL
    .STACK 100h
    .DATA
;_find_closest_pair variables
     ArrSize        DW ?
     i              DW ?
     j              DW ?
     tmpSub         DD ?
     minSub         DD ?
     tmpDI          DW ?

;_find_closest_matrix_pair variables
     MatrixSize     DW ?
     i1             DW ?
     i2             DW ?
     j1             DW ?
     j2             DW ?
     .CODE
     .386
PUBLIC _find_closest_pair
;extern long int find_closest_pair(long int arr1[], long int arr2[], int n, int *i_index, int *j_index);
;                                       [BP+4]         [BP+6]      [BP+8]     [BP+10]      [BP+12]
_find_closest_pair  PROC NEAR
     PUSH BP
     MOV BP, SP
     PUSH DI
     PUSH SI

     ;put the arrays size in a variable
     MOV AX,[BP+8]
     MOV ArrSize,AX

     ;[DI] --> Arr1[0]
     MOV DI,[BP+4]

     ;[SI] --> Arr2[0]
     MOV SI,[BP+6]

; intialize minSub to |(arr1[0]-arr2[0])|
     MOV EAX, [DI]
     SUB EAX, [SI]
     JNS positive
negative:
     NEG EAX
positive:
     MOV minSub, EAX

;==============CODE IN C:==============
;   for(i=0;;i<ArrSize;i++)
;       for(j=0;j<ArrSize;j++)
;       {
;           tmpSub=(arr1[i]-arr2[j])
;           if(tmpSub<0)
;               tmpSub*=-1;
;           if (tmpSub<minSub){
;               minSub=tmpSub
;               i_index=i;
;               j_index=j;
;               }
;       }
;=====================================

;initialize i=0 for first loop  :
     XOR AX, AX
     MOV i, AX
subLoopOut:

     MOV BX, i
     SHL BX, 2 ;i*4
     MOV ECX, [DI+BX] ;ECX= arr1[i]

;initialize j=0 for second loop:
     XOR AX, AX
     MOV j, AX
subLoopin:
     MOV BX, j
     SHL BX, 2 ;j*4
     MOV EAX, [SI+BX] ;EAX= arr2[j]
     SUB EAX, ECX       ;tmpsuB= arr2[J] - srr2[I]
     JNS not_neg
     NEG EAX
not_neg:
     MOV tmpSub, EAX
     CMP EAX, minSub
     JG doNotUpdateMin

     MOV tmpDI, DI ;save DI value

     ;update minSub
     MOV minSub, EAX

     ;update i_index
     MOV DI, [BP+10]
     MOV AX, i
     MOV [DI], AX

     ;update j_index
     MOV DI, [BP+12]
     MOV AX, j
     MOV [DI], AX

     MOV DI, tmpDI ;return DI his original value

doNotUpdateMin:
     ;subLoopin iteration check
     INC j
     MOV AX, ArrSize
     CMP j, AX
     JB subLoopin

     ;subLoopOut iteration check
     INC i
     MOV AX, ArrSize
     DEC AX
     CMP i, AX
     JB subLoopOut

     ;return DX:AX
     PUSH minSub
     POP AX
     POP DX

     POP SI
     POP DI
     POP BP
;Ending procedure find_closest_pair
     RET
     _find_closest_pair  ENDP


PUBLIC _find_closest_matrix_pair
;extern long int find_closest_matrix_pair(long int *arr_ptr[], int n, int m, int *i1_index, int *j1_index,  int *i2_index, int *j2_index);
;                                                   [BP+4]     [BP+6] [BP+8]      [BP+10]        [BP+12]        [BP+14]         [BP+16]
_find_closest_matrix_pair  PROC NEAR
     PUSH BP
     MOV BP, SP
     PUSH DI
     PUSH SI

     ;insert n to MatrixSize
     MOV AX,[BP+6]
     MOV MatrixSize,AX
     ;insert m to ArrSize
     MOV AX,[BP+8]
     MOV ArrSize,AX

     ;[DI] --> arr_ptr[0]
     MOV DI,[BP+4]
     ;[SI] --> arr_ptr[0]
     MOV SI,[BP+4]

     ;initiate minSub to the maximum value possible
     MOV minSub,0
     NOT minSub

;initialize i1=0 for first loop :
     XOR AX, AX
     MOV i1, AX
matLoopOut:

;initialize i2=i1+1 for second loop:
     MOV AX, i1
     INC AX
     MOV i2, AX
matLoopin:

        ;push values to stack, before calling func find_closest_pair
        PUSH OFFSET j1
        PUSH OFFSET j2
        PUSH ArrSize
        MOV BX,i2
        SHL BX,1 ;i2*2
        PUSH WORD PTR [DI+BX]
        MOV BX,i1
        SHL BX,1 ;i1*2
        PUSH WORD PTR [SI+BX]

        CALL _find_closest_pair

        ;ignore junk and clear stack
        ADD SP, 4
        POP ArrSize
        ADD SP, 4

        ;mov result saved in DX:AX to tmpSub
        PUSH DX
        PUSH AX
        POP tmpSub

        ;check if (tmpSub < minSub)
        MOV EAX,tmpSub
        CMP EAX,minSub
        JG dontUpdateMin

        MOV tmpDI, DI ;save DI value

        ;Update minSub = tmpSub
        MOV minSub,EAX

        ;Update indexes
        MOV DI,[BP+10]
        MOV BX,i1
        MOV [DI],BX ;*i1_index=i1

        MOV DI,[BP+12]
        MOV BX,j1
        MOV [DI],BX ;*j1_index=l1

        MOV DI,[BP+14]
        MOV BX,i2
        MOV [DI],BX ;*i2_index=i2

        MOV DI,[BP+16]
        MOV BX,j2
        MOV [DI],BX ;*j2_index=j2

        MOV DI, tmpDI ;return DI his original value

 dontUpdateMin:
     ;sumLoopin iteration check  (i2<MatrixSize)
     INC i2
     MOV AX, MatrixSize
     CMP i2, AX
     JB matLoopin

     ;sumLoopOut iteration check (i1<MatrixSize-1)
     INC i1
     MOV AX, MatrixSize
     DEC AX
     CMP i1, AX
     JB matLoopOut

     ;return DX:AX
     PUSH minSub
     POP AX
     POP DX

     POP SI
     POP DI
     POP BP
;Ending procedure find_closest_matrix_pair
     RET
     _find_closest_matrix_pair  ENDP
END