hi$,$ i have to do matrix multiplication in scala, but i have no previous experience in scala. Can you please help me with this?

Part $1$ Matrix Multiplicaiton of Coordinate Matrices

$1\mathrm{.}1$ Small Matrices

$//$ Define two small matrices M and N

val M $=$ Array$($Array$(1\mathrm{.}0,2\mathrm{.}0),$ Array$(3\mathrm{.}0,4\mathrm{.}0))$

val N $=$ Array$($Array$(5\mathrm{.}0,6\mathrm{.}0),$ Array$(7\mathrm{.}0,8\mathrm{.}0))$

$////$ Convert the small matrices to RDDs

val M$\_$RDD$\_$Small $=$ sc$.$parallelize$($M$.$zipWithIndex.flatMap $\{$ case $($row$,$ i$)=>$ row.zipWithIndex.map $\{$ case $($value$,$ j$)=>(($i$.$toInt, j$.$toInt$),$ value$)\}\})$

val N$\_$RDD$\_$Small $=$ sc$.$parallelize$($N$.$zipWithIndex.flatMap $\{$ case $($row$,$ i$)=>$ row.zipWithIndex.map $\{$ case $($value$,$ j$)=>(($i$.$toInt, j$.$toInt$),$ value$)\}\})$

$1\mathrm{.}1\mathrm{.}2[$TODO$]$ Function to perform matrix multiplication of RDDs

def COOMatrixMultiply $($ M: RDD$[(($Int$,$Int$),$Double$)],$ N: RDD$[(($Int$,$Int$),$Double$)])$: RDD$[(($Int$,$Int$),$Double$)]=\{$

$//$ Your Code

$\}$

val R$\_$RDD$\_$Small $=$ COOMatrixMultiply$($M$\_$RDD$\_$Small, N$\_$RDD$\_$Small$)$

R$\_$RDD$\_$Small.collect.foreach$($println$)$

$1\mathrm{.}1\mathrm{.}3$ Validate the result

def manualMatrixMultiply$($M: Array$[$Array$[$Double$]],$ N: Array$[$Array$[$Double$]])$: Array$[$Array$[$Double$]]=\{$

val result $=$ Array.ofDim$[$Double$]($M$.$length, N$(0).$length$)$

for $\{$

i $<-$ M$.$indices

j $<-$ N$(0).$indices

k $<-$ M$(0).$indices

$\}$ result$($i$)($j$)+=$ M$($i$)($k$)*$ N$($k$)($j$)$

result

$\}$

val result$\_$manual $=$ R$\_$RDD$\_$Small.collect$().$map $\{$ case $(($i$,$ j$),$ value$)=>($i$,$ j$,$ value$)\}.$sortBy $\{$ case $($i$,$ j$,\_)=>($i$,$ j$)\}$

val resultArray $=$ Array.ofDim$[$Double$]($M$.$length, N$(0).$length$)$

for $(($i$,$ j$,$ value$)<-$ result$\_$manual$)\{$

resultArray$($i$)($j$)=$ value

$\}$

val expectedResult $=$ manualMatrixMultiply$($M$,$ N$)$

assert$($resultArray$.$deep $==$ expectedResult.deep, "Result mismatch"$)$

$1\mathrm{.}2$ Large Datasets

$1\mathrm{.}2\mathrm{.}1$ Generate Random Coordinate Matrices

import scala.util.Random

$//$ Function to generate random coordinate matrices for large datasets

def randomCOOMatrix $($ n: Int, m: Int $)$: RDD$[(($Int$,$Int$),$Double$)]=\{$

val max $=10$

val l $=$ Random.shuffle$((0$ until n$).$toList$)$

val r $=$ Random.shuffle$((0$ until m$).$toList$)$

sc$.$parallelize$($l$)$

$.$flatMap$\{$ i $=>$ val rand $=$ new Random$()$

r$.$map$\{$ j $=>(($i$.$toInt,j$.$toInt$),$rand.nextDouble$()*$max$)\}$

$\}$

$\}$

$1//$Set the dimensions of matrices M and N as $1024$x$1024.$

val n $=$

val m $=$

val M$\_$RDD$\_$Large $=$ randomCOOMatrix$($n$,$m$)$

val N$\_$RDD$\_$Large $=$ randomCOOMatrix$($m$,$n$)\}$

$\}\mathrm{.}2\mathrm{.}2[$TODO$]$ Set the Dimensions of the Matrices

$//$Set the dimensions of matrices M and N as $1024$x$1024.$

val n $=$

val m $=$

val M$\_$RDD$\_$Large $=$ randomCOOMatrix$($n$,$m$)$

val N$\_$RDD$\_$Large $=$ randomCOOMatrix$($m$,$n$)$

$//$Perform Multiplication

val R$\_$RDD$\_$Large $=$ COOMatrixMultiply$($M$\_$RDD$\_$Large, N$\_$RDD$\_$Large$)$

$//$ Notice the time it takes to multiply two $1024$x$1024$ matrices

R$\_$RDD$\_$Large.count

Part $2$ Matrix Multiplication of Block Matrices

$2\mathrm{.}1$ Small Block Matrix Multiplication

import org.apache.spark.mllib.linalg.distributed.$\_$

$//$ Convert small coordinate matrices to block matrices

val M$\_$Block$\_$Matrix $=$ new CoordinateMatrix$($M$\_$RDD$\_$Small.map $\{$ case $(($i$,$ j$),$ value$)=>$ MatrixEntry$($i$,$ j$,$ value$)\}).$toBlockMatrix$()$

val N$\_$Block$\_$Matrix $=$ new CoordinateMatrix$($N$\_$RDD$\_$Small.map $\{$ case $(($i$,$ j$),$ value$)=>$ MatrixEntry$($i$,$ j$,$ value$)\}).$toBlockMatrix$()$

M$\_$Block$\_$Matrix.blocks.collect.foreach$($println$)$

N$\_$Block$\_$Matrix.blocks.collect.foreach$($println$)$

$//$ Perform multiplication of small block matrices

val R$\_$Block$\_$Small $=$ M$\_$Block$\_$Matrix.multiply$($N$\_$Block$\_$Matrix$)$

R$\_$Block$\_$Small.blocks.collect.foreach$($println$)$

$2\mathrm{.}2$ Large Block Multiplication

$[$TODO$]$ Set the Block Size

$//$set the number of rows and columns per block to be $64$

val r$\_$b $=$

val c$\_$b $=$

$////$ Convert large coordinate matrices to block matrices where each block has $64$ rows and $64$ columns

val M$\_$Block$\_$Matrix$\_$Large $=$ new CoordinateMatrix$($M$\_$RDD$\_$Large.map $\{$ case $(($i$,$ j$),$ value$)=>$ MatrixEntry$($i$,$ j$,$ value$)\}).$toBlockMatrix$($r$\_$b$,$c$\_$b$)$

val N$\_$Block$\_$Matrix$\_$Large $=$ new CoordinateMatrix$($N$\_$RDD$\_$Large.map $\{$ case $(($i$,$ j$),$ value$)=>$ MatrixEntry$($i$,$ j$,$ value$)\}).$toBlockMatrix$($c$\_$b$,$c$\_$b$)$

M$\_$Block$\_$Matrix$\_$Large.validate

N$\_$Block$\_$Matrix$\_$Large.validate

assert$($M$\_$Block$\_$Matrix$\_$Large.numRowBlocks $==16,$ "Result mismatch"$)$

assert$($M$\_$Block$\_$Matrix$\_$Large.numColBlocks $==16,$ "Result mismatch"$)$

assert$($N$\_$Block$\_$Matrix$\_$Large.numRowBlocks $==16,$ "Result mismatch"$)$

assert$($N$\_$Block$\_$Matrix$\_$Large.numColBlocks $==16,$ "Result mismatch"$)$

val R$\_$Block$\_$Large $=$ M$\_$Block$\_$Matrix$\_$Large.multiply$($N$\_$Block$\_$Matrix$\_$Large$)$

$//$ Notice the time it takes to multiply two $1024$x$1024$ block matrices

R$\_$Block$\_$Large.blocks.count

Bonus: Provide a Faster Implementation of Matrix Multiplication than Block Matrix Multiplication! $(20$ points$)$

Please help me with this :$($