eigenlldb.EigenSparseMatrixChildProvider Class Reference

Public Member Functions
def	__init__ (self, valobj, internal_dict)
def	num_children (self)
def	get_child_index (self, name)
def	get_child_at_index (self, index)
def	update (self)

Private Member Functions
def	_child_name (self, outer_index, inner_index)

Private Attributes
	_valobj
	_scalar_type
	_scalar_size
	_index_type
	_index_size
	_row_major
	_outer_size
	_values
	_inner_indices
	_outer_starts
	_inner_nnzs
	_compressed
	_child_indices
	_nnz

Constructor & Destructor Documentation

__init__()

def eigenlldb.EigenSparseMatrixChildProvider.__init__	(		self,
			valobj,
			internal_dict
	)

    def __init__(self, valobj, internal_dict):
        self._valobj = valobj
        valtype = valobj.GetType().GetCanonicalType()
        scalar_type = valtype.GetTemplateArgumentType(0)
        if not scalar_type.IsValid():
            # In the case that scalar_type is invalid on LLDB 9.0 on Windows with CLion
            data = valobj.GetChildMemberWithName("m_data")
            values = data.GetChildMemberWithName("m_values")
            scalar_type = values.GetType().GetPointeeType()
        self._scalar_type = scalar_type
        self._scalar_size = scalar_type.GetByteSize()
 
        index_type = valtype.GetTemplateArgumentType(2)
        if not index_type.IsValid():
            # In the case that scalar_type is invalid on LLDB 9.0 on Windows with CLion
            outer_starts = valobj.GetChildMemberWithName("m_outerIndex")
            index_type = outer_starts.GetType().GetPointeeType()
        self._index_type = index_type
        self._index_size = index_type.GetByteSize()
 
        name = valtype.GetName()
        template_begin = name.find("<")
        template_end = name.find(">")
        template_args = name[(template_begin + 1):template_end].split(",")
        self._row_major = (int(template_args[1]) & 1) != 0
 

Member Function Documentation

_child_name()

def eigenlldb.EigenSparseMatrixChildProvider._child_name (   self,   outer_index,   inner_index  )

private

    def _child_name(self, outer_index, inner_index):
        if self._row_major:
            return "[{0},{1}]".format(outer_index, inner_index)
        else:
            return "[{1},{0}]".format(outer_index, inner_index)

References eigenlldb.EigenMatrixChildProvider._row_major, eigenlldb.EigenSparseMatrixChildProvider._row_major, and format().

get_child_at_index()

def eigenlldb.EigenSparseMatrixChildProvider.get_child_at_index	(		self,
			index
	)

    def get_child_at_index(self, index):
        if index == 0:
            name = "rows" if self._row_major else "cols"
            return self._valobj.GetChildMemberWithName("m_outerSize") \
                .CreateChildAtOffset(name, 0, self._index_type)
        elif index == 1:
            name = "cols" if self._row_major else "rows"
            return self._valobj.GetChildMemberWithName("m_innerSize") \
                .CreateChildAtOffset(name, 0, self._index_type)
        else:
            index = index - 2
        outer_index = bisect.bisect_right(self._child_indices, index) - 1
        total_nnzs = self._child_indices[outer_index]
        if self._compressed:
            item_index = index
            inner_index = self._inner_indices \
                .CreateChildAtOffset("", item_index * self._index_size, self._index_type) \
                .GetValueAsUnsigned()
            return self._values \
                .CreateChildAtOffset(self._child_name(outer_index, inner_index),
                                     item_index * self._scalar_size,
                                     self._scalar_type)
        else:
            index_begin = self._outer_starts \
                .CreateChildAtOffset("", outer_index * self._index_size, self._index_type) \
                .GetValueAsUnsigned()
            item_index = index - total_nnzs + index_begin
            inner_index = self._inner_indices \
                .CreateChildAtOffset("", item_index * self._index_size, self._index_type) \
                .GetValueAsUnsigned()
            return self._values \
                .CreateChildAtOffset(self._child_name(outer_index, inner_index),
                                     item_index * self._scalar_size,
                                     self._scalar_type)
 

get_child_index()

def eigenlldb.EigenSparseMatrixChildProvider.get_child_index	(		self,
			name
	)

    def get_child_index(self, name):
        pass
 

num_children()

def eigenlldb.EigenSparseMatrixChildProvider.num_children

(

self

)

    def num_children(self):
        return self._nnz + 2
 

References eigenlldb.EigenSparseMatrixChildProvider._nnz.

update()

def eigenlldb.EigenSparseMatrixChildProvider.update

(

self

)

    def update(self):
        valobj = self._valobj
        self._outer_size = valobj.GetChildMemberWithName("m_outerSize").GetValueAsUnsigned()
        data = valobj.GetChildMemberWithName("m_data")
        self._values = data.GetChildMemberWithName("m_values")
        self._inner_indices = data.GetChildMemberWithName("m_indices")
        self._outer_starts = valobj.GetChildMemberWithName("m_outerIndex")
        self._inner_nnzs = valobj.GetChildMemberWithName("m_innerNonZeros")
 
        self._compressed = self._inner_nnzs.GetValueAsUnsigned() == 0
 
        total_nnzs = 0
        child_indices = [0]
        for outer_index in range(self._outer_size):
            if self._compressed:
                index_end = self._outer_starts \
                    .CreateChildAtOffset("", (outer_index + 1) * self._index_size, self._index_type) \
                    .GetValueAsUnsigned()
                total_nnzs = index_end
                child_indices.append(total_nnzs)
            else:
                nnzs = self._inner_nnzs \
                    .CreateChildAtOffset("", outer_index * self._index_size, self._index_type) \
                    .GetValueAsUnsigned()
                total_nnzs = total_nnzs + nnzs
                child_indices.append(total_nnzs)
        self._child_indices = child_indices
        self._nnz = total_nnzs
 

References eigenlldb.EigenMatrixChildProvider._valobj, and eigenlldb.EigenSparseMatrixChildProvider._valobj.

Referenced by smc.smc.recursiveBayesian().

Member Data Documentation

_child_indices

eigenlldb.EigenSparseMatrixChildProvider._child_indices

private

_compressed

eigenlldb.EigenSparseMatrixChildProvider._compressed

private

_index_size

eigenlldb.EigenSparseMatrixChildProvider._index_size

private

_index_type

eigenlldb.EigenSparseMatrixChildProvider._index_type

private

_inner_indices

eigenlldb.EigenSparseMatrixChildProvider._inner_indices

private

_inner_nnzs

eigenlldb.EigenSparseMatrixChildProvider._inner_nnzs

private

_nnz

eigenlldb.EigenSparseMatrixChildProvider._nnz

private

Referenced by eigenlldb.EigenSparseMatrixChildProvider.num_children().

_outer_size

eigenlldb.EigenSparseMatrixChildProvider._outer_size

private

_outer_starts

eigenlldb.EigenSparseMatrixChildProvider._outer_starts

private

_row_major

eigenlldb.EigenSparseMatrixChildProvider._row_major

private

Referenced by eigenlldb.EigenSparseMatrixChildProvider._child_name().

_scalar_size

eigenlldb.EigenSparseMatrixChildProvider._scalar_size

private

_scalar_type

eigenlldb.EigenSparseMatrixChildProvider._scalar_type

private

_valobj

eigenlldb.EigenSparseMatrixChildProvider._valobj

private

Referenced by eigenlldb.EigenMatrixChildProvider._cols(), eigenlldb.EigenMatrixChildProvider._rows(), and eigenlldb.EigenSparseMatrixChildProvider.update().

_values

eigenlldb.EigenSparseMatrixChildProvider._values

private

---

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

• eigenlldb.py