`#include <RTOp_SparseSubVector.h>`

## Public Attributes | |

RTOp_index_type | global_offset |

RTOp_index_type | sub_dim |

RTOp_index_type | sub_nz |

const RTOp_value_type * | values |

ptrdiff_t | values_stride |

const RTOp_index_type * | indices |

ptrdiff_t | indices_stride |

ptrdiff_t | local_offset |

int | is_sorted |

Sparse and dense local vectors are supported as follows:

A dense vector `vec`

is identified by `vec.sub_dim == vec.sub_nz`

and `vec.indices == NULL`

in which case `vec.indices_stride`

, `vec.local_offset`

and `vec.is_sorted`

are ignored. For a dense sub-vector `vec`

, the corresponding entries in the global vector `x(j)`

(one based) are as follows:

x( vec.global_offset + k ) = vec.values[ vec.value_stride * (k-1) ] for k = 1,...,vec.sub_dim

`vec.value_stride`

may be positive (>0), negative (<0) or even zero (0). A negative stride `vec.value_stride < 0`

allows a reverse traversal of the elements in `vec.values[]`

. A zero stride `vec.value_stride == 0`

allows a vector with all the elements the same.
A sparse vector is identified by `vec.sub_dim > vec.sub_nz`

or `vec.indices != NULL`

in which case all the fields in the structure are meaningful. The corresponding elements in the global vector `x(j)`

defined as:

x( vec.global_offset + vec.local_offset + vec.indices[vec.indices_stride*(k-1)] ) = vec.values[vec.value_stride*(k-1)] for k = 1,...,vec.sub_nz

`vec.sub_nz == 0`

then it is allowed for `vec.indices == NULL`

. If `vec.sub_dim > vec.sub_nz > 0`

then `vec.indices != NULL`

must be true.
A sparse sub-vector may be sorted (`vec.is_sorted!=0`

) or unsorted (`vec.is_sorted==0`

) but the indices `vec.indices[k]`

must be unique. A sorted vector (`vec.is_sorted!=0`

) means that the indices are in ascending order:

vec.indices[vec.indices_stride*(k-1)] < vec.indices[vec.indices_stride*(k)] for k = 1,...,vec.sub_nz-1

`vec.local_offset`

is used to shift the values in `vec.indices[]`

to be in range of the local sub-vector. In other words: 1 <= vec.local_offset + vec.indices[vec.indices_stride*(k-1)] <= vec.sub_nz for k = 1...vec.sub_nz

`vec.value_stride`

may be positive (>0), negative (<0) or zero (0). However, the member `vec.indices_stride`

may be may be positive (>0) or negative (<0) but not zero (0). Allowing `vec.indices_stride == 0`

would mean that a vector would have `vec.sub_nz`

nonzero elements with all the same value and all the same indexes and non-unique indices are not allowed. Allowing non-unique indexes would make some operations (e.g. dot product) very difficult to implement and therefore can not be allowed. A sparse vector where `vec.value_stride == 0`

is one where all of the nonzeros have the value `vec.values[0]`

. If `vec.sub_nz == 0`

for a sparse vector then it is allowed for `vec.values == NULL`

and `vec.indices == NULL`

.This specification allows a lot of flexibility in determining how the vectors are laid out in memory. However, allowing vectors to be sparse and unsorted may make many user defined operations considerably harder and expensive to implement.

To avoid making mistakes in setting the members of this struct use one of the helper functions `RTOp_sparse_sub_vector_from_dense()`

, `RTOp_sparse_sub_vector()`

or `RTOp_sub_vector_null()`

.

Definition at line 118 of file RTOp_SparseSubVector.h.

const RTOp_index_type* RTOp_SparseSubVector::indices |

Array (size min{|`indices_stride*sub_nz`

|,1} if not `NULL`

) for the indices of the nonzero elements in the vector (sparse vectors only)

Definition at line 133 of file RTOp_SparseSubVector.h.

The documentation for this struct was generated from the following file:

Generated on Wed May 12 21:50:36 2010 for RTOpPack: Extra C/C++ Code for Vector Reduction/Transformation Operators by 1.4.7