sparse_mat

The sparse_mat data type is designed to hold the interaction matrix , which is generally a sparse matrix. It is built up of array<double> and iarray<int> components:

class sparse_mat
{
 public:
  array diag, val;
  iarray row, col;
  sparse_mat(int s=0, int o=0)
    {diag=array(s); val=array(o); row=iarray(o); col=iarray(o);}
  array operator*(iarray& x);  /* matrix multiplication */
  sparse_mat operator=(sparse_mat x);
  void init_rand(int conn, double sigma);
};

diag stores the diagonal components of the array, val is the packed list of offdiagonal values, with row and col being the index lists. The only important operator defined for this class is the matrix operation, which is defined as

beta*x == beta.diag*x + (beta.val*x[beta.col])[beta.row]

but is implemented separately for efficiency reasons.

init_rand is a utility routine for randomly initialising the nonzero pattern of the offdiagonal elements. The average number of nonzeros per row is conn, and the standard deviation of the number of nonzeros is sigma.

It is possible to represent the offdiagonal array differently for efficiency reasons. For example, if it is desired to represent the offdiagonal elements as a dense 2D array, one can create an extra pointer in the underlying implementation of array. Most of the time, this pointer is NULL, but when the cs_arrays routine offmul is called, it will check this pointer for the val array. If it is NULL, it will create the efficient representation, otherwise it will reuse the existing one. Because the only way the array's actual value will get out of synch with the efficient representation is by index assignment, put_double() and put_double_array (as well as obviously delete_array()) will need to be modified to deallocate the efficient representation.