FasmWorldПрограммирование на ассемблере FASM для начинающих и не только

Вот, кажется работает. Только вот какая фигня: при делении получается целое в ах и остаток — целое в dx, а ср. арифметическое — целое+дробь. А как такое получить не знаю.
use16
org 100h
jmp start
;————————
array1 dw 1,2,3,4,5,6,6
array2 dw 2,5,6,8,9
array3 dw 5,5,7,6,8,8
n1 dw 7
n2 dw 5
n3 dw 6
sr1 rw 1
sr2 rw 1
sr3 rw 1
;—————————-
start:
mov cx,[n1]
mov bx,array1
call sr_arifm
mov [sr1],ax

mov cx,[n2]
mov bx,array2
call sr_arifm
mov [sr2],ax

mov cx,[n3]
mov bx,array3
call sr_arifm
mov [sr3],ax
jmp quit

sr_arifm:
xor di,di
xor si,si
xor ax,ax
xor dx,dx
mov si,cx

lp:
add ax,[bx+di]
add di,2
jcxz return
loop lp
return:
div si
ret

quit:
mov ax,4c00h
int 21h

А у меня почему-то при втором вхождении в функцию во время деления ошибка и программа завершается.

use16
org 100h
mov bx,array_1
mov cx,word[len_1]
call Function
mov dx,array_2
mov cx,word[len_2]
call Function
mov ax,4c00h
int 21h

Function: ; bx:адрес массива, cx:длинна массива, ax:результат
xor si,si
push cx
Sum:
add ax,word[bx+si]
add si,2
loop Sum
pop cx
div cx
ret

;——————
array_1 dw 1111,2222,3333
array_2 dw 111,222,333,444
len_1 dw 3
len_2 dw 4

mov dx,array_2

В предыдущих примерах не рассмотрена проблема размерности суммы элементов массива слов, которая ограничена 65 535*65 535 — т.е. двойным словом.
И еще интересно было засовывать результаты в стек.
use16
org 100h
jmp start

array1 dw 1,26,789,666,564,0,1000,998,33
array2 dw 2300,7070,234,890,0,105,9999,467,9876,15000,876,43000
array3 dw 32000,62786,56789,1,345,60000,59003,34234,45789,31765,8890,456,7654,55555,23400
arl1 dw 9
arl2 dw 12
arl3 dw 15

start:
mov bx,array1
mov cx,[arl1]
call sr_ar
mov bx,array2
mov cx,[arl2]
call sr_ar
mov bx,array3
mov cx,[arl3]
call sr_ar

mov ax,4C00h
int 21h

sr_ar:
push cx ;ещё пригодиться
xor ax,ax
xor si,si
xor dx,dx ;обнуляем регистры
sym: add ax,[bx+si];суммируем элементы
jnc kon;если нет переноса суммируем дальше
inc dx ; если есть, то добавляем его в dx
kon: inc si
inc si
loop sym
pop cx
div cx;пригодилось
pop cx;чтоб положить что-то,сначала надо достать кое-что
push ax
push cx;возвращаем адрес на место
ret

    add ax,[bx+si];суммируем элементы
    jnc kon;если нет переноса суммируем дальше
    inc dx ; если есть, то добавляем его в dx

    add ax,[bx+si]
    adc dx,0

use16
org 100h
jmp start
;————————
array1 dw 1,2,3,4,5,6,7
array2 dw 1,2,3,4,5
n1 dw 7
n2 dw 5
;—————————-
start:
mov bx,array1
mov ax ,[n1]
call prozidura
mov [n1],ax ; сохраняем результат
;——-2 вызов——
mov bx,array2
mov ax ,[n2]
mov [n2],ax
call prozidura
mov ax,4c00h
int 21h
;—————————
prozidura: ; BX адрес начала даных AX количество элементов al результат
mov si,0;смешение
mov cx,ax
mov dx,ax ; dl=ax
xor ax,ax
zicol:
add ax,word[bx+si]
add si,2
loop zicol
div dl
ret

    xor ah,ah

use16
org 100h
jmp start

array1 dw 12, 8456, 0
length1 dw 3
array2 dw 56875, 1546, 154, 84, 6
length2 dw 5
array3 dw 156, 8974, 1548, 7895
length3 dw 4

start:
mov bx, array1
mov cx, [length1]
call sr_arifm
mov bx, array2
mov cx, [length2]
call sr_arifm
mov bx, array3
mov cx, [length3]
call sr_arifm

mov ax, 4C00h
int 21h

sr_arifm:
push cx
xor si, si
xor ax, ax
lp:
add ax, [bx+si]
add si, 2
loop lp
pop cx
div cx
ret
Считает правильно только первый раз.
Не подскажешь, в чем ошибка?

[code]
use16
org 100h
jmp Start

;========================[data]==
arrA dw 0xA0, 0xA1, 0xA2, 0xA3, 0xA4, 0xA5
arrAlen db 6

arrB dw 0xB0, 0xB1, 0xB2, 0xB3, 0xB4
arrBlen db 5

arrC dw 0xC0, 0xC1, 0xC2, 0xC3
arrClen db 4

average rw 3 ; arrA = 0xA2, arrB = 0xB2, arrC = 0xC1
;================================
Start:
xor si, si

mov bx, arrA
movzx cx, [arrAlen]
call get_average
mov [average+si], ax

inc si
mov bx, arrB
movzx cx, [arrBlen]
call get_average
mov [average+si], ax

inc si
mov bx, arrC
movzx cx, [arrClen]
call get_average
mov [average+si], ax

mov ax, 4c00h
int 21h

;——————————
get_average: ; bx == arrN, cx == count, ax == return result of average
xor ax, ax
push cx
calc:
add ax, [bx]
add bx, 2
loop calc
pop cx
call divide
ret

divide: ; ax == divided, cx == divisor, ax == result
cwd
div cx
ret
[/code]

use16
org 100h

    jmp main
;=====================================;
arr1 dw 834,536,1744,6890,241
arr1_length db 5
arr2 dw 486,6574,19,684
arr2_length db 4
arr3 dw 8577,985,911,648,6578,9894,245
arr3_length db 7
;=====================================;
main:
    xor cx,cx
    cld
    mov si,arr1
    mov cl,[arr1_length]
    call getAvrg ;ax — среднее арифметическое arr1
    mov si,arr2
    mov cl,[arr2_length]
    call getAvrg ;ax — среднее арифметическое arr2
    mov si,arr3
    mov cl,[arr3_length]
    call getAvrg ;ax — среднее арифметическое arr3

    mov ax,4c00h
    int 21h
;=====================================;
;si — адрес массива
;cl — длина массива
getAvrg:
    xor ax,ax
    mov bx,ax
    mov dx,ax
getAvrg_loop:
    lodsw
    add bx,ax
    adc dx,0
getAvrg_loop_end:
    loop getAvrg_loop
getAvrg_end:
    lodsb
    xor ah,ah
    xchg ax,bx
    div bx
    ret
;=====================================;

А как все тоже самое делать под linux, так надоело для этого виртуальную машину грузить?

use16
org 100h
jmp start
array1 dw 15,25,35,65,55
array2 dw 10,20,30,40,50,60
array3 dw 42,34,76,28,44,12,88
len1 dw 5
len2 dw 6
len3 dw 7
aver1 dw ?
aver2 dw ?
aver3 dw ?
start:
mov bx,array1
mov cx,[len1]
call ar_average
mov [aver1],bx

mov bx,array2
mov cx,[len2]
call ar_average
mov [aver2],bx

mov bx,array3
mov cx,[len3]
call ar_average
mov [aver3],bx

mov ax,4c00h
int 21h
;———————————————————————
ar_average:
push ax
push dx
push si
xor ax,ax
xor dx,dx
mov si,cx
sum_loop:
add ax,[bx]
adc dx,0
add bx,2
loop sum_loop
div si
mov bx,ax
pop si
pop dx
pop ax
ret

Вот задачка:
Имеется массив слов, для которого надо вычислить ср.арифм.
Вот я сломал мозг об это — array dw 0ffffh,0eeeeh,0ddddh,0cccch,0bbbbh,0aaaah
Что делать, когда сумма элементов вылезает за пределы слова?
Зациклить вычисление СА от СА предыдущих элементов и следующего элемента не вариант, т.к. теряется точность при нечётной сумме.

Всё, нашёл ошибку, в исправленном виде так:

. . .

calc:
xor si,si
xor dx,dx
mov cx,ax
push cx
xor ax,ax
@1: add ax,[bx+si]
adc dx,0
inc si
inc si
loop @1
pop cx
div cx
ret

. . .