Matrix Types
[Overview of the Implementation]

---

Detailed Description

The matrix types module implements an internal run-time database of matrix types available to the library implementation.

Matrix types are identified by three pieces of information:

1. Matrix type name: a unique string descriptor (e.g., "CSR", "CSC", "BCSR", ...)
2. Integer index type ID: An integer ID number indicating the type of the integer indices stored by this data structure (see oski/scalinfo.h for a list of available types).
3. Non-zero value type ID: An integer ID number indicating the type of the scalar non-zero values stored by this data structure (see oski/scalinfo.h).

The library maintains a list of the available matrix types (g_avail_mattypes). This list is managed via the matrix type manager module (oski/mattypes.h).

We use this matrix type system for two reasons:

1. Kernel implementations may be registered at run-time on systems supporting shared libraries and dynamic linking.
2. Kernel implementations may be "incomplete". For example, the user may define a new matrix type, but only has to provide an implementation of matrix-vector multiply on that type.

Regarding incomplete kernel implementations, an implementor of a new matrix type does not, for example, have to define sparse kernel since a default implementation based on just matrix-vector multiply is possible. However, if she can provide a special tuned implementation, she may do so.

Matrix types implement the interface defined in Matrix Type Interface, where we distinguish betwen the methods a matrix type must provide versus those it may provide.

If you are implementing a new matrix type, start with the code in the matrix type template (Matrix Type Template) and refer to any of the existing types for detailed examples.

Files
file	mattypes.h
	Matrix type management routines.
file	mattypes_internal.h
	Defines a matrix type record.
file	scalinfo.h
	Define the scalar types available to the library.
file	TRIPART/format.h
	\ Block compressed sparse row data structure.
Modules
	Matrix Type Interface
	This interface defines the list of possible routines the library expects a matrix type may implement.
	Block Compressed Sparse Row (BCSR) Format
	Single Block Diagonal (BDIAG1) Format
	BDIAG1 format stores only 1 block diagonal of a matrix, where the blocks are stored as dense blocks of size .
	Cache Blocked (CB) Format
	Cache blocking implementation in which each submatrix is stored as a complete matrix handle to an arbitrary matrix type.
	Compressed Sparse Column (CSC) Format
	The CSC implementation reuses most of the CSR (Compressed Sparse Row (CSR) Format) infrastructure, since the arrays representing a matrix in CSC format are the same as the arrays that would be used to store in CSR format.
	Compressed Sparse Row (CSR) Format
	BeBOP-OSKI supports a general form of compressed sparse row, with the following "features": Either 0-based or 1-based indexing, for C and Fortran compatibility.
	Dense (DENSE) Format
	Dense matrix in unpacked column major format.
	Generalized Compressed Sparse Row (GCSR) Format
	Generalized compressed sparse row (GCSR) format augments the traditional CSR with an optional list of row indices, allowing entire rows to be sparse.
	Matrix Type Template
	Developers implementing their own matrix types can start with this template, replacing all instances of MATTYPE_TEMPLATE within these files to the custom matrix type name (e.g., CSR, BCSR).
	Modified Block Compressed Sparse Row (MBCSR) Format
	Modified block compressed sparse row format stores the block diagonal elements separately from the off-diagonal elements.
	Variable Block Row (VBR) Format
	Variable block row (VBR) format logically partitions the rows and columns, and stores all non-zero blocks block-row-wise.

---