# Block Matrices

Summary

Here we show how to use the block matrix API

The algebra package contains a number of block matrix implementations.

Class Represents Notes
PartitionedMatrix A general block matrix User facing i.e. can be instantiated directly
LowerTriPartitionedMatrix Lower triangular block matrix Result of algebra API calls
UpperTriPartitionedMatrix Upper triangular block matrix Result of algebra API calls
PartitionedPSDMatrix Symmetric positive semi-definite matrix Result of applying kernel function on data.

## Creation¶

Block can be created in two major ways.

### From Input Blocks¶

  1 2 3 4 5 6 7 8 9 10 11 12 13 val index_set = (0L until 10L).toStream //Create the data blocks val data_blocks: Stream[((Long, Long), DenseVector[Double])] = utils.combine(index_set).map( indices => ( (indices.head, indices.last), DenseMatrix.ones[Double](500, 500) ) ) //Instantiate the partitioned matrix //must provide dimensions val part_matrix = PartitionedMatrix( data_blocks, numrows = 5000L, numcols = 5000L) 

### From Tabulating Functions¶

  1 2 3 4 5 6 7 8 9 10 11 val tabFunc: (Long, Long) => Double = (indexR: Long, indexC: Long) => { math.sin(2d*math.Pi*indexR/5000d)*math.cos(2d*math.Pi*indexC/5000d) } //Instantiate the partitioned matrix val part_matrix = PartitionedMatrix( nRows = 5000L, nCols = 5000L, numElementsPerRBlock = 1000, numElementsPerCBlock = 1000, tabFunc) 

### From Outer Product¶

A PartitionedMatrix can also be constructed from the product of a PartitionedDualVector and PartitionedVector.

 1 2 3 4 5 6 val random_var = RandomVariable(new Beta(1.5, 2.5)) val rand_vec1 = PartitionedVector.rand(2000L, 500, random_var) val rand_vec2 = PartitionedVector.rand(2000L, 500, random_var) val p_mat = rand_vec1*rand_vec2.t 

### Matrix Concatenation¶

You can vertically join matrices, as long as the number of rows and row blocks match.

 1 2 3 4 val mat1: PartitionedMatrix = _ val mat2: PartitionedMatrix = _ val mat3 = PartitionedMatrix.vertcat(mat1, mat2) 

Positive Semi-Definite Matrices

The class PartitionedPSDMatrix can be instantiated in two ways.

• From outer product.

 1 2 3 4 val random_var = RandomVariable(new Beta(1.5, 2.5)) val rand_vec = PartitionedVector.rand(2000L, 500, random_var) val psd_mat = PartitionedPSDMatrix.fromOuterProduct(rand_vec) 
• From kernel evaluation

 1 2 3 4 5 6 //Obtain data val data: Seq[DenseVector[Double]] = _ //Create kernel instance val kernel: LocalScalarKernel[DenseVector[Double]] = _ val psd_gram_mat = kernel.buildBlockedKernelMatrix(data, data.length) 

## Algebraic Operations¶

Partitioned vectors and dual vectors have a number of algebraic operations available in the API.

  1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 val beta_var = RandomVariable(Beta(1.5, 2.5)) val gamma_var = RandomVariable(Gamma(1.5, 2.5)) val p_vec_beta = PartitionedVector.rand(5000L, 1000, beta_var) val p_vec_gamma = PartitionedVector.rand(5000L, 1000, gamma_var) val dvec_beta = p_vec_beta.t val dvec_gamma = p_vec_gamma.t val mat1 = p_vec_gamma*dvec_gamma val mat2 = p_vec_beta*dvec_beta //Addition val add_mat = mat1 + mat2 //Subtraction val sub_mat = mat2 - mat1 //Element wise multiplication val mult_mat = mat1 :* mat2 //Matrix matrix product val prod_mat = mat1*mat2 //matrix vector Product val prod = mat1*p_vec_beta val prod_dual = dvec_gamma*mat2 //Scaler multiplication val sc_mat = mat1*1.5 

## Misc. Operations¶

### Map Partitions¶

Map each index, partition pair by a Scala function.

 1 2 3 4 5 val vec: PartitionedMatrix = _ val other_vec = vec.map( (pair: ((Long, Long), DenseMatrix[Double])) => (pair._1, pair._2*1.5) ) 

### Slice¶

Obtain subset of elements, the new matrix is repartitioned and re-indexed accordingly.

 1 2 3 4 5 val vec: PartitionedVector = PartitionedVector.ones(5000L, 1000) val mat = vec*vec.t val other_mat = vec(999L until 2000L, 0L until 999L) 

### Upper and Lower Triangular Sections¶

 1 2 3 4 5 6 val vec: PartitionedVector = PartitionedVector.ones(5000L, 1000) val mat = vec*vec.t val lower_tri: LowerTriPartitionedMatrix = mat.L val upper_tri: UpperTriPartitionedMatrix = mat.U 

### Convert to Breeze Matrix¶

 1 2 3 4 5 val mat: PartitionedMatrix = _ //Do not use on large vectors as //it might lead to overflow of memory. val breeze_mat = mat.toBreezeMatrix