Практична частина

3.1 Опис програми.

В даній роботі використовуються такі регістри загального призначення. До них відносяться 16-розрядні регістри АХ, ВХ, СХ, DX, кожен з яких поділений на 2 частини по 8 розрядів:

АХ складається з АН (старша частина) і AL (молодша частина);

ВХ складається з ВH і BL;

СХ складається з СН і CL;

DX складається з DH і DL.

Опишемо основні підпрограми , що обробляють рядкові дані та дані відповідно заданого масиву . Розглянемло відповідні підпрограми роботи із двохвимірним масивом даних .

Підпрограма , що відповідає за виведення числа із регістру ах на дисплей .

write_element :

push cx

push -1

podgotovka:

xor dx, dx

mov cx , 10

div cx

push dx

cmp ax , 0

jne podgotovka

mov ah ,02h

vyvedennja:

pop dx

cmp dx , -1

je goout

add dl , 30h

int 21h

jmp vyvedennja

goout:

pop cx

ret

Принцип роботи : спочатку заносимо в стек число -1 , для того , щоб знати коли саме припиняти роботу, далі кожного разу ділимо число в регістрі ах на 10 та заносимо значення в стек , потім просто виводимо значення із стеку на дисплей ,поки не дійдемо до -1 .

Підпрограма , що відповідає за введення числа із клавіатури .

inp_val:

xor bx, bx

push ax

inp_n:

mov ah , 01h

int 21h

cmp al , 13

je after_inp_n

sub al , 48

push ax

mov ax , bx

mov bx , 10

mul bx

mov bx , ax

pop ax

add bl , al

jmp inp_n

after_inp_n:

pop ax

ret

Принцип роботи : користуючись 1 функцією 21-го переривання зчитуємо символ , перевіряємо чи введено не «Enter» якщо ж ні , то за умовою , що вводяться числа , маємо цифру в регістрі аl , множимо регістр bx (в якому і буде результат ) на 10 та додаємо введену цифру . В bx отримуємо число , що вводилося з клавіатури .

Підпрограма , що відповідає за виведення матриці на дисплей .

outputing_matrix :

call ryso4ka

mov si , 0

mov ax , [N]

mul ax

mov cx , ax

mov bx , [N]

GoOutput :

mov ax , A[si]

call write_element

mov ah , 02h

mov dl ,' '

int 21h

add si , 2

dec bx

cmp bx , 0

jne gO_

call endl

mov bx , [N]

gO_:

loop GoOutput

ret

Принцип роботи : йдемо по всіх елементах відповідної матриці та користуючись функцією “write_element” виводимо значення на дисплей .

Підпрограма , що відповідає за введення матриці із клавіатури .

inputing_matrix :

xor bx , bx

xor si , si

mov ax , [N]

mul ax

mov cx , ax

call ryso4ka

input_go:

mov ah , 09h

lea dx , message_first_part_inp

int 21h

mov ax ,[N]

mul ax

sub ax , cx

inc ax

call write_element

mov ah , 09h

lea dx , message_second_part_inp

int 21h

call inp_val

mov A[si] ,bx

add si , 2

call endl

loop input_go

ret

Принцип роботи : спочатку виводимо повідомлення , що треба ввести наступний елемент матриці , потім користуючись функцією «inp_val» заповнюємо відповідну матрицю введеними значеннями .

Підпрограма , що відповідає за завантаження в відповідну матрицю значень із матриці заданої константно.

load_from_constant:

mov [N] , 4

mov cx , [N]

lea di , const_matrix

mov bx , 0

external_load:

push cx

mov cx , [N]

mov si , 0

internal_load:

mov dx , [di]

mov A[bx][si], dx

add si , 2

add di , 2

loop internal_load

pop cx

add bx ,8

loop external_load

ret

Принцип роботи : спочатку встановлюємо в N розмір матриці , в даному випадку це 4 , тобто матриця матиме розмір 4х4 , йдемо елементами константної матриці та переписуємо значення в задану .

Підпрограма , що відповідає за введення матриці із клавіатури .

LetsGetSum:

call ryso4ka

mov cx , [N]

mov bx , 0

external_GetSum:

push cx

mov cx , [N]

mov si , 0

internal_GetSum:

mov ax , A[bx][si]

mov dl , 2

div dl

cmp ah, 0

jne ifNeParne

mov dx , [Sum]

add dx , A[bx][si]

mov [Sum] , dx

mov dx , [count_of_elements]

inc dx

mov [count_of_elements] , dx

ifNeParne:

add si , 2

loop internal_GetSum

pop cx

mov ax , [N]

mov dx ,2

mul dx

add bx ,ax

loop external_GetSum

ret

Принцип роботи : йдемо елементами заданої матриці , якщо зустрічаємо парний елемент то додаємо його до суми , та збільшуємо лічильник парних елементів , пройшовши всі елементи значення суми та кількості парних елементів будуть збережені в змінних “Sum” та “Count_of_elements” відповідно .

Підпрограма , що відповідає за заміну непарних елементів на 0.

LetsChangeElements:

mov cx , [N]

mov bx , 0

external_CH:

push cx

mov cx , [N]

mov si , 0

internal_CH:

mov ax , A[bx][si]

mov dl , 2

div dl

cmp ah, 0

je ifParne

mov dx , 0

mov A[bx][si], dx

ifParne:

add si , 2

loop internal_CH

pop cx

mov ax , [N]

mov dx ,2

mul dx

add bx ,ax

loop external_CH

ret

Принцип роботи : йдемо елементами заданої матриці , якщо зустрічаємо непарний елемент то замінюємо його на 0.

Підпрограма , що відповідає за підрахунок нулів у стовпцях матриці.

CountingZeroes:

call ryso4ka

mov cx , [N]

mov di , 0

mov [i] , 0

ex_:

mov si , di

mov bx , 0

push cx

mov cx ,[N]

in_:

mov dx , A[si]

cmp dx , 0

jne after_

inc bx

after_:

mov ax , [N]

mov dx ,2

mul dx

add si ,ax

loop in_

pop cx

add di ,2

mov ah ,09h

lea dx ,message_count_of_zeroes

int 21h

mov dx , [i]

inc dx

mov [i] ,dx

mov ax , [i]

call write_element

mov ah , 02h

mov dl , ' '

int 21h

mov ax , bx

call write_element

call endl

loop ex_

ret

Принцип роботи : утворюємо цикл обходу матриці по стовпцях , в якому підраховуємо кількість нулів у кожному із стовпців , на кожній ітерації зовнішнього циклу (ex_: .. loop ex_), тобто після N ітерацій внутрішнього циклу(in_: … loop in_) виводимо на дисплей повідомлення про кількість нулів у даному рядку .

Підпрограма , що відповідає за утворення матриці «В».

Create_B_Matrix :

mov si , 0

mov bx , 0

mov cx , [N]

external_BM :

push cx

mov cx, [N]

mov bx , si

mov di , 0

internal_BM:

mov dx , A[si]

mov ax , A[si+2]

add dx , ax

mov B[si],dx

cmp cx , 2

jne afterthis

dec cx

mov dx , A[si+2]

mov ax , A[BX]

add dx , ax

mov B[si+2] , dx

afterthis:

add si ,2

loop internal_BM

pop cx

add si ,2

loop external_BM

ret

Принцип роботи : йдемо рядками матриці «A» , та утворюємо відповідні рядкові елементи матриці «В» шляхом додавання і –го елементу до і+1 елементу відповідного рядку , якщо і-ий елемент рядку є останній то додаємо до нього перший елемент цього ж рядку .

Підпрограма , що відповідає за відображення та обробку пунктів головного меню .

Mainmenu:

call ryso4ka

mov ah ,09h

lea dx ,message_oberit

int 21h

lea dx , m_1

int 21h

lea dx , m_2

int 21h

lea dx , m_3

int 21h

lea dx , m_4

int 21h

call ryso4ka

mov ah ,01h

int 21h

call endl

cmp al , '1'

je gomsg1

cmp al , '2'

je gomsg2

cmp al , '3'

je gomsg3

cmp al , '4'

je gomsg4

mov ah ,09h

lea dx ,message_incorect_input

int 21h

call exit

gomsg1:

call LetsGetSum

mov ah , 09h

lea dx ,message_count_of_elements

int 21h

mov ax , [Count_of_elements]

call write_element

call endl

mov ah ,09h

lea dx , message_sum_is

int 21h

mov ax , [Sum]

call write_element

call endl

call exit

gomsg2:

call LetsChangeElements

call outputing_matrix

call exit

gomsg3:

call CountingZeroes

call exit

gomsg4:

call Create_B_Matrix

call outputing_B_matrix

call exit

ret

Принцип роботи : виводимо відповідні пункти меню на дисплей , що являють собой вище поставлені завдання щодо обобки матриць та обробляємо обраний користувачем варіант .