Multiply Two Random Matrices And Then Find Sum, Min And Max Value In The Product Matrix Assignment Solution

Instructions

Objective

Write a program to multiply two random matrices and then find sum, min and max value in the product matrix.

Requirements and Specifications

The two operand matrices will be implemented as a single 2D array. Each cell in this array is a structure of two values: x and y. Hence, we have an x and a y matrix. This 2D array is NN, where N is specified by the user through the command prompt. The matrices are randomly populated with integers less than or equal to 100.

First, the 2D matrix with each cell is printed with a pair of values "(X,y)". Then, display the x matrix and the y matrix separately.

Second, calculate the multiplication of matrix x and y and store the product (x*y) matrix in a new 2D array.

Display the product matrix.

Third, Calculate the sum, max, and min values in the product matrix and store the values in a structure.

Finally display the summary structure.

Screenshots of output

Source Code

.equ pos_x, 0 // position of the x field in structure .equ pos_y, 4 // position of the y field in structure .equ st_sum, 0 // position of the sum in structure .equ st_max, 4 // position of the max in structure .equ st_min, 8 // position of the min in structure .data num: .word 0 // variable to save read N struct: .space 16 // allocate space for result structure .section .rodata prompt: .string "Matrix dimension N?: " nerror: .string "Error: N must be positive\n" memerror: .string "Error: out of memory\n" matrixmsg: .string "\nMatrix contents:\n" matxmsg: .string "Matrix X contents:\n" matymsg: .string "Matrix Y contents:\n" mulmsg: .string "Result of multiplication X*Y:\n" summsg: .string "X*Y sum: %d\n" maxmsg: .string "X*Y max: %d\n" minmsg: .string "X*Y min: %d\n" intfmt: .string "%d" mat2fmt: .string "(%d,%d) " mat1fmt: .string "%d " nline: .string "\n" .text // Main function .type main,%function .global main main: stp x29, x30, [sp, -16]! // save fp and lr in stack // initialize random seed mov w0, wzr // load zero in afunction argument bl time // call time(0) bl srand // call srand(time(0)) to initialize random seed // read input number ldr x0, =prompt // load address of prompt string bl printf // print prompt string ldr x0, =intfmt // load format to read an integer ldr x1, =num // read in variable bl scanf // read the input number ldr x1, =num // load variable address ldr w19, [x1] // load variable value cmp w19, 0 // see if it's a valid number ble badinput // if not, print error // create new matrix of structures (x,y) mov w0, w19 // copy read N mul w0, w0, w19 // N*N lsl w0, w0, 3 // multiply N*N by 8, the size of one structure bl malloc // allocate space in heap cmp x0, 0 // if error allocating beq outmem // print error mov x20, x0 // save allocated memory pointer in x20 // fill x,y maxtrix with random values mov x21, 0 // i = 0 fori1: mov x22, 0 // j = 0 forj1: mul x0, x21, x19 // i*N add x0, x0, x22 // add i*N + j lsl x0, x0, 3 // (i*N + j) * (size of structure = 8) add x23, x0, x20 // get address of arr[i][j] bl generate_num // generate random number str w0, [x23, pos_x] // save in position x bl generate_num // generate random number str w0, [x23, pos_y] // save in position y add x22, x22, 1 // increment j cmp w22, w19 // if j blt forj1 // repeat add x21, x21, 1 // increment i cmp w21, w19 // if i blt fori1 // repeat ldr x0, =matrixmsg // load address of string bl printf // print string // print x,y matrix mov x21, 0 // i = 0 fori2: mov x22, 0 // j = 0 forj2: mul x0, x21, x19 // i*N add x0, x0, x22 // add i*N + j lsl x0, x0, 3 // (i*N + j) * (size of structure = 8) add x23, x0, x20 // get address of arr[i][j] ldr w1, [x23, pos_x] // load x ldr w2, [x23, pos_y] // load y ldr x0, =mat2fmt // load format to print a matrix element bl printf // print matrix element add x22, x22, 1 // increment j cmp w22, w19 // if j blt forj2 // repeat ldr x0, =nline // load format to print a newline bl printf // print newline add x21, x21, 1 // increment i cmp w21, w19 // if i blt fori2 // repeat ldr x0, =nline // load format to print a newline bl printf // print newline ldr x0, =matxmsg // load address of string bl printf // print string // print x matrix mov x21, 0 // i = 0 fori3: mov x22, 0 // j = 0 forj3: mul x0, x21, x19 // i*N add x0, x0, x22 // add i*N + j lsl x0, x0, 3 // (i*N + j) * (size of structure = 8) add x23, x0, x20 // get address of arr[i][j] ldr w1, [x23, pos_x] // load x ldr x0, =mat1fmt // load format to print a matrix element bl printf // print matrix element add x22, x22, 1 // increment j cmp w22, w19 // if j blt forj3 // repeat ldr x0, =nline // load format to print a newline bl printf // print newline add x21, x21, 1 // increment i cmp w21, w19 // if i blt fori3 // repeat ldr x0, =nline // load format to print a newline bl printf // print newline ldr x0, =matymsg // load address of string bl printf // print string // print y matrix mov x21, 0 // i = 0 fori4: mov x22, 0 // j = 0 forj4: mul x0, x21, x19 // i*N add x0, x0, x22 // add i*N + j lsl x0, x0, 3 // (i*N + j) * (size of structure = 8) add x23, x0, x20 // get address of arr[i][j] ldr w1, [x23, pos_y] // load y ldr x0, =mat1fmt // load format to print a matrix element bl printf // print matrix element add x22, x22, 1 // increment j cmp w22, w19 // if j blt forj4 // repeat ldr x0, =nline // load format to print a newline bl printf // print newline add x21, x21, 1 // increment i cmp w21, w19 // if i blt fori4 // repeat ldr x0, =nline // load format to print a newline bl printf // print newline // create new matrix to hold product mul w0, w19, w19 // N*N lsl w0, w0, 2 // multiply N*N by 4, the size of one word bl malloc // allocate space in heap cmp x0, 0 // if error allocating beq outmem // print error mov x24, x0 // save pointer // calculate product x*y mov x1, 0 // i = 0 fori5: mov x2, 0 // j = 0 forj5: mov w7, 0 // sum = 0 mov x3, 0 // k = 0 fork5: mul x4, x1, x19 // i*N add x4, x4, x3 // add i*N + k lsl x4, x4, 3 // (i*N + k) * (size of structure = 8) add x4, x4, x20 // get address of x[i][k] ldr w5, [x4, pos_x] // load x mul x4, x3, x19 // k*N add x4, x4, x2 // add k*N + j lsl x4, x4, 3 // (k*N + j) * (size of structure = 8) add x4, x4, x20 // get address of y[k][j] ldr w6, [x4, pos_y] // load y mul w4, w5, w6 // x[i][k] * y[k][j] add w7, w7, w4 // sum += x[i][k] * y[k][j] add x3, x3, 1 // increment k cmp w3, w19 // if k blt fork5 // repeat mul x4, x1, x19 // i*N add x4, x4, x2 // add i*N + j lsl x4, x4, 2 // (i*N + j) * (size of array element = 4) add x4, x4, x24 // get address of mul[i][j] str w7, [x4] // save multiplication result add x2, x2, 1 // increment j cmp w2, w19 // if j blt forj5 // repeat add x1, x1, 1 // increment i cmp w1, w19 // if i blt fori5 // repeat ldr x0, =mulmsg // load address of string bl printf // print string // print multiplication result mov x21, 0 // i = 0 fori6: mov x22, 0 // j = 0 forj6: mul x0, x21, x19 // i*N add x0, x0, x22 // add i*N + j lsl x0, x0, 2 // (i*N + j) * (size of element = 4) add x0, x0, x24 // get address of arr[i][j] ldr w1, [x0] // load arr[i][j] ldr x0, =mat1fmt // load format to print a matrix element bl printf // print matrix element add x22, x22, 1 // increment j cmp w22, w19 // if j blt forj6 // repeat ldr x0, =nline // load format to print a newline bl printf // print newline add x21, x21, 1 // increment i cmp w21, w19 // if i blt fori6 // repeat ldr x0, =nline // load format to print a newline bl printf // print newline // calculate sum, max and min and save in structure mov w4, 0 // sum = 0 ldr w5, [x24] // max = first element ldr w6, [x24] // min = first element ldr x7, =struct // point to start of structure str w4, [x7, st_sum] // save initial sum str w5, [x7, st_max] // save initial max str w6, [x7, st_min] // save initial min mov x1, 0 // i = 0 fori7: mov x2, 0 // j = 0 forj7: mul x3, x1, x19 // i*N add x3, x3, x2 // add i*N + j lsl x3, x3, 2 // (i*N + j) * (size of array element = 4) add x3, x3, x24 // get address of mul[i][j] ldr x7, =struct // point to start of structure ldr w4, [x7, st_sum] // load sum ldr w5, [x7, st_max] // load max ldr w6, [x7, st_min] // load min ldr w0, [x3] // load multiplication element [i][j] add w4, w4, w0 // sum += mul[i][j] cmp w0, w5 // compare with max ble chkmin // if <= max, check minimum mov w5, w0 // else, set as maximum b skip chkmin: cmp w0, w6 // compare with min bge skip // if >= min, skip mov w6, w0 // else, set as minimum skip: str w4, [x7, st_sum] // save sum str w5, [x7, st_max] // save max str w6, [x7, st_min] // save min add x2, x2, 1 // increment j cmp w2, w19 // if j blt forj7 // repeat add x1, x1, 1 // increment i cmp w1, w19 // if i blt fori7 // repeat // print results ldr x0, =summsg // load address of sum result string ldr x2, =struct // point to start of structure ldr w1, [x2, st_sum] // load sum result bl printf // print string ldr x0, =maxmsg // load address of max result string ldr x2, =struct // point to start of structure ldr w1, [x2, st_max] // load max result bl printf // print string ldr x0, =minmsg // load address of min result string ldr x2, =struct // point to start of structure ldr w1, [x2, st_min] // load min result bl printf // print string // delete the created matrices mov x0, x24 // load multiplication array pointer bl free // free all allocated memory mov x0, x20 // load array pointer bl free // free all allocated memory b return // terminate program badinput: ldr x0, =nerror // load address or error string bl printf // print error string b return // terminate program outmem: ldr x0, =memerror // load address or error string bl printf // print error string return: mov w0, wzr // return 0 ldp x29, x30, [sp], 16 // load fp and lr from stack ret // return to caller .size main, (. - main) // Function to generate a number between 1 and 100 // Returns w0 = random number .type generate_num, %function generate_num: stp x29, x30, [sp, -16]! // save fp and lr in stack bl rand // generate random number mov w1, 100 // load 100 to make division udiv w2, w0, w1 // divide random num by 100 to get remainder 0 msub w0, w2, w1, w0 // get remainder = randnum - quotient*100 add w0, w0, 1 // get number 1<=x<=100 ldp x29, x30, [sp], 16 // load fp and lr from stack ret // return .size generate_num, (. - generate_n