Hw3Large

; Hw3Large.asm

    .MODEL LARGE
    .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 ?
    minSubTotal     DD ?

     .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+6]         [BP+10]     [BP+14]    [BP+16]      [BP+20]
_find_closest_pair  PROC FAR
     PUSH BP
     MOV BP, SP
     PUSH DI
     PUSH SI

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

     ;ES:[DI] --> Arr1[0]
     MOV DI,[BP+6]
     MOV ES,[BP+8]

     ;FS:[SI] --> Arr2[0]
     MOV SI,[BP+10]
     MOV FS,[BP+12]

; intialize minSub to |(arr1[0]-arr2[0])|
     MOV EAX, ES:[DI]
     SUB EAX, FS:[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, ES:[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, FS:[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
     JA doNotUpdateMin

     MOV tmpDI, DI ;save DI value

     ;update minSub
     MOV minSub, EAX

     ;update i_index
     MOV DI, [BP+16]
     MOV GS, [BP+18]
     MOV AX, i
     MOV GS:[DI], AX

     ;update j_index
     MOV DI, [BP+20]
     MOV GS, [BP+22]
     MOV AX, j
     MOV GS:[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
     JBE subLoopOut

     ;return DX:AX
     PUSH minSub
     POP AX
     POP DX

     POP SI
     POP DI
     POP BP
;Ending procedure
     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+6]     [BP+10] [BP+12]    [BP+14]        [BP+18]        [BP+22]         [BP+26]
_find_closest_matrix_pair  PROC NEAR
     PUSH BP
     MOV BP, SP
     PUSH DI
     PUSH SI

     ;insert n to MatrixSize
     MOV AX,[BP+10]
     MOV MatrixSize,AX
     ;insert m to ArrSize
     MOV AX,[BP+12]
     MOV ArrSize,AX

     ;[DI] --> arr_ptr[0]
     MOV DI,[BP+6]
     MOV ES,[BP+8]
     ;[SI] --> arr_ptr[0]
     MOV SI,[BP+6]

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

;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

        LEA DX, [j2]
        LEA CX, [j1]

        ;address of j2
        PUSH DS
        PUSH DX

        ;address of j1
        PUSH DS
        PUSH CX

        PUSH ArrSize

        ;arr_ptr[i2]
        MOV BX,i2
        SHL BX,2 ;i2*4
        MOV ECX, ES:[DI+BX]
        PUSH ECX

        ;arr_ptr[i1]
        MOV BX,i1
        SHL BX,2 ;i1*4
        MOV EDX, ES:[SI+BX]
        PUSH EDX

        CALL _find_closest_pair

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

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

        ;check if (tmpSub < minSubTotal)
        MOV EAX,tmpSub
        CMP EAX,minSubTotal
        JA dontUpdateMin
        ;save DI value
        MOV tmpDI,DI

        ;Update minSubTotal = tmpSub
        MOV minSubTotal,EAX

        ;Update indexes
        MOV DI,[BP+14]
        MOV FS,[BP+16]
        MOV BX,i1
        MOV FS:[DI],BX ;*i1_index=i1

        MOV DI,[BP+18]
        MOV FS,[BP+20]
        MOV BX,j1
        MOV FS:[DI],BX ;*j1_index=l1

        MOV DI,[BP+22]
        MOV FS,[BP+24]
        MOV BX,i2
        MOV FS:[DI],BX ;*i2_index=i2

        MOV DI,[BP+26]
        MOV FS,[BP+28]
        MOV BX,j2
        MOV FS:[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 minSubTotal
     POP AX
     POP DX

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