INCLUDE Irvine32.inc
.data

;Prompts
inputPrompt     BYTE "Please enter a number, 0 to exit: ", 0
output          BYTE "The square root is: ", 0
absErrorPrompt  BYTE "The absoulte error is: ", 0
relErrorPrompt  BYTE "The relative error is: ", 0
actualRootPrompt BYTE "The actual square root is: ", 0

;Constants
zero    REAL8 0.0 ;0 constant
two             REAL8 2.0 ;2 constant

;Variables
inputVar REAL8 ?                ;Number to find sqrt of
min             REAL8 ?                 ;minimum boundary
mid             REAL8 ?                 ;mid point
max             REAL8 ?                 ;maximum boundary
epsilon REAL8 1.0E-12   ;Epsilon
root    REAL8 ?                 ;Square sqrt
realRoot REAL8 ?                ;Stores actual sqrt for later calculations
midSquared REAL8 ?              ;variable for calculations
absError REAL8 ?                ;The value of absolute error
relError Real8 ?                ;The value of relative error

.code
main PROC
        finit
;Gets input from user and finds max boundary, lower boundary, and does sqrt function for later
input:
        fld zero                                                        ;Load zero to stack
        fstp min                                                        ;Set min bound as 0

        mov edx,OFFSET inputPrompt                      ;Print input prompt
        call WriteString

        call ReadFloat                                          ;Read in number
        fst inputVar                                            ;Store as input variable
        fst max                                                         ;Make max input variable
        fsqrt                                                           ;Gets sqrt of var for later
        fstp realRoot                                           ;Stores in realRoot variable

        fld inputVar                                            ;Load input
        fld zero                                                        ;Load zero
        fcomip st(0), st(1)                                     ;Compare input and 0
        je finish                                                       ;If input 0 end program

;Main while loop for calculations
while_loop:
        ffree st(0)
        ffree st(1)

        fld min                                                         ;Load min
        fadd max                                                        ;Min + Max
        fdiv two                                                        ;(Min + Max) / 2
        fst mid                                                         ;Store in mid
        fst root                                                        ;Stores mid in root
        fmul mid                                                        ;Mid^2
        fstp midSquared                                         ;Store in midSquared

        fld inputVar                                            ;Loads input
        fsub midSquared                                         ;Input - mid^2
        fabs                                                            ;Takes absolute value

        fld epsilon                                                     ;Loads epsilon
        fcomip st(0), st(1)                                     ;Compares differrence between mid^2 and input
        ja end_loop                                                     ;If smaller prints out results

        ffree st(0)                                                     ;Clears stack
        ffree st(1)

        fld inputVar                                            ;Loads inputVar
        fld midSquared                                          ;Loads mid^2
        fcomip st(0), st(1)                                     ;Compares mid^2 to inputVar
        jb if_lower                                                     ;If mid^2 lower jumps to if lower

;If square root is greater than actual root
if_greater:
        fld mid                                                         ;Loads mid
        fstp max                                                        ;Stores in high
        jmp while_loop                                          ;Jumps back to while loop

;If square root is lower than actual sqrt
if_lower:
        fld mid                                                         ;Loads mid
        fstp min                                                        ;Stores in low
        jmp while_loop                                          ;Jumps back to while loop

;Calculates error
end_loop:
        ffree st(0)                                                     ;Clears stack
        ffree st(1)

        fld realRoot                                            ;Actual sqrt
        fsub root                                                       ;Actual sqrt - measured sqrt
        fstp absError                                           ;Stores absolute error

        fld absError                                            ;Loads absolute error
        fdiv realRoot                                           ;Divides by real root
        fstp relError                                           ;Stores in relative root


;Outputs results
print_output:
        mov edx,OFFSET output                           ;Prints out calculated root
        call WriteString

        fld root
        call WriteFloat
        call CrLf
        ffree st(0)                                                     ;Clears stack

        mov edx,OFFSET actualRootPrompt         ;Prints out actual root
        call WriteString

        fld realRoot
        call WriteFloat
        call CrLf
        ffree st(0)                                                     ;Clears stack

        mov edx,OFFSET absErrorPrompt           ;Prints absolute error
        call WriteString

        fld absError
        call WriteFloat
        ffree st(0)                                                     ;Clears stack
        call CrLf

        mov edx,OFFSET relErrorPrompt           ;Prints relative error
        call WriteString

        fld relError
        call WriteFloat
        ffree st(0)                                                     ;Clears stack
        call CrLf
        call CrLf
        jmp input                                                       ;Starts over

finish:
        call WaitMsg                    ; wait for user to read results
        exit
main ENDP
END main