CLAS - Clean Linear Algebra Subroutines version 0.7

---

CLAS provides basic operations for numerical linear algebra. Its name and organization is inspired by BLAS (Basic Linear Algebra Subroutines), which exist for many imperative languages such as C and FORTRAN.

CLAS is (much like BLAS) organized in three levels/modules of increasing complexity and some additional modules.
The levels are

• Clas1: Operation of linear complexity: e. g. vector addition, scalar product, vector norms
• Clas2: Operation of quadratic complexity: e. g. matrix vector multiplication, forward/backward substitution
• Clas3: Operation of cubic complexity: e. g. matrix matrix multiplication, LU decomposition, Gauss-Jordan method (matrix inversion)

Importing one level, all lower levels will be imported as well, plus SampleVec and SampleMat.

At this time the CLAS functions are provided for full matrices only, defined as

:: Vector :== {# Real}
:: Matrix :== {# .Vector}

Sparse storage schemes are being investigated and will be included at a later time.

With version 0.7 slicing is introduced in module slicing with instructive examples in slicingExamples.

CLAS

Clas1

Clas2

Clas3

SampleVec

SampleMat

Slicing

What is a slice?

In general a slice is a rectangular sub-array of a multidimensional array, a matrix in our case. In FORTRAN 90 this is referred to as a section.

What can they be used for?

Working with slices of a matrix rather than with the whole matrix is useful for many algorithms that manipulate matrix elements. It can lead to very concise and elegant code.

How are they defined in Clean?

In general slices can be defined by stating a lower and an upper bound of the slice for each dimension.

We implement the type of a slice as a constructor followed by two lists of integers, one for each dimension of a matrix.

:: Sli =  Sli ![Int] ![Int]

The integers in the lists indicate the row/column numbers of a given matrix, that we want to treat as a slice.

For example within a matrix a, Sli [i .. (i+l)] [j .. (j+k)] refers to:

But besides continuous submatrices of a matrix we can define parts of a matrix less restrictively with lists. Lists allow us

• to define non-continuous parts of a matrix,
• to reorder/permute rows and columns, or
• to have rows and columns appear more than once.

Here is an example: Within a matrix a, Sli [1,7,5,5,13] [1,2,7,1] refers to

Besides Sli there are three more types defined for the following case: If one (or both) of the lists has got only one entry, the yielded slice is one-dimensional and thus some part of a row or of a column or just a single element:

:: Row =  Row Int ![Int]
:: Col =  Col ![Int] Int
:: Ele =  Ele Int Int

We have to distinguish these one-dimensional slices from the "proper" slices, as operations change depending upon the dimension of the slices involved. We will see how later.

How can I work with slices?

Typically slice operations involve two or three slices. An obvious way to carry out this kind of operation is to cut slices out of their respective matrices (i. e. to copy them). Then the operation itself is performed, resulting in a new matrix or vector, which then has to be embedded into a matrix again.

For large matrices with almost equally large slices this becomes prohibitively expensive in both execution time and storage requirements, due to copying. Therefore we have to exploit uniqueness typing for the matrix we want to embed the resulting slice in. Luckily there are many algorithms in which all involved slices stem from the same matrix. Therefore we provide (among others) two families of functions named sliceXX(X) which take two and three slices along with one or two functions (that define the operation on the elements) and a unique matrix. The Xs indicate which kind of slice is involved and determines the operation. For example

sliceSS :: !Sli (Real Real -> Real) !Sli *Matrix -> *Matrix

We can use sliceSS for instance to add two slices and write its result to the first slice. In MATLAB this can be programmed as

A = ...;
A(1:3,1:3) = A(1:3,1:3) + A(4:6,4:6);

In Clean using CLAS it looks like this:

a :: .Matrix
a = ...
Start = sliceSS (Sli [1 .. 3] [1 .. 3]) (+) (Sli [1 .. 3] [4 .. 6]) a

This function overwrites the elements of the first slice with the (elementwise) sum of both slices:

Another very typical application is the outer product of a column and a row slice being add to a slice. In MATLAB again this can be coded as

A(k+1:n,k+1:n) = A(k+1:n,k+1:n) + A(k+1:n,k) * A(k,k+1:n);

In Clean using CLAS this is:

a :: .Matrix
a = ...
Start = sliceSCR (Sli [inc k .. n] [inc k .. n]) (+) (Col [inc k .. n] k) (*) (Row k [inc k .. n]) a

And again this is the effect on the matrix:

Two issues need special attention:

• The user has to make sure, that the dimensions of the involved slices match.
• The user further has to be aware that overlapping slices are not detected at compile time.

Which slicing functions are available?

• sliceXYZ

This family of functions performs operations of the kind

a <- a * (b o c),

where a,b and c are slices and (*) and (o) are operations on their elements.

Due to the absence of multiple type classes, we have to define a function for each feasible combination of slice types. Along with our four types of slices (Sli, Row, Col, Ele) we also accept the type Vector and the type Matrix to be able to work with external references as well. So there are actually 6³ = 216 combinations of types to fill in X, Y and Z in the function sliceXYZ. However not all these combinations are sensible (If you think otherwise, feel free to fill in your definition). The following table shows all combinations we want to provide: The entry at the crossing of a row (the Y) and a column (the Z) is the type of the result (the X):

sliceXYZ	Sli	Row	Col	Ele	Matrix	Vector
Sli	Sli			Sli	Sli
Row		Row	Ele	Row		Row
Col		Sli	Col	Col		Col
Ele	Sli	Row	Col	Ele
Matrix	Sli				Sli
Vector		Row	Col			Sli, Row, Col, Ele

Let us find the entry of the previous example of an outer product: sliceSCR, i. e. Sli, Col and Row. For Col and Row we find Sli, which is the result type. Changing the order to Row and Col we find Ele. So there is another function called sliceERC. It computes some kind of dot product between a Row and a Col and writes it to an Ele.

In the case of two vectors the first letter determines, how the vectors are interpreted.The type Vector does not carry the information of a vector is a column or a row vector. For instance if the two vectors are one row and one column vector, the result is a Sli (sliceSVV), two column vectors result in a Col (sliceCVV).

• sliceXY

  The family of functions sliceXY follows pretty much the same idea. The operation is

a <- a * b,

where a and b are slices and (*) is an operation on their elements. Following our convention, that the first slice is used for the result, types Matrix and Vector are not allowed in the first position. The following table shows all defined functions. Notice that the result matches the first slice type.

sliceXY	Sli	Row	Col	Ele	Matrix	Vector
Sli	Sli			Sli	Sli
Row		Row		Row		Row
Col	Col		Col	Col		Col
Ele				Ele

• sliceMipX

  The two functions sliceMipC and sliceMipS provide inner products of slices with an external matrix. As the result will be written to the slice, the dimension of the external matrix has to be appropriate.

• imbedX

  The functions imbedR, imbedC take a slice and an external vector and imbed the external vector at the place of the slice. The function imbedS takes a slice and a matrix and imbeds the external matrix at the position of the slice.

• cutX

  The functions cutR and cutC return vectors with element of a given slice. The functions cutS, cutRM and cutCM return matrices, the latter two a matrix with only one row or column respectively.

• transposeSlice

  The function transposeSlice takes a pair of a slice and a matrix and returns such a pair with the matrix and slicing information transposed.

All slicing operations are defined in Slicing, along with sample programs (for Gaussian LU, Householder QR and Givens QR decomposition) in SampleSlice.

Slicing

SampleSlicing