hip.hipsparse

hip.hipsparse#

(No short description)

Attributes:

bsrsv2Info_t:: alias of bsrsv2Info
bsrsm2Info_t:: alias of bsrsm2Info
bsrilu02Info_t:: alias of bsrilu02Info
bsric02Info_t:: alias of bsric02Info
csrsv2Info_t:: alias of csrsv2Info
csrsm2Info_t:: alias of csrsm2Info
csrilu02Info_t:: alias of csrilu02Info
csric02Info_t:: alias of csric02Info
csrgemm2Info_t:: alias of csrgemm2Info
pruneInfo_t:: alias of pruneInfo
csru2csrInfo_t:: alias of csru2csrInfo
hipsparseSpGEMMDescr_t:: alias of hipsparseSpGEMMDescr
hipsparseSpSVDescr_t:: alias of hipsparseSpSVDescr
hipsparseSpSMDescr_t:: alias of hipsparseSpSMDescr

class hip.hipsparse.bsrsv2Info#

Bases: Pointer

Python wrapper for cdef class chipsparse.bsrsv2Info.

If this type is initialized via its __init__ method, it allocates a member of the underlying C type and destroys it again if the wrapper type is deallocated.

This type also serves as adapter when appearing as argument type in a function signature. In this case, the type can further be initialized from a number of Python objects:

None:

This will set the self._ptr attribute to NULL.
int:

Interprets the integer value as pointer address and writes it to self._ptr. No ownership is transferred.
ctypes.c_void_p:

Takes the pointer address pyobj.value and writes it to self._ptr. No ownership is transferred.
object that implements the CUDA Array Interface protocol:

Takes the integer-valued pointer address, i.e. the first entry of the data tuple from pyobj’s member __cuda_array_interface__ and writes it to self._ptr.
object that implements the Python buffer protocol:

If the object represents a simple contiguous array, writes the Py_buffer associated with pyobj to self._py_buffer, sets the self._py_buffer_acquired flag to True, and writes self._py_buffer.buf to the data pointer self._ptr.
hip._util.types.Pointer:

Takes the pointer address pyobj._ptr and writes it to self._ptr. No ownership is transferred.

Type checks are performed in the above order.

C Attributes:

_ptr (C type void *, protected):: Stores a pointer to the data of the original Python object.
_is_ptr_owner (C type bint, protected):: If this wrapper is the owner of the underlying data.
_py_buffer (C type ``Py_buffer`, protected):: Stores a pointer to the data of the original Python object.
_py_buffer_acquired (C type bint, protected):: Stores a pointer to the data of the original Python object.

static PROPERTIES()#

__getitem__(key, /)#: Return self[key].

__init__()#

Constructor.

Args:

pyobj (object):: See the class description Pointer for information about accepted types for pyobj. Defaults to None.

Raises:

TypeError: If the input object pyobj is not of the right type.

as_c_void_p(self)#: Returns the data’s address as ctypes.c_void_p Note:

Implemented as function to not collide with autogenerated property names.

createRef(self) → Pointer#

Creates are reference to this pointer.

Returns a Pointer that stores the address of this `~.Pointer’s data pointer.

Note:: No ownership information is transferred.

static fromObj(pyobj)#

Creates a bsrsv2Info from a Python object.

Derives a bsrsv2Info from the given Python object pyobj. In case pyobj is itself an bsrsv2Info reference, this method returns it directly. No new bsrsv2Info is created in this case.

is_ptr_null#: If data pointer is NULL.

class hip.hipsparse.bsrsm2Info#

Bases: Pointer

Python wrapper for cdef class chipsparse.bsrsm2Info.

If this type is initialized via its __init__ method, it allocates a member of the underlying C type and destroys it again if the wrapper type is deallocated.

This type also serves as adapter when appearing as argument type in a function signature. In this case, the type can further be initialized from a number of Python objects:

None:

This will set the self._ptr attribute to NULL.
int:

Interprets the integer value as pointer address and writes it to self._ptr. No ownership is transferred.
ctypes.c_void_p:

Takes the pointer address pyobj.value and writes it to self._ptr. No ownership is transferred.
object that implements the CUDA Array Interface protocol:

Takes the integer-valued pointer address, i.e. the first entry of the data tuple from pyobj’s member __cuda_array_interface__ and writes it to self._ptr.
object that implements the Python buffer protocol:

If the object represents a simple contiguous array, writes the Py_buffer associated with pyobj to self._py_buffer, sets the self._py_buffer_acquired flag to True, and writes self._py_buffer.buf to the data pointer self._ptr.
hip._util.types.Pointer:

Takes the pointer address pyobj._ptr and writes it to self._ptr. No ownership is transferred.

Type checks are performed in the above order.

C Attributes:

_ptr (C type void *, protected):: Stores a pointer to the data of the original Python object.
_is_ptr_owner (C type bint, protected):: If this wrapper is the owner of the underlying data.
_py_buffer (C type ``Py_buffer`, protected):: Stores a pointer to the data of the original Python object.
_py_buffer_acquired (C type bint, protected):: Stores a pointer to the data of the original Python object.

static PROPERTIES()#

__getitem__(key, /)#: Return self[key].

__init__()#

Constructor.

Args:

pyobj (object):: See the class description Pointer for information about accepted types for pyobj. Defaults to None.

Raises:

TypeError: If the input object pyobj is not of the right type.

as_c_void_p(self)#: Returns the data’s address as ctypes.c_void_p Note:

Implemented as function to not collide with autogenerated property names.

createRef(self) → Pointer#

Creates are reference to this pointer.

Returns a Pointer that stores the address of this `~.Pointer’s data pointer.

Note:: No ownership information is transferred.

static fromObj(pyobj)#

Creates a bsrsm2Info from a Python object.

Derives a bsrsm2Info from the given Python object pyobj. In case pyobj is itself an bsrsm2Info reference, this method returns it directly. No new bsrsm2Info is created in this case.

is_ptr_null#: If data pointer is NULL.

class hip.hipsparse.bsrilu02Info#

Bases: Pointer

Python wrapper for cdef class chipsparse.bsrilu02Info.

If this type is initialized via its __init__ method, it allocates a member of the underlying C type and destroys it again if the wrapper type is deallocated.

This type also serves as adapter when appearing as argument type in a function signature. In this case, the type can further be initialized from a number of Python objects:

None:

This will set the self._ptr attribute to NULL.
int:

Interprets the integer value as pointer address and writes it to self._ptr. No ownership is transferred.
ctypes.c_void_p:

Takes the pointer address pyobj.value and writes it to self._ptr. No ownership is transferred.
object that implements the CUDA Array Interface protocol:

Takes the integer-valued pointer address, i.e. the first entry of the data tuple from pyobj’s member __cuda_array_interface__ and writes it to self._ptr.
object that implements the Python buffer protocol:

If the object represents a simple contiguous array, writes the Py_buffer associated with pyobj to self._py_buffer, sets the self._py_buffer_acquired flag to True, and writes self._py_buffer.buf to the data pointer self._ptr.
hip._util.types.Pointer:

Takes the pointer address pyobj._ptr and writes it to self._ptr. No ownership is transferred.

Type checks are performed in the above order.

C Attributes:

_ptr (C type void *, protected):: Stores a pointer to the data of the original Python object.
_is_ptr_owner (C type bint, protected):: If this wrapper is the owner of the underlying data.
_py_buffer (C type ``Py_buffer`, protected):: Stores a pointer to the data of the original Python object.
_py_buffer_acquired (C type bint, protected):: Stores a pointer to the data of the original Python object.

static PROPERTIES()#

__getitem__(key, /)#: Return self[key].

__init__()#

Constructor.

Args:

pyobj (object):: See the class description Pointer for information about accepted types for pyobj. Defaults to None.

Raises:

TypeError: If the input object pyobj is not of the right type.

as_c_void_p(self)#: Returns the data’s address as ctypes.c_void_p Note:

Implemented as function to not collide with autogenerated property names.

createRef(self) → Pointer#

Creates are reference to this pointer.

Returns a Pointer that stores the address of this `~.Pointer’s data pointer.

Note:: No ownership information is transferred.

static fromObj(pyobj)#

Creates a bsrilu02Info from a Python object.

Derives a bsrilu02Info from the given Python object pyobj. In case pyobj is itself an bsrilu02Info reference, this method returns it directly. No new bsrilu02Info is created in this case.

is_ptr_null#: If data pointer is NULL.

class hip.hipsparse.bsric02Info#

Bases: Pointer

Python wrapper for cdef class chipsparse.bsric02Info.

If this type is initialized via its __init__ method, it allocates a member of the underlying C type and destroys it again if the wrapper type is deallocated.

This type also serves as adapter when appearing as argument type in a function signature. In this case, the type can further be initialized from a number of Python objects:

None:

This will set the self._ptr attribute to NULL.
int:

Interprets the integer value as pointer address and writes it to self._ptr. No ownership is transferred.
ctypes.c_void_p:

Takes the pointer address pyobj.value and writes it to self._ptr. No ownership is transferred.
object that implements the CUDA Array Interface protocol:

Takes the integer-valued pointer address, i.e. the first entry of the data tuple from pyobj’s member __cuda_array_interface__ and writes it to self._ptr.
object that implements the Python buffer protocol:

If the object represents a simple contiguous array, writes the Py_buffer associated with pyobj to self._py_buffer, sets the self._py_buffer_acquired flag to True, and writes self._py_buffer.buf to the data pointer self._ptr.
hip._util.types.Pointer:

Takes the pointer address pyobj._ptr and writes it to self._ptr. No ownership is transferred.

Type checks are performed in the above order.

C Attributes:

_ptr (C type void *, protected):: Stores a pointer to the data of the original Python object.
_is_ptr_owner (C type bint, protected):: If this wrapper is the owner of the underlying data.
_py_buffer (C type ``Py_buffer`, protected):: Stores a pointer to the data of the original Python object.
_py_buffer_acquired (C type bint, protected):: Stores a pointer to the data of the original Python object.

static PROPERTIES()#

__getitem__(key, /)#: Return self[key].

__init__()#

Constructor.

Args:

pyobj (object):: See the class description Pointer for information about accepted types for pyobj. Defaults to None.

Raises:

TypeError: If the input object pyobj is not of the right type.

as_c_void_p(self)#: Returns the data’s address as ctypes.c_void_p Note:

Implemented as function to not collide with autogenerated property names.

createRef(self) → Pointer#

Creates are reference to this pointer.

Returns a Pointer that stores the address of this `~.Pointer’s data pointer.

Note:: No ownership information is transferred.

static fromObj(pyobj)#

Creates a bsric02Info from a Python object.

Derives a bsric02Info from the given Python object pyobj. In case pyobj is itself an bsric02Info reference, this method returns it directly. No new bsric02Info is created in this case.

is_ptr_null#: If data pointer is NULL.

class hip.hipsparse.csrsv2Info#

Bases: Pointer

Python wrapper for cdef class chipsparse.csrsv2Info.

If this type is initialized via its __init__ method, it allocates a member of the underlying C type and destroys it again if the wrapper type is deallocated.

This type also serves as adapter when appearing as argument type in a function signature. In this case, the type can further be initialized from a number of Python objects:

None:

This will set the self._ptr attribute to NULL.
int:

Interprets the integer value as pointer address and writes it to self._ptr. No ownership is transferred.
ctypes.c_void_p:

Takes the pointer address pyobj.value and writes it to self._ptr. No ownership is transferred.
object that implements the CUDA Array Interface protocol:

Takes the integer-valued pointer address, i.e. the first entry of the data tuple from pyobj’s member __cuda_array_interface__ and writes it to self._ptr.
object that implements the Python buffer protocol:

If the object represents a simple contiguous array, writes the Py_buffer associated with pyobj to self._py_buffer, sets the self._py_buffer_acquired flag to True, and writes self._py_buffer.buf to the data pointer self._ptr.
hip._util.types.Pointer:

Takes the pointer address pyobj._ptr and writes it to self._ptr. No ownership is transferred.

Type checks are performed in the above order.

C Attributes:

_ptr (C type void *, protected):: Stores a pointer to the data of the original Python object.
_is_ptr_owner (C type bint, protected):: If this wrapper is the owner of the underlying data.
_py_buffer (C type ``Py_buffer`, protected):: Stores a pointer to the data of the original Python object.
_py_buffer_acquired (C type bint, protected):: Stores a pointer to the data of the original Python object.

static PROPERTIES()#

__getitem__(key, /)#: Return self[key].

__init__()#

Constructor.

Args:

pyobj (object):: See the class description Pointer for information about accepted types for pyobj. Defaults to None.

Raises:

TypeError: If the input object pyobj is not of the right type.

as_c_void_p(self)#: Returns the data’s address as ctypes.c_void_p Note:

Implemented as function to not collide with autogenerated property names.

createRef(self) → Pointer#

Creates are reference to this pointer.

Returns a Pointer that stores the address of this `~.Pointer’s data pointer.

Note:: No ownership information is transferred.

static fromObj(pyobj)#

Creates a csrsv2Info from a Python object.

Derives a csrsv2Info from the given Python object pyobj. In case pyobj is itself an csrsv2Info reference, this method returns it directly. No new csrsv2Info is created in this case.

is_ptr_null#: If data pointer is NULL.

class hip.hipsparse.csrsm2Info#

Bases: Pointer

Python wrapper for cdef class chipsparse.csrsm2Info.

If this type is initialized via its __init__ method, it allocates a member of the underlying C type and destroys it again if the wrapper type is deallocated.

This type also serves as adapter when appearing as argument type in a function signature. In this case, the type can further be initialized from a number of Python objects:

None:

This will set the self._ptr attribute to NULL.
int:

Interprets the integer value as pointer address and writes it to self._ptr. No ownership is transferred.
ctypes.c_void_p:

Takes the pointer address pyobj.value and writes it to self._ptr. No ownership is transferred.
object that implements the CUDA Array Interface protocol:

Takes the integer-valued pointer address, i.e. the first entry of the data tuple from pyobj’s member __cuda_array_interface__ and writes it to self._ptr.
object that implements the Python buffer protocol:

If the object represents a simple contiguous array, writes the Py_buffer associated with pyobj to self._py_buffer, sets the self._py_buffer_acquired flag to True, and writes self._py_buffer.buf to the data pointer self._ptr.
hip._util.types.Pointer:

Takes the pointer address pyobj._ptr and writes it to self._ptr. No ownership is transferred.

Type checks are performed in the above order.

C Attributes:

_ptr (C type void *, protected):: Stores a pointer to the data of the original Python object.
_is_ptr_owner (C type bint, protected):: If this wrapper is the owner of the underlying data.
_py_buffer (C type ``Py_buffer`, protected):: Stores a pointer to the data of the original Python object.
_py_buffer_acquired (C type bint, protected):: Stores a pointer to the data of the original Python object.

static PROPERTIES()#

__getitem__(key, /)#: Return self[key].

__init__()#

Constructor.

Args:

pyobj (object):: See the class description Pointer for information about accepted types for pyobj. Defaults to None.

Raises:

TypeError: If the input object pyobj is not of the right type.

as_c_void_p(self)#: Returns the data’s address as ctypes.c_void_p Note:

Implemented as function to not collide with autogenerated property names.

createRef(self) → Pointer#

Creates are reference to this pointer.

Returns a Pointer that stores the address of this `~.Pointer’s data pointer.

Note:: No ownership information is transferred.

static fromObj(pyobj)#

Creates a csrsm2Info from a Python object.

Derives a csrsm2Info from the given Python object pyobj. In case pyobj is itself an csrsm2Info reference, this method returns it directly. No new csrsm2Info is created in this case.

is_ptr_null#: If data pointer is NULL.

class hip.hipsparse.csrilu02Info#

Bases: Pointer

Python wrapper for cdef class chipsparse.csrilu02Info.

If this type is initialized via its __init__ method, it allocates a member of the underlying C type and destroys it again if the wrapper type is deallocated.

This type also serves as adapter when appearing as argument type in a function signature. In this case, the type can further be initialized from a number of Python objects:

None:

This will set the self._ptr attribute to NULL.
int:

Interprets the integer value as pointer address and writes it to self._ptr. No ownership is transferred.
ctypes.c_void_p:

Takes the pointer address pyobj.value and writes it to self._ptr. No ownership is transferred.
object that implements the CUDA Array Interface protocol:

Takes the integer-valued pointer address, i.e. the first entry of the data tuple from pyobj’s member __cuda_array_interface__ and writes it to self._ptr.
object that implements the Python buffer protocol:

If the object represents a simple contiguous array, writes the Py_buffer associated with pyobj to self._py_buffer, sets the self._py_buffer_acquired flag to True, and writes self._py_buffer.buf to the data pointer self._ptr.
hip._util.types.Pointer:

Takes the pointer address pyobj._ptr and writes it to self._ptr. No ownership is transferred.

Type checks are performed in the above order.

C Attributes:

_ptr (C type void *, protected):: Stores a pointer to the data of the original Python object.
_is_ptr_owner (C type bint, protected):: If this wrapper is the owner of the underlying data.
_py_buffer (C type ``Py_buffer`, protected):: Stores a pointer to the data of the original Python object.
_py_buffer_acquired (C type bint, protected):: Stores a pointer to the data of the original Python object.

static PROPERTIES()#

__getitem__(key, /)#: Return self[key].

__init__()#

Constructor.

Args:

pyobj (object):: See the class description Pointer for information about accepted types for pyobj. Defaults to None.

Raises:

TypeError: If the input object pyobj is not of the right type.

as_c_void_p(self)#: Returns the data’s address as ctypes.c_void_p Note:

Implemented as function to not collide with autogenerated property names.

createRef(self) → Pointer#

Creates are reference to this pointer.

Returns a Pointer that stores the address of this `~.Pointer’s data pointer.

Note:: No ownership information is transferred.

static fromObj(pyobj)#

Creates a csrilu02Info from a Python object.

Derives a csrilu02Info from the given Python object pyobj. In case pyobj is itself an csrilu02Info reference, this method returns it directly. No new csrilu02Info is created in this case.

is_ptr_null#: If data pointer is NULL.

class hip.hipsparse.csric02Info#

Bases: Pointer

Python wrapper for cdef class chipsparse.csric02Info.

If this type is initialized via its __init__ method, it allocates a member of the underlying C type and destroys it again if the wrapper type is deallocated.

This type also serves as adapter when appearing as argument type in a function signature. In this case, the type can further be initialized from a number of Python objects:

None:

This will set the self._ptr attribute to NULL.
int:

Interprets the integer value as pointer address and writes it to self._ptr. No ownership is transferred.
ctypes.c_void_p:

Takes the pointer address pyobj.value and writes it to self._ptr. No ownership is transferred.
object that implements the CUDA Array Interface protocol:

Takes the integer-valued pointer address, i.e. the first entry of the data tuple from pyobj’s member __cuda_array_interface__ and writes it to self._ptr.
object that implements the Python buffer protocol:

If the object represents a simple contiguous array, writes the Py_buffer associated with pyobj to self._py_buffer, sets the self._py_buffer_acquired flag to True, and writes self._py_buffer.buf to the data pointer self._ptr.
hip._util.types.Pointer:

Takes the pointer address pyobj._ptr and writes it to self._ptr. No ownership is transferred.

Type checks are performed in the above order.

C Attributes:

_ptr (C type void *, protected):: Stores a pointer to the data of the original Python object.
_is_ptr_owner (C type bint, protected):: If this wrapper is the owner of the underlying data.
_py_buffer (C type ``Py_buffer`, protected):: Stores a pointer to the data of the original Python object.
_py_buffer_acquired (C type bint, protected):: Stores a pointer to the data of the original Python object.

static PROPERTIES()#

__getitem__(key, /)#: Return self[key].

__init__()#

Constructor.

Args:

pyobj (object):: See the class description Pointer for information about accepted types for pyobj. Defaults to None.

Raises:

TypeError: If the input object pyobj is not of the right type.

as_c_void_p(self)#: Returns the data’s address as ctypes.c_void_p Note:

Implemented as function to not collide with autogenerated property names.

createRef(self) → Pointer#

Creates are reference to this pointer.

Returns a Pointer that stores the address of this `~.Pointer’s data pointer.

Note:: No ownership information is transferred.

static fromObj(pyobj)#

Creates a csric02Info from a Python object.

Derives a csric02Info from the given Python object pyobj. In case pyobj is itself an csric02Info reference, this method returns it directly. No new csric02Info is created in this case.

is_ptr_null#: If data pointer is NULL.

class hip.hipsparse.csrgemm2Info#

Bases: Pointer

Python wrapper for cdef class chipsparse.csrgemm2Info.

If this type is initialized via its __init__ method, it allocates a member of the underlying C type and destroys it again if the wrapper type is deallocated.

This type also serves as adapter when appearing as argument type in a function signature. In this case, the type can further be initialized from a number of Python objects:

None:

This will set the self._ptr attribute to NULL.
int:

Interprets the integer value as pointer address and writes it to self._ptr. No ownership is transferred.
ctypes.c_void_p:

Takes the pointer address pyobj.value and writes it to self._ptr. No ownership is transferred.
object that implements the CUDA Array Interface protocol:

Takes the integer-valued pointer address, i.e. the first entry of the data tuple from pyobj’s member __cuda_array_interface__ and writes it to self._ptr.
object that implements the Python buffer protocol:

If the object represents a simple contiguous array, writes the Py_buffer associated with pyobj to self._py_buffer, sets the self._py_buffer_acquired flag to True, and writes self._py_buffer.buf to the data pointer self._ptr.
hip._util.types.Pointer:

Takes the pointer address pyobj._ptr and writes it to self._ptr. No ownership is transferred.

Type checks are performed in the above order.

C Attributes:

_ptr (C type void *, protected):: Stores a pointer to the data of the original Python object.
_is_ptr_owner (C type bint, protected):: If this wrapper is the owner of the underlying data.
_py_buffer (C type ``Py_buffer`, protected):: Stores a pointer to the data of the original Python object.
_py_buffer_acquired (C type bint, protected):: Stores a pointer to the data of the original Python object.

static PROPERTIES()#

__getitem__(key, /)#: Return self[key].

__init__()#

Constructor.

Args:

pyobj (object):: See the class description Pointer for information about accepted types for pyobj. Defaults to None.

Raises:

TypeError: If the input object pyobj is not of the right type.

as_c_void_p(self)#: Returns the data’s address as ctypes.c_void_p Note:

Implemented as function to not collide with autogenerated property names.

createRef(self) → Pointer#

Creates are reference to this pointer.

Returns a Pointer that stores the address of this `~.Pointer’s data pointer.

Note:: No ownership information is transferred.

static fromObj(pyobj)#

Creates a csrgemm2Info from a Python object.

Derives a csrgemm2Info from the given Python object pyobj. In case pyobj is itself an csrgemm2Info reference, this method returns it directly. No new csrgemm2Info is created in this case.

is_ptr_null#: If data pointer is NULL.

class hip.hipsparse.pruneInfo#

Bases: Pointer

Python wrapper for cdef class chipsparse.pruneInfo.

If this type is initialized via its __init__ method, it allocates a member of the underlying C type and destroys it again if the wrapper type is deallocated.

This type also serves as adapter when appearing as argument type in a function signature. In this case, the type can further be initialized from a number of Python objects:

None:

This will set the self._ptr attribute to NULL.
int:

Interprets the integer value as pointer address and writes it to self._ptr. No ownership is transferred.
ctypes.c_void_p:

Takes the pointer address pyobj.value and writes it to self._ptr. No ownership is transferred.
object that implements the CUDA Array Interface protocol:

Takes the integer-valued pointer address, i.e. the first entry of the data tuple from pyobj’s member __cuda_array_interface__ and writes it to self._ptr.
object that implements the Python buffer protocol:

If the object represents a simple contiguous array, writes the Py_buffer associated with pyobj to self._py_buffer, sets the self._py_buffer_acquired flag to True, and writes self._py_buffer.buf to the data pointer self._ptr.
hip._util.types.Pointer:

Takes the pointer address pyobj._ptr and writes it to self._ptr. No ownership is transferred.

Type checks are performed in the above order.

C Attributes:

_ptr (C type void *, protected):: Stores a pointer to the data of the original Python object.
_is_ptr_owner (C type bint, protected):: If this wrapper is the owner of the underlying data.
_py_buffer (C type ``Py_buffer`, protected):: Stores a pointer to the data of the original Python object.
_py_buffer_acquired (C type bint, protected):: Stores a pointer to the data of the original Python object.

static PROPERTIES()#

__getitem__(key, /)#: Return self[key].

__init__()#

Constructor.

Args:

pyobj (object):: See the class description Pointer for information about accepted types for pyobj. Defaults to None.

Raises:

TypeError: If the input object pyobj is not of the right type.

as_c_void_p(self)#: Returns the data’s address as ctypes.c_void_p Note:

Implemented as function to not collide with autogenerated property names.

createRef(self) → Pointer#

Creates are reference to this pointer.

Returns a Pointer that stores the address of this `~.Pointer’s data pointer.

Note:: No ownership information is transferred.

static fromObj(pyobj)#

Creates a pruneInfo from a Python object.

Derives a pruneInfo from the given Python object pyobj. In case pyobj is itself an pruneInfo reference, this method returns it directly. No new pruneInfo is created in this case.

is_ptr_null#: If data pointer is NULL.

class hip.hipsparse.csru2csrInfo#

Bases: Pointer

Python wrapper for cdef class chipsparse.csru2csrInfo.

If this type is initialized via its __init__ method, it allocates a member of the underlying C type and destroys it again if the wrapper type is deallocated.

This type also serves as adapter when appearing as argument type in a function signature. In this case, the type can further be initialized from a number of Python objects:

None:

This will set the self._ptr attribute to NULL.
int:

Interprets the integer value as pointer address and writes it to self._ptr. No ownership is transferred.
ctypes.c_void_p:

Takes the pointer address pyobj.value and writes it to self._ptr. No ownership is transferred.
object that implements the CUDA Array Interface protocol:

Takes the integer-valued pointer address, i.e. the first entry of the data tuple from pyobj’s member __cuda_array_interface__ and writes it to self._ptr.
object that implements the Python buffer protocol:

If the object represents a simple contiguous array, writes the Py_buffer associated with pyobj to self._py_buffer, sets the self._py_buffer_acquired flag to True, and writes self._py_buffer.buf to the data pointer self._ptr.
hip._util.types.Pointer:

Takes the pointer address pyobj._ptr and writes it to self._ptr. No ownership is transferred.

Type checks are performed in the above order.

C Attributes:

_ptr (C type void *, protected):: Stores a pointer to the data of the original Python object.
_is_ptr_owner (C type bint, protected):: If this wrapper is the owner of the underlying data.
_py_buffer (C type ``Py_buffer`, protected):: Stores a pointer to the data of the original Python object.
_py_buffer_acquired (C type bint, protected):: Stores a pointer to the data of the original Python object.

static PROPERTIES()#

__getitem__(key, /)#: Return self[key].

__init__()#

Constructor.

Args:

pyobj (object):: See the class description Pointer for information about accepted types for pyobj. Defaults to None.

Raises:

TypeError: If the input object pyobj is not of the right type.

as_c_void_p(self)#: Returns the data’s address as ctypes.c_void_p Note:

Implemented as function to not collide with autogenerated property names.

createRef(self) → Pointer#

Creates are reference to this pointer.

Returns a Pointer that stores the address of this `~.Pointer’s data pointer.

Note:: No ownership information is transferred.

static fromObj(pyobj)#

Creates a csru2csrInfo from a Python object.

Derives a csru2csrInfo from the given Python object pyobj. In case pyobj is itself an csru2csrInfo reference, this method returns it directly. No new csru2csrInfo is created in this case.

is_ptr_null#: If data pointer is NULL.

hip.hipsparse.bsrsv2Info_t#: alias of bsrsv2Info

hip.hipsparse.bsrsm2Info_t#: alias of bsrsm2Info

hip.hipsparse.bsrilu02Info_t#: alias of bsrilu02Info

hip.hipsparse.bsric02Info_t#: alias of bsric02Info

hip.hipsparse.csrsv2Info_t#: alias of csrsv2Info

hip.hipsparse.csrsm2Info_t#: alias of csrsm2Info

hip.hipsparse.csrilu02Info_t#: alias of csrilu02Info

hip.hipsparse.csric02Info_t#: alias of csric02Info

hip.hipsparse.csrgemm2Info_t#: alias of csrgemm2Info

hip.hipsparse.pruneInfo_t#: alias of pruneInfo

hip.hipsparse.csru2csrInfo_t#: alias of csru2csrInfo

class hip.hipsparse.hipsparseStatus_t(value)#

Bases: _hipsparseStatus_t__Base

Attributes:

HIPSPARSE_STATUS_SUCCESS:: Function succeeds
HIPSPARSE_STATUS_NOT_INITIALIZED:: hipSPARSE was not initialized
HIPSPARSE_STATUS_ALLOC_FAILED:: Resource allocation failed
HIPSPARSE_STATUS_INVALID_VALUE:: Unsupported value was passed to the function
HIPSPARSE_STATUS_ARCH_MISMATCH:: Device architecture not supported
HIPSPARSE_STATUS_MAPPING_ERROR:: Access to GPU memory space failed
HIPSPARSE_STATUS_EXECUTION_FAILED:: GPU program failed to execute
HIPSPARSE_STATUS_INTERNAL_ERROR:: An internal hipSPARSE operation failed
HIPSPARSE_STATUS_MATRIX_TYPE_NOT_SUPPORTED:: Matrix type not supported
HIPSPARSE_STATUS_ZERO_PIVOT:: Zero pivot was computed
HIPSPARSE_STATUS_NOT_SUPPORTED:: Operation is not supported
HIPSPARSE_STATUS_INSUFFICIENT_RESOURCES:: Resources are insufficient

conjugate()#: Returns self, the complex conjugate of any int.

bit_length()#

Number of bits necessary to represent self in binary.

>>> bin(37)
'0b100101'
>>> (37).bit_length()
6

bit_count()#

Number of ones in the binary representation of the absolute value of self.

Also known as the population count.

>>> bin(13)
'0b1101'
>>> (13).bit_count()
3

to_bytes(length, byteorder, *, signed=False)#

Return an array of bytes representing an integer.

length: Length of bytes object to use. An OverflowError is raised if the integer is not representable with the given number of bytes.
byteorder: The byte order used to represent the integer. If byteorder is ‘big’, the most significant byte is at the beginning of the byte array. If byteorder is ‘little’, the most significant byte is at the end of the byte array. To request the native byte order of the host system, use `sys.byteorder’ as the byte order value.
signed: Determines whether two’s complement is used to represent the integer. If signed is False and a negative integer is given, an OverflowError is raised.

from_bytes(byteorder, *, signed=False)#

Return the integer represented by the given array of bytes.

bytes: Holds the array of bytes to convert. The argument must either support the buffer protocol or be an iterable object producing bytes. Bytes and bytearray are examples of built-in objects that support the buffer protocol.
byteorder: The byte order used to represent the integer. If byteorder is ‘big’, the most significant byte is at the beginning of the byte array. If byteorder is ‘little’, the most significant byte is at the end of the byte array. To request the native byte order of the host system, use `sys.byteorder’ as the byte order value.
signed: Indicates whether two’s complement is used to represent the integer.

as_integer_ratio()#

Return integer ratio.

Return a pair of integers, whose ratio is exactly equal to the original int and with a positive denominator.

>>> (10).as_integer_ratio()
(10, 1)
>>> (-10).as_integer_ratio()
(-10, 1)
>>> (0).as_integer_ratio()
(0, 1)

real#: the real part of a complex number

imag#: the imaginary part of a complex number

numerator#: the numerator of a rational number in lowest terms

denominator#: the denominator of a rational number in lowest terms

static ctypes_type()#: The type of the enum constants as ctypes type.

HIPSPARSE_STATUS_SUCCESS = 0#

HIPSPARSE_STATUS_NOT_INITIALIZED = 1#

HIPSPARSE_STATUS_ALLOC_FAILED = 2#

HIPSPARSE_STATUS_INVALID_VALUE = 3#

HIPSPARSE_STATUS_ARCH_MISMATCH = 4#

HIPSPARSE_STATUS_MAPPING_ERROR = 5#

HIPSPARSE_STATUS_EXECUTION_FAILED = 6#

HIPSPARSE_STATUS_INTERNAL_ERROR = 7#

HIPSPARSE_STATUS_MATRIX_TYPE_NOT_SUPPORTED = 8#

HIPSPARSE_STATUS_ZERO_PIVOT = 9#

HIPSPARSE_STATUS_NOT_SUPPORTED = 10#

HIPSPARSE_STATUS_INSUFFICIENT_RESOURCES = 11#

class hip.hipsparse.hipsparsePointerMode_t(value)#

Bases: _hipsparsePointerMode_t__Base

Indicates if the pointer is device pointer or host pointer.

Attributes:

HIPSPARSE_POINTER_MODE_HOST:: Scalar pointers are in host memory
HIPSPARSE_POINTER_MODE_DEVICE:: Scalar pointers are in device memory

conjugate()#: Returns self, the complex conjugate of any int.

bit_length()#

Number of bits necessary to represent self in binary.

>>> bin(37)
'0b100101'
>>> (37).bit_length()
6

bit_count()#

Number of ones in the binary representation of the absolute value of self.

Also known as the population count.

>>> bin(13)
'0b1101'
>>> (13).bit_count()
3

to_bytes(length, byteorder, *, signed=False)#

Return an array of bytes representing an integer.

length: Length of bytes object to use. An OverflowError is raised if the integer is not representable with the given number of bytes.
byteorder: The byte order used to represent the integer. If byteorder is ‘big’, the most significant byte is at the beginning of the byte array. If byteorder is ‘little’, the most significant byte is at the end of the byte array. To request the native byte order of the host system, use `sys.byteorder’ as the byte order value.
signed: Determines whether two’s complement is used to represent the integer. If signed is False and a negative integer is given, an OverflowError is raised.

from_bytes(byteorder, *, signed=False)#

Return the integer represented by the given array of bytes.

bytes: Holds the array of bytes to convert. The argument must either support the buffer protocol or be an iterable object producing bytes. Bytes and bytearray are examples of built-in objects that support the buffer protocol.
byteorder: The byte order used to represent the integer. If byteorder is ‘big’, the most significant byte is at the beginning of the byte array. If byteorder is ‘little’, the most significant byte is at the end of the byte array. To request the native byte order of the host system, use `sys.byteorder’ as the byte order value.
signed: Indicates whether two’s complement is used to represent the integer.

as_integer_ratio()#

Return integer ratio.

Return a pair of integers, whose ratio is exactly equal to the original int and with a positive denominator.

>>> (10).as_integer_ratio()
(10, 1)
>>> (-10).as_integer_ratio()
(-10, 1)
>>> (0).as_integer_ratio()
(0, 1)

real#: the real part of a complex number

imag#: the imaginary part of a complex number

numerator#: the numerator of a rational number in lowest terms

denominator#: the denominator of a rational number in lowest terms

static ctypes_type()#: The type of the enum constants as ctypes type.

HIPSPARSE_POINTER_MODE_HOST = 0#

HIPSPARSE_POINTER_MODE_DEVICE = 1#

class hip.hipsparse.hipsparseAction_t(value)#

Bases: _hipsparseAction_t__Base

Specify where the operation is performed on.

Attributes:

HIPSPARSE_ACTION_SYMBOLIC:: Operate only on indices
HIPSPARSE_ACTION_NUMERIC:: Operate on data and indices

conjugate()#: Returns self, the complex conjugate of any int.

bit_length()#

Number of bits necessary to represent self in binary.

>>> bin(37)
'0b100101'
>>> (37).bit_length()
6

bit_count()#

Number of ones in the binary representation of the absolute value of self.

Also known as the population count.

>>> bin(13)
'0b1101'
>>> (13).bit_count()
3

to_bytes(length, byteorder, *, signed=False)#

Return an array of bytes representing an integer.

length: Length of bytes object to use. An OverflowError is raised if the integer is not representable with the given number of bytes.
byteorder: The byte order used to represent the integer. If byteorder is ‘big’, the most significant byte is at the beginning of the byte array. If byteorder is ‘little’, the most significant byte is at the end of the byte array. To request the native byte order of the host system, use `sys.byteorder’ as the byte order value.
signed: Determines whether two’s complement is used to represent the integer. If signed is False and a negative integer is given, an OverflowError is raised.

from_bytes(byteorder, *, signed=False)#

Return the integer represented by the given array of bytes.

bytes: Holds the array of bytes to convert. The argument must either support the buffer protocol or be an iterable object producing bytes. Bytes and bytearray are examples of built-in objects that support the buffer protocol.
byteorder: The byte order used to represent the integer. If byteorder is ‘big’, the most significant byte is at the beginning of the byte array. If byteorder is ‘little’, the most significant byte is at the end of the byte array. To request the native byte order of the host system, use `sys.byteorder’ as the byte order value.
signed: Indicates whether two’s complement is used to represent the integer.

as_integer_ratio()#

Return integer ratio.

Return a pair of integers, whose ratio is exactly equal to the original int and with a positive denominator.

>>> (10).as_integer_ratio()
(10, 1)
>>> (-10).as_integer_ratio()
(-10, 1)
>>> (0).as_integer_ratio()
(0, 1)

real#: the real part of a complex number

imag#: the imaginary part of a complex number

numerator#: the numerator of a rational number in lowest terms

denominator#: the denominator of a rational number in lowest terms

static ctypes_type()#: The type of the enum constants as ctypes type.

HIPSPARSE_ACTION_SYMBOLIC = 0#

HIPSPARSE_ACTION_NUMERIC = 1#

class hip.hipsparse.hipsparseMatrixType_t(value)#

Bases: _hipsparseMatrixType_t__Base

Specify the matrix type.

Attributes:

HIPSPARSE_MATRIX_TYPE_GENERAL:: General matrix type
HIPSPARSE_MATRIX_TYPE_SYMMETRIC:: Symmetric matrix type
HIPSPARSE_MATRIX_TYPE_HERMITIAN:: Hermitian matrix type
HIPSPARSE_MATRIX_TYPE_TRIANGULAR:: Triangular matrix type

conjugate()#: Returns self, the complex conjugate of any int.

bit_length()#

Number of bits necessary to represent self in binary.

>>> bin(37)
'0b100101'
>>> (37).bit_length()
6

bit_count()#

Number of ones in the binary representation of the absolute value of self.

Also known as the population count.

>>> bin(13)
'0b1101'
>>> (13).bit_count()
3

to_bytes(length, byteorder, *, signed=False)#

Return an array of bytes representing an integer.

length: Length of bytes object to use. An OverflowError is raised if the integer is not representable with the given number of bytes.
byteorder: The byte order used to represent the integer. If byteorder is ‘big’, the most significant byte is at the beginning of the byte array. If byteorder is ‘little’, the most significant byte is at the end of the byte array. To request the native byte order of the host system, use `sys.byteorder’ as the byte order value.
signed: Determines whether two’s complement is used to represent the integer. If signed is False and a negative integer is given, an OverflowError is raised.

from_bytes(byteorder, *, signed=False)#

Return the integer represented by the given array of bytes.

bytes: Holds the array of bytes to convert. The argument must either support the buffer protocol or be an iterable object producing bytes. Bytes and bytearray are examples of built-in objects that support the buffer protocol.
byteorder: The byte order used to represent the integer. If byteorder is ‘big’, the most significant byte is at the beginning of the byte array. If byteorder is ‘little’, the most significant byte is at the end of the byte array. To request the native byte order of the host system, use `sys.byteorder’ as the byte order value.
signed: Indicates whether two’s complement is used to represent the integer.

as_integer_ratio()#

Return integer ratio.

Return a pair of integers, whose ratio is exactly equal to the original int and with a positive denominator.

>>> (10).as_integer_ratio()
(10, 1)
>>> (-10).as_integer_ratio()
(-10, 1)
>>> (0).as_integer_ratio()
(0, 1)

real#: the real part of a complex number

imag#: the imaginary part of a complex number

numerator#: the numerator of a rational number in lowest terms

denominator#: the denominator of a rational number in lowest terms

static ctypes_type()#: The type of the enum constants as ctypes type.

HIPSPARSE_MATRIX_TYPE_GENERAL = 0#

HIPSPARSE_MATRIX_TYPE_SYMMETRIC = 1#

HIPSPARSE_MATRIX_TYPE_HERMITIAN = 2#

HIPSPARSE_MATRIX_TYPE_TRIANGULAR = 3#

class hip.hipsparse.hipsparseFillMode_t(value)#

Bases: _hipsparseFillMode_t__Base

Specify the matrix fill mode.

Attributes:

HIPSPARSE_FILL_MODE_LOWER:: Lower triangular part is stored
HIPSPARSE_FILL_MODE_UPPER:: Upper triangular part is stored

conjugate()#: Returns self, the complex conjugate of any int.

bit_length()#

Number of bits necessary to represent self in binary.

>>> bin(37)
'0b100101'
>>> (37).bit_length()
6

bit_count()#

Number of ones in the binary representation of the absolute value of self.

Also known as the population count.

>>> bin(13)
'0b1101'
>>> (13).bit_count()
3

to_bytes(length, byteorder, *, signed=False)#

Return an array of bytes representing an integer.

length: Length of bytes object to use. An OverflowError is raised if the integer is not representable with the given number of bytes.
byteorder: The byte order used to represent the integer. If byteorder is ‘big’, the most significant byte is at the beginning of the byte array. If byteorder is ‘little’, the most significant byte is at the end of the byte array. To request the native byte order of the host system, use `sys.byteorder’ as the byte order value.
signed: Determines whether two’s complement is used to represent the integer. If signed is False and a negative integer is given, an OverflowError is raised.

from_bytes(byteorder, *, signed=False)#

Return the integer represented by the given array of bytes.

bytes: Holds the array of bytes to convert. The argument must either support the buffer protocol or be an iterable object producing bytes. Bytes and bytearray are examples of built-in objects that support the buffer protocol.
byteorder: The byte order used to represent the integer. If byteorder is ‘big’, the most significant byte is at the beginning of the byte array. If byteorder is ‘little’, the most significant byte is at the end of the byte array. To request the native byte order of the host system, use `sys.byteorder’ as the byte order value.
signed: Indicates whether two’s complement is used to represent the integer.

as_integer_ratio()#

Return integer ratio.

Return a pair of integers, whose ratio is exactly equal to the original int and with a positive denominator.

>>> (10).as_integer_ratio()
(10, 1)
>>> (-10).as_integer_ratio()
(-10, 1)
>>> (0).as_integer_ratio()
(0, 1)

real#: the real part of a complex number

imag#: the imaginary part of a complex number

numerator#: the numerator of a rational number in lowest terms

denominator#: the denominator of a rational number in lowest terms

static ctypes_type()#: The type of the enum constants as ctypes type.

HIPSPARSE_FILL_MODE_LOWER = 0#

HIPSPARSE_FILL_MODE_UPPER = 1#

class hip.hipsparse.hipsparseDiagType_t(value)#

Bases: _hipsparseDiagType_t__Base

Indicates if the diagonal entries are unity.

Attributes:

HIPSPARSE_DIAG_TYPE_NON_UNIT:: Diagonal entries are non-unity
HIPSPARSE_DIAG_TYPE_UNIT:: Diagonal entries are unity

conjugate()#: Returns self, the complex conjugate of any int.

bit_length()#

Number of bits necessary to represent self in binary.

>>> bin(37)
'0b100101'
>>> (37).bit_length()
6

bit_count()#

Number of ones in the binary representation of the absolute value of self.

Also known as the population count.

>>> bin(13)
'0b1101'
>>> (13).bit_count()
3

to_bytes(length, byteorder, *, signed=False)#

Return an array of bytes representing an integer.

length: Length of bytes object to use. An OverflowError is raised if the integer is not representable with the given number of bytes.
byteorder: The byte order used to represent the integer. If byteorder is ‘big’, the most significant byte is at the beginning of the byte array. If byteorder is ‘little’, the most significant byte is at the end of the byte array. To request the native byte order of the host system, use `sys.byteorder’ as the byte order value.
signed: Determines whether two’s complement is used to represent the integer. If signed is False and a negative integer is given, an OverflowError is raised.

from_bytes(byteorder, *, signed=False)#

Return the integer represented by the given array of bytes.

bytes: Holds the array of bytes to convert. The argument must either support the buffer protocol or be an iterable object producing bytes. Bytes and bytearray are examples of built-in objects that support the buffer protocol.
byteorder: The byte order used to represent the integer. If byteorder is ‘big’, the most significant byte is at the beginning of the byte array. If byteorder is ‘little’, the most significant byte is at the end of the byte array. To request the native byte order of the host system, use `sys.byteorder’ as the byte order value.
signed: Indicates whether two’s complement is used to represent the integer.

as_integer_ratio()#

Return integer ratio.

Return a pair of integers, whose ratio is exactly equal to the original int and with a positive denominator.

>>> (10).as_integer_ratio()
(10, 1)
>>> (-10).as_integer_ratio()
(-10, 1)
>>> (0).as_integer_ratio()
(0, 1)

real#: the real part of a complex number

imag#: the imaginary part of a complex number

numerator#: the numerator of a rational number in lowest terms

denominator#: the denominator of a rational number in lowest terms

static ctypes_type()#: The type of the enum constants as ctypes type.

HIPSPARSE_DIAG_TYPE_NON_UNIT = 0#

HIPSPARSE_DIAG_TYPE_UNIT = 1#

class hip.hipsparse.hipsparseIndexBase_t(value)#

Bases: _hipsparseIndexBase_t__Base

Specify the matrix index base.

Attributes:

HIPSPARSE_INDEX_BASE_ZERO:: Zero based indexing
HIPSPARSE_INDEX_BASE_ONE:: One based indexing

conjugate()#: Returns self, the complex conjugate of any int.

bit_length()#

Number of bits necessary to represent self in binary.

>>> bin(37)
'0b100101'
>>> (37).bit_length()
6

bit_count()#

Number of ones in the binary representation of the absolute value of self.

Also known as the population count.

>>> bin(13)
'0b1101'
>>> (13).bit_count()
3

to_bytes(length, byteorder, *, signed=False)#

Return an array of bytes representing an integer.

length: Length of bytes object to use. An OverflowError is raised if the integer is not representable with the given number of bytes.
byteorder: The byte order used to represent the integer. If byteorder is ‘big’, the most significant byte is at the beginning of the byte array. If byteorder is ‘little’, the most significant byte is at the end of the byte array. To request the native byte order of the host system, use `sys.byteorder’ as the byte order value.
signed: Determines whether two’s complement is used to represent the integer. If signed is False and a negative integer is given, an OverflowError is raised.

from_bytes(byteorder, *, signed=False)#

Return the integer represented by the given array of bytes.

bytes: Holds the array of bytes to convert. The argument must either support the buffer protocol or be an iterable object producing bytes. Bytes and bytearray are examples of built-in objects that support the buffer protocol.
byteorder: The byte order used to represent the integer. If byteorder is ‘big’, the most significant byte is at the beginning of the byte array. If byteorder is ‘little’, the most significant byte is at the end of the byte array. To request the native byte order of the host system, use `sys.byteorder’ as the byte order value.
signed: Indicates whether two’s complement is used to represent the integer.

as_integer_ratio()#

Return integer ratio.

Return a pair of integers, whose ratio is exactly equal to the original int and with a positive denominator.

>>> (10).as_integer_ratio()
(10, 1)
>>> (-10).as_integer_ratio()
(-10, 1)
>>> (0).as_integer_ratio()
(0, 1)

real#: the real part of a complex number

imag#: the imaginary part of a complex number

numerator#: the numerator of a rational number in lowest terms

denominator#: the denominator of a rational number in lowest terms

static ctypes_type()#: The type of the enum constants as ctypes type.

HIPSPARSE_INDEX_BASE_ZERO = 0#

HIPSPARSE_INDEX_BASE_ONE = 1#

class hip.hipsparse.hipsparseOperation_t(value)#

Bases: _hipsparseOperation_t__Base

Specify whether the matrix is to be transposed or not.

Attributes:

HIPSPARSE_OPERATION_NON_TRANSPOSE:: Operate with matrix
HIPSPARSE_OPERATION_TRANSPOSE:: Operate with transpose
HIPSPARSE_OPERATION_CONJUGATE_TRANSPOSE:: Operate with conj. transpose

conjugate()#: Returns self, the complex conjugate of any int.

bit_length()#

Number of bits necessary to represent self in binary.

>>> bin(37)
'0b100101'
>>> (37).bit_length()
6

bit_count()#

Number of ones in the binary representation of the absolute value of self.

Also known as the population count.

>>> bin(13)
'0b1101'
>>> (13).bit_count()
3

to_bytes(length, byteorder, *, signed=False)#

Return an array of bytes representing an integer.

length: Length of bytes object to use. An OverflowError is raised if the integer is not representable with the given number of bytes.
byteorder: The byte order used to represent the integer. If byteorder is ‘big’, the most significant byte is at the beginning of the byte array. If byteorder is ‘little’, the most significant byte is at the end of the byte array. To request the native byte order of the host system, use `sys.byteorder’ as the byte order value.
signed: Determines whether two’s complement is used to represent the integer. If signed is False and a negative integer is given, an OverflowError is raised.

from_bytes(byteorder, *, signed=False)#

Return the integer represented by the given array of bytes.

bytes: Holds the array of bytes to convert. The argument must either support the buffer protocol or be an iterable object producing bytes. Bytes and bytearray are examples of built-in objects that support the buffer protocol.
byteorder: The byte order used to represent the integer. If byteorder is ‘big’, the most significant byte is at the beginning of the byte array. If byteorder is ‘little’, the most significant byte is at the end of the byte array. To request the native byte order of the host system, use `sys.byteorder’ as the byte order value.
signed: Indicates whether two’s complement is used to represent the integer.

as_integer_ratio()#

Return integer ratio.

Return a pair of integers, whose ratio is exactly equal to the original int and with a positive denominator.

>>> (10).as_integer_ratio()
(10, 1)
>>> (-10).as_integer_ratio()
(-10, 1)
>>> (0).as_integer_ratio()
(0, 1)

real#: the real part of a complex number

imag#: the imaginary part of a complex number

numerator#: the numerator of a rational number in lowest terms

denominator#: the denominator of a rational number in lowest terms

static ctypes_type()#: The type of the enum constants as ctypes type.

HIPSPARSE_OPERATION_NON_TRANSPOSE = 0#

HIPSPARSE_OPERATION_TRANSPOSE = 1#

HIPSPARSE_OPERATION_CONJUGATE_TRANSPOSE = 2#

class hip.hipsparse.hipsparseHybPartition_t(value)#

Bases: _hipsparseHybPartition_t__Base

HYB matrix partitioning type.

Attributes:

HIPSPARSE_HYB_PARTITION_AUTO:: Automatically decide on ELL nnz per row
HIPSPARSE_HYB_PARTITION_USER:: User given ELL nnz per row
HIPSPARSE_HYB_PARTITION_MAX:: Max ELL nnz per row, no COO part

conjugate()#: Returns self, the complex conjugate of any int.

bit_length()#

Number of bits necessary to represent self in binary.

>>> bin(37)
'0b100101'
>>> (37).bit_length()
6

bit_count()#

Number of ones in the binary representation of the absolute value of self.

Also known as the population count.

>>> bin(13)
'0b1101'
>>> (13).bit_count()
3

to_bytes(length, byteorder, *, signed=False)#

Return an array of bytes representing an integer.

length: Length of bytes object to use. An OverflowError is raised if the integer is not representable with the given number of bytes.
byteorder: The byte order used to represent the integer. If byteorder is ‘big’, the most significant byte is at the beginning of the byte array. If byteorder is ‘little’, the most significant byte is at the end of the byte array. To request the native byte order of the host system, use `sys.byteorder’ as the byte order value.
signed: Determines whether two’s complement is used to represent the integer. If signed is False and a negative integer is given, an OverflowError is raised.

from_bytes(byteorder, *, signed=False)#

Return the integer represented by the given array of bytes.

bytes: Holds the array of bytes to convert. The argument must either support the buffer protocol or be an iterable object producing bytes. Bytes and bytearray are examples of built-in objects that support the buffer protocol.
byteorder: The byte order used to represent the integer. If byteorder is ‘big’, the most significant byte is at the beginning of the byte array. If byteorder is ‘little’, the most significant byte is at the end of the byte array. To request the native byte order of the host system, use `sys.byteorder’ as the byte order value.
signed: Indicates whether two’s complement is used to represent the integer.

as_integer_ratio()#

Return integer ratio.

Return a pair of integers, whose ratio is exactly equal to the original int and with a positive denominator.

>>> (10).as_integer_ratio()
(10, 1)
>>> (-10).as_integer_ratio()
(-10, 1)
>>> (0).as_integer_ratio()
(0, 1)

real#: the real part of a complex number

imag#: the imaginary part of a complex number

numerator#: the numerator of a rational number in lowest terms

denominator#: the denominator of a rational number in lowest terms

static ctypes_type()#: The type of the enum constants as ctypes type.

HIPSPARSE_HYB_PARTITION_AUTO = 0#

HIPSPARSE_HYB_PARTITION_USER = 1#

HIPSPARSE_HYB_PARTITION_MAX = 2#

class hip.hipsparse.hipsparseSolvePolicy_t(value)#

Bases: _hipsparseSolvePolicy_t__Base

Specify policy in triangular solvers and factorizations.

Attributes:

HIPSPARSE_SOLVE_POLICY_NO_LEVEL:: No level information generated
HIPSPARSE_SOLVE_POLICY_USE_LEVEL:: Generate level information

conjugate()#: Returns self, the complex conjugate of any int.

bit_length()#

Number of bits necessary to represent self in binary.

>>> bin(37)
'0b100101'
>>> (37).bit_length()
6

bit_count()#

Number of ones in the binary representation of the absolute value of self.

Also known as the population count.

>>> bin(13)
'0b1101'
>>> (13).bit_count()
3

to_bytes(length, byteorder, *, signed=False)#

Return an array of bytes representing an integer.

length: Length of bytes object to use. An OverflowError is raised if the integer is not representable with the given number of bytes.
byteorder: The byte order used to represent the integer. If byteorder is ‘big’, the most significant byte is at the beginning of the byte array. If byteorder is ‘little’, the most significant byte is at the end of the byte array. To request the native byte order of the host system, use `sys.byteorder’ as the byte order value.
signed: Determines whether two’s complement is used to represent the integer. If signed is False and a negative integer is given, an OverflowError is raised.

from_bytes(byteorder, *, signed=False)#

Return the integer represented by the given array of bytes.

bytes: Holds the array of bytes to convert. The argument must either support the buffer protocol or be an iterable object producing bytes. Bytes and bytearray are examples of built-in objects that support the buffer protocol.
byteorder: The byte order used to represent the integer. If byteorder is ‘big’, the most significant byte is at the beginning of the byte array. If byteorder is ‘little’, the most significant byte is at the end of the byte array. To request the native byte order of the host system, use `sys.byteorder’ as the byte order value.
signed: Indicates whether two’s complement is used to represent the integer.

as_integer_ratio()#

Return integer ratio.

Return a pair of integers, whose ratio is exactly equal to the original int and with a positive denominator.

>>> (10).as_integer_ratio()
(10, 1)
>>> (-10).as_integer_ratio()
(-10, 1)
>>> (0).as_integer_ratio()
(0, 1)

real#: the real part of a complex number

imag#: the imaginary part of a complex number

numerator#: the numerator of a rational number in lowest terms

denominator#: the denominator of a rational number in lowest terms

static ctypes_type()#: The type of the enum constants as ctypes type.

HIPSPARSE_SOLVE_POLICY_NO_LEVEL = 0#

HIPSPARSE_SOLVE_POLICY_USE_LEVEL = 1#

class hip.hipsparse.hipsparseSideMode_t(value)#

Bases: _hipsparseSideMode_t__Base

Attributes:

HIPSPARSE_SIDE_LEFT:: (undocumented)
HIPSPARSE_SIDE_RIGHT:: (undocumented)

conjugate()#: Returns self, the complex conjugate of any int.

bit_length()#

Number of bits necessary to represent self in binary.

>>> bin(37)
'0b100101'
>>> (37).bit_length()
6

bit_count()#

Number of ones in the binary representation of the absolute value of self.

Also known as the population count.

>>> bin(13)
'0b1101'
>>> (13).bit_count()
3

to_bytes(length, byteorder, *, signed=False)#

Return an array of bytes representing an integer.

length: Length of bytes object to use. An OverflowError is raised if the integer is not representable with the given number of bytes.
byteorder: The byte order used to represent the integer. If byteorder is ‘big’, the most significant byte is at the beginning of the byte array. If byteorder is ‘little’, the most significant byte is at the end of the byte array. To request the native byte order of the host system, use `sys.byteorder’ as the byte order value.
signed: Determines whether two’s complement is used to represent the integer. If signed is False and a negative integer is given, an OverflowError is raised.

from_bytes(byteorder, *, signed=False)#

Return the integer represented by the given array of bytes.

bytes: Holds the array of bytes to convert. The argument must either support the buffer protocol or be an iterable object producing bytes. Bytes and bytearray are examples of built-in objects that support the buffer protocol.
byteorder: The byte order used to represent the integer. If byteorder is ‘big’, the most significant byte is at the beginning of the byte array. If byteorder is ‘little’, the most significant byte is at the end of the byte array. To request the native byte order of the host system, use `sys.byteorder’ as the byte order value.
signed: Indicates whether two’s complement is used to represent the integer.

as_integer_ratio()#

Return integer ratio.

Return a pair of integers, whose ratio is exactly equal to the original int and with a positive denominator.

>>> (10).as_integer_ratio()
(10, 1)
>>> (-10).as_integer_ratio()
(-10, 1)
>>> (0).as_integer_ratio()
(0, 1)

real#: the real part of a complex number

imag#: the imaginary part of a complex number

numerator#: the numerator of a rational number in lowest terms

denominator#: the denominator of a rational number in lowest terms

static ctypes_type()#: The type of the enum constants as ctypes type.

HIPSPARSE_SIDE_LEFT = 0#

HIPSPARSE_SIDE_RIGHT = 1#

class hip.hipsparse.hipsparseDirection_t(value)#

Bases: _hipsparseDirection_t__Base

Specify the matrix direction.

Attributes:

HIPSPARSE_DIRECTION_ROW:: Parse the matrix by rows
HIPSPARSE_DIRECTION_COLUMN:: Parse the matrix by columns

conjugate()#: Returns self, the complex conjugate of any int.

bit_length()#

Number of bits necessary to represent self in binary.

>>> bin(37)
'0b100101'
>>> (37).bit_length()
6

bit_count()#

Number of ones in the binary representation of the absolute value of self.

Also known as the population count.

>>> bin(13)
'0b1101'
>>> (13).bit_count()
3

to_bytes(length, byteorder, *, signed=False)#

Return an array of bytes representing an integer.

length: Length of bytes object to use. An OverflowError is raised if the integer is not representable with the given number of bytes.
byteorder: The byte order used to represent the integer. If byteorder is ‘big’, the most significant byte is at the beginning of the byte array. If byteorder is ‘little’, the most significant byte is at the end of the byte array. To request the native byte order of the host system, use `sys.byteorder’ as the byte order value.
signed: Determines whether two’s complement is used to represent the integer. If signed is False and a negative integer is given, an OverflowError is raised.

from_bytes(byteorder, *, signed=False)#

Return the integer represented by the given array of bytes.

bytes: Holds the array of bytes to convert. The argument must either support the buffer protocol or be an iterable object producing bytes. Bytes and bytearray are examples of built-in objects that support the buffer protocol.
byteorder: The byte order used to represent the integer. If byteorder is ‘big’, the most significant byte is at the beginning of the byte array. If byteorder is ‘little’, the most significant byte is at the end of the byte array. To request the native byte order of the host system, use `sys.byteorder’ as the byte order value.
signed: Indicates whether two’s complement is used to represent the integer.

as_integer_ratio()#

Return integer ratio.

Return a pair of integers, whose ratio is exactly equal to the original int and with a positive denominator.

>>> (10).as_integer_ratio()
(10, 1)
>>> (-10).as_integer_ratio()
(-10, 1)
>>> (0).as_integer_ratio()
(0, 1)

real#: the real part of a complex number

imag#: the imaginary part of a complex number

numerator#: the numerator of a rational number in lowest terms

denominator#: the denominator of a rational number in lowest terms

static ctypes_type()#: The type of the enum constants as ctypes type.

HIPSPARSE_DIRECTION_ROW = 0#

HIPSPARSE_DIRECTION_COLUMN = 1#

hip.hipsparse.hipsparseCreate()#

Create a hipsparse handle

hipsparseCreate creates the hipSPARSE library context. It must be initialized before any other hipSPARSE API function is invoked and must be passed to all subsequent library function calls. The handle should be destroyed at the end using hipsparseDestroy().

Returns:

A tuple of size 1 that contains (in that order):

handle (Pointer/object):
(undocumented)

hip.hipsparse.hipsparseDestroy(handle)#

Destroy a hipsparse handle

hipsparseDestroy destroys the hipSPARSE library context and releases all resources used by the hipSPARSE library.

Args:

handle (Pointer/object):: (undocumented)

hip.hipsparse.hipsparseGetErrorName(status)#

Return the string representation of a hipSPARSE status’s matching backend status enum name

hipsparseGetErrorName takes a hipSPARSE status as input and first converts it to the matching backend status (either rocsparse_status or cusparseStatus_t). It then returns the string representation of this status enum name. If the status is not recognized, the function returns “Unrecognized status code”.

For example, hipsparseGetErrorName(HIPSPARSE_STATUS_SUCCESS) on a system with a rocSPARSE backend will return “rocsparse_status_success”. On a system with a cuSPARSE backend this function would return “CUSPARSE_STATUS_SUCCESS”.

Args:

status (hipsparseStatus_t):: (undocumented)

hip.hipsparse.hipsparseGetErrorString(status)#

Return the hipSPARSE status’s matching backend status description as a string

hipsparseGetErrorString takes a hipSPARSE status as input and first converts it to the matching backend status (either rocsparse_status or cusparseStatus_t). It then returns the string description of this status. If the status is not recognized, the function returns “Unrecognized status code”.

Args:

status (hipsparseStatus_t):: (undocumented)

hip.hipsparse.hipsparseGetVersion(handle, version)#

Get hipSPARSE version

hipsparseGetVersion gets the hipSPARSE library version number. - patch = version % 100 - minor = version / 100 % 1000 - major = version / 100000

Args:

handle (Pointer/object):: (undocumented)
version (Pointer/object):: (undocumented)

hip.hipsparse.hipsparseGetGitRevision(handle, rev)#

Get hipSPARSE git revision

hipsparseGetGitRevision gets the hipSPARSE library git commit revision (SHA-1).

Args:

handle (Pointer/object):: (undocumented)
rev (Pointer/object):: (undocumented)

hip.hipsparse.hipsparseSetStream(handle, streamId)#

Specify user defined HIP stream

hipsparseSetStream specifies the stream to be used by the hipSPARSE library context and all subsequent function calls.

Args:

handle (Pointer/object):: (undocumented)
streamId (ihipStream_t/object):: (undocumented)

hip.hipsparse.hipsparseGetStream(handle)#

Get current stream from library context

hipsparseGetStream gets the hipSPARSE library context stream which is currently used for all subsequent function calls.

Args:

handle (Pointer/object):: (undocumented)

Returns:

A tuple of size 1 that contains (in that order):

streamId (ihipStream_t):
(undocumented)

hip.hipsparse.hipsparseSetPointerMode(handle, mode)#

Specify pointer mode

hipsparseSetPointerMode specifies the pointer mode to be used by the hipSPARSE library context and all subsequent function calls. By default, all values are passed by reference on the host. Valid pointer modes are HIPSPARSE_POINTER_MODE_HOST or HIPSPARSE_POINTER_MODE_DEVICE .

Args:

handle (Pointer/object):: (undocumented)
mode (hipsparsePointerMode_t):: (undocumented)

hip.hipsparse.hipsparseGetPointerMode(handle, mode)#

Get current pointer mode from library context

hipsparseGetPointerMode gets the hipSPARSE library context pointer mode which is currently used for all subsequent function calls.

Args:

handle (Pointer/object):: (undocumented)
mode (Pointer/object):: (undocumented)

hip.hipsparse.hipsparseCreateMatDescr(descrA)#

Create a matrix descriptor

hipsparseCreateMatDescr creates a matrix descriptor. It initializes hipsparseMatrixType_t to HIPSPARSE_MATRIX_TYPE_GENERAL and hipsparseIndexBase_t to HIPSPARSE_INDEX_BASE_ZERO . It should be destroyed at the end using hipsparseDestroyMatDescr().

Args:

descrA (Pointer/object):: (undocumented)

hip.hipsparse.hipsparseDestroyMatDescr(descrA)#

Destroy a matrix descriptor

hipsparseDestroyMatDescr destroys a matrix descriptor and releases all resources used by the descriptor.

Args:

descrA (Pointer/object):: (undocumented)

hip.hipsparse.hipsparseCopyMatDescr(dest, src)#

Copy a matrix descriptor

hipsparseCopyMatDescr copies a matrix descriptor. Both, source and destination matrix descriptors must be initialized prior to calling hipsparseCopyMatDescr.

Args:

dest (Pointer/object):: (undocumented)
src (Pointer/object):: (undocumented)

hip.hipsparse.hipsparseSetMatType(descrA, type)#

Specify the matrix type of a matrix descriptor

hipsparseSetMatType sets the matrix type of a matrix descriptor. Valid matrix types are HIPSPARSE_MATRIX_TYPE_GENERAL , HIPSPARSE_MATRIX_TYPE_SYMMETRIC , HIPSPARSE_MATRIX_TYPE_HERMITIAN or HIPSPARSE_MATRIX_TYPE_TRIANGULAR .

Args:

descrA (Pointer/object):: (undocumented)
type (hipsparseMatrixType_t):: (undocumented)

hip.hipsparse.hipsparseGetMatType(descrA)#

Get the matrix type of a matrix descriptor

hipsparseGetMatType returns the matrix type of a matrix descriptor.

Args:

descrA (Pointer/object):: (undocumented)

hip.hipsparse.hipsparseSetMatFillMode(descrA, fillMode)#

Specify the matrix fill mode of a matrix descriptor

hipsparseSetMatFillMode sets the matrix fill mode of a matrix descriptor. Valid fill modes are HIPSPARSE_FILL_MODE_LOWER or HIPSPARSE_FILL_MODE_UPPER .

Args:

descrA (Pointer/object):: (undocumented)
fillMode (hipsparseFillMode_t):: (undocumented)

hip.hipsparse.hipsparseGetMatFillMode(descrA)#

Get the matrix fill mode of a matrix descriptor

hipsparseGetMatFillMode returns the matrix fill mode of a matrix descriptor.

Args:

descrA (Pointer/object):: (undocumented)

hip.hipsparse.hipsparseSetMatDiagType(descrA, diagType)#

Specify the matrix diagonal type of a matrix descriptor

hipsparseSetMatDiagType sets the matrix diagonal type of a matrix descriptor. Valid diagonal types are HIPSPARSE_DIAG_TYPE_UNIT or HIPSPARSE_DIAG_TYPE_NON_UNIT .

Args:

descrA (Pointer/object):: (undocumented)
diagType (hipsparseDiagType_t):: (undocumented)

hip.hipsparse.hipsparseGetMatDiagType(descrA)#

Get the matrix diagonal type of a matrix descriptor

hipsparseGetMatDiagType returns the matrix diagonal type of a matrix descriptor.

Args:

descrA (Pointer/object):: (undocumented)

hip.hipsparse.hipsparseSetMatIndexBase(descrA, base)#

Specify the index base of a matrix descriptor

hipsparseSetMatIndexBase sets the index base of a matrix descriptor. Valid options are HIPSPARSE_INDEX_BASE_ZERO or HIPSPARSE_INDEX_BASE_ONE .

Args:

descrA (Pointer/object):: (undocumented)
base (hipsparseIndexBase_t):: (undocumented)

hip.hipsparse.hipsparseGetMatIndexBase(descrA)#

Get the index base of a matrix descriptor

hipsparseGetMatIndexBase returns the index base of a matrix descriptor.

Args:

descrA (Pointer/object):: (undocumented)

hip.hipsparse.hipsparseCreateHybMat(hybA)#

Create a HYB matrix structure

hipsparseCreateHybMat creates a structure that holds the matrix in HYB storage format. It should be destroyed at the end using hipsparseDestroyHybMat().

Args:

hybA (Pointer/object):: (undocumented)

hip.hipsparse.hipsparseDestroyHybMat(hybA)#

Destroy a HYB matrix structure

hipsparseDestroyHybMat destroys a HYB structure.

Args:

hybA (Pointer/object):: (undocumented)

hip.hipsparse.hipsparseCreateBsrsv2Info()#

Create a bsrsv2 info structure

hipsparseCreateBsrsv2Info creates a structure that holds the bsrsv2 info data that is gathered during the analysis routines available. It should be destroyed at the end using hipsparseDestroyBsrsv2Info().

Returns:

A tuple of size 1 that contains (in that order):

info (bsrsv2Info):
(undocumented)

hip.hipsparse.hipsparseDestroyBsrsv2Info(info)#

Destroy a bsrsv2 info structure

hipsparseDestroyBsrsv2Info destroys a bsrsv2 info structure.

Args:

info (bsrsv2Info/object):: (undocumented)

hip.hipsparse.hipsparseCreateBsrsm2Info()#

Create a bsrsm2 info structure

hipsparseCreateBsrsm2Info creates a structure that holds the bsrsm2 info data that is gathered during the analysis routines available. It should be destroyed at the end using hipsparseDestroyBsrsm2Info().

Returns:

A tuple of size 1 that contains (in that order):

info (bsrsm2Info):
(undocumented)

hip.hipsparse.hipsparseDestroyBsrsm2Info(info)#

Destroy a bsrsm2 info structure

hipsparseDestroyBsrsm2Info destroys a bsrsm2 info structure.

Args:

info (bsrsm2Info/object):: (undocumented)

hip.hipsparse.hipsparseCreateBsrilu02Info()#

Create a bsrilu02 info structure

hipsparseCreateBsrilu02Info creates a structure that holds the bsrilu02 info data that is gathered during the analysis routines available. It should be destroyed at the end using hipsparseDestroyBsrilu02Info().

Returns:

A tuple of size 1 that contains (in that order):

info (bsrilu02Info):
(undocumented)

hip.hipsparse.hipsparseDestroyBsrilu02Info(info)#

Destroy a bsrilu02 info structure

hipsparseDestroyBsrilu02Info destroys a bsrilu02 info structure.

Args:

info (bsrilu02Info/object):: (undocumented)

hip.hipsparse.hipsparseCreateBsric02Info()#

Create a bsric02 info structure

hipsparseCreateBsric02Info creates a structure that holds the bsric02 info data that is gathered during the analysis routines available. It should be destroyed at the end using hipsparseDestroyBsric02Info().

Returns:

A tuple of size 1 that contains (in that order):

info (bsric02Info):
(undocumented)

hip.hipsparse.hipsparseDestroyBsric02Info(info)#

Destroy a bsric02 info structure

hipsparseDestroyBsric02Info destroys a bsric02 info structure.

Args:

info (bsric02Info/object):: (undocumented)

hip.hipsparse.hipsparseCreateCsrsv2Info()#

Create a csrsv2 info structure

hipsparseCreateCsrsv2Info creates a structure that holds the csrsv2 info data that is gathered during the analysis routines available. It should be destroyed at the end using hipsparseDestroyCsrsv2Info().

Returns:

A tuple of size 1 that contains (in that order):

info (csrsv2Info):
(undocumented)

hip.hipsparse.hipsparseDestroyCsrsv2Info(info)#

Destroy a csrsv2 info structure

hipsparseDestroyCsrsv2Info destroys a csrsv2 info structure.

Args:

info (csrsv2Info/object):: (undocumented)

hip.hipsparse.hipsparseCreateCsrsm2Info()#

Create a csrsm2 info structure

hipsparseCreateCsrsm2Info creates a structure that holds the csrsm2 info data that is gathered during the analysis routines available. It should be destroyed at the end using hipsparseDestroyCsrsm2Info().

Returns:

A tuple of size 1 that contains (in that order):

info (csrsm2Info):
(undocumented)

hip.hipsparse.hipsparseDestroyCsrsm2Info(info)#

Destroy a csrsm2 info structure

hipsparseDestroyCsrsm2Info destroys a csrsm2 info structure.

Args:

info (csrsm2Info/object):: (undocumented)

hip.hipsparse.hipsparseCreateCsrilu02Info()#

Create a csrilu02 info structure

hipsparseCreateCsrilu02Info creates a structure that holds the csrilu02 info data that is gathered during the analysis routines available. It should be destroyed at the end using hipsparseDestroyCsrilu02Info().

Returns:

A tuple of size 1 that contains (in that order):

info (csrilu02Info):
(undocumented)

hip.hipsparse.hipsparseDestroyCsrilu02Info(info)#

Destroy a csrilu02 info structure

hipsparseDestroyCsrilu02Info destroys a csrilu02 info structure.

Args:

info (csrilu02Info/object):: (undocumented)

hip.hipsparse.hipsparseCreateCsric02Info()#

Create a csric02 info structure

hipsparseCreateCsric02Info creates a structure that holds the csric02 info data that is gathered during the analysis routines available. It should be destroyed at the end using hipsparseDestroyCsric02Info().

Returns:

A tuple of size 1 that contains (in that order):

info (csric02Info):
(undocumented)

hip.hipsparse.hipsparseDestroyCsric02Info(info)#

Destroy a csric02 info structure

hipsparseDestroyCsric02Info destroys a csric02 info structure.

Args:

info (csric02Info/object):: (undocumented)

hip.hipsparse.hipsparseCreateCsru2csrInfo()#

Create a csru2csr info structure

hipsparseCreateCsru2csrInfo creates a structure that holds the csru2csr info data that is gathered during the analysis routines available. It should be destroyed at the end using hipsparseDestroyCsru2csrInfo().

Returns:

A tuple of size 1 that contains (in that order):

info (csru2csrInfo):
(undocumented)

hip.hipsparse.hipsparseDestroyCsru2csrInfo(info)#

Destroy a csru2csr info structure

hipsparseDestroyCsru2csrInfo destroys a csru2csr info structure.

Args:

info (csru2csrInfo/object):: (undocumented)

hip.hipsparse.hipsparseCreateColorInfo(info)#

Create a color info structure

hipsparseCreateColorInfo creates a structure that holds the color info data that is gathered during the analysis routines available. It should be destroyed at the end using hipsparseDestroyColorInfo().

Args:

info (Pointer/object):: (undocumented)

hip.hipsparse.hipsparseDestroyColorInfo(info)#

Destroy a color info structure

hipsparseDestroyColorInfo destroys a color info structure.

Args:

info (Pointer/object):: (undocumented)

hip.hipsparse.hipsparseCreateCsrgemm2Info()#

Create a csrgemm2 info structure

hipsparseCreateCsrgemm2Info creates a structure that holds the csrgemm2 info data that is gathered during the analysis routines available. It should be destroyed at the end using hipsparseDestroyCsrgemm2Info().

Returns:

A tuple of size 1 that contains (in that order):

info (csrgemm2Info):
(undocumented)

hip.hipsparse.hipsparseDestroyCsrgemm2Info(info)#

Destroy a csrgemm2 info structure

hipsparseDestroyCsrgemm2Info destroys a csrgemm2 info structure.

Args:

info (csrgemm2Info/object):: (undocumented)

hip.hipsparse.hipsparseCreatePruneInfo()#

Create a prune info structure

hipsparseCreatePruneInfo creates a structure that holds the prune info data that is gathered during the analysis routines available. It should be destroyed at the end using hipsparseDestroyPruneInfo().

Returns:

A tuple of size 1 that contains (in that order):

info (pruneInfo):
(undocumented)

hip.hipsparse.hipsparseDestroyPruneInfo(info)#

Destroy a prune info structure

hipsparseDestroyPruneInfo destroys a prune info structure.

Args:

info (pruneInfo/object):: (undocumented)

hip.hipsparse.hipsparseSaxpyi(handle, int nnz, alpha, xVal, xInd, y, idxBase)#

Scale a sparse vector and add it to a dense vector.

hipsparseXaxpyi multiplies the sparse vector \(x\) with scalar \(\alpha\) and adds the result to the dense vector \(y\), such that

\[y := y + \alpha \cdot x\]

for(i = 0; i < nnz; ++i)
{
    y[x_ind[i]] = y[x_ind[i]] + alpha * x_val[i];
}

Note:

This function is non blocking and executed asynchronously with respect to the host. It may return before the actual computation has finished.

Args:

handle (Pointer/object):: (undocumented)
nnz (int):: (undocumented)
alpha (Pointer/object):: (undocumented)
xVal (Pointer/object):: (undocumented)
xInd (Pointer/object):: (undocumented)
y (Pointer/object):: (undocumented)
idxBase (hipsparseIndexBase_t):: (undocumented)

hip.hipsparse.hipsparseDaxpyi(handle, int nnz, alpha, xVal, xInd, y, idxBase)#

(No short description, might be part of a group.)

Args:

handle (Pointer/object):: (undocumented)
nnz (int):: (undocumented)
alpha (Pointer/object):: (undocumented)
xVal (Pointer/object):: (undocumented)
xInd (Pointer/object):: (undocumented)
y (Pointer/object):: (undocumented)
idxBase (hipsparseIndexBase_t):: (undocumented)

hip.hipsparse.hipsparseCaxpyi(handle, int nnz, alpha, xVal, xInd, y, idxBase)#

(No short description, might be part of a group.)

Args:

handle (Pointer/object):: (undocumented)
nnz (int):: (undocumented)
alpha (float2/object):: (undocumented)
xVal (float2/object):: (undocumented)
xInd (Pointer/object):: (undocumented)
y (float2/object):: (undocumented)
idxBase (hipsparseIndexBase_t):: (undocumented)

hip.hipsparse.hipsparseZaxpyi(handle, int nnz, alpha, xVal, xInd, y, idxBase)#

(No short description, might be part of a group.)

Args:

handle (Pointer/object):: (undocumented)
nnz (int):: (undocumented)
alpha (double2/object):: (undocumented)
xVal (double2/object):: (undocumented)
xInd (Pointer/object):: (undocumented)
y (double2/object):: (undocumented)
idxBase (hipsparseIndexBase_t):: (undocumented)

hip.hipsparse.hipsparseSdoti(handle, int nnz, xVal, xInd, y, result, idxBase)#

Compute the dot product of a sparse vector with a dense vector.

hipsparseXdoti computes the dot product of the sparse vector \(x\) with the dense vector \(y\), such that

\[\text{result} := y^T x\]

for(i = 0; i < nnz; ++i)
{
    result += x_val[i] * y[x_ind[i]];
}

Note:

This function is non blocking and executed asynchronously with respect to the host. It may return before the actual computation has finished.

Args:

handle (Pointer/object):: (undocumented)
nnz (int):: (undocumented)
xVal (Pointer/object):: (undocumented)
xInd (Pointer/object):: (undocumented)
y (Pointer/object):: (undocumented)
result (Pointer/object):: (undocumented)
idxBase (hipsparseIndexBase_t):: (undocumented)

hip.hipsparse.hipsparseDdoti(handle, int nnz, xVal, xInd, y, result, idxBase)#

(No short description, might be part of a group.)

Args:

handle (Pointer/object):: (undocumented)
nnz (int):: (undocumented)
xVal (Pointer/object):: (undocumented)
xInd (Pointer/object):: (undocumented)
y (Pointer/object):: (undocumented)
result (Pointer/object):: (undocumented)
idxBase (hipsparseIndexBase_t):: (undocumented)

hip.hipsparse.hipsparseCdoti(handle, int nnz, xVal, xInd, y, result, idxBase)#

(No short description, might be part of a group.)

Args:

handle (Pointer/object):: (undocumented)
nnz (int):: (undocumented)
xVal (float2/object):: (undocumented)
xInd (Pointer/object):: (undocumented)
y (float2/object):: (undocumented)
result (float2/object):: (undocumented)
idxBase (hipsparseIndexBase_t):: (undocumented)

hip.hipsparse.hipsparseZdoti(handle, int nnz, xVal, xInd, y, result, idxBase)#

(No short description, might be part of a group.)

Args:

handle (Pointer/object):: (undocumented)
nnz (int):: (undocumented)
xVal (double2/object):: (undocumented)
xInd (Pointer/object):: (undocumented)
y (double2/object):: (undocumented)
result (double2/object):: (undocumented)
idxBase (hipsparseIndexBase_t):: (undocumented)

hip.hipsparse.hipsparseCdotci(handle, int nnz, xVal, xInd, y, result, idxBase)#

Compute the dot product of a complex conjugate sparse vector with a dense vector.

hipsparseXdotci computes the dot product of the complex conjugate sparse vector \(x\) with the dense vector \(y\), such that

\[\text{result} := \bar{x}^H y\]

for(i = 0; i < nnz; ++i)
{
    result += conj(x_val[i]) * y[x_ind[i]];
}

Note:

This function is non blocking and executed asynchronously with respect to the host. It may return before the actual computation has finished.

Args:

handle (Pointer/object):: (undocumented)
nnz (int):: (undocumented)
xVal (float2/object):: (undocumented)
xInd (Pointer/object):: (undocumented)
y (float2/object):: (undocumented)
result (float2/object):: (undocumented)
idxBase (hipsparseIndexBase_t):: (undocumented)

hip.hipsparse.hipsparseZdotci(handle, int nnz, xVal, xInd, y, result, idxBase)#

(No short description, might be part of a group.)

Args:

handle (Pointer/object):: (undocumented)
nnz (int):: (undocumented)
xVal (double2/object):: (undocumented)
xInd (Pointer/object):: (undocumented)
y (double2/object):: (undocumented)
result (double2/object):: (undocumented)
idxBase (hipsparseIndexBase_t):: (undocumented)

hip.hipsparse.hipsparseSgthr(handle, int nnz, y, xVal, xInd, idxBase)#

Gather elements from a dense vector and store them into a sparse vector.

hipsparseXgthr gathers the elements that are listed in x_ind from the dense vector \(y\) and stores them in the sparse vector \(x\).

for(i = 0; i < nnz; ++i)
{
    x_val[i] = y[x_ind[i]];
}

Note:

This function is non blocking and executed asynchronously with respect to the host. It may return before the actual computation has finished.

Args:

handle (Pointer/object):: (undocumented)
nnz (int):: (undocumented)
y (Pointer/object):: (undocumented)
xVal (Pointer/object):: (undocumented)
xInd (Pointer/object):: (undocumented)
idxBase (hipsparseIndexBase_t):: (undocumented)

hip.hipsparse.hipsparseDgthr(handle, int nnz, y, xVal, xInd, idxBase)#

(No short description, might be part of a group.)

Args:

handle (Pointer/object):: (undocumented)
nnz (int):: (undocumented)
y (Pointer/object):: (undocumented)
xVal (Pointer/object):: (undocumented)
xInd (Pointer/object):: (undocumented)
idxBase (hipsparseIndexBase_t):: (undocumented)

hip.hipsparse.hipsparseCgthr(handle, int nnz, y, xVal, xInd, idxBase)#

(No short description, might be part of a group.)

Args:

handle (Pointer/object):: (undocumented)
nnz (int):: (undocumented)
y (float2/object):: (undocumented)
xVal (float2/object):: (undocumented)
xInd (Pointer/object):: (undocumented)
idxBase (hipsparseIndexBase_t):: (undocumented)

hip.hipsparse.hipsparseZgthr(handle, int nnz, y, xVal, xInd, idxBase)#

(No short description, might be part of a group.)

Args:

handle (Pointer/object):: (undocumented)
nnz (int):: (undocumented)
y (double2/object):: (undocumented)
xVal (double2/object):: (undocumented)
xInd (Pointer/object):: (undocumented)
idxBase (hipsparseIndexBase_t):: (undocumented)

hip.hipsparse.hipsparseSgthrz(handle, int nnz, y, xVal, xInd, idxBase)#

Gather and zero out elements from a dense vector and store them into a sparse vector.

hipsparseXgthrz gathers the elements that are listed in x_ind from the dense vector \(y\) and stores them in the sparse vector \(x\). The gathered elements in \(y\) are replaced by zero.

for(i = 0; i < nnz; ++i)
{
    x_val[i]    = y[x_ind[i]];
    y[x_ind[i]] = 0;
}

Note:

This function is non blocking and executed asynchronously with respect to the host. It may return before the actual computation has finished.

Args:

handle (Pointer/object):: (undocumented)
nnz (int):: (undocumented)
y (Pointer/object):: (undocumented)
xVal (Pointer/object):: (undocumented)
xInd (Pointer/object):: (undocumented)
idxBase (hipsparseIndexBase_t):: (undocumented)

hip.hipsparse.hipsparseDgthrz(handle, int nnz, y, xVal, xInd, idxBase)#

(No short description, might be part of a group.)

Args:

handle (Pointer/object):: (undocumented)
nnz (int):: (undocumented)
y (Pointer/object):: (undocumented)
xVal (Pointer/object):: (undocumented)
xInd (Pointer/object):: (undocumented)
idxBase (hipsparseIndexBase_t):: (undocumented)

hip.hipsparse.hipsparseCgthrz(handle, int nnz, y, xVal, xInd, idxBase)#

(No short description, might be part of a group.)

Args:

handle (Pointer/object):: (undocumented)
nnz (int):: (undocumented)
y (float2/object):: (undocumented)
xVal (float2/object):: (undocumented)
xInd (Pointer/object):: (undocumented)
idxBase (hipsparseIndexBase_t):: (undocumented)

hip.hipsparse.hipsparseZgthrz(handle, int nnz, y, xVal, xInd, idxBase)#

(No short description, might be part of a group.)

Args:

handle (Pointer/object):: (undocumented)
nnz (int):: (undocumented)
y (double2/object):: (undocumented)
xVal (double2/object):: (undocumented)
xInd (Pointer/object):: (undocumented)
idxBase (hipsparseIndexBase_t):: (undocumented)

hip.hipsparse.hipsparseSroti(handle, int nnz, xVal, xInd, y, c, s, idxBase)#

Apply Givens rotation to a dense and a sparse vector.

hipsparseXroti applies the Givens rotation matrix \(G\) to the sparse vector \(x\) and the dense vector \(y\), where

\[\begin{split}G = \begin{pmatrix} c & s \\ -s & c \end{pmatrix}\end{split}\]

for(i = 0; i < nnz; ++i)
{
    x_tmp = x_val[i];
    y_tmp = y[x_ind[i]];

    x_val[i]    = c * x_tmp + s * y_tmp;
    y[x_ind[i]] = c * y_tmp - s * x_tmp;
}

Note:

This function is non blocking and executed asynchronously with respect to the host. It may return before the actual computation has finished.

Args:

handle (Pointer/object):: (undocumented)
nnz (int):: (undocumented)
xVal (Pointer/object):: (undocumented)
xInd (Pointer/object):: (undocumented)
y (Pointer/object):: (undocumented)
c (Pointer/object):: (undocumented)
s (Pointer/object):: (undocumented)
idxBase (hipsparseIndexBase_t):: (undocumented)

hip.hipsparse.hipsparseDroti(handle, int nnz, xVal, xInd, y, c, s, idxBase)#

(No short description, might be part of a group.)

Args:

handle (Pointer/object):: (undocumented)
nnz (int):: (undocumented)
xVal (Pointer/object):: (undocumented)
xInd (Pointer/object):: (undocumented)
y (Pointer/object):: (undocumented)
c (Pointer/object):: (undocumented)
s (Pointer/object):: (undocumented)
idxBase (hipsparseIndexBase_t):: (undocumented)

hip.hipsparse.hipsparseSsctr(handle, int nnz, xVal, xInd, y, idxBase)#

Scatter elements from a dense vector across a sparse vector.

hipsparseXsctr scatters the elements that are listed in x_ind from the sparse vector \(x\) into the dense vector \(y\). Indices of \(y\) that are not listed in x_ind remain unchanged.

for(i = 0; i < nnz; ++i)
{
    y[x_ind[i]] = x_val[i];
}

Note:

This function is non blocking and executed asynchronously with respect to the host. It may return before the actual computation has finished.

Args:

handle (Pointer/object):: (undocumented)
nnz (int):: (undocumented)
xVal (Pointer/object):: (undocumented)
xInd (Pointer/object):: (undocumented)
y (Pointer/object):: (undocumented)
idxBase (hipsparseIndexBase_t):: (undocumented)

hip.hipsparse.hipsparseDsctr(handle, int nnz, xVal, xInd, y, idxBase)#

(No short description, might be part of a group.)

Args:

handle (Pointer/object):: (undocumented)
nnz (int):: (undocumented)
xVal (Pointer/object):: (undocumented)
xInd (Pointer/object):: (undocumented)
y (Pointer/object):: (undocumented)
idxBase (hipsparseIndexBase_t):: (undocumented)

hip.hipsparse.hipsparseCsctr(handle, int nnz, xVal, xInd, y, idxBase)#

(No short description, might be part of a group.)

Args:

handle (Pointer/object):: (undocumented)
nnz (int):: (undocumented)
xVal (float2/object):: (undocumented)
xInd (Pointer/object):: (undocumented)
y (float2/object):: (undocumented)
idxBase (hipsparseIndexBase_t):: (undocumented)

hip.hipsparse.hipsparseZsctr(handle, int nnz, xVal, xInd, y, idxBase)#

(No short description, might be part of a group.)

Args:

handle (Pointer/object):: (undocumented)
nnz (int):: (undocumented)
xVal (double2/object):: (undocumented)
xInd (Pointer/object):: (undocumented)
y (double2/object):: (undocumented)
idxBase (hipsparseIndexBase_t):: (undocumented)

hip.hipsparse.hipsparseScsrmv(handle, transA, int m, int n, int nnz, alpha, descrA, csrSortedValA, csrSortedRowPtrA, csrSortedColIndA, x, beta, y)#

Sparse matrix vector multiplication using CSR storage format

hipsparseXcsrmv multiplies the scalar \(\alpha\) with a sparse \(m \times n\) matrix, defined in CSR storage format, and the dense vector \(x\) and adds the result to the dense vector \(y\) that is multiplied by the scalar \(\beta\), such that

\[y := \alpha \cdot op(A) \cdot x + \beta \cdot y,\]

with

\[\begin{split}op(A) = \left\{ \begin{array}{ll} A, & \text{if trans == HIPSPARSE_OPERATION_NON_TRANSPOSE} \\ A^T, & \text{if trans == HIPSPARSE_OPERATION_TRANSPOSE} \\ A^H, & \text{if trans == HIPSPARSE_OPERATION_CONJUGATE_TRANSPOSE} \end{array} \right.\end{split}\]

for(i = 0; i < m; ++i)
{
    y[i] = beta * y[i];

    for(j = csr_row_ptr[i]; j < csr_row_ptr[i + 1]; ++j)
    {
        y[i] = y[i] + alpha * csr_val[j] * x[csr_col_ind[j]];
    }
}

Note:

This function is non blocking and executed asynchronously with respect to the host. It may return before the actual computation has finished.

Note:

Currently, only trans == HIPSPARSE_OPERATION_NON_TRANSPOSE is supported.

Args:

handle (Pointer/object):: (undocumented)
transA (hipsparseOperation_t):: (undocumented)
m (int):: (undocumented)
n (int):: (undocumented)
nnz (int):: (undocumented)
alpha (Pointer/object):: (undocumented)
descrA (Pointer/object):: (undocumented)
csrSortedValA (Pointer/object):: (undocumented)
csrSortedRowPtrA (Pointer/object):: (undocumented)
csrSortedColIndA (Pointer/object):: (undocumented)
x (Pointer/object):: (undocumented)
beta (Pointer/object):: (undocumented)
y (Pointer/object):: (undocumented)

hip.hipsparse.hipsparseDcsrmv(handle, transA, int m, int n, int nnz, alpha, descrA, csrSortedValA, csrSortedRowPtrA, csrSortedColIndA, x, beta, y)#

(No short description, might be part of a group.)

Args:

handle (Pointer/object):: (undocumented)
transA (hipsparseOperation_t):: (undocumented)
m (int):: (undocumented)
n (int):: (undocumented)
nnz (int):: (undocumented)
alpha (Pointer/object):: (undocumented)
descrA (Pointer/object):: (undocumented)
csrSortedValA (Pointer/object):: (undocumented)
csrSortedRowPtrA (Pointer/object):: (undocumented)
csrSortedColIndA (Pointer/object):: (undocumented)
x (Pointer/object):: (undocumented)
beta (Pointer/object):: (undocumented)
y (Pointer/object):: (undocumented)

hip.hipsparse.hipsparseCcsrmv(handle, transA, int m, int n, int nnz, alpha, descrA, csrSortedValA, csrSortedRowPtrA, csrSortedColIndA, x, beta, y)#

(No short description, might be part of a group.)

Args:

handle (Pointer/object):: (undocumented)
transA (hipsparseOperation_t):: (undocumented)
m (int):: (undocumented)
n (int):: (undocumented)
nnz (int):: (undocumented)
alpha (float2/object):: (undocumented)
descrA (Pointer/object):: (undocumented)
csrSortedValA (float2/object):: (undocumented)
csrSortedRowPtrA (Pointer/object):: (undocumented)
csrSortedColIndA (Pointer/object):: (undocumented)
x (float2/object):: (undocumented)
beta (float2/object):: (undocumented)
y (float2/object):: (undocumented)

hip.hipsparse.hipsparseZcsrmv(handle, transA, int m, int n, int nnz, alpha, descrA, csrSortedValA, csrSortedRowPtrA, csrSortedColIndA, x, beta, y)#

(No short description, might be part of a group.)

Args:

handle (Pointer/object):: (undocumented)
transA (hipsparseOperation_t):: (undocumented)
m (int):: (undocumented)
n (int):: (undocumented)
nnz (int):: (undocumented)
alpha (double2/object):: (undocumented)
descrA (Pointer/object):: (undocumented)
csrSortedValA (double2/object):: (undocumented)
csrSortedRowPtrA (Pointer/object):: (undocumented)
csrSortedColIndA (Pointer/object):: (undocumented)
x (double2/object):: (undocumented)
beta (double2/object):: (undocumented)
y (double2/object):: (undocumented)

hip.hipsparse.hipsparseXcsrsv2_zeroPivot(handle, info, position)#

Sparse triangular solve using CSR storage format

hipsparseXcsrsv2_zeroPivot returns HIPSPARSE_STATUS_ZERO_PIVOT , if either a structural or numerical zero has been found during hipsparseScsrsv2_solve(), hipsparseDcsrsv2_solve(), hipsparseCcsrsv2_solve() or hipsparseZcsrsv2_solve() computation. The first zero pivot \(j\) at \(A_{j,j}\) is stored in position, using same index base as the CSR matrix.

position can be in host or device memory. If no zero pivot has been found, position is set to -1 and HIPSPARSE_STATUS_SUCCESS is returned instead.

Note:

hipsparseXcsrsv2_zeroPivot is a blocking function. It might influence performance negatively.

Args:

handle (Pointer/object):: (undocumented)
info (csrsv2Info/object):: (undocumented)
position (Pointer/object):: (undocumented)

hip.hipsparse.hipsparseScsrsv2_bufferSize(handle, transA, int m, int nnz, descrA, csrSortedValA, csrSortedRowPtrA, csrSortedColIndA, info, pBufferSizeInBytes)#

Sparse triangular solve using CSR storage format

hipsparseXcsrsv2_bufferSize returns the size of the temporary storage buffer in bytes that is required by hipsparseScsrsv2_analysis(), hipsparseDcsrsv2_analysis(), hipsparseCcsrsv2_analysis(), hipsparseZcsrsv2_analysis(), hipsparseScsrsv2_solve(), hipsparseDcsrsv2_solve(), hipsparseCcsrsv2_solve() and hipsparseZcsrsv2_solve(). The temporary storage buffer must be allocated by the user.

Args:

handle (Pointer/object):: (undocumented)
transA (hipsparseOperation_t):: (undocumented)
m (int):: (undocumented)
nnz (int):: (undocumented)
descrA (Pointer/object):: (undocumented)
csrSortedValA (Pointer/object):: (undocumented)
csrSortedRowPtrA (Pointer/object):: (undocumented)
csrSortedColIndA (Pointer/object):: (undocumented)
info (csrsv2Info/object):: (undocumented)
pBufferSizeInBytes (Pointer/object):: (undocumented)

hip.hipsparse.hipsparseDcsrsv2_bufferSize(handle, transA, int m, int nnz, descrA, csrSortedValA, csrSortedRowPtrA, csrSortedColIndA, info, pBufferSizeInBytes)#

(No short description, might be part of a group.)

Args:

handle (Pointer/object):: (undocumented)
transA (hipsparseOperation_t):: (undocumented)
m (int):: (undocumented)
nnz (int):: (undocumented)
descrA (Pointer/object):: (undocumented)
csrSortedValA (Pointer/object):: (undocumented)
csrSortedRowPtrA (Pointer/object):: (undocumented)
csrSortedColIndA (Pointer/object):: (undocumented)
info (csrsv2Info/object):: (undocumented)
pBufferSizeInBytes (Pointer/object):: (undocumented)

hip.hipsparse.hipsparseCcsrsv2_bufferSize(handle, transA, int m, int nnz, descrA, csrSortedValA, csrSortedRowPtrA, csrSortedColIndA, info, pBufferSizeInBytes)#

(No short description, might be part of a group.)

Args:

handle (Pointer/object):: (undocumented)
transA (hipsparseOperation_t):: (undocumented)
m (int):: (undocumented)
nnz (int):: (undocumented)
descrA (Pointer/object):: (undocumented)
csrSortedValA (float2/object):: (undocumented)
csrSortedRowPtrA (Pointer/object):: (undocumented)
csrSortedColIndA (Pointer/object):: (undocumented)
info (csrsv2Info/object):: (undocumented)
pBufferSizeInBytes (Pointer/object):: (undocumented)

hip.hipsparse.hipsparseZcsrsv2_bufferSize(handle, transA, int m, int nnz, descrA, csrSortedValA, csrSortedRowPtrA, csrSortedColIndA, info, pBufferSizeInBytes)#

(No short description, might be part of a group.)

Args:

handle (Pointer/object):: (undocumented)
transA (hipsparseOperation_t):: (undocumented)
m (int):: (undocumented)
nnz (int):: (undocumented)
descrA (Pointer/object):: (undocumented)
csrSortedValA (double2/object):: (undocumented)
csrSortedRowPtrA (Pointer/object):: (undocumented)
csrSortedColIndA (Pointer/object):: (undocumented)
info (csrsv2Info/object):: (undocumented)
pBufferSizeInBytes (Pointer/object):: (undocumented)

hip.hipsparse.hipsparseScsrsv2_bufferSizeExt(handle, transA, int m, int nnz, descrA, csrSortedValA, csrSortedRowPtrA, csrSortedColIndA, info, pBufferSizeInBytes)#

Sparse triangular solve using CSR storage format

hipsparseXcsrsv2_bufferSizeExt returns the size of the temporary storage buffer in bytes that is required by hipsparseScsrsv2_analysis(), hipsparseDcsrsv2_analysis(), hipsparseCcsrsv2_analysis(), hipsparseZcsrsv2_analysis(), hipsparseScsrsv2_solve(), hipsparseDcsrsv2_solve(), hipsparseCcsrsv2_solve() and hipsparseZcsrsv2_solve(). The temporary storage buffer must be allocated by the user.

Args:

handle (Pointer/object):: (undocumented)
transA (hipsparseOperation_t):: (undocumented)
m (int):: (undocumented)
nnz (int):: (undocumented)
descrA (Pointer/object):: (undocumented)
csrSortedValA (Pointer/object):: (undocumented)
csrSortedRowPtrA (Pointer/object):: (undocumented)
csrSortedColIndA (Pointer/object):: (undocumented)
info (csrsv2Info/object):: (undocumented)
pBufferSizeInBytes (Pointer/object):: (undocumented)

hip.hipsparse.hipsparseDcsrsv2_bufferSizeExt(handle, transA, int m, int nnz, descrA, csrSortedValA, csrSortedRowPtrA, csrSortedColIndA, info, pBufferSizeInBytes)#

(No short description, might be part of a group.)

Args:

handle (Pointer/object):: (undocumented)
transA (hipsparseOperation_t):: (undocumented)
m (int):: (undocumented)
nnz (int):: (undocumented)
descrA (Pointer/object):: (undocumented)
csrSortedValA (Pointer/object):: (undocumented)
csrSortedRowPtrA (Pointer/object):: (undocumented)
csrSortedColIndA (Pointer/object):: (undocumented)
info (csrsv2Info/object):: (undocumented)
pBufferSizeInBytes (Pointer/object):: (undocumented)

hip.hipsparse.hipsparseCcsrsv2_bufferSizeExt(handle, transA, int m, int nnz, descrA, csrSortedValA, csrSortedRowPtrA, csrSortedColIndA, info, pBufferSizeInBytes)#

(No short description, might be part of a group.)

Args:

handle (Pointer/object):: (undocumented)
transA (hipsparseOperation_t):: (undocumented)
m (int):: (undocumented)
nnz (int):: (undocumented)
descrA (Pointer/object):: (undocumented)
csrSortedValA (float2/object):: (undocumented)
csrSortedRowPtrA (Pointer/object):: (undocumented)
csrSortedColIndA (Pointer/object):: (undocumented)
info (csrsv2Info/object):: (undocumented)
pBufferSizeInBytes (Pointer/object):: (undocumented)

hip.hipsparse.hipsparseZcsrsv2_bufferSizeExt(handle, transA, int m, int nnz, descrA, csrSortedValA, csrSortedRowPtrA, csrSortedColIndA, info, pBufferSizeInBytes)#

(No short description, might be part of a group.)

Args:

handle (Pointer/object):: (undocumented)
transA (hipsparseOperation_t):: (undocumented)
m (int):: (undocumented)
nnz (int):: (undocumented)
descrA (Pointer/object):: (undocumented)
csrSortedValA (double2/object):: (undocumented)
csrSortedRowPtrA (Pointer/object):: (undocumented)
csrSortedColIndA (Pointer/object):: (undocumented)
info (csrsv2Info/object):: (undocumented)
pBufferSizeInBytes (Pointer/object):: (undocumented)

hip.hipsparse.hipsparseScsrsv2_analysis(handle, transA, int m, int nnz, descrA, csrSortedValA, csrSortedRowPtrA, csrSortedColIndA, info, policy, pBuffer)#

Sparse triangular solve using CSR storage format

hipsparseXcsrsv2_analysis performs the analysis step for hipsparseScsrsv2_solve(), hipsparseDcsrsv2_solve(), hipsparseCcsrsv2_solve() and hipsparseZcsrsv2_solve().

Note:

This function is non blocking and executed asynchronously with respect to the host. It may return before the actual computation has finished.

Args:

handle (Pointer/object):: (undocumented)
transA (hipsparseOperation_t):: (undocumented)
m (int):: (undocumented)
nnz (int):: (undocumented)
descrA (Pointer/object):: (undocumented)
csrSortedValA (Pointer/object):: (undocumented)
csrSortedRowPtrA (Pointer/object):: (undocumented)
csrSortedColIndA (Pointer/object):: (undocumented)
info (csrsv2Info/object):: (undocumented)
policy (hipsparseSolvePolicy_t):: (undocumented)
pBuffer (Pointer/object):: (undocumented)

hip.hipsparse.hipsparseDcsrsv2_analysis(handle, transA, int m, int nnz, descrA, csrSortedValA, csrSortedRowPtrA, csrSortedColIndA, info, policy, pBuffer)#

(No short description, might be part of a group.)

Args:

handle (Pointer/object):: (undocumented)
transA (hipsparseOperation_t):: (undocumented)
m (int):: (undocumented)
nnz (int):: (undocumented)
descrA (Pointer/object):: (undocumented)
csrSortedValA (Pointer/object):: (undocumented)
csrSortedRowPtrA (Pointer/object):: (undocumented)
csrSortedColIndA (Pointer/object):: (undocumented)
info (csrsv2Info/object):: (undocumented)
policy (hipsparseSolvePolicy_t):: (undocumented)
pBuffer (Pointer/object):: (undocumented)

hip.hipsparse.hipsparseCcsrsv2_analysis(handle, transA, int m, int nnz, descrA, csrSortedValA, csrSortedRowPtrA, csrSortedColIndA, info, policy, pBuffer)#

(No short description, might be part of a group.)

Args:

handle (Pointer/object):: (undocumented)
transA (hipsparseOperation_t):: (undocumented)
m (int):: (undocumented)
nnz (int):: (undocumented)
descrA (Pointer/object):: (undocumented)
csrSortedValA (float2/object):: (undocumented)
csrSortedRowPtrA (Pointer/object):: (undocumented)
csrSortedColIndA (Pointer/object):: (undocumented)
info (csrsv2Info/object):: (undocumented)
policy (hipsparseSolvePolicy_t):: (undocumented)
pBuffer (Pointer/object):: (undocumented)

hip.hipsparse.hipsparseZcsrsv2_analysis(handle, transA, int m, int nnz, descrA, csrSortedValA, csrSortedRowPtrA, csrSortedColIndA, info, policy, pBuffer)#

(No short description, might be part of a group.)

Args:

handle (Pointer/object):: (undocumented)
transA (hipsparseOperation_t):: (undocumented)
m (int):: (undocumented)
nnz (int):: (undocumented)
descrA (Pointer/object):: (undocumented)
csrSortedValA (double2/object):: (undocumented)
csrSortedRowPtrA (Pointer/object):: (undocumented)
csrSortedColIndA (Pointer/object):: (undocumented)
info (csrsv2Info/object):: (undocumented)
policy (hipsparseSolvePolicy_t):: (undocumented)
pBuffer (Pointer/object):: (undocumented)

hip.hipsparse.hipsparseScsrsv2_solve(handle, transA, int m, int nnz, alpha, descrA, csrSortedValA, csrSortedRowPtrA, csrSortedColIndA, info, f, x, policy, pBuffer)#

Sparse triangular solve using CSR storage format

hipsparseXcsrsv2_solve solves a sparse triangular linear system of a sparse \(m \times m\) matrix, defined in CSR storage format, a dense solution vector \(y\) and the right-hand side \(x\) that is multiplied by \(\alpha\), such that

\[op(A) \cdot y = \alpha \cdot x,\]

with

\[\begin{split}op(A) = \left\{ \begin{array}{ll} A, & \text{if trans == HIPSPARSE_OPERATION_NON_TRANSPOSE} \\ A^T, & \text{if trans == HIPSPARSE_OPERATION_TRANSPOSE} \\ A^H, & \text{if trans == HIPSPARSE_OPERATION_CONJUGATE_TRANSPOSE} \end{array} \right.\end{split}\]

Note:

The sparse CSR matrix has to be sorted. This can be achieved by calling hipsparseXcsrsort().

Note:

This function is non blocking and executed asynchronously with respect to the host. It may return before the actual computation has finished.

Note:

Currently, only trans == HIPSPARSE_OPERATION_NON_TRANSPOSE and trans == HIPSPARSE_OPERATION_TRANSPOSE is supported.

Args:

handle (Pointer/object):: (undocumented)
transA (hipsparseOperation_t):: (undocumented)
m (int):: (undocumented)
nnz (int):: (undocumented)
alpha (Pointer/object):: (undocumented)
descrA (Pointer/object):: (undocumented)
csrSortedValA (Pointer/object):: (undocumented)
csrSortedRowPtrA (Pointer/object):: (undocumented)
csrSortedColIndA (Pointer/object):: (undocumented)
info (csrsv2Info/object):: (undocumented)
f (Pointer/object):: (undocumented)
x (Pointer/object):: (undocumented)
policy (hipsparseSolvePolicy_t):: (undocumented)
pBuffer (Pointer/object):: (undocumented)

hip.hipsparse.hipsparseDcsrsv2_solve(handle, transA, int m, int nnz, alpha, descrA, csrSortedValA, csrSortedRowPtrA, csrSortedColIndA, info, f, x, policy, pBuffer)#

(No short description, might be part of a group.)

Args:

handle (Pointer/object):: (undocumented)
transA (hipsparseOperation_t):: (undocumented)
m (int):: (undocumented)
nnz (int):: (undocumented)
alpha (Pointer/object):: (undocumented)
descrA (Pointer/object):: (undocumented)
csrSortedValA (Pointer/object):: (undocumented)
csrSortedRowPtrA (Pointer/object):: (undocumented)
csrSortedColIndA (Pointer/object):: (undocumented)
info (csrsv2Info/object):: (undocumented)
f (Pointer/object):: (undocumented)
x (Pointer/object):: (undocumented)
policy (hipsparseSolvePolicy_t):: (undocumented)
pBuffer (Pointer/object):: (undocumented)

hip.hipsparse.hipsparseCcsrsv2_solve(handle, transA, int m, int nnz, alpha, descrA, csrSortedValA, csrSortedRowPtrA, csrSortedColIndA, info, f, x, policy, pBuffer)#

(No short description, might be part of a group.)

Args:

handle (Pointer/object):: (undocumented)
transA (hipsparseOperation_t):: (undocumented)
m (int):: (undocumented)
nnz (int):: (undocumented)
alpha (float2/object):: (undocumented)
descrA (Pointer/object):: (undocumented)
csrSortedValA (float2/object):: (undocumented)
csrSortedRowPtrA (Pointer/object):: (undocumented)
csrSortedColIndA (Pointer/object):: (undocumented)
info (csrsv2Info/object):: (undocumented)
f (float2/object):: (undocumented)
x (float2/object):: (undocumented)
policy (hipsparseSolvePolicy_t):: (undocumented)
pBuffer (Pointer/object):: (undocumented)

hip.hipsparse.hipsparseZcsrsv2_solve(handle, transA, int m, int nnz, alpha, descrA, csrSortedValA, csrSortedRowPtrA, csrSortedColIndA, info, f, x, policy, pBuffer)#

(No short description, might be part of a group.)

Args:

handle (Pointer/object):: (undocumented)
transA (hipsparseOperation_t):: (undocumented)
m (int):: (undocumented)
nnz (int):: (undocumented)
alpha (double2/object):: (undocumented)
descrA (Pointer/object):: (undocumented)
csrSortedValA (double2/object):: (undocumented)
csrSortedRowPtrA (Pointer/object):: (undocumented)
csrSortedColIndA (Pointer/object):: (undocumented)
info (csrsv2Info/object):: (undocumented)
f (double2/object):: (undocumented)
x (double2/object):: (undocumented)
policy (hipsparseSolvePolicy_t):: (undocumented)
pBuffer (Pointer/object):: (undocumented)

hip.hipsparse.hipsparseShybmv(handle, transA, alpha, descrA, hybA, x, beta, y)#

Sparse matrix vector multiplication using HYB storage format

hipsparseXhybmv multiplies the scalar \(\alpha\) with a sparse \(m \times n\) matrix, defined in HYB storage format, and the dense vector \(x\) and adds the result to the dense vector \(y\) that is multiplied by the scalar \(\beta\), such that

\[y := \alpha \cdot op(A) \cdot x + \beta \cdot y,\]

with

\[\begin{split}op(A) = \left\{ \begin{array}{ll} A, & \text{if trans == HIPSPARSE_OPERATION_NON_TRANSPOSE} \\ A^T, & \text{if trans == HIPSPARSE_OPERATION_TRANSPOSE} \\ A^H, & \text{if trans == HIPSPARSE_OPERATION_CONJUGATE_TRANSPOSE} \end{array} \right.\end{split}\]

Note:

This function is non blocking and executed asynchronously with respect to the host. It may return before the actual computation has finished.

Note:

Currently, only trans == HIPSPARSE_OPERATION_NON_TRANSPOSE is supported.

Args:

handle (Pointer/object):: (undocumented)
transA (hipsparseOperation_t):: (undocumented)
alpha (Pointer/object):: (undocumented)
descrA (Pointer/object):: (undocumented)
hybA (Pointer/object):: (undocumented)
x (Pointer/object):: (undocumented)
beta (Pointer/object):: (undocumented)
y (Pointer/object):: (undocumented)

hip.hipsparse.hipsparseDhybmv(handle, transA, alpha, descrA, hybA, x, beta, y)#

(No short description, might be part of a group.)

Args:

handle (Pointer/object):: (undocumented)
transA (hipsparseOperation_t):: (undocumented)
alpha (Pointer/object):: (undocumented)
descrA (Pointer/object):: (undocumented)
hybA (Pointer/object):: (undocumented)
x (Pointer/object):: (undocumented)
beta (Pointer/object):: (undocumented)
y (Pointer/object):: (undocumented)

hip.hipsparse.hipsparseChybmv(handle, transA, alpha, descrA, hybA, x, beta, y)#

(No short description, might be part of a group.)

Args:

handle (Pointer/object):: (undocumented)
transA (hipsparseOperation_t):: (undocumented)
alpha (float2/object):: (undocumented)
descrA (Pointer/object):: (undocumented)
hybA (Pointer/object):: (undocumented)
x (float2/object):: (undocumented)
beta (float2/object):: (undocumented)
y (float2/object):: (undocumented)

hip.hipsparse.hipsparseZhybmv(handle, transA, alpha, descrA, hybA, x, beta, y)#

(No short description, might be part of a group.)

Args:

handle (Pointer/object):: (undocumented)
transA (hipsparseOperation_t):: (undocumented)
alpha (double2/object):: (undocumented)
descrA (Pointer/object):: (undocumented)
hybA (Pointer/object):: (undocumented)
x (double2/object):: (undocumented)
beta (double2/object):: (undocumented)
y (double2/object):: (undocumented)

hip.hipsparse.hipsparseSbsrmv(handle, dirA, transA, int mb, int nb, int nnzb, alpha, descrA, bsrSortedValA, bsrSortedRowPtrA, bsrSortedColIndA, int blockDim, x, beta, y)#

Sparse matrix vector multiplication using BSR storage format

hipsparseXbsrmv multiplies the scalar \(\alpha\) with a sparse

math:(mb cdot text{block_dim}) times (nb cdot text{block_dim}) matrix, defined in BSR storage format, and the dense vector \(x\) and adds the result to the dense vector \(y\) that is multiplied by the scalar \(\beta\), such that

\[y := \alpha \cdot op(A) \cdot x + \beta \cdot y,\]

with

\[\begin{split}op(A) = \left\{ \begin{array}{ll} A, & \text{if trans == HIPSPARSE_OPERATION_NON_TRANSPOSE} \\ A^T, & \text{if trans == HIPSPARSE_OPERATION_TRANSPOSE} \\ A^H, & \text{if trans == HIPSPARSE_OPERATION_CONJUGATE_TRANSPOSE} \end{array} \right.\end{split}\]

Note:

This function is non blocking and executed asynchronously with respect to the host. It may return before the actual computation has finished.

Note:

Currently, only trans == HIPSPARSE_OPERATION_NON_TRANSPOSE is supported.

Args:

handle (Pointer/object):: (undocumented)
dirA (hipsparseDirection_t):: (undocumented)
transA (hipsparseOperation_t):: (undocumented)
mb (int):: (undocumented)
nb (int):: (undocumented)
nnzb (int):: (undocumented)
alpha (Pointer/object):: (undocumented)
descrA (Pointer/object):: (undocumented)
bsrSortedValA (Pointer/object):: (undocumented)
bsrSortedRowPtrA (Pointer/object):: (undocumented)
bsrSortedColIndA (Pointer/object):: (undocumented)
blockDim (int):: (undocumented)
x (Pointer/object):: (undocumented)
beta (Pointer/object):: (undocumented)
y (Pointer/object):: (undocumented)

hip.hipsparse.hipsparseDbsrmv(handle, dirA, transA, int mb, int nb, int nnzb, alpha, descrA, bsrSortedValA, bsrSortedRowPtrA, bsrSortedColIndA, int blockDim, x, beta, y)#

(No short description, might be part of a group.)

Args:

handle (Pointer/object):: (undocumented)
dirA (hipsparseDirection_t):: (undocumented)
transA (hipsparseOperation_t):: (undocumented)
mb (int):: (undocumented)
nb (int):: (undocumented)
nnzb (int):: (undocumented)
alpha (Pointer/object):: (undocumented)
descrA (Pointer/object):: (undocumented)
bsrSortedValA (Pointer/object):: (undocumented)
bsrSortedRowPtrA (Pointer/object):: (undocumented)
bsrSortedColIndA (Pointer/object):: (undocumented)
blockDim (int):: (undocumented)
x (Pointer/object):: (undocumented)
beta (Pointer/object):: (undocumented)
y (Pointer/object):: (undocumented)

hip.hipsparse.hipsparseCbsrmv(handle, dirA, transA, int mb, int nb, int nnzb, alpha, descrA, bsrSortedValA, bsrSortedRowPtrA, bsrSortedColIndA, int blockDim, x, beta, y)#

(No short description, might be part of a group.)

Args:

handle (Pointer/object):: (undocumented)
dirA (hipsparseDirection_t):: (undocumented)
transA (hipsparseOperation_t):: (undocumented)
mb (int):: (undocumented)
nb (int):: (undocumented)
nnzb (int):: (undocumented)
alpha (float2/object):: (undocumented)
descrA (Pointer/object):: (undocumented)
bsrSortedValA (float2/object):: (undocumented)
bsrSortedRowPtrA (Pointer/object):: (undocumented)
bsrSortedColIndA (Pointer/object):: (undocumented)
blockDim (int):: (undocumented)
x (float2/object):: (undocumented)
beta (float2/object):: (undocumented)
y (float2/object):: (undocumented)

hip.hipsparse.hipsparseZbsrmv(handle, dirA, transA, int mb, int nb, int nnzb, alpha, descrA, bsrSortedValA, bsrSortedRowPtrA, bsrSortedColIndA, int blockDim, x, beta, y)#

(No short description, might be part of a group.)

Args:

handle (Pointer/object):: (undocumented)
dirA (hipsparseDirection_t):: (undocumented)
transA (hipsparseOperation_t):: (undocumented)
mb (int):: (undocumented)
nb (int):: (undocumented)
nnzb (int):: (undocumented)
alpha (double2/object):: (undocumented)
descrA (Pointer/object):: (undocumented)
bsrSortedValA (double2/object):: (undocumented)
bsrSortedRowPtrA (Pointer/object):: (undocumented)
bsrSortedColIndA (Pointer/object):: (undocumented)
blockDim (int):: (undocumented)
x (double2/object):: (undocumented)
beta (double2/object):: (undocumented)
y (double2/object):: (undocumented)

hip.hipsparse.hipsparseSbsrxmv(handle, dir, trans, int sizeOfMask, int mb, int nb, int nnzb, alpha, descr, bsrVal, bsrMaskPtr, bsrRowPtr, bsrEndPtr, bsrColInd, int blockDim, x, beta, y)#

Sparse matrix vector multiplication with mask operation using BSR storage format

hipsparseXbsrxmv multiplies the scalar \(\alpha\) with a sparse

math:(mb cdot text{block_dim}) times (nb cdot text{block_dim}) modified matrix, defined in BSR storage format, and the dense vector \(x\) and adds the result to the dense vector \(y\) that is multiplied by the scalar \(\beta\), such that

\[y := \left( \alpha \cdot op(A) \cdot x + \beta \cdot y \right)\left( \text{mask} \right),\]

with

\[\begin{split}op(A) = \left\{ \begin{array}{ll} A, & \text{if trans == HIPSPARSE_OPERATION_NON_TRANSPOSE} \\ A^T, & \text{if trans == HIPSPARSE_OPERATION_TRANSPOSE} \\ A^H, & \text{if trans == HIPSPARSE_OPERATION_CONJUGATE_TRANSPOSE} \end{array} \right.\end{split}\]

Note:

This function is non blocking and executed asynchronously with respect to the host. It may return before the actual computation has finished.

Note:

Currently, only trans == HIPSPARSE_OPERATION_NON_TRANSPOSE is supported. Currently, block_dim == 1 is not supported.

Args:

handle (Pointer/object):: (undocumented)
dir (hipsparseDirection_t):: (undocumented)
trans (hipsparseOperation_t):: (undocumented)
sizeOfMask (int):: (undocumented)
mb (int):: (undocumented)
nb (int):: (undocumented)
nnzb (int):: (undocumented)
alpha (Pointer/object):: (undocumented)
descr (Pointer/object):: (undocumented)
bsrVal (Pointer/object):: (undocumented)
bsrMaskPtr (Pointer/object):: (undocumented)
bsrRowPtr (Pointer/object):: (undocumented)
bsrEndPtr (Pointer/object):: (undocumented)
bsrColInd (Pointer/object):: (undocumented)
blockDim (int):: (undocumented)
x (Pointer/object):: (undocumented)
beta (Pointer/object):: (undocumented)
y (Pointer/object):: (undocumented)

hip.hipsparse.hipsparseDbsrxmv(handle, dir, trans, int sizeOfMask, int mb, int nb, int nnzb, alpha, descr, bsrVal, bsrMaskPtr, bsrRowPtr, bsrEndPtr, bsrColInd, int blockDim, x, beta, y)#

(No short description, might be part of a group.)

Args:

handle (Pointer/object):: (undocumented)
dir (hipsparseDirection_t):: (undocumented)
trans (hipsparseOperation_t):: (undocumented)
sizeOfMask (int):: (undocumented)
mb (int):: (undocumented)
nb (int):: (undocumented)
nnzb (int):: (undocumented)
alpha (Pointer/object):: (undocumented)
descr (Pointer/object):: (undocumented)
bsrVal (Pointer/object):: (undocumented)
bsrMaskPtr (Pointer/object):: (undocumented)
bsrRowPtr (Pointer/object):: (undocumented)
bsrEndPtr (Pointer/object):: (undocumented)
bsrColInd (Pointer/object):: (undocumented)
blockDim (int):: (undocumented)
x (Pointer/object):: (undocumented)
beta (Pointer/object):: (undocumented)
y (Pointer/object):: (undocumented)

hip.hipsparse.hipsparseCbsrxmv(handle, dir, trans, int sizeOfMask, int mb, int nb, int nnzb, alpha, descr, bsrVal, bsrMaskPtr, bsrRowPtr, bsrEndPtr, bsrColInd, int blockDim, x, beta, y)#

(No short description, might be part of a group.)

Args:

handle (Pointer/object):: (undocumented)
dir (hipsparseDirection_t):: (undocumented)
trans (hipsparseOperation_t):: (undocumented)
sizeOfMask (int):: (undocumented)
mb (int):: (undocumented)
nb (int):: (undocumented)
nnzb (int):: (undocumented)
alpha (float2/object):: (undocumented)
descr (Pointer/object):: (undocumented)
bsrVal (float2/object):: (undocumented)
bsrMaskPtr (Pointer/object):: (undocumented)
bsrRowPtr (Pointer/object):: (undocumented)
bsrEndPtr (Pointer/object):: (undocumented)
bsrColInd (Pointer/object):: (undocumented)
blockDim (int):: (undocumented)
x (float2/object):: (undocumented)
beta (float2/object):: (undocumented)
y (float2/object):: (undocumented)

hip.hipsparse.hipsparseZbsrxmv(handle, dir, trans, int sizeOfMask, int mb, int nb, int nnzb, alpha, descr, bsrVal, bsrMaskPtr, bsrRowPtr, bsrEndPtr, bsrColInd, int blockDim, x, beta, y)#

(No short description, might be part of a group.)

Args:

handle (Pointer/object):: (undocumented)
dir (hipsparseDirection_t):: (undocumented)
trans (hipsparseOperation_t):: (undocumented)
sizeOfMask (int):: (undocumented)
mb (int):: (undocumented)
nb (int):: (undocumented)
nnzb (int):: (undocumented)
alpha (double2/object):: (undocumented)
descr (Pointer/object):: (undocumented)
bsrVal (double2/object):: (undocumented)
bsrMaskPtr (Pointer/object):: (undocumented)
bsrRowPtr (Pointer/object):: (undocumented)
bsrEndPtr (Pointer/object):: (undocumented)
bsrColInd (Pointer/object):: (undocumented)
blockDim (int):: (undocumented)
x (double2/object):: (undocumented)
beta (double2/object):: (undocumented)
y (double2/object):: (undocumented)

hip.hipsparse.hipsparseXbsrsv2_zeroPivot(handle, info, position)#

Sparse triangular solve using BSR storage format

hipsparseXbsrsv2_zeroPivot returns HIPSPARSE_STATUS_ZERO_PIVOT , if either a structural or numerical zero has been found during hipsparseXbsrsv2_analysis() or hipsparseXbsrsv2_solve() computation. The first zero pivot \(j\) at \(A_{j,j}\) is stored in position, using same index base as the BSR matrix.

position can be in host or device memory. If no zero pivot has been found, position is set to -1 and HIPSPARSE_STATUS_SUCCESS is returned instead.

Note:

hipsparseXbsrsv2_zeroPivot is a blocking function. It might influence performance negatively.

Args:

handle (Pointer/object):: (undocumented)
info (bsrsv2Info/object):: (undocumented)
position (Pointer/object):: (undocumented)

hip.hipsparse.hipsparseSbsrsv2_bufferSize(handle, dirA, transA, int mb, int nnzb, descrA, bsrSortedValA, bsrSortedRowPtrA, bsrSortedColIndA, int blockDim, info, pBufferSizeInBytes)#

Sparse triangular solve using BSR storage format

hipsparseXbsrsv2_bufferSize returns the size of the temporary storage buffer in bytes that is required by hipsparseXbsrsv2_analysis() and hipsparseXbsrsv2_solve(). The temporary storage buffer must be allocated by the user.

Args:

handle (Pointer/object):: (undocumented)
dirA (hipsparseDirection_t):: (undocumented)
transA (hipsparseOperation_t):: (undocumented)
mb (int):: (undocumented)
nnzb (int):: (undocumented)
descrA (Pointer/object):: (undocumented)
bsrSortedValA (Pointer/object):: (undocumented)
bsrSortedRowPtrA (Pointer/object):: (undocumented)
bsrSortedColIndA (Pointer/object):: (undocumented)
blockDim (int):: (undocumented)
info (bsrsv2Info/object):: (undocumented)
pBufferSizeInBytes (Pointer/object):: (undocumented)

hip.hipsparse.hipsparseDbsrsv2_bufferSize(handle, dirA, transA, int mb, int nnzb, descrA, bsrSortedValA, bsrSortedRowPtrA, bsrSortedColIndA, int blockDim, info, pBufferSizeInBytes)#

(No short description, might be part of a group.)

Args:

handle (Pointer/object):: (undocumented)
dirA (hipsparseDirection_t):: (undocumented)
transA (hipsparseOperation_t):: (undocumented)
mb (int):: (undocumented)
nnzb (int):: (undocumented)
descrA (Pointer/object):: (undocumented)
bsrSortedValA (Pointer/object):: (undocumented)
bsrSortedRowPtrA (Pointer/object):: (undocumented)
bsrSortedColIndA (Pointer/object):: (undocumented)
blockDim (int):: (undocumented)
info (bsrsv2Info/object):: (undocumented)
pBufferSizeInBytes (Pointer/object):: (undocumented)

hip.hipsparse.hipsparseCbsrsv2_bufferSize(handle, dirA, transA, int mb, int nnzb, descrA, bsrSortedValA, bsrSortedRowPtrA, bsrSortedColIndA, int blockDim, info, pBufferSizeInBytes)#

(No short description, might be part of a group.)

Args:

handle (Pointer/object):: (undocumented)
dirA (hipsparseDirection_t):: (undocumented)
transA (hipsparseOperation_t):: (undocumented)
mb (int):: (undocumented)
nnzb (int):: (undocumented)
descrA (Pointer/object):: (undocumented)
bsrSortedValA (float2/object):: (undocumented)
bsrSortedRowPtrA (Pointer/object):: (undocumented)
bsrSortedColIndA (Pointer/object):: (undocumented)
blockDim (int):: (undocumented)
info (bsrsv2Info/object):: (undocumented)
pBufferSizeInBytes (Pointer/object):: (undocumented)

hip.hipsparse.hipsparseZbsrsv2_bufferSize(handle, dirA, transA, int mb, int nnzb, descrA, bsrSortedValA, bsrSortedRowPtrA, bsrSortedColIndA, int blockDim, info, pBufferSizeInBytes)#

(No short description, might be part of a group.)

Args:

handle (Pointer/object):: (undocumented)
dirA (hipsparseDirection_t):: (undocumented)
transA (hipsparseOperation_t):: (undocumented)
mb (int):: (undocumented)
nnzb (int):: (undocumented)
descrA (Pointer/object):: (undocumented)
bsrSortedValA (double2/object):: (undocumented)
bsrSortedRowPtrA (Pointer/object):: (undocumented)
bsrSortedColIndA (Pointer/object):: (undocumented)
blockDim (int):: (undocumented)
info (bsrsv2Info/object):: (undocumented)
pBufferSizeInBytes (Pointer/object):: (undocumented)

hip.hipsparse.hipsparseSbsrsv2_bufferSizeExt(handle, dirA, transA, int mb, int nnzb, descrA, bsrSortedValA, bsrSortedRowPtrA, bsrSortedColIndA, int blockDim, info, pBufferSizeInBytes)#

Sparse triangular solve using BSR storage format

hipsparseXbsrsv2_bufferSizeExt returns the size of the temporary storage buffer in bytes that is required by hipsparseXbsrsv2_analysis() and hipsparseXbsrsv2_solve(). The temporary storage buffer must be allocated by the user.

Args:

handle (Pointer/object):: (undocumented)
dirA (hipsparseDirection_t):: (undocumented)
transA (hipsparseOperation_t):: (undocumented)
mb (int):: (undocumented)
nnzb (int):: (undocumented)
descrA (Pointer/object):: (undocumented)
bsrSortedValA (Pointer/object):: (undocumented)
bsrSortedRowPtrA (Pointer/object):: (undocumented)
bsrSortedColIndA (Pointer/object):: (undocumented)
blockDim (int):: (undocumented)
info (bsrsv2Info/object):: (undocumented)
pBufferSizeInBytes (Pointer/object):: (undocumented)

hip.hipsparse.hipsparseDbsrsv2_bufferSizeExt(handle, dirA, transA, int mb, int nnzb, descrA, bsrSortedValA, bsrSortedRowPtrA, bsrSortedColIndA, int blockDim, info, pBufferSizeInBytes)#

(No short description, might be part of a group.)

Args:

handle (Pointer/object):: (undocumented)
dirA (hipsparseDirection_t):: (undocumented)
transA (hipsparseOperation_t):: (undocumented)
mb (int):: (undocumented)
nnzb (int):: (undocumented)
descrA (Pointer/object):: (undocumented)
bsrSortedValA (Pointer/object):: (undocumented)
bsrSortedRowPtrA (Pointer/object):: (undocumented)
bsrSortedColIndA (Pointer/object):: (undocumented)
blockDim (int):: (undocumented)
info (bsrsv2Info/object):: (undocumented)
pBufferSizeInBytes (Pointer/object):: (undocumented)

hip.hipsparse.hipsparseCbsrsv2_bufferSizeExt(handle, dirA, transA, int mb, int nnzb, descrA, bsrSortedValA, bsrSortedRowPtrA, bsrSortedColIndA, int blockDim, info, pBufferSizeInBytes)#

(No short description, might be part of a group.)

Args:

handle (Pointer/object):: (undocumented)
dirA (hipsparseDirection_t):: (undocumented)
transA (hipsparseOperation_t):: (undocumented)
mb (int):: (undocumented)
nnzb (int):: (undocumented)
descrA (Pointer/object):: (undocumented)
bsrSortedValA (float2/object):: (undocumented)
bsrSortedRowPtrA (Pointer/object):: (undocumented)
bsrSortedColIndA (Pointer/object):: (undocumented)
blockDim (int):: (undocumented)
info (bsrsv2Info/object):: (undocumented)
pBufferSizeInBytes (Pointer/object):: (undocumented)

hip.hipsparse.hipsparseZbsrsv2_bufferSizeExt(handle, dirA, transA, int mb, int nnzb, descrA, bsrSortedValA, bsrSortedRowPtrA, bsrSortedColIndA, int blockDim, info, pBufferSizeInBytes)#

(No short description, might be part of a group.)

Args:

handle (Pointer/object):: (undocumented)
dirA (hipsparseDirection_t):: (undocumented)
transA (hipsparseOperation_t):: (undocumented)
mb (int):: (undocumented)
nnzb (int):: (undocumented)
descrA (Pointer/object):: (undocumented)
bsrSortedValA (double2/object):: (undocumented)
bsrSortedRowPtrA (Pointer/object):: (undocumented)
bsrSortedColIndA (Pointer/object):: (undocumented)
blockDim (int):: (undocumented)
info (bsrsv2Info/object):: (undocumented)
pBufferSizeInBytes (Pointer/object):: (undocumented)

hip.hipsparse.hipsparseSbsrsv2_analysis(handle, dirA, transA, int mb, int nnzb, descrA, bsrSortedValA, bsrSortedRowPtrA, bsrSortedColIndA, int blockDim, info, policy, pBuffer)#

Sparse triangular solve using BSR storage format

hipsparseXbsrsv2_analysis performs the analysis step for hipsparseXbsrsv2_solve().

Note:

If the matrix sparsity pattern changes, the gathered information will become invalid.

Note:

This function is non blocking and executed asynchronously with respect to the host. It may return before the actual computation has finished.

Args:

handle (Pointer/object):: (undocumented)
dirA (hipsparseDirection_t):: (undocumented)
transA (hipsparseOperation_t):: (undocumented)
mb (int):: (undocumented)
nnzb (int):: (undocumented)
descrA (Pointer/object):: (undocumented)
bsrSortedValA (Pointer/object):: (undocumented)
bsrSortedRowPtrA (Pointer/object):: (undocumented)
bsrSortedColIndA (Pointer/object):: (undocumented)
blockDim (int):: (undocumented)
info (bsrsv2Info/object):: (undocumented)
policy (hipsparseSolvePolicy_t):: (undocumented)
pBuffer (Pointer/object):: (undocumented)

hip.hipsparse.hipsparseDbsrsv2_analysis(handle, dirA, transA, int mb, int nnzb, descrA, bsrSortedValA, bsrSortedRowPtrA, bsrSortedColIndA, int blockDim, info, policy, pBuffer)#

(No short description, might be part of a group.)

Args:

handle (Pointer/object):: (undocumented)
dirA (hipsparseDirection_t):: (undocumented)
transA (hipsparseOperation_t):: (undocumented)
mb (int):: (undocumented)
nnzb (int):: (undocumented)
descrA (Pointer/object):: (undocumented)
bsrSortedValA (Pointer/object):: (undocumented)
bsrSortedRowPtrA (Pointer/object):: (undocumented)
bsrSortedColIndA (Pointer/object):: (undocumented)
blockDim (int):: (undocumented)
info (bsrsv2Info/object):: (undocumented)
policy (hipsparseSolvePolicy_t):: (undocumented)
pBuffer (Pointer/object):: (undocumented)

hip.hipsparse.hipsparseCbsrsv2_analysis(handle, dirA, transA, int mb, int nnzb, descrA, bsrSortedValA, bsrSortedRowPtrA, bsrSortedColIndA, int blockDim, info, policy, pBuffer)#

(No short description, might be part of a group.)

Args:

handle (Pointer/object):: (undocumented)
dirA (hipsparseDirection_t):: (undocumented)
transA (hipsparseOperation_t):: (undocumented)
mb (int):: (undocumented)
nnzb (int):: (undocumented)
descrA (Pointer/object):: (undocumented)
bsrSortedValA (float2/object):: (undocumented)
bsrSortedRowPtrA (Pointer/object):: (undocumented)
bsrSortedColIndA (Pointer/object):: (undocumented)
blockDim (int):: (undocumented)
info (bsrsv2Info/object):: (undocumented)
policy (hipsparseSolvePolicy_t):: (undocumented)
pBuffer (Pointer/object):: (undocumented)

hip.hipsparse.hipsparseZbsrsv2_analysis(handle, dirA, transA, int mb, int nnzb, descrA, bsrSortedValA, bsrSortedRowPtrA, bsrSortedColIndA, int blockDim, info, policy, pBuffer)#

(No short description, might be part of a group.)

Args:

handle (Pointer/object):: (undocumented)
dirA (hipsparseDirection_t):: (undocumented)
transA (hipsparseOperation_t):: (undocumented)
mb (int):: (undocumented)
nnzb (int):: (undocumented)
descrA (Pointer/object):: (undocumented)
bsrSortedValA (double2/object):: (undocumented)
bsrSortedRowPtrA (Pointer/object):: (undocumented)
bsrSortedColIndA (Pointer/object):: (undocumented)
blockDim (int):: (undocumented)
info (bsrsv2Info/object):: (undocumented)
policy (hipsparseSolvePolicy_t):: (undocumented)
pBuffer (Pointer/object):: (undocumented)

hip.hipsparse.hipsparseSbsrsv2_solve(handle, dirA, transA, int mb, int nnzb, alpha, descrA, bsrSortedValA, bsrSortedRowPtrA, bsrSortedColIndA, int blockDim, info, f, x, policy, pBuffer)#

Sparse triangular solve using BSR storage format

hipsparseXbsrsv2_solve solves a sparse triangular linear system of a sparse \(m \times m\) matrix, defined in BSR storage format, a dense solution vector \(y\) and the right-hand side \(x\) that is multiplied by \(\alpha\), such that

\[op(A) \cdot y = \alpha \cdot x,\]

with

\[\begin{split}op(A) = \left\{ \begin{array}{ll} A, & \text{if trans == HIPSPARSE_OPERATION_NON_TRANSPOSE} \\ A^T, & \text{if trans == HIPSPARSE_OPERATION_TRANSPOSE} \\ A^H, & \text{if trans == HIPSPARSE_OPERATION_CONJUGATE_TRANSPOSE} \end{array} \right.\end{split}\]

Note:

The sparse BSR matrix has to be sorted.

Note:

This function is non blocking and executed asynchronously with respect to the host. It may return before the actual computation has finished.

Note:

Currently, only trans == HIPSPARSE_OPERATION_NON_TRANSPOSE and trans == HIPSPARSE_OPERATION_TRANSPOSE is supported.

Args:

handle (Pointer/object):: (undocumented)
dirA (hipsparseDirection_t):: (undocumented)
transA (hipsparseOperation_t):: (undocumented)
mb (int):: (undocumented)
nnzb (int):: (undocumented)
alpha (Pointer/object):: (undocumented)
descrA (Pointer/object):: (undocumented)
bsrSortedValA (Pointer/object):: (undocumented)
bsrSortedRowPtrA (Pointer/object):: (undocumented)
bsrSortedColIndA (Pointer/object):: (undocumented)
blockDim (int):: (undocumented)
info (bsrsv2Info/object):: (undocumented)
f (Pointer/object):: (undocumented)
x (Pointer/object):: (undocumented)
policy (hipsparseSolvePolicy_t):: (undocumented)
pBuffer (Pointer/object):: (undocumented)

hip.hipsparse.hipsparseDbsrsv2_solve(handle, dirA, transA, int mb, int nnzb, alpha, descrA, bsrSortedValA, bsrSortedRowPtrA, bsrSortedColIndA, int blockDim, info, f, x, policy, pBuffer)#

(No short description, might be part of a group.)

Args:

handle (Pointer/object):: (undocumented)
dirA (hipsparseDirection_t):: (undocumented)
transA (hipsparseOperation_t):: (undocumented)
mb (int):: (undocumented)
nnzb (int):: (undocumented)
alpha (Pointer/object):: (undocumented)
descrA (Pointer/object):: (undocumented)
bsrSortedValA (Pointer/object):: (undocumented)
bsrSortedRowPtrA (Pointer/object):: (undocumented)
bsrSortedColIndA (Pointer/object):: (undocumented)
blockDim (int):: (undocumented)
info (bsrsv2Info/object):: (undocumented)
f (Pointer/object):: (undocumented)
x (Pointer/object):: (undocumented)
policy (hipsparseSolvePolicy_t):: (undocumented)
pBuffer (Pointer/object):: (undocumented)

hip.hipsparse.hipsparseCbsrsv2_solve(handle, dirA, transA, int mb, int nnzb, alpha, descrA, bsrSortedValA, bsrSortedRowPtrA, bsrSortedColIndA, int blockDim, info, f, x, policy, pBuffer)#

(No short description, might be part of a group.)

Args:

handle (Pointer/object):: (undocumented)
dirA (hipsparseDirection_t):: (undocumented)
transA (hipsparseOperation_t):: (undocumented)
mb (int):: (undocumented)
nnzb (int):: (undocumented)
alpha (float2/object):: (undocumented)
descrA (Pointer/object):: (undocumented)
bsrSortedValA (float2/object):: (undocumented)
bsrSortedRowPtrA (Pointer/object):: (undocumented)
bsrSortedColIndA (Pointer/object):: (undocumented)
blockDim (int):: (undocumented)
info (bsrsv2Info/object):: (undocumented)
f (float2/object):: (undocumented)
x (float2/object):: (undocumented)
policy (hipsparseSolvePolicy_t):: (undocumented)
pBuffer (Pointer/object):: (undocumented)

hip.hipsparse.hipsparseZbsrsv2_solve(handle, dirA, transA, int mb, int nnzb, alpha, descrA, bsrSortedValA, bsrSortedRowPtrA, bsrSortedColIndA, int blockDim, info, f, x, policy, pBuffer)#

(No short description, might be part of a group.)

Args:

handle (Pointer/object):: (undocumented)
dirA (hipsparseDirection_t):: (undocumented)
transA (hipsparseOperation_t):: (undocumented)
mb (int):: (undocumented)
nnzb (int):: (undocumented)
alpha (double2/object):: (undocumented)
descrA (Pointer/object):: (undocumented)
bsrSortedValA (double2/object):: (undocumented)
bsrSortedRowPtrA (Pointer/object):: (undocumented)
bsrSortedColIndA (Pointer/object):: (undocumented)
blockDim (int):: (undocumented)
info (bsrsv2Info/object):: (undocumented)
f (double2/object):: (undocumented)
x (double2/object):: (undocumented)
policy (hipsparseSolvePolicy_t):: (undocumented)
pBuffer (Pointer/object):: (undocumented)

hip.hipsparse.hipsparseSgemvi_bufferSize(handle, transA, int m, int n, int nnz, pBufferSizeInBytes)#

Dense matrix sparse vector multiplication

hipsparseXgemvi_bufferSize returns the size of the temporary storage buffer in bytes required by hipsparseXgemvi(). The temporary storage buffer must be allocated by the user.

Args:

handle (Pointer/object):: (undocumented)
transA (hipsparseOperation_t):: (undocumented)
m (int):: (undocumented)
n (int):: (undocumented)
nnz (int):: (undocumented)
pBufferSizeInBytes (Pointer/object):: (undocumented)

hip.hipsparse.hipsparseDgemvi_bufferSize(handle, transA, int m, int n, int nnz, pBufferSizeInBytes)#

(No short description, might be part of a group.)

Args:

handle (Pointer/object):: (undocumented)
transA (hipsparseOperation_t):: (undocumented)
m (int):: (undocumented)
n (int):: (undocumented)
nnz (int):: (undocumented)
pBufferSizeInBytes (Pointer/object):: (undocumented)

hip.hipsparse.hipsparseCgemvi_bufferSize(handle, transA, int m, int n, int nnz, pBufferSizeInBytes)#

(No short description, might be part of a group.)

Args:

handle (Pointer/object):: (undocumented)
transA (hipsparseOperation_t):: (undocumented)
m (int):: (undocumented)
n (int):: (undocumented)
nnz (int):: (undocumented)
pBufferSizeInBytes (Pointer/object):: (undocumented)

hip.hipsparse.hipsparseZgemvi_bufferSize(handle, transA, int m, int n, int nnz, pBufferSizeInBytes)#

(No short description, might be part of a group.)

Args:

handle (Pointer/object):: (undocumented)
transA (hipsparseOperation_t):: (undocumented)
m (int):: (undocumented)
n (int):: (undocumented)
nnz (int):: (undocumented)
pBufferSizeInBytes (Pointer/object):: (undocumented)

hip.hipsparse.hipsparseSgemvi(handle, transA, int m, int n, alpha, A, int lda, int nnz, x, xInd, beta, y, idxBase, pBuffer)#

Dense matrix sparse vector multiplication

hipsparseXgemvi multiplies the scalar \(\alpha\) with a dense \(m \times n\) matrix \(A\) and the sparse vector \(x\) and adds the result to the dense vector \(y\) that is multiplied by the scalar \(\beta\), such that

\[y := \alpha \cdot op(A) \cdot x + \beta \cdot y,\]

with

\[\begin{split}op(A) = \left\{ \begin{array}{ll} A, & \text{if trans == HIPSPARSE_OPERATION_NON_TRANSPOSE} \\ A^T, & \text{if trans == HIPSPARSE_OPERATION_TRANSPOSE} \\ A^H, & \text{if trans == HIPSPARSE_OPERATION_CONJUGATE_TRANSPOSE} \end{array} \right.\end{split}\]

Note:

This function is non blocking and executed asynchronously with respect to the host. It may return before the actual computation has finished.

Note:

Currently, only trans == HIPSPARSE_OPERATION_NON_TRANSPOSE is supported.

Args:

handle (Pointer/object):: (undocumented)
transA (hipsparseOperation_t):: (undocumented)
m (int):: (undocumented)
n (int):: (undocumented)
alpha (Pointer/object):: (undocumented)
A (Pointer/object):: (undocumented)
lda (int):: (undocumented)
nnz (int):: (undocumented)
x (Pointer/object):: (undocumented)
xInd (Pointer/object):: (undocumented)
beta (Pointer/object):: (undocumented)
y (Pointer/object):: (undocumented)
idxBase (hipsparseIndexBase_t):: (undocumented)
pBuffer (Pointer/object):: (undocumented)

hip.hipsparse.hipsparseDgemvi(handle, transA, int m, int n, alpha, A, int lda, int nnz, x, xInd, beta, y, idxBase, pBuffer)#

(No short description, might be part of a group.)

Args:

handle (Pointer/object):: (undocumented)
transA (hipsparseOperation_t):: (undocumented)
m (int):: (undocumented)
n (int):: (undocumented)
alpha (Pointer/object):: (undocumented)
A (Pointer/object):: (undocumented)
lda (int):: (undocumented)
nnz (int):: (undocumented)
x (Pointer/object):: (undocumented)
xInd (Pointer/object):: (undocumented)
beta (Pointer/object):: (undocumented)
y (Pointer/object):: (undocumented)
idxBase (hipsparseIndexBase_t):: (undocumented)
pBuffer (Pointer/object):: (undocumented)

hip.hipsparse.hipsparseCgemvi(handle, transA, int m, int n, alpha, A, int lda, int nnz, x, xInd, beta, y, idxBase, pBuffer)#

(No short description, might be part of a group.)

Args:

handle (Pointer/object):: (undocumented)
transA (hipsparseOperation_t):: (undocumented)
m (int):: (undocumented)
n (int):: (undocumented)
alpha (float2/object):: (undocumented)
A (float2/object):: (undocumented)
lda (int):: (undocumented)
nnz (int):: (undocumented)
x (float2/object):: (undocumented)
xInd (Pointer/object):: (undocumented)
beta (float2/object):: (undocumented)
y (float2/object):: (undocumented)
idxBase (hipsparseIndexBase_t):: (undocumented)
pBuffer (Pointer/object):: (undocumented)

hip.hipsparse.hipsparseZgemvi(handle, transA, int m, int n, alpha, A, int lda, int nnz, x, xInd, beta, y, idxBase, pBuffer)#

(No short description, might be part of a group.)

Args:

handle (Pointer/object):: (undocumented)
transA (hipsparseOperation_t):: (undocumented)
m (int):: (undocumented)
n (int):: (undocumented)
alpha (double2/object):: (undocumented)
A (double2/object):: (undocumented)
lda (int):: (undocumented)
nnz (int):: (undocumented)
x (double2/object):: (undocumented)
xInd (Pointer/object):: (undocumented)
beta (double2/object):: (undocumented)
y (double2/object):: (undocumented)
idxBase (hipsparseIndexBase_t):: (undocumented)
pBuffer (Pointer/object):: (undocumented)

hip.hipsparse.hipsparseSbsrmm(handle, dirA, transA, transB, int mb, int n, int kb, int nnzb, alpha, descrA, bsrValA, bsrRowPtrA, bsrColIndA, int blockDim, B, int ldb, beta, C, int ldc)#

Sparse matrix dense matrix multiplication using BSR storage format

hipsparseXbsrmm multiplies the scalar \(\alpha\) with a sparse \(mb \times kb\) matrix \(A\), defined in BSR storage format, and the dense \(k \times n\) matrix \(B\) (where \(k = block\_dim \times kb\)) and adds the result to the dense \(m \times n\) matrix \(C\) (where \(m = block\_dim \times mb\)) that is multiplied by the scalar \(\beta\), such that

\[C := \alpha \cdot op(A) \cdot op(B) + \beta \cdot C,\]

with

\[\begin{split}op(A) = \left\{ \begin{array}{ll} A, & \text{if trans_A == HIPSPARSE_OPERATION_NON_TRANSPOSE} \\ \end{array} \right.\end{split}\]

and

\[\begin{split}op(B) = \left\{ \begin{array}{ll} B, & \text{if trans_B == HIPSPARSE_OPERATION_NON_TRANSPOSE} \\ B^T, & \text{if trans_B == HIPSPARSE_OPERATION_TRANSPOSE} \\ \end{array} \right.\end{split}\]

Note:

This function is non blocking and executed asynchronously with respect to the host. It may return before the actual computation has finished.

Note:

Currently, only trans_A == HIPSPARSE_OPERATION_NON_TRANSPOSE is supported.

Args:

handle (Pointer/object):: (undocumented)
dirA (hipsparseDirection_t):: (undocumented)
transA (hipsparseOperation_t):: (undocumented)
transB (hipsparseOperation_t):: (undocumented)
mb (int):: (undocumented)
n (int):: (undocumented)
kb (int):: (undocumented)
nnzb (int):: (undocumented)
alpha (Pointer/object):: (undocumented)
descrA (Pointer/object):: (undocumented)
bsrValA (Pointer/object):: (undocumented)
bsrRowPtrA (Pointer/object):: (undocumented)
bsrColIndA (Pointer/object):: (undocumented)
blockDim (int):: (undocumented)
B (Pointer/object):: (undocumented)
ldb (int):: (undocumented)
beta (Pointer/object):: (undocumented)
C (Pointer/object):: (undocumented)
ldc (int):: (undocumented)

hip.hipsparse.hipsparseDbsrmm(handle, dirA, transA, transB, int mb, int n, int kb, int nnzb, alpha, descrA, bsrValA, bsrRowPtrA, bsrColIndA, int blockDim, B, int ldb, beta, C, int ldc)#

(No short description, might be part of a group.)

Args:

handle (Pointer/object):: (undocumented)
dirA (hipsparseDirection_t):: (undocumented)
transA (hipsparseOperation_t):: (undocumented)
transB (hipsparseOperation_t):: (undocumented)
mb (int):: (undocumented)
n (int):: (undocumented)
kb (int):: (undocumented)
nnzb (int):: (undocumented)
alpha (Pointer/object):: (undocumented)
descrA (Pointer/object):: (undocumented)
bsrValA (Pointer/object):: (undocumented)
bsrRowPtrA (Pointer/object):: (undocumented)
bsrColIndA (Pointer/object):: (undocumented)
blockDim (int):: (undocumented)
B (Pointer/object):: (undocumented)
ldb (int):: (undocumented)
beta (Pointer/object):: (undocumented)
C (Pointer/object):: (undocumented)
ldc (int):: (undocumented)

hip.hipsparse.hipsparseCbsrmm(handle, dirA, transA, transB, int mb, int n, int kb, int nnzb, alpha, descrA, bsrValA, bsrRowPtrA, bsrColIndA, int blockDim, B, int ldb, beta, C, int ldc)#

(No short description, might be part of a group.)

Args:

handle (Pointer/object):: (undocumented)
dirA (hipsparseDirection_t):: (undocumented)
transA (hipsparseOperation_t):: (undocumented)
transB (hipsparseOperation_t):: (undocumented)
mb (int):: (undocumented)
n (int):: (undocumented)
kb (int):: (undocumented)
nnzb (int):: (undocumented)
alpha (float2/object):: (undocumented)
descrA (Pointer/object):: (undocumented)
bsrValA (float2/object):: (undocumented)
bsrRowPtrA (Pointer/object):: (undocumented)
bsrColIndA (Pointer/object):: (undocumented)
blockDim (int):: (undocumented)
B (float2/object):: (undocumented)
ldb (int):: (undocumented)
beta (float2/object):: (undocumented)
C (float2/object):: (undocumented)
ldc (int):: (undocumented)

hip.hipsparse.hipsparseZbsrmm(handle, dirA, transA, transB, int mb, int n, int kb, int nnzb, alpha, descrA, bsrValA, bsrRowPtrA, bsrColIndA, int blockDim, B, int ldb, beta, C, int ldc)#

(No short description, might be part of a group.)

Args:

handle (Pointer/object):: (undocumented)
dirA (hipsparseDirection_t):: (undocumented)
transA (hipsparseOperation_t):: (undocumented)
transB (hipsparseOperation_t):: (undocumented)
mb (int):: (undocumented)
n (int):: (undocumented)
kb (int):: (undocumented)
nnzb (int):: (undocumented)
alpha (double2/object):: (undocumented)
descrA (Pointer/object):: (undocumented)
bsrValA (double2/object):: (undocumented)
bsrRowPtrA (Pointer/object):: (undocumented)
bsrColIndA (Pointer/object):: (undocumented)
blockDim (int):: (undocumented)
B (double2/object):: (undocumented)
ldb (int):: (undocumented)
beta (double2/object):: (undocumented)
C (double2/object):: (undocumented)
ldc (int):: (undocumented)

hip.hipsparse.hipsparseScsrmm(handle, transA, int m, int n, int k, int nnz, alpha, descrA, csrSortedValA, csrSortedRowPtrA, csrSortedColIndA, B, int ldb, beta, C, int ldc)#

Sparse matrix dense matrix multiplication using CSR storage format

hipsparseXcsrmm multiplies the scalar \(\alpha\) with a sparse \(m \times k\) matrix \(A\), defined in CSR storage format, and the dense \(k \times n\) matrix \(B\) and adds the result to the dense \(m \times n\) matrix \(C\) that is multiplied by the scalar \(\beta\), such that

\[C := \alpha \cdot op(A) \cdot B + \beta \cdot C,\]

with

\[\begin{split}op(A) = \left\{ \begin{array}{ll} A, & \text{if trans_A == HIPSPARSE_OPERATION_NON_TRANSPOSE} \\ A^T, & \text{if trans_A == HIPSPARSE_OPERATION_TRANSPOSE} \\ A^H, & \text{if trans_A == HIPSPARSE_OPERATION_CONJUGATE_TRANSPOSE} \end{array} \right.\end{split}\]

for(i = 0; i < ldc; ++i)
{
    for(j = 0; j < n; ++j)
    {
        C[i][j] = beta * C[i][j];

        for(k = csr_row_ptr[i]; k < csr_row_ptr[i + 1]; ++k)
        {
            C[i][j] += alpha * csr_val[k] * B[csr_col_ind[k]][j];
        }
    }
}

Note:

This function is non blocking and executed asynchronously with respect to the host. It may return before the actual computation has finished.

Args:

handle (Pointer/object):: (undocumented)
transA (hipsparseOperation_t):: (undocumented)
m (int):: (undocumented)
n (int):: (undocumented)
k (int):: (undocumented)
nnz (int):: (undocumented)
alpha (Pointer/object):: (undocumented)
descrA (Pointer/object):: (undocumented)
csrSortedValA (Pointer/object):: (undocumented)
csrSortedRowPtrA (Pointer/object):: (undocumented)
csrSortedColIndA (Pointer/object):: (undocumented)
B (Pointer/object):: (undocumented)
ldb (int):: (undocumented)
beta (Pointer/object):: (undocumented)
C (Pointer/object):: (undocumented)
ldc (int):: (undocumented)

hip.hipsparse.hipsparseDcsrmm(handle, transA, int m, int n, int k, int nnz, alpha, descrA, csrSortedValA, csrSortedRowPtrA, csrSortedColIndA, B, int ldb, beta, C, int ldc)#

(No short description, might be part of a group.)

Args:

handle (Pointer/object):: (undocumented)
transA (hipsparseOperation_t):: (undocumented)
m (int):: (undocumented)
n (int):: (undocumented)
k (int):: (undocumented)
nnz (int):: (undocumented)
alpha (Pointer/object):: (undocumented)
descrA (Pointer/object):: (undocumented)
csrSortedValA (Pointer/object):: (undocumented)
csrSortedRowPtrA (Pointer/object):: (undocumented)
csrSortedColIndA (Pointer/object):: (undocumented)
B (Pointer/object):: (undocumented)
ldb (int):: (undocumented)
beta (Pointer/object):: (undocumented)
C (Pointer/object):: (undocumented)
ldc (int):: (undocumented)

hip.hipsparse.hipsparseCcsrmm(handle, transA, int m, int n, int k, int nnz, alpha, descrA, csrSortedValA, csrSortedRowPtrA, csrSortedColIndA, B, int ldb, beta, C, int ldc)#

(No short description, might be part of a group.)

Args:

handle (Pointer/object):: (undocumented)
transA (hipsparseOperation_t):: (undocumented)
m (int):: (undocumented)
n (int):: (undocumented)
k (int):: (undocumented)
nnz (int):: (undocumented)
alpha (float2/object):: (undocumented)
descrA (Pointer/object):: (undocumented)
csrSortedValA (float2/object):: (undocumented)
csrSortedRowPtrA (Pointer/object):: (undocumented)
csrSortedColIndA (Pointer/object):: (undocumented)
B (float2/object):: (undocumented)
ldb (int):: (undocumented)
beta (float2/object):: (undocumented)
C (float2/object):: (undocumented)
ldc (int):: (undocumented)

hip.hipsparse.hipsparseZcsrmm(handle, transA, int m, int n, int k, int nnz, alpha, descrA, csrSortedValA, csrSortedRowPtrA, csrSortedColIndA, B, int ldb, beta, C, int ldc)#

(No short description, might be part of a group.)

Args:

handle (Pointer/object):: (undocumented)
transA (hipsparseOperation_t):: (undocumented)
m (int):: (undocumented)
n (int):: (undocumented)
k (int):: (undocumented)
nnz (int):: (undocumented)
alpha (double2/object):: (undocumented)
descrA (Pointer/object):: (undocumented)
csrSortedValA (double2/object):: (undocumented)
csrSortedRowPtrA (Pointer/object):: (undocumented)
csrSortedColIndA (Pointer/object):: (undocumented)
B (double2/object):: (undocumented)
ldb (int):: (undocumented)
beta (double2/object):: (undocumented)
C (double2/object):: (undocumented)
ldc (int):: (undocumented)

hip.hipsparse.hipsparseScsrmm2(handle, transA, transB, int m, int n, int k, int nnz, alpha, descrA, csrSortedValA, csrSortedRowPtrA, csrSortedColIndA, B, int ldb, beta, C, int ldc)#

Sparse matrix dense matrix multiplication using CSR storage format

hipsparseXcsrmm2 multiplies the scalar \(\alpha\) with a sparse \(m \times k\) matrix \(A\), defined in CSR storage format, and the dense \(k \times n\) matrix \(B\) and adds the result to the dense \(m \times n\) matrix \(C\) that is multiplied by the scalar \(\beta\), such that

\[C := \alpha \cdot op(A) \cdot op(B) + \beta \cdot C,\]

with

\[\begin{split}op(A) = \left\{ \begin{array}{ll} A, & \text{if trans_A == HIPSPARSE_OPERATION_NON_TRANSPOSE} \\ A^T, & \text{if trans_A == HIPSPARSE_OPERATION_TRANSPOSE} \\ A^H, & \text{if trans_A == HIPSPARSE_OPERATION_CONJUGATE_TRANSPOSE} \end{array} \right.\end{split}\]

and

\[\begin{split}op(B) = \left\{ \begin{array}{ll} B, & \text{if trans_B == HIPSPARSE_OPERATION_NON_TRANSPOSE} \\ B^T, & \text{if trans_B == HIPSPARSE_OPERATION_TRANSPOSE} \\ B^H, & \text{if trans_B == HIPSPARSE_OPERATION_CONJUGATE_TRANSPOSE} \end{array} \right.\end{split}\]

for(i = 0; i < ldc; ++i)
{
    for(j = 0; j < n; ++j)
    {
        C[i][j] = beta * C[i][j];

        for(k = csr_row_ptr[i]; k < csr_row_ptr[i + 1]; ++k)
        {
            C[i][j] += alpha * csr_val[k] * B[csr_col_ind[k]][j];
        }
    }
}

Note:

This function is non blocking and executed asynchronously with respect to the host. It may return before the actual computation has finished.

Args:

handle (Pointer/object):: (undocumented)
transA (hipsparseOperation_t):: (undocumented)
transB (hipsparseOperation_t):: (undocumented)
m (int):: (undocumented)
n (int):: (undocumented)
k (int):: (undocumented)
nnz (int):: (undocumented)
alpha (Pointer/object):: (undocumented)
descrA (Pointer/object):: (undocumented)
csrSortedValA (Pointer/object):: (undocumented)
csrSortedRowPtrA (Pointer/object):: (undocumented)
csrSortedColIndA (Pointer/object):: (undocumented)
B (Pointer/object):: (undocumented)
ldb (int):: (undocumented)
beta (Pointer/object):: (undocumented)
C (Pointer/object):: (undocumented)
ldc (int):: (undocumented)

hip.hipsparse.hipsparseDcsrmm2(handle, transA, transB, int m, int n, int k, int nnz, alpha, descrA, csrSortedValA, csrSortedRowPtrA, csrSortedColIndA, B, int ldb, beta, C, int ldc)#

(No short description, might be part of a group.)

Args:

handle (Pointer/object):: (undocumented)
transA (hipsparseOperation_t):: (undocumented)
transB (hipsparseOperation_t):: (undocumented)
m (int):: (undocumented)
n (int):: (undocumented)
k (int):: (undocumented)
nnz (int):: (undocumented)
alpha (Pointer/object):: (undocumented)
descrA (Pointer/object):: (undocumented)
csrSortedValA (Pointer/object):: (undocumented)
csrSortedRowPtrA (Pointer/object):: (undocumented)
csrSortedColIndA (Pointer/object):: (undocumented)
B (Pointer/object):: (undocumented)
ldb (int):: (undocumented)
beta (Pointer/object):: (undocumented)
C (Pointer/object):: (undocumented)
ldc (int):: (undocumented)

hip.hipsparse.hipsparseCcsrmm2(handle, transA, transB, int m, int n, int k, int nnz, alpha, descrA, csrSortedValA, csrSortedRowPtrA, csrSortedColIndA, B, int ldb, beta, C, int ldc)#

(No short description, might be part of a group.)

Args:

handle (Pointer/object):: (undocumented)
transA (hipsparseOperation_t):: (undocumented)
transB (hipsparseOperation_t):: (undocumented)
m (int):: (undocumented)
n (int):: (undocumented)
k (int):: (undocumented)
nnz (int):: (undocumented)
alpha (float2/object):: (undocumented)
descrA (Pointer/object):: (undocumented)
csrSortedValA (float2/object):: (undocumented)
csrSortedRowPtrA (Pointer/object):: (undocumented)
csrSortedColIndA (Pointer/object):: (undocumented)
B (float2/object):: (undocumented)
ldb (int):: (undocumented)
beta (float2/object):: (undocumented)
C (float2/object):: (undocumented)
ldc (int):: (undocumented)

hip.hipsparse.hipsparseZcsrmm2(handle, transA, transB, int m, int n, int k, int nnz, alpha, descrA, csrSortedValA, csrSortedRowPtrA, csrSortedColIndA, B, int ldb, beta, C, int ldc)#

(No short description, might be part of a group.)

Args:

handle (Pointer/object):: (undocumented)
transA (hipsparseOperation_t):: (undocumented)
transB (hipsparseOperation_t):: (undocumented)
m (int):: (undocumented)
n (int):: (undocumented)
k (int):: (undocumented)
nnz (int):: (undocumented)
alpha (double2/object):: (undocumented)
descrA (Pointer/object):: (undocumented)
csrSortedValA (double2/object):: (undocumented)
csrSortedRowPtrA (Pointer/object):: (undocumented)
csrSortedColIndA (Pointer/object):: (undocumented)
B (double2/object):: (undocumented)
ldb (int):: (undocumented)
beta (double2/object):: (undocumented)
C (double2/object):: (undocumented)
ldc (int):: (undocumented)

hip.hipsparse.hipsparseXbsrsm2_zeroPivot(handle, info, position)#

Sparse triangular system solve using BSR storage format

hipsparseXbsrsm2_zeroPivot returns HIPSPARSE_STATUS_ZERO_PIVOT , if either a structural or numerical zero has been found during hipsparseXbsrsm2_analysis() or hipsparseXbsrsm2_solve() computation. The first zero pivot \(j\) at \(A_{j,j}\) is stored in position, using same index base as the BSR matrix.

position can be in host or device memory. If no zero pivot has been found, position is set to -1 and HIPSPARSE_STATUS_SUCCESS is returned instead.

Note:

hipsparseXbsrsm2_zeroPivot is a blocking function. It might influence performance negatively.

Args:

handle (Pointer/object):: (undocumented)
info (bsrsm2Info/object):: (undocumented)
position (Pointer/object):: (undocumented)

hip.hipsparse.hipsparseSbsrsm2_bufferSize(handle, dirA, transA, transX, int mb, int nrhs, int nnzb, descrA, bsrSortedValA, bsrSortedRowPtrA, bsrSortedColIndA, int blockDim, info, pBufferSizeInBytes)#

Sparse triangular system solve using BSR storage format

hipsparseXbsrsm2_buffer_size returns the size of the temporary storage buffer in bytes that is required by hipsparseXbsrsm2_analysis() and hipsparseXbsrsm2_solve(). The temporary storage buffer must be allocated by the user.

Args:

handle (Pointer/object):: (undocumented)
dirA (hipsparseDirection_t):: (undocumented)
transA (hipsparseOperation_t):: (undocumented)
transX (hipsparseOperation_t):: (undocumented)
mb (int):: (undocumented)
nrhs (int):: (undocumented)
nnzb (int):: (undocumented)
descrA (Pointer/object):: (undocumented)
bsrSortedValA (Pointer/object):: (undocumented)
bsrSortedRowPtrA (Pointer/object):: (undocumented)
bsrSortedColIndA (Pointer/object):: (undocumented)
blockDim (int):: (undocumented)
info (bsrsm2Info/object):: (undocumented)
pBufferSizeInBytes (Pointer/object):: (undocumented)

hip.hipsparse.hipsparseDbsrsm2_bufferSize(handle, dirA, transA, transX, int mb, int nrhs, int nnzb, descrA, bsrSortedValA, bsrSortedRowPtrA, bsrSortedColIndA, int blockDim, info, pBufferSizeInBytes)#

(No short description, might be part of a group.)

Args:

handle (Pointer/object):: (undocumented)
dirA (hipsparseDirection_t):: (undocumented)
transA (hipsparseOperation_t):: (undocumented)
transX (hipsparseOperation_t):: (undocumented)
mb (int):: (undocumented)
nrhs (int):: (undocumented)
nnzb (int):: (undocumented)
descrA (Pointer/object):: (undocumented)
bsrSortedValA (Pointer/object):: (undocumented)
bsrSortedRowPtrA (Pointer/object):: (undocumented)
bsrSortedColIndA (Pointer/object):: (undocumented)
blockDim (int):: (undocumented)
info (bsrsm2Info/object):: (undocumented)
pBufferSizeInBytes (Pointer/object):: (undocumented)

hip.hipsparse.hipsparseCbsrsm2_bufferSize(handle, dirA, transA, transX, int mb, int nrhs, int nnzb, descrA, bsrSortedValA, bsrSortedRowPtrA, bsrSortedColIndA, int blockDim, info, pBufferSizeInBytes)#

(No short description, might be part of a group.)

Args:

handle (Pointer/object):: (undocumented)
dirA (hipsparseDirection_t):: (undocumented)
transA (hipsparseOperation_t):: (undocumented)
transX (hipsparseOperation_t):: (undocumented)
mb (int):: (undocumented)
nrhs (int):: (undocumented)
nnzb (int):: (undocumented)
descrA (Pointer/object):: (undocumented)
bsrSortedValA (float2/object):: (undocumented)
bsrSortedRowPtrA (Pointer/object):: (undocumented)
bsrSortedColIndA (Pointer/object):: (undocumented)
blockDim (int):: (undocumented)
info (bsrsm2Info/object):: (undocumented)
pBufferSizeInBytes (Pointer/object):: (undocumented)

hip.hipsparse.hipsparseZbsrsm2_bufferSize(handle, dirA, transA, transX, int mb, int nrhs, int nnzb, descrA, bsrSortedValA, bsrSortedRowPtrA, bsrSortedColIndA, int blockDim, info, pBufferSizeInBytes)#

(No short description, might be part of a group.)

Args:

handle (Pointer/object):: (undocumented)
dirA (hipsparseDirection_t):: (undocumented)
transA (hipsparseOperation_t):: (undocumented)
transX (hipsparseOperation_t):: (undocumented)
mb (int):: (undocumented)
nrhs (int):: (undocumented)
nnzb (int):: (undocumented)
descrA (Pointer/object):: (undocumented)
bsrSortedValA (double2/object):: (undocumented)
bsrSortedRowPtrA (Pointer/object):: (undocumented)
bsrSortedColIndA (Pointer/object):: (undocumented)
blockDim (int):: (undocumented)
info (bsrsm2Info/object):: (undocumented)
pBufferSizeInBytes (Pointer/object):: (undocumented)

hip.hipsparse.hipsparseSbsrsm2_analysis(handle, dirA, transA, transX, int mb, int nrhs, int nnzb, descrA, bsrSortedValA, bsrSortedRowPtrA, bsrSortedColIndA, int blockDim, info, policy, pBuffer)#

Sparse triangular system solve using BSR storage format

hipsparseXbsrsm2_analysis performs the analysis step for hipsparseXbsrsm2_solve().

Note:

If the matrix sparsity pattern changes, the gathered information will become invalid.

Note:

This function is non blocking and executed asynchronously with respect to the host. It may return before the actual computation has finished.

Args:

handle (Pointer/object):: (undocumented)
dirA (hipsparseDirection_t):: (undocumented)
transA (hipsparseOperation_t):: (undocumented)
transX (hipsparseOperation_t):: (undocumented)
mb (int):: (undocumented)
nrhs (int):: (undocumented)
nnzb (int):: (undocumented)
descrA (Pointer/object):: (undocumented)
bsrSortedValA (Pointer/object):: (undocumented)
bsrSortedRowPtrA (Pointer/object):: (undocumented)
bsrSortedColIndA (Pointer/object):: (undocumented)
blockDim (int):: (undocumented)
info (bsrsm2Info/object):: (undocumented)
policy (hipsparseSolvePolicy_t):: (undocumented)
pBuffer (Pointer/object):: (undocumented)

hip.hipsparse.hipsparseDbsrsm2_analysis(handle, dirA, transA, transX, int mb, int nrhs, int nnzb, descrA, bsrSortedValA, bsrSortedRowPtrA, bsrSortedColIndA, int blockDim, info, policy, pBuffer)#

(No short description, might be part of a group.)

Args:

handle (Pointer/object):: (undocumented)
dirA (hipsparseDirection_t):: (undocumented)
transA (hipsparseOperation_t):: (undocumented)
transX (hipsparseOperation_t):: (undocumented)
mb (int):: (undocumented)
nrhs (int):: (undocumented)
nnzb (int):: (undocumented)
descrA (Pointer/object):: (undocumented)
bsrSortedValA (Pointer/object):: (undocumented)
bsrSortedRowPtrA (Pointer/object):: (undocumented)
bsrSortedColIndA (Pointer/object):: (undocumented)
blockDim (int):: (undocumented)
info (bsrsm2Info/object):: (undocumented)
policy (hipsparseSolvePolicy_t):: (undocumented)
pBuffer (Pointer/object):: (undocumented)

hip.hipsparse.hipsparseCbsrsm2_analysis(handle, dirA, transA, transX, int mb, int nrhs, int nnzb, descrA, bsrSortedValA, bsrSortedRowPtrA, bsrSortedColIndA, int blockDim, info, policy, pBuffer)#

(No short description, might be part of a group.)

Args:

handle (Pointer/object):: (undocumented)
dirA (hipsparseDirection_t):: (undocumented)
transA (hipsparseOperation_t):: (undocumented)
transX (hipsparseOperation_t):: (undocumented)
mb (int):: (undocumented)
nrhs (int):: (undocumented)
nnzb (int):: (undocumented)
descrA (Pointer/object):: (undocumented)
bsrSortedValA (float2/object):: (undocumented)
bsrSortedRowPtrA (Pointer/object):: (undocumented)
bsrSortedColIndA (Pointer/object):: (undocumented)
blockDim (int):: (undocumented)
info (bsrsm2Info/object):: (undocumented)
policy (hipsparseSolvePolicy_t):: (undocumented)
pBuffer (Pointer/object):: (undocumented)

hip.hipsparse.hipsparseZbsrsm2_analysis(handle, dirA, transA, transX, int mb, int nrhs, int nnzb, descrA, bsrSortedValA, bsrSortedRowPtrA, bsrSortedColIndA, int blockDim, info, policy, pBuffer)#

(No short description, might be part of a group.)

Args:

handle (Pointer/object):: (undocumented)
dirA (hipsparseDirection_t):: (undocumented)
transA (hipsparseOperation_t):: (undocumented)
transX (hipsparseOperation_t):: (undocumented)
mb (int):: (undocumented)
nrhs (int):: (undocumented)
nnzb (int):: (undocumented)
descrA (Pointer/object):: (undocumented)
bsrSortedValA (double2/object):: (undocumented)
bsrSortedRowPtrA (Pointer/object):: (undocumented)
bsrSortedColIndA (Pointer/object):: (undocumented)
blockDim (int):: (undocumented)
info (bsrsm2Info/object):: (undocumented)
policy (hipsparseSolvePolicy_t):: (undocumented)
pBuffer (Pointer/object):: (undocumented)

hip.hipsparse.hipsparseSbsrsm2_solve(handle, dirA, transA, transX, int mb, int nrhs, int nnzb, alpha, descrA, bsrSortedValA, bsrSortedRowPtrA, bsrSortedColIndA, int blockDim, info, B, int ldb, X, int ldx, policy, pBuffer)#

Sparse triangular system solve using BSR storage format

hipsparseXbsrsm2_solve solves a sparse triangular linear system of a sparse \(m \times m\) matrix, defined in BSR storage format, a dense solution matrix \(X\) and the right-hand side matrix \(B\) that is multiplied by \(\alpha\), such that

\[op(A) \cdot op(X) = \alpha \cdot op(B),\]

with

\[\begin{split}op(A) = \left\{ \begin{array}{ll} A, & \text{if trans_A == HIPSPARSE_OPERATION_NON_TRANSPOSE} \\ A^T, & \text{if trans_A == HIPSPARSE_OPERATION_TRANSPOSE} \\ A^H, & \text{if trans_A == HIPSPARSE_OPERATION_CONJUGATE_TRANSPOSE} \end{array} \right.\end{split}\]

,

\[\begin{split}op(X) = \left\{ \begin{array}{ll} X, & \text{if trans_X == HIPSPARSE_OPERATION_NON_TRANSPOSE} \\ X^T, & \text{if trans_X == HIPSPARSE_OPERATION_TRANSPOSE} \\ X^H, & \text{if trans_X == HIPSPARSE_OPERATION_CONJUGATE_TRANSPOSE} \end{array} \right.\end{split}\]

Note:

The sparse BSR matrix has to be sorted.

Note:

Operation type of B and X must match, if \(op(B)=B, op(X)=X\).

Note:

This function is non blocking and executed asynchronously with respect to the host. It may return before the actual computation has finished.

Note:

Currently, only trans_A != HIPSPARSE_OPERATION_CONJUGATE_TRANSPOSE and trans_X != HIPSPARSE_OPERATION_CONJUGATE_TRANSPOSE is supported.

Args:

handle (Pointer/object):: (undocumented)
dirA (hipsparseDirection_t):: (undocumented)
transA (hipsparseOperation_t):: (undocumented)
transX (hipsparseOperation_t):: (undocumented)
mb (int):: (undocumented)
nrhs (int):: (undocumented)
nnzb (int):: (undocumented)
alpha (Pointer/object):: (undocumented)
descrA (Pointer/object):: (undocumented)
bsrSortedValA (Pointer/object):: (undocumented)
bsrSortedRowPtrA (Pointer/object):: (undocumented)
bsrSortedColIndA (Pointer/object):: (undocumented)
blockDim (int):: (undocumented)
info (bsrsm2Info/object):: (undocumented)
B (Pointer/object):: (undocumented)
ldb (int):: (undocumented)
X (Pointer/object):: (undocumented)
ldx (int):: (undocumented)
policy (hipsparseSolvePolicy_t):: (undocumented)
pBuffer (Pointer/object):: (undocumented)

hip.hipsparse.hipsparseDbsrsm2_solve(handle, dirA, transA, transX, int mb, int nrhs, int nnzb, alpha, descrA, bsrSortedValA, bsrSortedRowPtrA, bsrSortedColIndA, int blockDim, info, B, int ldb, X, int ldx, policy, pBuffer)#

(No short description, might be part of a group.)

Args:

handle (Pointer/object):: (undocumented)
dirA (hipsparseDirection_t):: (undocumented)
transA (hipsparseOperation_t):: (undocumented)
transX (hipsparseOperation_t):: (undocumented)
mb (int):: (undocumented)
nrhs (int):: (undocumented)
nnzb (int):: (undocumented)
alpha (Pointer/object):: (undocumented)
descrA (Pointer/object):: (undocumented)
bsrSortedValA (Pointer/object):: (undocumented)
bsrSortedRowPtrA (Pointer/object):: (undocumented)
bsrSortedColIndA (Pointer/object):: (undocumented)
blockDim (int):: (undocumented)
info (bsrsm2Info/object):: (undocumented)
B (Pointer/object):: (undocumented)
ldb (int):: (undocumented)
X (Pointer/object):: (undocumented)
ldx (int):: (undocumented)
policy (hipsparseSolvePolicy_t):: (undocumented)
pBuffer (Pointer/object):: (undocumented)

hip.hipsparse.hipsparseCbsrsm2_solve(handle, dirA, transA, transX, int mb, int nrhs, int nnzb, alpha, descrA, bsrSortedValA, bsrSortedRowPtrA, bsrSortedColIndA, int blockDim, info, B, int ldb, X, int ldx, policy, pBuffer)#

(No short description, might be part of a group.)

Args:

handle (Pointer/object):: (undocumented)
dirA (hipsparseDirection_t):: (undocumented)
transA (hipsparseOperation_t):: (undocumented)
transX (hipsparseOperation_t):: (undocumented)
mb (int):: (undocumented)
nrhs (int):: (undocumented)
nnzb (int):: (undocumented)
alpha (float2/object):: (undocumented)
descrA (Pointer/object):: (undocumented)
bsrSortedValA (float2/object):: (undocumented)
bsrSortedRowPtrA (Pointer/object):: (undocumented)
bsrSortedColIndA (Pointer/object):: (undocumented)
blockDim (int):: (undocumented)
info (bsrsm2Info/object):: (undocumented)
B (float2/object):: (undocumented)
ldb (int):: (undocumented)
X (float2/object):: (undocumented)
ldx (int):: (undocumented)
policy (hipsparseSolvePolicy_t):: (undocumented)
pBuffer (Pointer/object):: (undocumented)

hip.hipsparse.hipsparseZbsrsm2_solve(handle, dirA, transA, transX, int mb, int nrhs, int nnzb, alpha, descrA, bsrSortedValA, bsrSortedRowPtrA, bsrSortedColIndA, int blockDim, info, B, int ldb, X, int ldx, policy, pBuffer)#

(No short description, might be part of a group.)

Args:

handle (Pointer/object):: (undocumented)
dirA (hipsparseDirection_t):: (undocumented)
transA (hipsparseOperation_t):: (undocumented)
transX (hipsparseOperation_t):: (undocumented)
mb (int):: (undocumented)
nrhs (int):: (undocumented)
nnzb (int):: (undocumented)
alpha (double2/object):: (undocumented)
descrA (Pointer/object):: (undocumented)
bsrSortedValA (double2/object):: (undocumented)
bsrSortedRowPtrA (Pointer/object):: (undocumented)
bsrSortedColIndA (Pointer/object):: (undocumented)
blockDim (int):: (undocumented)
info (bsrsm2Info/object):: (undocumented)
B (double2/object):: (undocumented)
ldb (int):: (undocumented)
X (double2/object):: (undocumented)
ldx (int):: (undocumented)
policy (hipsparseSolvePolicy_t):: (undocumented)
pBuffer (Pointer/object):: (undocumented)

hip.hipsparse.hipsparseXcsrsm2_zeroPivot(handle, info, position)#

Sparse triangular system solve using CSR storage format

hipsparseXcsrsm2_zeroPivot returns HIPSPARSE_STATUS_ZERO_PIVOT , if either a structural or numerical zero has been found during hipsparseXcsrsm2_analysis() or hipsparseXcsrsm2_solve() computation. The first zero pivot \(j\) at \(A_{j,j}\) is stored in position, using same index base as the CSR matrix.

position can be in host or device memory. If no zero pivot has been found, position is set to -1 and HIPSPARSE_STATUS_SUCCESS is returned instead.

Note:

hipsparseXcsrsm2_zeroPivot is a blocking function. It might influence performance negatively.

Args:

handle (Pointer/object):: (undocumented)
info (csrsm2Info/object):: (undocumented)
position (Pointer/object):: (undocumented)

hip.hipsparse.hipsparseScsrsm2_bufferSizeExt(handle, int algo, transA, transB, int m, int nrhs, int nnz, alpha, descrA, csrSortedValA, csrSortedRowPtrA, csrSortedColIndA, B, int ldb, info, policy, pBufferSizeInBytes)#

Sparse triangular system solve using CSR storage format

hipsparseXcsrsm2_bufferSizeExt returns the size of the temporary storage buffer in bytes that is required by hipsparseXcsrsm2_analysis() and hipsparseXcsrsm2_solve(). The temporary storage buffer must be allocated by the user.

Args:

handle (Pointer/object):: (undocumented)
algo (int):: (undocumented)
transA (hipsparseOperation_t):: (undocumented)
transB (hipsparseOperation_t):: (undocumented)
m (int):: (undocumented)
nrhs (int):: (undocumented)
nnz (int):: (undocumented)
alpha (Pointer/object):: (undocumented)
descrA (Pointer/object):: (undocumented)
csrSortedValA (Pointer/object):: (undocumented)
csrSortedRowPtrA (Pointer/object):: (undocumented)
csrSortedColIndA (Pointer/object):: (undocumented)
B (Pointer/object):: (undocumented)
ldb (int):: (undocumented)
info (csrsm2Info/object):: (undocumented)
policy (hipsparseSolvePolicy_t):: (undocumented)
pBufferSizeInBytes (Pointer/object):: (undocumented)

hip.hipsparse.hipsparseDcsrsm2_bufferSizeExt(handle, int algo, transA, transB, int m, int nrhs, int nnz, alpha, descrA, csrSortedValA, csrSortedRowPtrA, csrSortedColIndA, B, int ldb, info, policy, pBufferSizeInBytes)#

(No short description, might be part of a group.)

Args:

handle (Pointer/object):: (undocumented)
algo (int):: (undocumented)
transA (hipsparseOperation_t):: (undocumented)
transB (hipsparseOperation_t):: (undocumented)
m (int):: (undocumented)
nrhs (int):: (undocumented)
nnz (int):: (undocumented)
alpha (Pointer/object):: (undocumented)
descrA (Pointer/object):: (undocumented)
csrSortedValA (Pointer/object):: (undocumented)
csrSortedRowPtrA (Pointer/object):: (undocumented)
csrSortedColIndA (Pointer/object):: (undocumented)
B (Pointer/object):: (undocumented)
ldb (int):: (undocumented)
info (csrsm2Info/object):: (undocumented)
policy (hipsparseSolvePolicy_t):: (undocumented)
pBufferSizeInBytes (Pointer/object):: (undocumented)

hip.hipsparse.hipsparseCcsrsm2_bufferSizeExt(handle, int algo, transA, transB, int m, int nrhs, int nnz, alpha, descrA, csrSortedValA, csrSortedRowPtrA, csrSortedColIndA, B, int ldb, info, policy, pBufferSizeInBytes)#

(No short description, might be part of a group.)

Args:

handle (Pointer/object):: (undocumented)
algo (int):: (undocumented)
transA (hipsparseOperation_t):: (undocumented)
transB (hipsparseOperation_t):: (undocumented)
m (int):: (undocumented)
nrhs (int):: (undocumented)
nnz (int):: (undocumented)
alpha (float2/object):: (undocumented)
descrA (Pointer/object):: (undocumented)
csrSortedValA (float2/object):: (undocumented)
csrSortedRowPtrA (Pointer/object):: (undocumented)
csrSortedColIndA (Pointer/object):: (undocumented)
B (float2/object):: (undocumented)
ldb (int):: (undocumented)
info (csrsm2Info/object):: (undocumented)
policy (hipsparseSolvePolicy_t):: (undocumented)
pBufferSizeInBytes (Pointer/object):: (undocumented)

hip.hipsparse.hipsparseZcsrsm2_bufferSizeExt(handle, int algo, transA, transB, int m, int nrhs, int nnz, alpha, descrA, csrSortedValA, csrSortedRowPtrA, csrSortedColIndA, B, int ldb, info, policy, pBufferSizeInBytes)#

(No short description, might be part of a group.)

Args:

handle (Pointer/object):: (undocumented)
algo (int):: (undocumented)
transA (hipsparseOperation_t):: (undocumented)
transB (hipsparseOperation_t):: (undocumented)
m (int):: (undocumented)
nrhs (int):: (undocumented)
nnz (int):: (undocumented)
alpha (double2/object):: (undocumented)
descrA (Pointer/object):: (undocumented)
csrSortedValA (double2/object):: (undocumented)
csrSortedRowPtrA (Pointer/object):: (undocumented)
csrSortedColIndA (Pointer/object):: (undocumented)
B (double2/object):: (undocumented)
ldb (int):: (undocumented)
info (csrsm2Info/object):: (undocumented)
policy (hipsparseSolvePolicy_t):: (undocumented)
pBufferSizeInBytes (Pointer/object):: (undocumented)

hip.hipsparse.hipsparseScsrsm2_analysis(handle, int algo, transA, transB, int m, int nrhs, int nnz, alpha, descrA, csrSortedValA, csrSortedRowPtrA, csrSortedColIndA, B, int ldb, info, policy, pBuffer)#

Sparse triangular system solve using CSR storage format

hipsparseXcsrsm2_analysis performs the analysis step for hipsparseXcsrsm2_solve().

Note:

If the matrix sparsity pattern changes, the gathered information will become invalid.

Note:

This function is non blocking and executed asynchronously with respect to the host. It may return before the actual computation has finished.

Args:

handle (Pointer/object):: (undocumented)
algo (int):: (undocumented)
transA (hipsparseOperation_t):: (undocumented)
transB (hipsparseOperation_t):: (undocumented)
m (int):: (undocumented)
nrhs (int):: (undocumented)
nnz (int):: (undocumented)
alpha (Pointer/object):: (undocumented)
descrA (Pointer/object):: (undocumented)
csrSortedValA (Pointer/object):: (undocumented)
csrSortedRowPtrA (Pointer/object):: (undocumented)
csrSortedColIndA (Pointer/object):: (undocumented)
B (Pointer/object):: (undocumented)
ldb (int):: (undocumented)
info (csrsm2Info/object):: (undocumented)
policy (hipsparseSolvePolicy_t):: (undocumented)
pBuffer (Pointer/object):: (undocumented)

hip.hipsparse.hipsparseDcsrsm2_analysis(handle, int algo, transA, transB, int m, int nrhs, int nnz, alpha, descrA, csrSortedValA, csrSortedRowPtrA, csrSortedColIndA, B, int ldb, info, policy, pBuffer)#

(No short description, might be part of a group.)

Args:

handle (Pointer/object):: (undocumented)
algo (int):: (undocumented)
transA (hipsparseOperation_t):: (undocumented)
transB (hipsparseOperation_t):: (undocumented)
m (int):: (undocumented)
nrhs (int):: (undocumented)
nnz (int):: (undocumented)
alpha (Pointer/object):: (undocumented)
descrA (Pointer/object):: (undocumented)
csrSortedValA (Pointer/object):: (undocumented)
csrSortedRowPtrA (Pointer/object):: (undocumented)
csrSortedColIndA (Pointer/object):: (undocumented)
B (Pointer/object):: (undocumented)
ldb (int):: (undocumented)
info (csrsm2Info/object):: (undocumented)
policy (hipsparseSolvePolicy_t):: (undocumented)
pBuffer (Pointer/object):: (undocumented)

hip.hipsparse.hipsparseCcsrsm2_analysis(handle, int algo, transA, transB, int m, int nrhs, int nnz, alpha, descrA, csrSortedValA, csrSortedRowPtrA, csrSortedColIndA, B, int ldb, info, policy, pBuffer)#

(No short description, might be part of a group.)

Args:

handle (Pointer/object):: (undocumented)
algo (int):: (undocumented)
transA (hipsparseOperation_t):: (undocumented)
transB (hipsparseOperation_t):: (undocumented)
m (int):: (undocumented)
nrhs (int):: (undocumented)
nnz (int):: (undocumented)
alpha (float2/object):: (undocumented)
descrA (Pointer/object):: (undocumented)
csrSortedValA (float2/object):: (undocumented)
csrSortedRowPtrA (Pointer/object):: (undocumented)
csrSortedColIndA (Pointer/object):: (undocumented)
B (float2/object):: (undocumented)
ldb (int):: (undocumented)
info (csrsm2Info/object):: (undocumented)
policy (hipsparseSolvePolicy_t):: (undocumented)
pBuffer (Pointer/object):: (undocumented)

hip.hipsparse.hipsparseZcsrsm2_analysis(handle, int algo, transA, transB, int m, int nrhs, int nnz, alpha, descrA, csrSortedValA, csrSortedRowPtrA, csrSortedColIndA, B, int ldb, info, policy, pBuffer)#

(No short description, might be part of a group.)

Args:

handle (Pointer/object):: (undocumented)
algo (int):: (undocumented)
transA (hipsparseOperation_t):: (undocumented)
transB (hipsparseOperation_t):: (undocumented)
m (int):: (undocumented)
nrhs (int):: (undocumented)
nnz (int):: (undocumented)
alpha (double2/object):: (undocumented)
descrA (Pointer/object):: (undocumented)
csrSortedValA (double2/object):: (undocumented)
csrSortedRowPtrA (Pointer/object):: (undocumented)
csrSortedColIndA (Pointer/object):: (undocumented)
B (double2/object):: (undocumented)
ldb (int):: (undocumented)
info (csrsm2Info/object):: (undocumented)
policy (hipsparseSolvePolicy_t):: (undocumented)
pBuffer (Pointer/object):: (undocumented)

hip.hipsparse.hipsparseScsrsm2_solve(handle, int algo, transA, transB, int m, int nrhs, int nnz, alpha, descrA, csrSortedValA, csrSortedRowPtrA, csrSortedColIndA, B, int ldb, info, policy, pBuffer)#

Sparse triangular system solve using CSR storage format

hipsparseXcsrsm2_solve solves a sparse triangular linear system of a sparse \(m \times m\) matrix, defined in CSR storage format, a dense solution matrix \(X\) and the right-hand side matrix \(B\) that is multiplied by \(\alpha\), such that

\[op(A) \cdot op(X) = \alpha \cdot op(B),\]

with

\[\begin{split}op(A) = \left\{ \begin{array}{ll} A, & \text{if trans_A == HIPSPARSE_OPERATION_NON_TRANSPOSE} \\ A^T, & \text{if trans_A == HIPSPARSE_OPERATION_TRANSPOSE} \\ A^H, & \text{if trans_A == HIPSPARSE_OPERATION_CONJUGATE_TRANSPOSE} \end{array} \right.\end{split}\]

,

\[\begin{split}op(B) = \left\{ \begin{array}{ll} B, & \text{if trans_B == HIPSPARSE_OPERATION_NON_TRANSPOSE} \\ B^T, & \text{if trans_B == HIPSPARSE_OPERATION_TRANSPOSE} \\ B^H, & \text{if trans_B == HIPSPARSE_OPERATION_CONJUGATE_TRANSPOSE} \end{array} \right.\end{split}\]

and

\[\begin{split}op(X) = \left\{ \begin{array}{ll} X, & \text{if trans_B == HIPSPARSE_OPERATION_NON_TRANSPOSE} \\ X^T, & \text{if trans_B == HIPSPARSE_OPERATION_TRANSPOSE} \\ X^H, & \text{if trans_B == HIPSPARSE_OPERATION_CONJUGATE_TRANSPOSE} \end{array} \right.\end{split}\]

Note:

The sparse CSR matrix has to be sorted. This can be achieved by calling hipsparseXcsrsort().

Note:

This function is non blocking and executed asynchronously with respect to the host. It may return before the actual computation has finished.

Note:

Currently, only trans_A != HIPSPARSE_OPERATION_CONJUGATE_TRANSPOSE and trans_B != HIPSPARSE_OPERATION_CONJUGATE_TRANSPOSE is supported.

Args:

handle (Pointer/object):: (undocumented)
algo (int):: (undocumented)
transA (hipsparseOperation_t):: (undocumented)
transB (hipsparseOperation_t):: (undocumented)
m (int):: (undocumented)
nrhs (int):: (undocumented)
nnz (int):: (undocumented)
alpha (Pointer/object):: (undocumented)
descrA (Pointer/object):: (undocumented)
csrSortedValA (Pointer/object):: (undocumented)
csrSortedRowPtrA (Pointer/object):: (undocumented)
csrSortedColIndA (Pointer/object):: (undocumented)
B (Pointer/object):: (undocumented)
ldb (int):: (undocumented)
info (csrsm2Info/object):: (undocumented)
policy (hipsparseSolvePolicy_t):: (undocumented)
pBuffer (Pointer/object):: (undocumented)

hip.hipsparse.hipsparseDcsrsm2_solve(handle, int algo, transA, transB, int m, int nrhs, int nnz, alpha, descrA, csrSortedValA, csrSortedRowPtrA, csrSortedColIndA, B, int ldb, info, policy, pBuffer)#

(No short description, might be part of a group.)

Args:

handle (Pointer/object):: (undocumented)
algo (int):: (undocumented)
transA (hipsparseOperation_t):: (undocumented)
transB (hipsparseOperation_t):: (undocumented)
m (int):: (undocumented)
nrhs (int):: (undocumented)
nnz (int):: (undocumented)
alpha (Pointer/object):: (undocumented)
descrA (Pointer/object):: (undocumented)
csrSortedValA (Pointer/object):: (undocumented)
csrSortedRowPtrA (Pointer/object):: (undocumented)
csrSortedColIndA (Pointer/object):: (undocumented)
B (Pointer/object):: (undocumented)
ldb (int):: (undocumented)
info (csrsm2Info/object):: (undocumented)
policy (hipsparseSolvePolicy_t):: (undocumented)
pBuffer (Pointer/object):: (undocumented)

hip.hipsparse.hipsparseCcsrsm2_solve(handle, int algo, transA, transB, int m, int nrhs, int nnz, alpha, descrA, csrSortedValA, csrSortedRowPtrA, csrSortedColIndA, B, int ldb, info, policy, pBuffer)#

(No short description, might be part of a group.)

Args:

handle (Pointer/object):: (undocumented)
algo (int):: (undocumented)
transA (hipsparseOperation_t):: (undocumented)
transB (hipsparseOperation_t):: (undocumented)
m (int):: (undocumented)
nrhs (int):: (undocumented)
nnz (int):: (undocumented)
alpha (float2/object):: (undocumented)
descrA (Pointer/object):: (undocumented)
csrSortedValA (float2/object):: (undocumented)
csrSortedRowPtrA (Pointer/object):: (undocumented)
csrSortedColIndA (Pointer/object):: (undocumented)
B (float2/object):: (undocumented)
ldb (int):: (undocumented)
info (csrsm2Info/object):: (undocumented)
policy (hipsparseSolvePolicy_t):: (undocumented)
pBuffer (Pointer/object):: (undocumented)

hip.hipsparse.hipsparseZcsrsm2_solve(handle, int algo, transA, transB, int m, int nrhs, int nnz, alpha, descrA, csrSortedValA, csrSortedRowPtrA, csrSortedColIndA, B, int ldb, info, policy, pBuffer)#

(No short description, might be part of a group.)

Args:

handle (Pointer/object):: (undocumented)
algo (int):: (undocumented)
transA (hipsparseOperation_t):: (undocumented)
transB (hipsparseOperation_t):: (undocumented)
m (int):: (undocumented)
nrhs (int):: (undocumented)
nnz (int):: (undocumented)
alpha (double2/object):: (undocumented)
descrA (Pointer/object):: (undocumented)
csrSortedValA (double2/object):: (undocumented)
csrSortedRowPtrA (Pointer/object):: (undocumented)
csrSortedColIndA (Pointer/object):: (undocumented)
B (double2/object):: (undocumented)
ldb (int):: (undocumented)
info (csrsm2Info/object):: (undocumented)
policy (hipsparseSolvePolicy_t):: (undocumented)
pBuffer (Pointer/object):: (undocumented)

hip.hipsparse.hipsparseSgemmi(handle, int m, int n, int k, int nnz, alpha, A, int lda, cscValB, cscColPtrB, cscRowIndB, beta, C, int ldc)#

Dense matrix sparse matrix multiplication using CSR storage format

hipsparseXgemmi multiplies the scalar \(\alpha\) with a dense \(m \times k\) matrix \(A\) and the sparse \(k \times n\) matrix \(B\), defined in CSR storage format and adds the result to the dense \(m \times n\) matrix \(C\) that is multiplied by the scalar \(\beta\), such that

\[C := \alpha \cdot op(A) \cdot op(B) + \beta \cdot C\]

with

\[\begin{split}op(A) = \left\{ \begin{array}{ll} A, & \text{if trans_A == HIPSPARSE_OPERATION_NON_TRANSPOSE} \\ A^T, & \text{if trans_A == HIPSPARSE_OPERATION_TRANSPOSE} \\ A^H, & \text{if trans_A == HIPSPARSE_OPERATION_CONJUGATE_TRANSPOSE} \end{array} \right.\end{split}\]

and

\[\begin{split}op(B) = \left\{ \begin{array}{ll} B, & \text{if trans_B == HIPSPARSE_OPERATION_NON_TRANSPOSE} \\ B^T, & \text{if trans_B == HIPSPARSE_OPERATION_TRANSPOSE} \\ B^H, & \text{if trans_B == HIPSPARSE_OPERATION_CONJUGATE_TRANSPOSE} \end{array} \right.\end{split}\]

Note:

This function is non blocking and executed asynchronously with respect to the host. It may return before the actual computation has finished.

Args:

handle (Pointer/object):: (undocumented)
m (int):: (undocumented)
n (int):: (undocumented)
k (int):: (undocumented)
nnz (int):: (undocumented)
alpha (Pointer/object):: (undocumented)
A (Pointer/object):: (undocumented)
lda (int):: (undocumented)
cscValB (Pointer/object):: (undocumented)
cscColPtrB (Pointer/object):: (undocumented)
cscRowIndB (Pointer/object):: (undocumented)
beta (Pointer/object):: (undocumented)
C (Pointer/object):: (undocumented)
ldc (int):: (undocumented)

hip.hipsparse.hipsparseDgemmi(handle, int m, int n, int k, int nnz, alpha, A, int lda, cscValB, cscColPtrB, cscRowIndB, beta, C, int ldc)#

(No short description, might be part of a group.)

Args:

handle (Pointer/object):: (undocumented)
m (int):: (undocumented)
n (int):: (undocumented)
k (int):: (undocumented)
nnz (int):: (undocumented)
alpha (Pointer/object):: (undocumented)
A (Pointer/object):: (undocumented)
lda (int):: (undocumented)
cscValB (Pointer/object):: (undocumented)
cscColPtrB (Pointer/object):: (undocumented)
cscRowIndB (Pointer/object):: (undocumented)
beta (Pointer/object):: (undocumented)
C (Pointer/object):: (undocumented)
ldc (int):: (undocumented)

hip.hipsparse.hipsparseCgemmi(handle, int m, int n, int k, int nnz, alpha, A, int lda, cscValB, cscColPtrB, cscRowIndB, beta, C, int ldc)#

(No short description, might be part of a group.)

Args:

handle (Pointer/object):: (undocumented)
m (int):: (undocumented)
n (int):: (undocumented)
k (int):: (undocumented)
nnz (int):: (undocumented)
alpha (float2/object):: (undocumented)
A (float2/object):: (undocumented)
lda (int):: (undocumented)
cscValB (float2/object):: (undocumented)
cscColPtrB (Pointer/object):: (undocumented)
cscRowIndB (Pointer/object):: (undocumented)
beta (float2/object):: (undocumented)
C (float2/object):: (undocumented)
ldc (int):: (undocumented)

hip.hipsparse.hipsparseZgemmi(handle, int m, int n, int k, int nnz, alpha, A, int lda, cscValB, cscColPtrB, cscRowIndB, beta, C, int ldc)#

(No short description, might be part of a group.)

Args:

handle (Pointer/object):: (undocumented)
m (int):: (undocumented)
n (int):: (undocumented)
k (int):: (undocumented)
nnz (int):: (undocumented)
alpha (double2/object):: (undocumented)
A (double2/object):: (undocumented)
lda (int):: (undocumented)
cscValB (double2/object):: (undocumented)
cscColPtrB (Pointer/object):: (undocumented)
cscRowIndB (Pointer/object):: (undocumented)
beta (double2/object):: (undocumented)
C (double2/object):: (undocumented)
ldc (int):: (undocumented)

hip.hipsparse.hipsparseXcsrgeamNnz(handle, int m, int n, descrA, int nnzA, csrRowPtrA, csrColIndA, descrB, int nnzB, csrRowPtrB, csrColIndB, descrC, csrRowPtrC, nnzTotalDevHostPtr)#

Sparse matrix sparse matrix addition using CSR storage format

hipsparseXcsrgeamNnz computes the total CSR non-zero elements and the CSR row offsets, that point to the start of every row of the sparse CSR matrix, of the resulting matrix C. It is assumed that csr_row_ptr_C has been allocated with size m + 1.

Note:

This function is non blocking and executed asynchronously with respect to the host. It may return before the actual computation has finished.

Note:

Currently, only HIPSPARSE_MATRIX_TYPE_GENERAL is supported.

Args:

handle (Pointer/object):: (undocumented)
m (int):: (undocumented)
n (int):: (undocumented)
descrA (Pointer/object):: (undocumented)
nnzA (int):: (undocumented)
csrRowPtrA (Pointer/object):: (undocumented)
csrColIndA (Pointer/object):: (undocumented)
descrB (Pointer/object):: (undocumented)
nnzB (int):: (undocumented)
csrRowPtrB (Pointer/object):: (undocumented)
csrColIndB (Pointer/object):: (undocumented)
descrC (Pointer/object):: (undocumented)
csrRowPtrC (Pointer/object):: (undocumented)
nnzTotalDevHostPtr (Pointer/object):: (undocumented)

hip.hipsparse.hipsparseScsrgeam(handle, int m, int n, alpha, descrA, int nnzA, csrValA, csrRowPtrA, csrColIndA, beta, descrB, int nnzB, csrValB, csrRowPtrB, csrColIndB, descrC, csrValC, csrRowPtrC, csrColIndC)#

Sparse matrix sparse matrix addition using CSR storage format

hipsparseXcsrgeam multiplies the scalar \(\alpha\) with the sparse \(m \times n\) matrix \(A\), defined in CSR storage format, multiplies the scalar \(\beta\) with the sparse \(m \times n\) matrix \(B\), defined in CSR storage format, and adds both resulting matrices to obtain the sparse \(m \times n\) matrix \(C\), defined in CSR storage format, such that

\[C := \alpha \cdot A + \beta \cdot B.\]

Note:

Both scalars \(\alpha\) and \(beta\) have to be valid.

Note:

Currently, only HIPSPARSE_MATRIX_TYPE_GENERAL is supported.

Note:

This function is non blocking and executed asynchronously with respect to the host. It may return before the actual computation has finished.

Args:

handle (Pointer/object):: (undocumented)
m (int):: (undocumented)
n (int):: (undocumented)
alpha (Pointer/object):: (undocumented)
descrA (Pointer/object):: (undocumented)
nnzA (int):: (undocumented)
csrValA (Pointer/object):: (undocumented)
csrRowPtrA (Pointer/object):: (undocumented)
csrColIndA (Pointer/object):: (undocumented)
beta (Pointer/object):: (undocumented)
descrB (Pointer/object):: (undocumented)
nnzB (int):: (undocumented)
csrValB (Pointer/object):: (undocumented)
csrRowPtrB (Pointer/object):: (undocumented)
csrColIndB (Pointer/object):: (undocumented)
descrC (Pointer/object):: (undocumented)
csrValC (Pointer/object):: (undocumented)
csrRowPtrC (Pointer/object):: (undocumented)
csrColIndC (Pointer/object):: (undocumented)

hip.hipsparse.hipsparseDcsrgeam(handle, int m, int n, alpha, descrA, int nnzA, csrValA, csrRowPtrA, csrColIndA, beta, descrB, int nnzB, csrValB, csrRowPtrB, csrColIndB, descrC, csrValC, csrRowPtrC, csrColIndC)#

(No short description, might be part of a group.)

Args:

handle (Pointer/object):: (undocumented)
m (int):: (undocumented)
n (int):: (undocumented)
alpha (Pointer/object):: (undocumented)
descrA (Pointer/object):: (undocumented)
nnzA (int):: (undocumented)
csrValA (Pointer/object):: (undocumented)
csrRowPtrA (Pointer/object):: (undocumented)
csrColIndA (Pointer/object):: (undocumented)
beta (Pointer/object):: (undocumented)
descrB (Pointer/object):: (undocumented)
nnzB (int):: (undocumented)
csrValB (Pointer/object):: (undocumented)
csrRowPtrB (Pointer/object):: (undocumented)
csrColIndB (Pointer/object):: (undocumented)
descrC (Pointer/object):: (undocumented)
csrValC (Pointer/object):: (undocumented)
csrRowPtrC (Pointer/object):: (undocumented)
csrColIndC (Pointer/object):: (undocumented)

hip.hipsparse.hipsparseCcsrgeam(handle, int m, int n, alpha, descrA, int nnzA, csrValA, csrRowPtrA, csrColIndA, beta, descrB, int nnzB, csrValB, csrRowPtrB, csrColIndB, descrC, csrValC, csrRowPtrC, csrColIndC)#

(No short description, might be part of a group.)

Args:

handle (Pointer/object):: (undocumented)
m (int):: (undocumented)
n (int):: (undocumented)
alpha (float2/object):: (undocumented)
descrA (Pointer/object):: (undocumented)
nnzA (int):: (undocumented)
csrValA (float2/object):: (undocumented)
csrRowPtrA (Pointer/object):: (undocumented)
csrColIndA (Pointer/object):: (undocumented)
beta (float2/object):: (undocumented)
descrB (Pointer/object):: (undocumented)
nnzB (int):: (undocumented)
csrValB (float2/object):: (undocumented)
csrRowPtrB (Pointer/object):: (undocumented)
csrColIndB (Pointer/object):: (undocumented)
descrC (Pointer/object):: (undocumented)
csrValC (float2/object):: (undocumented)
csrRowPtrC (Pointer/object):: (undocumented)
csrColIndC (Pointer/object):: (undocumented)

hip.hipsparse.hipsparseZcsrgeam(handle, int m, int n, alpha, descrA, int nnzA, csrValA, csrRowPtrA, csrColIndA, beta, descrB, int nnzB, csrValB, csrRowPtrB, csrColIndB, descrC, csrValC, csrRowPtrC, csrColIndC)#

(No short description, might be part of a group.)

Args:

handle (Pointer/object):: (undocumented)
m (int):: (undocumented)
n (int):: (undocumented)
alpha (double2/object):: (undocumented)
descrA (Pointer/object):: (undocumented)
nnzA (int):: (undocumented)
csrValA (double2/object):: (undocumented)
csrRowPtrA (Pointer/object):: (undocumented)
csrColIndA (Pointer/object):: (undocumented)
beta (double2/object):: (undocumented)
descrB (Pointer/object):: (undocumented)
nnzB (int):: (undocumented)
csrValB (double2/object):: (undocumented)
csrRowPtrB (Pointer/object):: (undocumented)
csrColIndB (Pointer/object):: (undocumented)
descrC (Pointer/object):: (undocumented)
csrValC (double2/object):: (undocumented)
csrRowPtrC (Pointer/object):: (undocumented)
csrColIndC (Pointer/object):: (undocumented)

hip.hipsparse.hipsparseScsrgeam2_bufferSizeExt(handle, int m, int n, alpha, descrA, int nnzA, csrSortedValA, csrSortedRowPtrA, csrSortedColIndA, beta, descrB, int nnzB, csrSortedValB, csrSortedRowPtrB, csrSortedColIndB, descrC, csrSortedValC, csrSortedRowPtrC, csrSortedColIndC, pBufferSizeInBytes)#

Sparse matrix sparse matrix multiplication using CSR storage format

hipsparseXcsrgeam2_bufferSizeExt returns the size of the temporary storage buffer in bytes that is required by hipsparseXcsrgeam2Nnz() and hipsparseXcsrgeam2(). The temporary storage buffer must be allocated by the user.

Note:

Currently, only HIPSPARSE_MATRIX_TYPE_GENERAL is supported.

Args:

handle (Pointer/object):: (undocumented)
m (int):: (undocumented)
n (int):: (undocumented)
alpha (Pointer/object):: (undocumented)
descrA (Pointer/object):: (undocumented)
nnzA (int):: (undocumented)
csrSortedValA (Pointer/object):: (undocumented)
csrSortedRowPtrA (Pointer/object):: (undocumented)
csrSortedColIndA (Pointer/object):: (undocumented)
beta (Pointer/object):: (undocumented)
descrB (Pointer/object):: (undocumented)
nnzB (int):: (undocumented)
csrSortedValB (Pointer/object):: (undocumented)
csrSortedRowPtrB (Pointer/object):: (undocumented)
csrSortedColIndB (Pointer/object):: (undocumented)
descrC (Pointer/object):: (undocumented)
csrSortedValC (Pointer/object):: (undocumented)
csrSortedRowPtrC (Pointer/object):: (undocumented)
csrSortedColIndC (Pointer/object):: (undocumented)
pBufferSizeInBytes (Pointer/object):: (undocumented)

hip.hipsparse.hipsparseDcsrgeam2_bufferSizeExt(handle, int m, int n, alpha, descrA, int nnzA, csrSortedValA, csrSortedRowPtrA, csrSortedColIndA, beta, descrB, int nnzB, csrSortedValB, csrSortedRowPtrB, csrSortedColIndB, descrC, csrSortedValC, csrSortedRowPtrC, csrSortedColIndC, pBufferSizeInBytes)#

(No short description, might be part of a group.)

Args:

handle (Pointer/object):: (undocumented)
m (int):: (undocumented)
n (int):: (undocumented)
alpha (Pointer/object):: (undocumented)
descrA (Pointer/object):: (undocumented)
nnzA (int):: (undocumented)
csrSortedValA (Pointer/object):: (undocumented)
csrSortedRowPtrA (Pointer/object):: (undocumented)
csrSortedColIndA (Pointer/object):: (undocumented)
beta (Pointer/object):: (undocumented)
descrB (Pointer/object):: (undocumented)
nnzB (int):: (undocumented)
csrSortedValB (Pointer/object):: (undocumented)
csrSortedRowPtrB (Pointer/object):: (undocumented)
csrSortedColIndB (Pointer/object):: (undocumented)
descrC (Pointer/object):: (undocumented)
csrSortedValC (Pointer/object):: (undocumented)
csrSortedRowPtrC (Pointer/object):: (undocumented)
csrSortedColIndC (Pointer/object):: (undocumented)
pBufferSizeInBytes (Pointer/object):: (undocumented)

hip.hipsparse.hipsparseCcsrgeam2_bufferSizeExt(handle, int m, int n, alpha, descrA, int nnzA, csrSortedValA, csrSortedRowPtrA, csrSortedColIndA, beta, descrB, int nnzB, csrSortedValB, csrSortedRowPtrB, csrSortedColIndB, descrC, csrSortedValC, csrSortedRowPtrC, csrSortedColIndC, pBufferSizeInBytes)#

(No short description, might be part of a group.)

Args:

handle (Pointer/object):: (undocumented)
m (int):: (undocumented)
n (int):: (undocumented)
alpha (float2/object):: (undocumented)
descrA (Pointer/object):: (undocumented)
nnzA (int):: (undocumented)
csrSortedValA (float2/object):: (undocumented)
csrSortedRowPtrA (Pointer/object):: (undocumented)
csrSortedColIndA (Pointer/object):: (undocumented)
beta (float2/object):: (undocumented)
descrB (Pointer/object):: (undocumented)
nnzB (int):: (undocumented)
csrSortedValB (float2/object):: (undocumented)
csrSortedRowPtrB (Pointer/object):: (undocumented)
csrSortedColIndB (Pointer/object):: (undocumented)
descrC (Pointer/object):: (undocumented)
csrSortedValC (float2/object):: (undocumented)
csrSortedRowPtrC (Pointer/object):: (undocumented)
csrSortedColIndC (Pointer/object):: (undocumented)
pBufferSizeInBytes (Pointer/object):: (undocumented)

hip.hipsparse.hipsparseZcsrgeam2_bufferSizeExt(handle, int m, int n, alpha, descrA, int nnzA, csrSortedValA, csrSortedRowPtrA, csrSortedColIndA, beta, descrB, int nnzB, csrSortedValB, csrSortedRowPtrB, csrSortedColIndB, descrC, csrSortedValC, csrSortedRowPtrC, csrSortedColIndC, pBufferSizeInBytes)#

(No short description, might be part of a group.)

Args:

handle (Pointer/object):: (undocumented)
m (int):: (undocumented)
n (int):: (undocumented)
alpha (double2/object):: (undocumented)
descrA (Pointer/object):: (undocumented)
nnzA (int):: (undocumented)
csrSortedValA (double2/object):: (undocumented)
csrSortedRowPtrA (Pointer/object):: (undocumented)
csrSortedColIndA (Pointer/object):: (undocumented)
beta (double2/object):: (undocumented)
descrB (Pointer/object):: (undocumented)
nnzB (int):: (undocumented)
csrSortedValB (double2/object):: (undocumented)
csrSortedRowPtrB (Pointer/object):: (undocumented)
csrSortedColIndB (Pointer/object):: (undocumented)
descrC (Pointer/object):: (undocumented)
csrSortedValC (double2/object):: (undocumented)
csrSortedRowPtrC (Pointer/object):: (undocumented)
csrSortedColIndC (Pointer/object):: (undocumented)
pBufferSizeInBytes (Pointer/object):: (undocumented)

hip.hipsparse.hipsparseXcsrgeam2Nnz(handle, int m, int n, descrA, int nnzA, csrSortedRowPtrA, csrSortedColIndA, descrB, int nnzB, csrSortedRowPtrB, csrSortedColIndB, descrC, csrSortedRowPtrC, nnzTotalDevHostPtr, workspace)#

Sparse matrix sparse matrix addition using CSR storage format

hipsparseXcsrgeam2Nnz computes the total CSR non-zero elements and the CSR row offsets, that point to the start of every row of the sparse CSR matrix, of the resulting matrix C. It is assumed that csr_row_ptr_C has been allocated with size m + 1.

Note:

This function is non blocking and executed asynchronously with respect to the host. It may return before the actual computation has finished.

Note:

Currently, only HIPSPARSE_MATRIX_TYPE_GENERAL is supported.

Args:

handle (Pointer/object):: (undocumented)
m (int):: (undocumented)
n (int):: (undocumented)
descrA (Pointer/object):: (undocumented)
nnzA (int):: (undocumented)
csrSortedRowPtrA (Pointer/object):: (undocumented)
csrSortedColIndA (Pointer/object):: (undocumented)
descrB (Pointer/object):: (undocumented)
nnzB (int):: (undocumented)
csrSortedRowPtrB (Pointer/object):: (undocumented)
csrSortedColIndB (Pointer/object):: (undocumented)
descrC (Pointer/object):: (undocumented)
csrSortedRowPtrC (Pointer/object):: (undocumented)
nnzTotalDevHostPtr (Pointer/object):: (undocumented)
workspace (Pointer/object):: (undocumented)

hip.hipsparse.hipsparseScsrgeam2(handle, int m, int n, alpha, descrA, int nnzA, csrSortedValA, csrSortedRowPtrA, csrSortedColIndA, beta, descrB, int nnzB, csrSortedValB, csrSortedRowPtrB, csrSortedColIndB, descrC, csrSortedValC, csrSortedRowPtrC, csrSortedColIndC, pBuffer)#

Sparse matrix sparse matrix addition using CSR storage format

hipsparseXcsrgeam2 multiplies the scalar \(\alpha\) with the sparse \(m \times n\) matrix \(A\), defined in CSR storage format, multiplies the scalar \(\beta\) with the sparse \(m \times n\) matrix \(B\), defined in CSR storage format, and adds both resulting matrices to obtain the sparse \(m \times n\) matrix \(C\), defined in CSR storage format, such that

\[C := \alpha \cdot A + \beta \cdot B.\]

Note:

Both scalars \(\alpha\) and \(beta\) have to be valid.

Note:

Currently, only HIPSPARSE_MATRIX_TYPE_GENERAL is supported.

Note:

This function is non blocking and executed asynchronously with respect to the host. It may return before the actual computation has finished.

Args:

handle (Pointer/object):: (undocumented)
m (int):: (undocumented)
n (int):: (undocumented)
alpha (Pointer/object):: (undocumented)
descrA (Pointer/object):: (undocumented)
nnzA (int):: (undocumented)
csrSortedValA (Pointer/object):: (undocumented)
csrSortedRowPtrA (Pointer/object):: (undocumented)
csrSortedColIndA (Pointer/object):: (undocumented)
beta (Pointer/object):: (undocumented)
descrB (Pointer/object):: (undocumented)
nnzB (int):: (undocumented)
csrSortedValB (Pointer/object):: (undocumented)
csrSortedRowPtrB (Pointer/object):: (undocumented)
csrSortedColIndB (Pointer/object):: (undocumented)
descrC (Pointer/object):: (undocumented)
csrSortedValC (Pointer/object):: (undocumented)
csrSortedRowPtrC (Pointer/object):: (undocumented)
csrSortedColIndC (Pointer/object):: (undocumented)
pBuffer (Pointer/object):: (undocumented)

hip.hipsparse.hipsparseDcsrgeam2(handle, int m, int n, alpha, descrA, int nnzA, csrSortedValA, csrSortedRowPtrA, csrSortedColIndA, beta, descrB, int nnzB, csrSortedValB, csrSortedRowPtrB, csrSortedColIndB, descrC, csrSortedValC, csrSortedRowPtrC, csrSortedColIndC, pBuffer)#

(No short description, might be part of a group.)

Args:

handle (Pointer/object):: (undocumented)
m (int):: (undocumented)
n (int):: (undocumented)
alpha (Pointer/object):: (undocumented)
descrA (Pointer/object):: (undocumented)
nnzA (int):: (undocumented)
csrSortedValA (Pointer/object):: (undocumented)
csrSortedRowPtrA (Pointer/object):: (undocumented)
csrSortedColIndA (Pointer/object):: (undocumented)
beta (Pointer/object):: (undocumented)
descrB (Pointer/object):: (undocumented)
nnzB (int):: (undocumented)
csrSortedValB (Pointer/object):: (undocumented)
csrSortedRowPtrB (Pointer/object):: (undocumented)
csrSortedColIndB (Pointer/object):: (undocumented)
descrC (Pointer/object):: (undocumented)
csrSortedValC (Pointer/object):: (undocumented)
csrSortedRowPtrC (Pointer/object):: (undocumented)
csrSortedColIndC (Pointer/object):: (undocumented)
pBuffer (Pointer/object):: (undocumented)

hip.hipsparse.hipsparseCcsrgeam2(handle, int m, int n, alpha, descrA, int nnzA, csrSortedValA, csrSortedRowPtrA, csrSortedColIndA, beta, descrB, int nnzB, csrSortedValB, csrSortedRowPtrB, csrSortedColIndB, descrC, csrSortedValC, csrSortedRowPtrC, csrSortedColIndC, pBuffer)#

(No short description, might be part of a group.)

Args:

handle (Pointer/object):: (undocumented)
m (int):: (undocumented)
n (int):: (undocumented)
alpha (float2/object):: (undocumented)
descrA (Pointer/object):: (undocumented)
nnzA (int):: (undocumented)
csrSortedValA (float2/object):: (undocumented)
csrSortedRowPtrA (Pointer/object):: (undocumented)
csrSortedColIndA (Pointer/object):: (undocumented)
beta (float2/object):: (undocumented)
descrB (Pointer/object):: (undocumented)
nnzB (int):: (undocumented)
csrSortedValB (float2/object):: (undocumented)
csrSortedRowPtrB (Pointer/object):: (undocumented)
csrSortedColIndB (Pointer/object):: (undocumented)
descrC (Pointer/object):: (undocumented)
csrSortedValC (float2/object):: (undocumented)
csrSortedRowPtrC (Pointer/object):: (undocumented)
csrSortedColIndC (Pointer/object):: (undocumented)
pBuffer (Pointer/object):: (undocumented)

hip.hipsparse.hipsparseZcsrgeam2(handle, int m, int n, alpha, descrA, int nnzA, csrSortedValA, csrSortedRowPtrA, csrSortedColIndA, beta, descrB, int nnzB, csrSortedValB, csrSortedRowPtrB, csrSortedColIndB, descrC, csrSortedValC, csrSortedRowPtrC, csrSortedColIndC, pBuffer)#

(No short description, might be part of a group.)

Args:

handle (Pointer/object):: (undocumented)
m (int):: (undocumented)
n (int):: (undocumented)
alpha (double2/object):: (undocumented)
descrA (Pointer/object):: (undocumented)
nnzA (int):: (undocumented)
csrSortedValA (double2/object):: (undocumented)
csrSortedRowPtrA (Pointer/object):: (undocumented)
csrSortedColIndA (Pointer/object):: (undocumented)
beta (double2/object):: (undocumented)
descrB (Pointer/object):: (undocumented)
nnzB (int):: (undocumented)
csrSortedValB (double2/object):: (undocumented)
csrSortedRowPtrB (Pointer/object):: (undocumented)
csrSortedColIndB (Pointer/object):: (undocumented)
descrC (Pointer/object):: (undocumented)
csrSortedValC (double2/object):: (undocumented)
csrSortedRowPtrC (Pointer/object):: (undocumented)
csrSortedColIndC (Pointer/object):: (undocumented)
pBuffer (Pointer/object):: (undocumented)

hip.hipsparse.hipsparseXcsrgemmNnz(handle, transA, transB, int m, int n, int k, descrA, int nnzA, csrRowPtrA, csrColIndA, descrB, int nnzB, csrRowPtrB, csrColIndB, descrC, csrRowPtrC, nnzTotalDevHostPtr)#

Sparse matrix sparse matrix multiplication using CSR storage format

hipsparseXcsrgemmNnz computes the total CSR non-zero elements and the CSR row offsets, that point to the start of every row of the sparse CSR matrix, of the resulting multiplied matrix C. It is assumed that csr_row_ptr_C has been allocated with size m + 1.

Note:

This function is non blocking and executed asynchronously with respect to the host. It may return before the actual computation has finished.

Note:

Please note, that for matrix products with more than 8192 intermediate products per row, additional temporary storage buffer is allocated by the algorithm.

Note:

Currently, only trans_A == trans_B == HIPSPARSE_OPERATION_NON_TRANSPOSE is supported.

Note:

Currently, only HIPSPARSE_MATRIX_TYPE_GENERAL is supported.

Args:

handle (Pointer/object):: (undocumented)
transA (hipsparseOperation_t):: (undocumented)
transB (hipsparseOperation_t):: (undocumented)
m (int):: (undocumented)
n (int):: (undocumented)
k (int):: (undocumented)
descrA (Pointer/object):: (undocumented)
nnzA (int):: (undocumented)
csrRowPtrA (Pointer/object):: (undocumented)
csrColIndA (Pointer/object):: (undocumented)
descrB (Pointer/object):: (undocumented)
nnzB (int):: (undocumented)
csrRowPtrB (Pointer/object):: (undocumented)
csrColIndB (Pointer/object):: (undocumented)
descrC (Pointer/object):: (undocumented)
csrRowPtrC (Pointer/object):: (undocumented)
nnzTotalDevHostPtr (Pointer/object):: (undocumented)

hip.hipsparse.hipsparseScsrgemm(handle, transA, transB, int m, int n, int k, descrA, int nnzA, csrValA, csrRowPtrA, csrColIndA, descrB, int nnzB, csrValB, csrRowPtrB, csrColIndB, descrC, csrValC, csrRowPtrC, csrColIndC)#

Sparse matrix sparse matrix multiplication using CSR storage format

hipsparseXcsrgemm multiplies the sparse \(m \times k\) matrix \(A\), defined in CSR storage format with the sparse \(k \times n\) matrix \(B\), defined in CSR storage format, and stores the result in the sparse \(m \times n\) matrix \(C\), defined in CSR storage format, such that

\[C := op(A) \cdot op(B),\]

with

\[\begin{split}op(A) = \left\{ \begin{array}{ll} A, & \text{if trans_A == HIPSPARSE_OPERATION_NON_TRANSPOSE} \\ A^T, & \text{if trans_A == HIPSPARSE_OPERATION_TRANSPOSE} \\ A^H, & \text{if trans_A == HIPSPARSE_OPERATION_CONJUGATE_TRANSPOSE} \end{array} \right.\end{split}\]

and

\[\begin{split}op(B) = \left\{ \begin{array}{ll} B, & \text{if trans_B == HIPSPARSE_OPERATION_NON_TRANSPOSE} \\ B^T, & \text{if trans_B == HIPSPARSE_OPERATION_TRANSPOSE} \\ B^H, & \text{if trans_B == HIPSPARSE_OPERATION_CONJUGATE_TRANSPOSE} \end{array} \right.\end{split}\]

Note:

Currently, only trans_A == HIPSPARSE_OPERATION_NON_TRANSPOSE is supported.

Note:

Currently, only trans_B == HIPSPARSE_OPERATION_NON_TRANSPOSE is supported.

Note:

Currently, only HIPSPARSE_MATRIX_TYPE_GENERAL is supported.

Note:

This function is non blocking and executed asynchronously with respect to the host. It may return before the actual computation has finished.

Note:

Please note, that for matrix products with more than 4096 non-zero entries per row, additional temporary storage buffer is allocated by the algorithm.

Args:

handle (Pointer/object):: (undocumented)
transA (hipsparseOperation_t):: (undocumented)
transB (hipsparseOperation_t):: (undocumented)
m (int):: (undocumented)
n (int):: (undocumented)
k (int):: (undocumented)
descrA (Pointer/object):: (undocumented)
nnzA (int):: (undocumented)
csrValA (Pointer/object):: (undocumented)
csrRowPtrA (Pointer/object):: (undocumented)
csrColIndA (Pointer/object):: (undocumented)
descrB (Pointer/object):: (undocumented)
nnzB (int):: (undocumented)
csrValB (Pointer/object):: (undocumented)
csrRowPtrB (Pointer/object):: (undocumented)
csrColIndB (Pointer/object):: (undocumented)
descrC (Pointer/object):: (undocumented)
csrValC (Pointer/object):: (undocumented)
csrRowPtrC (Pointer/object):: (undocumented)
csrColIndC (Pointer/object):: (undocumented)

hip.hipsparse.hipsparseDcsrgemm(handle, transA, transB, int m, int n, int k, descrA, int nnzA, csrValA, csrRowPtrA, csrColIndA, descrB, int nnzB, csrValB, csrRowPtrB, csrColIndB, descrC, csrValC, csrRowPtrC, csrColIndC)#

(No short description, might be part of a group.)

Args:

handle (Pointer/object):: (undocumented)
transA (hipsparseOperation_t):: (undocumented)
transB (hipsparseOperation_t):: (undocumented)
m (int):: (undocumented)
n (int):: (undocumented)
k (int):: (undocumented)
descrA (Pointer/object):: (undocumented)
nnzA (int):: (undocumented)
csrValA (Pointer/object):: (undocumented)
csrRowPtrA (Pointer/object):: (undocumented)
csrColIndA (Pointer/object):: (undocumented)
descrB (Pointer/object):: (undocumented)
nnzB (int):: (undocumented)
csrValB (Pointer/object):: (undocumented)
csrRowPtrB (Pointer/object):: (undocumented)
csrColIndB (Pointer/object):: (undocumented)
descrC (Pointer/object):: (undocumented)
csrValC (Pointer/object):: (undocumented)
csrRowPtrC (Pointer/object):: (undocumented)
csrColIndC (Pointer/object):: (undocumented)

hip.hipsparse.hipsparseCcsrgemm(handle, transA, transB, int m, int n, int k, descrA, int nnzA, csrValA, csrRowPtrA, csrColIndA, descrB, int nnzB, csrValB, csrRowPtrB, csrColIndB, descrC, csrValC, csrRowPtrC, csrColIndC)#

(No short description, might be part of a group.)

Args:

handle (Pointer/object):: (undocumented)
transA (hipsparseOperation_t):: (undocumented)
transB (hipsparseOperation_t):: (undocumented)
m (int):: (undocumented)
n (int):: (undocumented)
k (int):: (undocumented)
descrA (Pointer/object):: (undocumented)
nnzA (int):: (undocumented)
csrValA (float2/object):: (undocumented)
csrRowPtrA (Pointer/object):: (undocumented)
csrColIndA (Pointer/object):: (undocumented)
descrB (Pointer/object):: (undocumented)
nnzB (int):: (undocumented)
csrValB (float2/object):: (undocumented)
csrRowPtrB (Pointer/object):: (undocumented)
csrColIndB (Pointer/object):: (undocumented)
descrC (Pointer/object):: (undocumented)
csrValC (float2/object):: (undocumented)
csrRowPtrC (Pointer/object):: (undocumented)
csrColIndC (Pointer/object):: (undocumented)

hip.hipsparse.hipsparseZcsrgemm(handle, transA, transB, int m, int n, int k, descrA, int nnzA, csrValA, csrRowPtrA, csrColIndA, descrB, int nnzB, csrValB, csrRowPtrB, csrColIndB, descrC, csrValC, csrRowPtrC, csrColIndC)#

(No short description, might be part of a group.)

Args:

handle (Pointer/object):: (undocumented)
transA (hipsparseOperation_t):: (undocumented)
transB (hipsparseOperation_t):: (undocumented)
m (int):: (undocumented)
n (int):: (undocumented)
k (int):: (undocumented)
descrA (Pointer/object):: (undocumented)
nnzA (int):: (undocumented)
csrValA (double2/object):: (undocumented)
csrRowPtrA (Pointer/object):: (undocumented)
csrColIndA (Pointer/object):: (undocumented)
descrB (Pointer/object):: (undocumented)
nnzB (int):: (undocumented)
csrValB (double2/object):: (undocumented)
csrRowPtrB (Pointer/object):: (undocumented)
csrColIndB (Pointer/object):: (undocumented)
descrC (Pointer/object):: (undocumented)
csrValC (double2/object):: (undocumented)
csrRowPtrC (Pointer/object):: (undocumented)
csrColIndC (Pointer/object):: (undocumented)

hip.hipsparse.hipsparseScsrgemm2_bufferSizeExt(handle, int m, int n, int k, alpha, descrA, int nnzA, csrRowPtrA, csrColIndA, descrB, int nnzB, csrRowPtrB, csrColIndB, beta, descrD, int nnzD, csrRowPtrD, csrColIndD, info, pBufferSizeInBytes)#

Sparse matrix sparse matrix multiplication using CSR storage format

hipsparseXcsrgemm2_bufferSizeExt returns the size of the temporary storage buffer in bytes that is required by hipsparseXcsrgemm2Nnz() and hipsparseXcsrgemm2(). The temporary storage buffer must be allocated by the user.

Note:

Please note, that for matrix products with more than 4096 non-zero entries per row, additional temporary storage buffer is allocated by the algorithm.

Note:

Please note, that for matrix products with more than 8192 intermediate products per row, additional temporary storage buffer is allocated by the algorithm.

Note:

Currently, only HIPSPARSE_MATRIX_TYPE_GENERAL is supported.

Args:

handle (Pointer/object):: (undocumented)
m (int):: (undocumented)
n (int):: (undocumented)
k (int):: (undocumented)
alpha (Pointer/object):: (undocumented)
descrA (Pointer/object):: (undocumented)
nnzA (int):: (undocumented)
csrRowPtrA (Pointer/object):: (undocumented)
csrColIndA (Pointer/object):: (undocumented)
descrB (Pointer/object):: (undocumented)
nnzB (int):: (undocumented)
csrRowPtrB (Pointer/object):: (undocumented)
csrColIndB (Pointer/object):: (undocumented)
beta (Pointer/object):: (undocumented)
descrD (Pointer/object):: (undocumented)
nnzD (int):: (undocumented)
csrRowPtrD (Pointer/object):: (undocumented)
csrColIndD (Pointer/object):: (undocumented)
info (csrgemm2Info/object):: (undocumented)
pBufferSizeInBytes (Pointer/object):: (undocumented)

hip.hipsparse.hipsparseDcsrgemm2_bufferSizeExt(handle, int m, int n, int k, alpha, descrA, int nnzA, csrRowPtrA, csrColIndA, descrB, int nnzB, csrRowPtrB, csrColIndB, beta, descrD, int nnzD, csrRowPtrD, csrColIndD, info, pBufferSizeInBytes)#

(No short description, might be part of a group.)

Args:

handle (Pointer/object):: (undocumented)
m (int):: (undocumented)
n (int):: (undocumented)
k (int):: (undocumented)
alpha (Pointer/object):: (undocumented)
descrA (Pointer/object):: (undocumented)
nnzA (int):: (undocumented)
csrRowPtrA (Pointer/object):: (undocumented)
csrColIndA (Pointer/object):: (undocumented)
descrB (Pointer/object):: (undocumented)
nnzB (int):: (undocumented)
csrRowPtrB (Pointer/object):: (undocumented)
csrColIndB (Pointer/object):: (undocumented)
beta (Pointer/object):: (undocumented)
descrD (Pointer/object):: (undocumented)
nnzD (int):: (undocumented)
csrRowPtrD (Pointer/object):: (undocumented)
csrColIndD (Pointer/object):: (undocumented)
info (csrgemm2Info/object):: (undocumented)
pBufferSizeInBytes (Pointer/object):: (undocumented)

hip.hipsparse.hipsparseCcsrgemm2_bufferSizeExt(handle, int m, int n, int k, alpha, descrA, int nnzA, csrRowPtrA, csrColIndA, descrB, int nnzB, csrRowPtrB, csrColIndB, beta, descrD, int nnzD, csrRowPtrD, csrColIndD, info, pBufferSizeInBytes)#

(No short description, might be part of a group.)

Args:

handle (Pointer/object):: (undocumented)
m (int):: (undocumented)
n (int):: (undocumented)
k (int):: (undocumented)
alpha (float2/object):: (undocumented)
descrA (Pointer/object):: (undocumented)
nnzA (int):: (undocumented)
csrRowPtrA (Pointer/object):: (undocumented)
csrColIndA (Pointer/object):: (undocumented)
descrB (Pointer/object):: (undocumented)
nnzB (int):: (undocumented)
csrRowPtrB (Pointer/object):: (undocumented)
csrColIndB (Pointer/object):: (undocumented)
beta (float2/object):: (undocumented)
descrD (Pointer/object):: (undocumented)
nnzD (int):: (undocumented)
csrRowPtrD (Pointer/object):: (undocumented)
csrColIndD (Pointer/object):: (undocumented)
info (csrgemm2Info/object):: (undocumented)
pBufferSizeInBytes (Pointer/object):: (undocumented)

hip.hipsparse.hipsparseZcsrgemm2_bufferSizeExt(handle, int m, int n, int k, alpha, descrA, int nnzA, csrRowPtrA, csrColIndA, descrB, int nnzB, csrRowPtrB, csrColIndB, beta, descrD, int nnzD, csrRowPtrD, csrColIndD, info, pBufferSizeInBytes)#

(No short description, might be part of a group.)

Args:

handle (Pointer/object):: (undocumented)
m (int):: (undocumented)
n (int):: (undocumented)
k (int):: (undocumented)
alpha (double2/object):: (undocumented)
descrA (Pointer/object):: (undocumented)
nnzA (int):: (undocumented)
csrRowPtrA (Pointer/object):: (undocumented)
csrColIndA (Pointer/object):: (undocumented)
descrB (Pointer/object):: (undocumented)
nnzB (int):: (undocumented)
csrRowPtrB (Pointer/object):: (undocumented)
csrColIndB (Pointer/object):: (undocumented)
beta (double2/object):: (undocumented)
descrD (Pointer/object):: (undocumented)
nnzD (int):: (undocumented)
csrRowPtrD (Pointer/object):: (undocumented)
csrColIndD (Pointer/object):: (undocumented)
info (csrgemm2Info/object):: (undocumented)
pBufferSizeInBytes (Pointer/object):: (undocumented)

hip.hipsparse.hipsparseXcsrgemm2Nnz(handle, int m, int n, int k, descrA, int nnzA, csrRowPtrA, csrColIndA, descrB, int nnzB, csrRowPtrB, csrColIndB, descrD, int nnzD, csrRowPtrD, csrColIndD, descrC, csrRowPtrC, nnzTotalDevHostPtr, info, pBuffer)#

Sparse matrix sparse matrix multiplication using CSR storage format

hipsparseXcsrgemm2Nnz computes the total CSR non-zero elements and the CSR row offsets, that point to the start of every row of the sparse CSR matrix, of the resulting multiplied matrix C. It is assumed that csr_row_ptr_C has been allocated with size m + 1. The required buffer size can be obtained by hipsparseXcsrgemm2_bufferSizeExt().

Note:

This function is non blocking and executed asynchronously with respect to the host. It may return before the actual computation has finished.

Note:

Please note, that for matrix products with more than 8192 intermediate products per row, additional temporary storage buffer is allocated by the algorithm.

Note:

Currently, only HIPSPARSE_MATRIX_TYPE_GENERAL is supported.

Args:

handle (Pointer/object):: (undocumented)
m (int):: (undocumented)
n (int):: (undocumented)
k (int):: (undocumented)
descrA (Pointer/object):: (undocumented)
nnzA (int):: (undocumented)
csrRowPtrA (Pointer/object):: (undocumented)
csrColIndA (Pointer/object):: (undocumented)
descrB (Pointer/object):: (undocumented)
nnzB (int):: (undocumented)
csrRowPtrB (Pointer/object):: (undocumented)
csrColIndB (Pointer/object):: (undocumented)
descrD (Pointer/object):: (undocumented)
nnzD (int):: (undocumented)
csrRowPtrD (Pointer/object):: (undocumented)
csrColIndD (Pointer/object):: (undocumented)
descrC (Pointer/object):: (undocumented)
csrRowPtrC (Pointer/object):: (undocumented)
nnzTotalDevHostPtr (Pointer/object):: (undocumented)
info (csrgemm2Info/object):: (undocumented)
pBuffer (Pointer/object):: (undocumented)

hip.hipsparse.hipsparseScsrgemm2(handle, int m, int n, int k, alpha, descrA, int nnzA, csrValA, csrRowPtrA, csrColIndA, descrB, int nnzB, csrValB, csrRowPtrB, csrColIndB, beta, descrD, int nnzD, csrValD, csrRowPtrD, csrColIndD, descrC, csrValC, csrRowPtrC, csrColIndC, info, pBuffer)#

Sparse matrix sparse matrix multiplication using CSR storage format

hipsparseXcsrgemm2 multiplies the scalar \(\alpha\) with the sparse \(m \times k\) matrix \(A\), defined in CSR storage format, and the sparse \(k \times n\) matrix \(B\), defined in CSR storage format, and adds the result to the sparse \(m \times n\) matrix \(D\) that is multiplied by \(\beta\). The final result is stored in the sparse \(m \times n\) matrix \(C\), defined in CSR storage format, such that

\[C := \alpha \cdot A \cdot B + \beta \cdot D\]

Note:

If \(\alpha == 0\), then \(C = \beta \cdot D\) will be computed.

Note:

If \(\beta == 0\), then \(C = \alpha \cdot A \cdot B\) will be computed.

Note:

math:alpha == beta == 0 is invalid.

Note:

Currently, only HIPSPARSE_MATRIX_TYPE_GENERAL is supported.

Note:

This function is non blocking and executed asynchronously with respect to the host. It may return before the actual computation has finished.

Note:

Please note, that for matrix products with more than 4096 non-zero entries per row, additional temporary storage buffer is allocated by the algorithm.

Args:

handle (Pointer/object):: (undocumented)
m (int):: (undocumented)
n (int):: (undocumented)
k (int):: (undocumented)
alpha (Pointer/object):: (undocumented)
descrA (Pointer/object):: (undocumented)
nnzA (int):: (undocumented)
csrValA (Pointer/object):: (undocumented)
csrRowPtrA (Pointer/object):: (undocumented)
csrColIndA (Pointer/object):: (undocumented)
descrB (Pointer/object):: (undocumented)
nnzB (int):: (undocumented)
csrValB (Pointer/object):: (undocumented)
csrRowPtrB (Pointer/object):: (undocumented)
csrColIndB (Pointer/object):: (undocumented)
beta (Pointer/object):: (undocumented)
descrD (Pointer/object):: (undocumented)
nnzD (int):: (undocumented)
csrValD (Pointer/object):: (undocumented)
csrRowPtrD (Pointer/object):: (undocumented)
csrColIndD (Pointer/object):: (undocumented)
descrC (Pointer/object):: (undocumented)
csrValC (Pointer/object):: (undocumented)
csrRowPtrC (Pointer/object):: (undocumented)
csrColIndC (Pointer/object):: (undocumented)
info (csrgemm2Info/object):: (undocumented)
pBuffer (Pointer/object):: (undocumented)

hip.hipsparse.hipsparseDcsrgemm2(handle, int m, int n, int k, alpha, descrA, int nnzA, csrValA, csrRowPtrA, csrColIndA, descrB, int nnzB, csrValB, csrRowPtrB, csrColIndB, beta, descrD, int nnzD, csrValD, csrRowPtrD, csrColIndD, descrC, csrValC, csrRowPtrC, csrColIndC, info, pBuffer)#

(No short description, might be part of a group.)

Args:

handle (Pointer/object):: (undocumented)
m (int):: (undocumented)
n (int):: (undocumented)
k (int):: (undocumented)
alpha (Pointer/object):: (undocumented)
descrA (Pointer/object):: (undocumented)
nnzA (int):: (undocumented)
csrValA (Pointer/object):: (undocumented)
csrRowPtrA (Pointer/object):: (undocumented)
csrColIndA (Pointer/object):: (undocumented)
descrB (Pointer/object):: (undocumented)
nnzB (int):: (undocumented)
csrValB (Pointer/object):: (undocumented)
csrRowPtrB (Pointer/object):: (undocumented)
csrColIndB (Pointer/object):: (undocumented)
beta (Pointer/object):: (undocumented)
descrD (Pointer/object):: (undocumented)
nnzD (int):: (undocumented)
csrValD (Pointer/object):: (undocumented)
csrRowPtrD (Pointer/object):: (undocumented)
csrColIndD (Pointer/object):: (undocumented)
descrC (Pointer/object):: (undocumented)
csrValC (Pointer/object):: (undocumented)
csrRowPtrC (Pointer/object):: (undocumented)
csrColIndC (Pointer/object):: (undocumented)
info (csrgemm2Info/object):: (undocumented)
pBuffer (Pointer/object):: (undocumented)

hip.hipsparse.hipsparseCcsrgemm2(handle, int m, int n, int k, alpha, descrA, int nnzA, csrValA, csrRowPtrA, csrColIndA, descrB, int nnzB, csrValB, csrRowPtrB, csrColIndB, beta, descrD, int nnzD, csrValD, csrRowPtrD, csrColIndD, descrC, csrValC, csrRowPtrC, csrColIndC, info, pBuffer)#

(No short description, might be part of a group.)

Args:

handle (Pointer/object):: (undocumented)
m (int):: (undocumented)
n (int):: (undocumented)
k (int):: (undocumented)
alpha (float2/object):: (undocumented)
descrA (Pointer/object):: (undocumented)
nnzA (int):: (undocumented)
csrValA (float2/object):: (undocumented)
csrRowPtrA (Pointer/object):: (undocumented)
csrColIndA (Pointer/object):: (undocumented)
descrB (Pointer/object):: (undocumented)
nnzB (int):: (undocumented)
csrValB (float2/object):: (undocumented)
csrRowPtrB (Pointer/object):: (undocumented)
csrColIndB (Pointer/object):: (undocumented)
beta (float2/object):: (undocumented)
descrD (Pointer/object):: (undocumented)
nnzD (int):: (undocumented)
csrValD (float2/object):: (undocumented)
csrRowPtrD (Pointer/object):: (undocumented)
csrColIndD (Pointer/object):: (undocumented)
descrC (Pointer/object):: (undocumented)
csrValC (float2/object):: (undocumented)
csrRowPtrC (Pointer/object):: (undocumented)
csrColIndC (Pointer/object):: (undocumented)
info (csrgemm2Info/object):: (undocumented)
pBuffer (Pointer/object):: (undocumented)

hip.hipsparse.hipsparseZcsrgemm2(handle, int m, int n, int k, alpha, descrA, int nnzA, csrValA, csrRowPtrA, csrColIndA, descrB, int nnzB, csrValB, csrRowPtrB, csrColIndB, beta, descrD, int nnzD, csrValD, csrRowPtrD, csrColIndD, descrC, csrValC, csrRowPtrC, csrColIndC, info, pBuffer)#

(No short description, might be part of a group.)

Args:

handle (Pointer/object):: (undocumented)
m (int):: (undocumented)
n (int):: (undocumented)
k (int):: (undocumented)
alpha (double2/object):: (undocumented)
descrA (Pointer/object):: (undocumented)
nnzA (int):: (undocumented)
csrValA (double2/object):: (undocumented)
csrRowPtrA (Pointer/object):: (undocumented)
csrColIndA (Pointer/object):: (undocumented)
descrB (Pointer/object):: (undocumented)
nnzB (int):: (undocumented)
csrValB (double2/object):: (undocumented)
csrRowPtrB (Pointer/object):: (undocumented)
csrColIndB (Pointer/object):: (undocumented)
beta (double2/object):: (undocumented)
descrD (Pointer/object):: (undocumented)
nnzD (int):: (undocumented)
csrValD (double2/object):: (undocumented)
csrRowPtrD (Pointer/object):: (undocumented)
csrColIndD (Pointer/object):: (undocumented)
descrC (Pointer/object):: (undocumented)
csrValC (double2/object):: (undocumented)
csrRowPtrC (Pointer/object):: (undocumented)
csrColIndC (Pointer/object):: (undocumented)
info (csrgemm2Info/object):: (undocumented)
pBuffer (Pointer/object):: (undocumented)

hip.hipsparse.hipsparseXbsrilu02_zeroPivot(handle, info, position)#

Incomplete LU factorization with 0 fill-ins and no pivoting using BSR storage format

hipsparseXbsrilu02_zeroPivot returns HIPSPARSE_STATUS_ZERO_PIVOT , if either a structural or numerical zero has been found during hipsparseXbsrilu02_analysis() or hipsparseXbsrilu02() computation. The first zero pivot \(j\) at \(A_{j,j}\) is stored in position, using same index base as the BSR matrix.

position can be in host or device memory. If no zero pivot has been found, position is set to -1 and HIPSPARSE_STATUS_SUCCESS is returned instead.

Note:

If a zero pivot is found, position \(=j\) means that either the diagonal block \(A_{j,j}\) is missing (structural zero) or the diagonal block \(A_{j,j}\) is not invertible (numerical zero).

Note:

hipsparseXbsrilu02_zeroPivot is a blocking function. It might influence performance negatively.

Args:

handle (Pointer/object):: (undocumented)
info (bsrilu02Info/object):: (undocumented)
position (Pointer/object):: (undocumented)

hip.hipsparse.hipsparseSbsrilu02_numericBoost(handle, info, int enable_boost, tol, boost_val)#

Incomplete LU factorization with 0 fill-ins and no pivoting using BSR storage format

hipsparseXbsrilu02_numericBoost enables the user to replace a numerical value in an incomplete LU factorization. tol is used to determine whether a numerical value is replaced by boost_val, such that \(A_{j,j} = \text{boost_val}\) if \(\text{tol} \ge \left|A_{j,j}\right|\).

Note:

The boost value is enabled by setting enable_boost to 1 or disabled by setting enable_boost to 0.

Note:

tol and boost_val can be in host or device memory.

Args:

handle (Pointer/object):: (undocumented)
info (bsrilu02Info/object):: (undocumented)
enable_boost (int):: (undocumented)
tol (Pointer/object):: (undocumented)
boost_val (Pointer/object):: (undocumented)

hip.hipsparse.hipsparseDbsrilu02_numericBoost(handle, info, int enable_boost, tol, boost_val)#

(No short description, might be part of a group.)

Args:

handle (Pointer/object):: (undocumented)
info (bsrilu02Info/object):: (undocumented)
enable_boost (int):: (undocumented)
tol (Pointer/object):: (undocumented)
boost_val (Pointer/object):: (undocumented)

hip.hipsparse.hipsparseCbsrilu02_numericBoost(handle, info, int enable_boost, tol, boost_val)#

(No short description, might be part of a group.)

Args:

handle (Pointer/object):: (undocumented)
info (bsrilu02Info/object):: (undocumented)
enable_boost (int):: (undocumented)
tol (Pointer/object):: (undocumented)
boost_val (float2/object):: (undocumented)

hip.hipsparse.hipsparseZbsrilu02_numericBoost(handle, info, int enable_boost, tol, boost_val)#

(No short description, might be part of a group.)

Args:

handle (Pointer/object):: (undocumented)
info (bsrilu02Info/object):: (undocumented)
enable_boost (int):: (undocumented)
tol (Pointer/object):: (undocumented)
boost_val (double2/object):: (undocumented)

hip.hipsparse.hipsparseSbsrilu02_bufferSize(handle, dirA, int mb, int nnzb, descrA, bsrSortedValA, bsrSortedRowPtrA, bsrSortedColIndA, int blockDim, info, pBufferSizeInBytes)#

Incomplete LU factorization with 0 fill-ins and no pivoting using BSR storage format

hipsparseXbsrilu02_bufferSize returns the size of the temporary storage buffer in bytes that is required by hipsparseXbsrilu02_analysis() and hipsparseXbsrilu02(). The temporary storage buffer must be allocated by the user.

Args:

handle (Pointer/object):: (undocumented)
dirA (hipsparseDirection_t):: (undocumented)
mb (int):: (undocumented)
nnzb (int):: (undocumented)
descrA (Pointer/object):: (undocumented)
bsrSortedValA (Pointer/object):: (undocumented)
bsrSortedRowPtrA (Pointer/object):: (undocumented)
bsrSortedColIndA (Pointer/object):: (undocumented)
blockDim (int):: (undocumented)
info (bsrilu02Info/object):: (undocumented)
pBufferSizeInBytes (Pointer/object):: (undocumented)

hip.hipsparse.hipsparseDbsrilu02_bufferSize(handle, dirA, int mb, int nnzb, descrA, bsrSortedValA, bsrSortedRowPtrA, bsrSortedColIndA, int blockDim, info, pBufferSizeInBytes)#

(No short description, might be part of a group.)

Args:

handle (Pointer/object):: (undocumented)
dirA (hipsparseDirection_t):: (undocumented)
mb (int):: (undocumented)
nnzb (int):: (undocumented)
descrA (Pointer/object):: (undocumented)
bsrSortedValA (Pointer/object):: (undocumented)
bsrSortedRowPtrA (Pointer/object):: (undocumented)
bsrSortedColIndA (Pointer/object):: (undocumented)
blockDim (int):: (undocumented)
info (bsrilu02Info/object):: (undocumented)
pBufferSizeInBytes (Pointer/object):: (undocumented)

hip.hipsparse.hipsparseCbsrilu02_bufferSize(handle, dirA, int mb, int nnzb, descrA, bsrSortedValA, bsrSortedRowPtrA, bsrSortedColIndA, int blockDim, info, pBufferSizeInBytes)#

(No short description, might be part of a group.)

Args:

handle (Pointer/object):: (undocumented)
dirA (hipsparseDirection_t):: (undocumented)
mb (int):: (undocumented)
nnzb (int):: (undocumented)
descrA (Pointer/object):: (undocumented)
bsrSortedValA (float2/object):: (undocumented)
bsrSortedRowPtrA (Pointer/object):: (undocumented)
bsrSortedColIndA (Pointer/object):: (undocumented)
blockDim (int):: (undocumented)
info (bsrilu02Info/object):: (undocumented)
pBufferSizeInBytes (Pointer/object):: (undocumented)

hip.hipsparse.hipsparseZbsrilu02_bufferSize(handle, dirA, int mb, int nnzb, descrA, bsrSortedValA, bsrSortedRowPtrA, bsrSortedColIndA, int blockDim, info, pBufferSizeInBytes)#

(No short description, might be part of a group.)

Args:

handle (Pointer/object):: (undocumented)
dirA (hipsparseDirection_t):: (undocumented)
mb (int):: (undocumented)
nnzb (int):: (undocumented)
descrA (Pointer/object):: (undocumented)
bsrSortedValA (double2/object):: (undocumented)
bsrSortedRowPtrA (Pointer/object):: (undocumented)
bsrSortedColIndA (Pointer/object):: (undocumented)
blockDim (int):: (undocumented)
info (bsrilu02Info/object):: (undocumented)
pBufferSizeInBytes (Pointer/object):: (undocumented)

hip.hipsparse.hipsparseSbsrilu02_analysis(handle, dirA, int mb, int nnzb, descrA, bsrSortedValA, bsrSortedRowPtrA, bsrSortedColIndA, int blockDim, info, policy, pBuffer)#

Incomplete LU factorization with 0 fill-ins and no pivoting using BSR storage format

hipsparseXbsrilu02_analysis performs the analysis step for hipsparseXbsrilu02().

Note:

If the matrix sparsity pattern changes, the gathered information will become invalid.

Note:

This function is non blocking and executed asynchronously with respect to the host. It may return before the actual computation has finished.

Args:

handle (Pointer/object):: (undocumented)
dirA (hipsparseDirection_t):: (undocumented)
mb (int):: (undocumented)
nnzb (int):: (undocumented)
descrA (Pointer/object):: (undocumented)
bsrSortedValA (Pointer/object):: (undocumented)
bsrSortedRowPtrA (Pointer/object):: (undocumented)
bsrSortedColIndA (Pointer/object):: (undocumented)
blockDim (int):: (undocumented)
info (bsrilu02Info/object):: (undocumented)
policy (hipsparseSolvePolicy_t):: (undocumented)
pBuffer (Pointer/object):: (undocumented)

hip.hipsparse.hipsparseDbsrilu02_analysis(handle, dirA, int mb, int nnzb, descrA, bsrSortedValA, bsrSortedRowPtrA, bsrSortedColIndA, int blockDim, info, policy, pBuffer)#

(No short description, might be part of a group.)

Args:

handle (Pointer/object):: (undocumented)
dirA (hipsparseDirection_t):: (undocumented)
mb (int):: (undocumented)
nnzb (int):: (undocumented)
descrA (Pointer/object):: (undocumented)
bsrSortedValA (Pointer/object):: (undocumented)
bsrSortedRowPtrA (Pointer/object):: (undocumented)
bsrSortedColIndA (Pointer/object):: (undocumented)
blockDim (int):: (undocumented)
info (bsrilu02Info/object):: (undocumented)
policy (hipsparseSolvePolicy_t):: (undocumented)
pBuffer (Pointer/object):: (undocumented)

hip.hipsparse.hipsparseCbsrilu02_analysis(handle, dirA, int mb, int nnzb, descrA, bsrSortedValA, bsrSortedRowPtrA, bsrSortedColIndA, int blockDim, info, policy, pBuffer)#

(No short description, might be part of a group.)

Args:

handle (Pointer/object):: (undocumented)
dirA (hipsparseDirection_t):: (undocumented)
mb (int):: (undocumented)
nnzb (int):: (undocumented)
descrA (Pointer/object):: (undocumented)
bsrSortedValA (float2/object):: (undocumented)
bsrSortedRowPtrA (Pointer/object):: (undocumented)
bsrSortedColIndA (Pointer/object):: (undocumented)
blockDim (int):: (undocumented)
info (bsrilu02Info/object):: (undocumented)
policy (hipsparseSolvePolicy_t):: (undocumented)
pBuffer (Pointer/object):: (undocumented)

hip.hipsparse.hipsparseZbsrilu02_analysis(handle, dirA, int mb, int nnzb, descrA, bsrSortedValA, bsrSortedRowPtrA, bsrSortedColIndA, int blockDim, info, policy, pBuffer)#

(No short description, might be part of a group.)

Args:

handle (Pointer/object):: (undocumented)
dirA (hipsparseDirection_t):: (undocumented)
mb (int):: (undocumented)
nnzb (int):: (undocumented)
descrA (Pointer/object):: (undocumented)
bsrSortedValA (double2/object):: (undocumented)
bsrSortedRowPtrA (Pointer/object):: (undocumented)
bsrSortedColIndA (Pointer/object):: (undocumented)
blockDim (int):: (undocumented)
info (bsrilu02Info/object):: (undocumented)
policy (hipsparseSolvePolicy_t):: (undocumented)
pBuffer (Pointer/object):: (undocumented)

hip.hipsparse.hipsparseSbsrilu02(handle, dirA, int mb, int nnzb, descrA, bsrSortedValA_valM, bsrSortedRowPtrA, bsrSortedColIndA, int blockDim, info, policy, pBuffer)#

Incomplete LU factorization with 0 fill-ins and no pivoting using BSR storage format

hipsparseXbsrilu02 computes the incomplete LU factorization with 0 fill-ins and no pivoting of a sparse \(mb \times mb\) BSR matrix \(A\), such that

\[A \approx LU\]

Note:

This function is non blocking and executed asynchronously with respect to the host. It may return before the actual computation has finished.

Args:

handle (Pointer/object):: (undocumented)
dirA (hipsparseDirection_t):: (undocumented)
mb (int):: (undocumented)
nnzb (int):: (undocumented)
descrA (Pointer/object):: (undocumented)
bsrSortedValA_valM (Pointer/object):: (undocumented)
bsrSortedRowPtrA (Pointer/object):: (undocumented)
bsrSortedColIndA (Pointer/object):: (undocumented)
blockDim (int):: (undocumented)
info (bsrilu02Info/object):: (undocumented)
policy (hipsparseSolvePolicy_t):: (undocumented)
pBuffer (Pointer/object):: (undocumented)

hip.hipsparse.hipsparseDbsrilu02(handle, dirA, int mb, int nnzb, descrA, bsrSortedValA_valM, bsrSortedRowPtrA, bsrSortedColIndA, int blockDim, info, policy, pBuffer)#

(No short description, might be part of a group.)

Args:

handle (Pointer/object):: (undocumented)
dirA (hipsparseDirection_t):: (undocumented)
mb (int):: (undocumented)
nnzb (int):: (undocumented)
descrA (Pointer/object):: (undocumented)
bsrSortedValA_valM (Pointer/object):: (undocumented)
bsrSortedRowPtrA (Pointer/object):: (undocumented)
bsrSortedColIndA (Pointer/object):: (undocumented)
blockDim (int):: (undocumented)
info (bsrilu02Info/object):: (undocumented)
policy (hipsparseSolvePolicy_t):: (undocumented)
pBuffer (Pointer/object):: (undocumented)

hip.hipsparse.hipsparseCbsrilu02(handle, dirA, int mb, int nnzb, descrA, bsrSortedValA_valM, bsrSortedRowPtrA, bsrSortedColIndA, int blockDim, info, policy, pBuffer)#

(No short description, might be part of a group.)

Args:

handle (Pointer/object):: (undocumented)
dirA (hipsparseDirection_t):: (undocumented)
mb (int):: (undocumented)
nnzb (int):: (undocumented)
descrA (Pointer/object):: (undocumented)
bsrSortedValA_valM (float2/object):: (undocumented)
bsrSortedRowPtrA (Pointer/object):: (undocumented)
bsrSortedColIndA (Pointer/object):: (undocumented)
blockDim (int):: (undocumented)
info (bsrilu02Info/object):: (undocumented)
policy (hipsparseSolvePolicy_t):: (undocumented)
pBuffer (Pointer/object):: (undocumented)

hip.hipsparse.hipsparseZbsrilu02(handle, dirA, int mb, int nnzb, descrA, bsrSortedValA_valM, bsrSortedRowPtrA, bsrSortedColIndA, int blockDim, info, policy, pBuffer)#

(No short description, might be part of a group.)

Args:

handle (Pointer/object):: (undocumented)
dirA (hipsparseDirection_t):: (undocumented)
mb (int):: (undocumented)
nnzb (int):: (undocumented)
descrA (Pointer/object):: (undocumented)
bsrSortedValA_valM (double2/object):: (undocumented)
bsrSortedRowPtrA (Pointer/object):: (undocumented)
bsrSortedColIndA (Pointer/object):: (undocumented)
blockDim (int):: (undocumented)
info (bsrilu02Info/object):: (undocumented)
policy (hipsparseSolvePolicy_t):: (undocumented)
pBuffer (Pointer/object):: (undocumented)

hip.hipsparse.hipsparseXcsrilu02_zeroPivot(handle, info, position)#

Incomplete LU factorization with 0 fill-ins and no pivoting using CSR storage format

hipsparseXcsrilu02_zeroPivot returns HIPSPARSE_STATUS_ZERO_PIVOT , if either a structural or numerical zero has been found during hipsparseXcsrilu02() computation. The first zero pivot \(j\) at \(A_{j,j}\) is stored in position, using same index base as the CSR matrix.

position can be in host or device memory. If no zero pivot has been found, position is set to -1 and HIPSPARSE_STATUS_SUCCESS is returned instead.

Note:

hipsparseXcsrilu02_zeroPivot is a blocking function. It might influence performance negatively.

Args:

handle (Pointer/object):: (undocumented)
info (csrilu02Info/object):: (undocumented)
position (Pointer/object):: (undocumented)

hip.hipsparse.hipsparseScsrilu02_numericBoost(handle, info, int enable_boost, tol, boost_val)#

Incomplete LU factorization with 0 fill-ins and no pivoting using CSR storage format

hipsparseXcsrilu02_numericBoost enables the user to replace a numerical value in an incomplete LU factorization. tol is used to determine whether a numerical value is replaced by boost_val, such that \(A_{j,j} = \text{boost_val}\) if \(\text{tol} \ge \left|A_{j,j}\right|\).

Note:

The boost value is enabled by setting enable_boost to 1 or disabled by setting enable_boost to 0.

Note:

tol and boost_val can be in host or device memory.

Args:

handle (Pointer/object):: (undocumented)
info (csrilu02Info/object):: (undocumented)
enable_boost (int):: (undocumented)
tol (Pointer/object):: (undocumented)
boost_val (Pointer/object):: (undocumented)

hip.hipsparse.hipsparseDcsrilu02_numericBoost(handle, info, int enable_boost, tol, boost_val)#

(No short description, might be part of a group.)

Args:

handle (Pointer/object):: (undocumented)
info (csrilu02Info/object):: (undocumented)
enable_boost (int):: (undocumented)
tol (Pointer/object):: (undocumented)
boost_val (Pointer/object):: (undocumented)

hip.hipsparse.hipsparseCcsrilu02_numericBoost(handle, info, int enable_boost, tol, boost_val)#

(No short description, might be part of a group.)

Args:

handle (Pointer/object):: (undocumented)
info (csrilu02Info/object):: (undocumented)
enable_boost (int):: (undocumented)
tol (Pointer/object):: (undocumented)
boost_val (float2/object):: (undocumented)

hip.hipsparse.hipsparseZcsrilu02_numericBoost(handle, info, int enable_boost, tol, boost_val)#

(No short description, might be part of a group.)

Args:

handle (Pointer/object):: (undocumented)
info (csrilu02Info/object):: (undocumented)
enable_boost (int):: (undocumented)
tol (Pointer/object):: (undocumented)
boost_val (double2/object):: (undocumented)

hip.hipsparse.hipsparseScsrilu02_bufferSize(handle, int m, int nnz, descrA, csrSortedValA, csrSortedRowPtrA, csrSortedColIndA, info, pBufferSizeInBytes)#

Incomplete LU factorization with 0 fill-ins and no pivoting using CSR storage format

hipsparseXcsrilu02_bufferSize returns the size of the temporary storage buffer in bytes that is required by hipsparseXcsrilu02_analysis() and hipsparseXcsrilu02_solve(). The temporary storage buffer must be allocated by the user.

Args:

handle (Pointer/object):: (undocumented)
m (int):: (undocumented)
nnz (int):: (undocumented)
descrA (Pointer/object):: (undocumented)
csrSortedValA (Pointer/object):: (undocumented)
csrSortedRowPtrA (Pointer/object):: (undocumented)
csrSortedColIndA (Pointer/object):: (undocumented)
info (csrilu02Info/object):: (undocumented)
pBufferSizeInBytes (Pointer/object):: (undocumented)

hip.hipsparse.hipsparseDcsrilu02_bufferSize(handle, int m, int nnz, descrA, csrSortedValA, csrSortedRowPtrA, csrSortedColIndA, info, pBufferSizeInBytes)#

(No short description, might be part of a group.)

Args:

handle (Pointer/object):: (undocumented)
m (int):: (undocumented)
nnz (int):: (undocumented)
descrA (Pointer/object):: (undocumented)
csrSortedValA (Pointer/object):: (undocumented)
csrSortedRowPtrA (Pointer/object):: (undocumented)
csrSortedColIndA (Pointer/object):: (undocumented)
info (csrilu02Info/object):: (undocumented)
pBufferSizeInBytes (Pointer/object):: (undocumented)

hip.hipsparse.hipsparseCcsrilu02_bufferSize(handle, int m, int nnz, descrA, csrSortedValA, csrSortedRowPtrA, csrSortedColIndA, info, pBufferSizeInBytes)#

(No short description, might be part of a group.)

Args:

handle (Pointer/object):: (undocumented)
m (int):: (undocumented)
nnz (int):: (undocumented)
descrA (Pointer/object):: (undocumented)
csrSortedValA (float2/object):: (undocumented)
csrSortedRowPtrA (Pointer/object):: (undocumented)
csrSortedColIndA (Pointer/object):: (undocumented)
info (csrilu02Info/object):: (undocumented)
pBufferSizeInBytes (Pointer/object):: (undocumented)

hip.hipsparse.hipsparseZcsrilu02_bufferSize(handle, int m, int nnz, descrA, csrSortedValA, csrSortedRowPtrA, csrSortedColIndA, info, pBufferSizeInBytes)#

(No short description, might be part of a group.)

Args:

handle (Pointer/object):: (undocumented)
m (int):: (undocumented)
nnz (int):: (undocumented)
descrA (Pointer/object):: (undocumented)
csrSortedValA (double2/object):: (undocumented)
csrSortedRowPtrA (Pointer/object):: (undocumented)
csrSortedColIndA (Pointer/object):: (undocumented)
info (csrilu02Info/object):: (undocumented)
pBufferSizeInBytes (Pointer/object):: (undocumented)

hip.hipsparse.hipsparseScsrilu02_bufferSizeExt(handle, int m, int nnz, descrA, csrSortedValA, csrSortedRowPtrA, csrSortedColIndA, info, pBufferSizeInBytes)#

Incomplete LU factorization with 0 fill-ins and no pivoting using CSR storage format

hipsparseXcsrilu02_bufferSizeExt returns the size of the temporary storage buffer in bytes that is required by hipsparseXcsrilu02_analysis() and hipsparseXcsrilu02_solve(). The temporary storage buffer must be allocated by the user.

Args:

handle (Pointer/object):: (undocumented)
m (int):: (undocumented)
nnz (int):: (undocumented)
descrA (Pointer/object):: (undocumented)
csrSortedValA (Pointer/object):: (undocumented)
csrSortedRowPtrA (Pointer/object):: (undocumented)
csrSortedColIndA (Pointer/object):: (undocumented)
info (csrilu02Info/object):: (undocumented)
pBufferSizeInBytes (Pointer/object):: (undocumented)

hip.hipsparse.hipsparseDcsrilu02_bufferSizeExt(handle, int m, int nnz, descrA, csrSortedValA, csrSortedRowPtrA, csrSortedColIndA, info, pBufferSizeInBytes)#

(No short description, might be part of a group.)

Args:

handle (Pointer/object):: (undocumented)
m (int):: (undocumented)
nnz (int):: (undocumented)
descrA (Pointer/object):: (undocumented)
csrSortedValA (Pointer/object):: (undocumented)
csrSortedRowPtrA (Pointer/object):: (undocumented)
csrSortedColIndA (Pointer/object):: (undocumented)
info (csrilu02Info/object):: (undocumented)
pBufferSizeInBytes (Pointer/object):: (undocumented)

hip.hipsparse.hipsparseCcsrilu02_bufferSizeExt(handle, int m, int nnz, descrA, csrSortedValA, csrSortedRowPtrA, csrSortedColIndA, info, pBufferSizeInBytes)#

(No short description, might be part of a group.)

Args:

handle (Pointer/object):: (undocumented)
m (int):: (undocumented)
nnz (int):: (undocumented)
descrA (Pointer/object):: (undocumented)
csrSortedValA (float2/object):: (undocumented)
csrSortedRowPtrA (Pointer/object):: (undocumented)
csrSortedColIndA (Pointer/object):: (undocumented)
info (csrilu02Info/object):: (undocumented)
pBufferSizeInBytes (Pointer/object):: (undocumented)

hip.hipsparse.hipsparseZcsrilu02_bufferSizeExt(handle, int m, int nnz, descrA, csrSortedValA, csrSortedRowPtrA, csrSortedColIndA, info, pBufferSizeInBytes)#

(No short description, might be part of a group.)

Args:

handle (Pointer/object):: (undocumented)
m (int):: (undocumented)
nnz (int):: (undocumented)
descrA (Pointer/object):: (undocumented)
csrSortedValA (double2/object):: (undocumented)
csrSortedRowPtrA (Pointer/object):: (undocumented)
csrSortedColIndA (Pointer/object):: (undocumented)
info (csrilu02Info/object):: (undocumented)
pBufferSizeInBytes (Pointer/object):: (undocumented)

hip.hipsparse.hipsparseScsrilu02_analysis(handle, int m, int nnz, descrA, csrSortedValA, csrSortedRowPtrA, csrSortedColIndA, info, policy, pBuffer)#

Incomplete LU factorization with 0 fill-ins and no pivoting using CSR storage format

hipsparseXcsrilu02_analysis performs the analysis step for hipsparseXcsrilu02().

Note:

If the matrix sparsity pattern changes, the gathered information will become invalid.

Note:

This function is non blocking and executed asynchronously with respect to the host. It may return before the actual computation has finished.

Args:

handle (Pointer/object):: (undocumented)
m (int):: (undocumented)
nnz (int):: (undocumented)
descrA (Pointer/object):: (undocumented)
csrSortedValA (Pointer/object):: (undocumented)
csrSortedRowPtrA (Pointer/object):: (undocumented)
csrSortedColIndA (Pointer/object):: (undocumented)
info (csrilu02Info/object):: (undocumented)
policy (hipsparseSolvePolicy_t):: (undocumented)
pBuffer (Pointer/object):: (undocumented)

hip.hipsparse.hipsparseDcsrilu02_analysis(handle, int m, int nnz, descrA, csrSortedValA, csrSortedRowPtrA, csrSortedColIndA, info, policy, pBuffer)#

(No short description, might be part of a group.)

Args:

handle (Pointer/object):: (undocumented)
m (int):: (undocumented)
nnz (int):: (undocumented)
descrA (Pointer/object):: (undocumented)
csrSortedValA (Pointer/object):: (undocumented)
csrSortedRowPtrA (Pointer/object):: (undocumented)
csrSortedColIndA (Pointer/object):: (undocumented)
info (csrilu02Info/object):: (undocumented)
policy (hipsparseSolvePolicy_t):: (undocumented)
pBuffer (Pointer/object):: (undocumented)

hip.hipsparse.hipsparseCcsrilu02_analysis(handle, int m, int nnz, descrA, csrSortedValA, csrSortedRowPtrA, csrSortedColIndA, info, policy, pBuffer)#

(No short description, might be part of a group.)

Args:

handle (Pointer/object):: (undocumented)
m (int):: (undocumented)
nnz (int):: (undocumented)
descrA (Pointer/object):: (undocumented)
csrSortedValA (float2/object):: (undocumented)
csrSortedRowPtrA (Pointer/object):: (undocumented)
csrSortedColIndA (Pointer/object):: (undocumented)
info (csrilu02Info/object):: (undocumented)
policy (hipsparseSolvePolicy_t):: (undocumented)
pBuffer (Pointer/object):: (undocumented)

hip.hipsparse.hipsparseZcsrilu02_analysis(handle, int m, int nnz, descrA, csrSortedValA, csrSortedRowPtrA, csrSortedColIndA, info, policy, pBuffer)#

(No short description, might be part of a group.)

Args:

handle (Pointer/object):: (undocumented)
m (int):: (undocumented)
nnz (int):: (undocumented)
descrA (Pointer/object):: (undocumented)
csrSortedValA (double2/object):: (undocumented)
csrSortedRowPtrA (Pointer/object):: (undocumented)
csrSortedColIndA (Pointer/object):: (undocumented)
info (csrilu02Info/object):: (undocumented)
policy (hipsparseSolvePolicy_t):: (undocumented)
pBuffer (Pointer/object):: (undocumented)

hip.hipsparse.hipsparseScsrilu02(handle, int m, int nnz, descrA, csrSortedValA_valM, csrSortedRowPtrA, csrSortedColIndA, info, policy, pBuffer)#

Incomplete LU factorization with 0 fill-ins and no pivoting using CSR storage format

hipsparseXcsrilu02 computes the incomplete LU factorization with 0 fill-ins and no pivoting of a sparse \(m \times m\) CSR matrix \(A\), such that

\[A \approx LU\]

Note:

The sparse CSR matrix has to be sorted. This can be achieved by calling hipsparseXcsrsort().

Note:

This function is non blocking and executed asynchronously with respect to the host. It may return before the actual computation has finished.

Args:

handle (Pointer/object):: (undocumented)
m (int):: (undocumented)
nnz (int):: (undocumented)
descrA (Pointer/object):: (undocumented)
csrSortedValA_valM (Pointer/object):: (undocumented)
csrSortedRowPtrA (Pointer/object):: (undocumented)
csrSortedColIndA (Pointer/object):: (undocumented)
info (csrilu02Info/object):: (undocumented)
policy (hipsparseSolvePolicy_t):: (undocumented)
pBuffer (Pointer/object):: (undocumented)

hip.hipsparse.hipsparseDcsrilu02(handle, int m, int nnz, descrA, csrSortedValA_valM, csrSortedRowPtrA, csrSortedColIndA, info, policy, pBuffer)#

(No short description, might be part of a group.)

Args:

handle (Pointer/object):: (undocumented)
m (int):: (undocumented)
nnz (int):: (undocumented)
descrA (Pointer/object):: (undocumented)
csrSortedValA_valM (Pointer/object):: (undocumented)
csrSortedRowPtrA (Pointer/object):: (undocumented)
csrSortedColIndA (Pointer/object):: (undocumented)
info (csrilu02Info/object):: (undocumented)
policy (hipsparseSolvePolicy_t):: (undocumented)
pBuffer (Pointer/object):: (undocumented)

hip.hipsparse.hipsparseCcsrilu02(handle, int m, int nnz, descrA, csrSortedValA_valM, csrSortedRowPtrA, csrSortedColIndA, info, policy, pBuffer)#

(No short description, might be part of a group.)

Args:

handle (Pointer/object):: (undocumented)
m (int):: (undocumented)
nnz (int):: (undocumented)
descrA (Pointer/object):: (undocumented)
csrSortedValA_valM (float2/object):: (undocumented)
csrSortedRowPtrA (Pointer/object):: (undocumented)
csrSortedColIndA (Pointer/object):: (undocumented)
info (csrilu02Info/object):: (undocumented)
policy (hipsparseSolvePolicy_t):: (undocumented)
pBuffer (Pointer/object):: (undocumented)

hip.hipsparse.hipsparseZcsrilu02(handle, int m, int nnz, descrA, csrSortedValA_valM, csrSortedRowPtrA, csrSortedColIndA, info, policy, pBuffer)#

(No short description, might be part of a group.)

Args:

handle (Pointer/object):: (undocumented)
m (int):: (undocumented)
nnz (int):: (undocumented)
descrA (Pointer/object):: (undocumented)
csrSortedValA_valM (double2/object):: (undocumented)
csrSortedRowPtrA (Pointer/object):: (undocumented)
csrSortedColIndA (Pointer/object):: (undocumented)
info (csrilu02Info/object):: (undocumented)
policy (hipsparseSolvePolicy_t):: (undocumented)
pBuffer (Pointer/object):: (undocumented)

hip.hipsparse.hipsparseXbsric02_zeroPivot(handle, info, position)#

Incomplete Cholesky factorization with 0 fill-ins and no pivoting using BSR storage format

hipsparseXbsric02_zeroPivot returns HIPSPARSE_STATUS_ZERO_PIVOT , if either a structural or numerical zero has been found during hipsparseXbsric02_analysis() or hipsparseXbsric02() computation. The first zero pivot \(j\) at \(A_{j,j}\) is stored in position, using same index base as the BSR matrix.

position can be in host or device memory. If no zero pivot has been found, position is set to -1 and HIPSPARSE_STATUS_SUCCESS is returned instead.

Note:

If a zero pivot is found, position=j means that either the diagonal block A(j,j) is missing (structural zero) or the diagonal block A(j,j) is not positive definite (numerical zero).

Note:

hipsparseXbsric02_zeroPivot is a blocking function. It might influence performance negatively.

Args:

handle (Pointer/object):: (undocumented)
info (bsric02Info/object):: (undocumented)
position (Pointer/object):: (undocumented)

hip.hipsparse.hipsparseSbsric02_bufferSize(handle, dirA, int mb, int nnzb, descrA, bsrValA, bsrRowPtrA, bsrColIndA, int blockDim, info, pBufferSizeInBytes)#

Incomplete Cholesky factorization with 0 fill-ins and no pivoting using BSR storage format

hipsparseXbsric02_bufferSize returns the size of the temporary storage buffer in bytes that is required by hipsparseXbsric02_analysis() and hipsparseXbsric02(). The temporary storage buffer must be allocated by the user.

Args:

handle (Pointer/object):: (undocumented)
dirA (hipsparseDirection_t):: (undocumented)
mb (int):: (undocumented)
nnzb (int):: (undocumented)
descrA (Pointer/object):: (undocumented)
bsrValA (Pointer/object):: (undocumented)
bsrRowPtrA (Pointer/object):: (undocumented)
bsrColIndA (Pointer/object):: (undocumented)
blockDim (int):: (undocumented)
info (bsric02Info/object):: (undocumented)
pBufferSizeInBytes (Pointer/object):: (undocumented)

hip.hipsparse.hipsparseDbsric02_bufferSize(handle, dirA, int mb, int nnzb, descrA, bsrValA, bsrRowPtrA, bsrColIndA, int blockDim, info, pBufferSizeInBytes)#

(No short description, might be part of a group.)

Args:

handle (Pointer/object):: (undocumented)
dirA (hipsparseDirection_t):: (undocumented)
mb (int):: (undocumented)
nnzb (int):: (undocumented)
descrA (Pointer/object):: (undocumented)
bsrValA (Pointer/object):: (undocumented)
bsrRowPtrA (Pointer/object):: (undocumented)
bsrColIndA (Pointer/object):: (undocumented)
blockDim (int):: (undocumented)
info (bsric02Info/object):: (undocumented)
pBufferSizeInBytes (Pointer/object):: (undocumented)

hip.hipsparse.hipsparseCbsric02_bufferSize(handle, dirA, int mb, int nnzb, descrA, bsrValA, bsrRowPtrA, bsrColIndA, int blockDim, info, pBufferSizeInBytes)#

(No short description, might be part of a group.)

Args:

handle (Pointer/object):: (undocumented)
dirA (hipsparseDirection_t):: (undocumented)
mb (int):: (undocumented)
nnzb (int):: (undocumented)
descrA (Pointer/object):: (undocumented)
bsrValA (float2/object):: (undocumented)
bsrRowPtrA (Pointer/object):: (undocumented)
bsrColIndA (Pointer/object):: (undocumented)
blockDim (int):: (undocumented)
info (bsric02Info/object):: (undocumented)
pBufferSizeInBytes (Pointer/object):: (undocumented)

hip.hipsparse.hipsparseZbsric02_bufferSize(handle, dirA, int mb, int nnzb, descrA, bsrValA, bsrRowPtrA, bsrColIndA, int blockDim, info, pBufferSizeInBytes)#

(No short description, might be part of a group.)

Args:

handle (Pointer/object):: (undocumented)
dirA (hipsparseDirection_t):: (undocumented)
mb (int):: (undocumented)
nnzb (int):: (undocumented)
descrA (Pointer/object):: (undocumented)
bsrValA (double2/object):: (undocumented)
bsrRowPtrA (Pointer/object):: (undocumented)
bsrColIndA (Pointer/object):: (undocumented)
blockDim (int):: (undocumented)
info (bsric02Info/object):: (undocumented)
pBufferSizeInBytes (Pointer/object):: (undocumented)

hip.hipsparse.hipsparseSbsric02_analysis(handle, dirA, int mb, int nnzb, descrA, bsrValA, bsrRowPtrA, bsrColIndA, int blockDim, info, policy, pBuffer)#

Incomplete Cholesky factorization with 0 fill-ins and no pivoting using BSR storage format

hipsparseXbsric02_analysis performs the analysis step for hipsparseXbsric02().

Note:

If the matrix sparsity pattern changes, the gathered information will become invalid.

Note:

This function is non blocking and executed asynchronously with respect to the host. It may return before the actual computation has finished.

Args:

handle (Pointer/object):: (undocumented)
dirA (hipsparseDirection_t):: (undocumented)
mb (int):: (undocumented)
nnzb (int):: (undocumented)
descrA (Pointer/object):: (undocumented)
bsrValA (Pointer/object):: (undocumented)
bsrRowPtrA (Pointer/object):: (undocumented)
bsrColIndA (Pointer/object):: (undocumented)
blockDim (int):: (undocumented)
info (bsric02Info/object):: (undocumented)
policy (hipsparseSolvePolicy_t):: (undocumented)
pBuffer (Pointer/object):: (undocumented)

hip.hipsparse.hipsparseDbsric02_analysis(handle, dirA, int mb, int nnzb, descrA, bsrValA, bsrRowPtrA, bsrColIndA, int blockDim, info, policy, pBuffer)#

(No short description, might be part of a group.)

Args:

handle (Pointer/object):: (undocumented)
dirA (hipsparseDirection_t):: (undocumented)
mb (int):: (undocumented)
nnzb (int):: (undocumented)
descrA (Pointer/object):: (undocumented)
bsrValA (Pointer/object):: (undocumented)
bsrRowPtrA (Pointer/object):: (undocumented)
bsrColIndA (Pointer/object):: (undocumented)
blockDim (int):: (undocumented)
info (bsric02Info/object):: (undocumented)
policy (hipsparseSolvePolicy_t):: (undocumented)
pBuffer (Pointer/object):: (undocumented)

hip.hipsparse.hipsparseCbsric02_analysis(handle, dirA, int mb, int nnzb, descrA, bsrValA, bsrRowPtrA, bsrColIndA, int blockDim, info, policy, pBuffer)#

(No short description, might be part of a group.)

Args:

handle (Pointer/object):: (undocumented)
dirA (hipsparseDirection_t):: (undocumented)
mb (int):: (undocumented)
nnzb (int):: (undocumented)
descrA (Pointer/object):: (undocumented)
bsrValA (float2/object):: (undocumented)
bsrRowPtrA (Pointer/object):: (undocumented)
bsrColIndA (Pointer/object):: (undocumented)
blockDim (int):: (undocumented)
info (bsric02Info/object):: (undocumented)
policy (hipsparseSolvePolicy_t):: (undocumented)
pBuffer (Pointer/object):: (undocumented)

hip.hipsparse.hipsparseZbsric02_analysis(handle, dirA, int mb, int nnzb, descrA, bsrValA, bsrRowPtrA, bsrColIndA, int blockDim, info, policy, pBuffer)#

(No short description, might be part of a group.)

Args:

handle (Pointer/object):: (undocumented)
dirA (hipsparseDirection_t):: (undocumented)
mb (int):: (undocumented)
nnzb (int):: (undocumented)
descrA (Pointer/object):: (undocumented)
bsrValA (double2/object):: (undocumented)
bsrRowPtrA (Pointer/object):: (undocumented)
bsrColIndA (Pointer/object):: (undocumented)
blockDim (int):: (undocumented)
info (bsric02Info/object):: (undocumented)
policy (hipsparseSolvePolicy_t):: (undocumented)
pBuffer (Pointer/object):: (undocumented)

hip.hipsparse.hipsparseSbsric02(handle, dirA, int mb, int nnzb, descrA, bsrValA, bsrRowPtrA, bsrColIndA, int blockDim, info, policy, pBuffer)#

Incomplete Cholesky factorization with 0 fill-ins and no pivoting using BSR storage format

hipsparseXbsric02 computes the incomplete Cholesky factorization with 0 fill-ins and no pivoting of a sparse \(mb \times mb\) BSR matrix \(A\), such that

\[A \approx LL^T\]

Note:

This function is non blocking and executed asynchronously with respect to the host. It may return before the actual computation has finished.

Args:

handle (Pointer/object):: (undocumented)
dirA (hipsparseDirection_t):: (undocumented)
mb (int):: (undocumented)
nnzb (int):: (undocumented)
descrA (Pointer/object):: (undocumented)
bsrValA (Pointer/object):: (undocumented)
bsrRowPtrA (Pointer/object):: (undocumented)
bsrColIndA (Pointer/object):: (undocumented)
blockDim (int):: (undocumented)
info (bsric02Info/object):: (undocumented)
policy (hipsparseSolvePolicy_t):: (undocumented)
pBuffer (Pointer/object):: (undocumented)

hip.hipsparse.hipsparseDbsric02(handle, dirA, int mb, int nnzb, descrA, bsrValA, bsrRowPtrA, bsrColIndA, int blockDim, info, policy, pBuffer)#

(No short description, might be part of a group.)

Args:

handle (Pointer/object):: (undocumented)
dirA (hipsparseDirection_t):: (undocumented)
mb (int):: (undocumented)
nnzb (int):: (undocumented)
descrA (Pointer/object):: (undocumented)
bsrValA (Pointer/object):: (undocumented)
bsrRowPtrA (Pointer/object):: (undocumented)
bsrColIndA (Pointer/object):: (undocumented)
blockDim (int):: (undocumented)
info (bsric02Info/object):: (undocumented)
policy (hipsparseSolvePolicy_t):: (undocumented)
pBuffer (Pointer/object):: (undocumented)

hip.hipsparse.hipsparseCbsric02(handle, dirA, int mb, int nnzb, descrA, bsrValA, bsrRowPtrA, bsrColIndA, int blockDim, info, policy, pBuffer)#

(No short description, might be part of a group.)

Args:

handle (Pointer/object):: (undocumented)
dirA (hipsparseDirection_t):: (undocumented)
mb (int):: (undocumented)
nnzb (int):: (undocumented)
descrA (Pointer/object):: (undocumented)
bsrValA (float2/object):: (undocumented)
bsrRowPtrA (Pointer/object):: (undocumented)
bsrColIndA (Pointer/object):: (undocumented)
blockDim (int):: (undocumented)
info (bsric02Info/object):: (undocumented)
policy (hipsparseSolvePolicy_t):: (undocumented)
pBuffer (Pointer/object):: (undocumented)

hip.hipsparse.hipsparseZbsric02(handle, dirA, int mb, int nnzb, descrA, bsrValA, bsrRowPtrA, bsrColIndA, int blockDim, info, policy, pBuffer)#

(No short description, might be part of a group.)

Args:

handle (Pointer/object):: (undocumented)
dirA (hipsparseDirection_t):: (undocumented)
mb (int):: (undocumented)
nnzb (int):: (undocumented)
descrA (Pointer/object):: (undocumented)
bsrValA (double2/object):: (undocumented)
bsrRowPtrA (Pointer/object):: (undocumented)
bsrColIndA (Pointer/object):: (undocumented)
blockDim (int):: (undocumented)
info (bsric02Info/object):: (undocumented)
policy (hipsparseSolvePolicy_t):: (undocumented)
pBuffer (Pointer/object):: (undocumented)

hip.hipsparse.hipsparseXcsric02_zeroPivot(handle, info, position)#

Incomplete Cholesky factorization with 0 fill-ins and no pivoting using CSR storage format

hipsparseXcsric02_zeroPivot returns HIPSPARSE_STATUS_ZERO_PIVOT , if either a structural or numerical zero has been found during hipsparseXcsric02_analysis() or hipsparseXcsric02() computation. The first zero pivot \(j\) at \(A_{j,j}\) is stored in position, using same index base as the CSR matrix.

position can be in host or device memory. If no zero pivot has been found, position is set to -1 and HIPSPARSE_STATUS_SUCCESS is returned instead.

Note:

hipsparseXcsric02_zeroPivot is a blocking function. It might influence performance negatively.

Args:

handle (Pointer/object):: (undocumented)
info (csric02Info/object):: (undocumented)
position (Pointer/object):: (undocumented)

hip.hipsparse.hipsparseScsric02_bufferSize(handle, int m, int nnz, descrA, csrSortedValA, csrSortedRowPtrA, csrSortedColIndA, info, pBufferSizeInBytes)#

Incomplete Cholesky factorization with 0 fill-ins and no pivoting using CSR storage format

hipsparseXcsric02_bufferSize returns the size of the temporary storage buffer in bytes that is required by hipsparseXcsric02_analysis() and hipsparseXcsric02().

Args:

handle (Pointer/object):: (undocumented)
m (int):: (undocumented)
nnz (int):: (undocumented)
descrA (Pointer/object):: (undocumented)
csrSortedValA (Pointer/object):: (undocumented)
csrSortedRowPtrA (Pointer/object):: (undocumented)
csrSortedColIndA (Pointer/object):: (undocumented)
info (csric02Info/object):: (undocumented)
pBufferSizeInBytes (Pointer/object):: (undocumented)

hip.hipsparse.hipsparseDcsric02_bufferSize(handle, int m, int nnz, descrA, csrSortedValA, csrSortedRowPtrA, csrSortedColIndA, info, pBufferSizeInBytes)#

(No short description, might be part of a group.)

Args:

handle (Pointer/object):: (undocumented)
m (int):: (undocumented)
nnz (int):: (undocumented)
descrA (Pointer/object):: (undocumented)
csrSortedValA (Pointer/object):: (undocumented)
csrSortedRowPtrA (Pointer/object):: (undocumented)
csrSortedColIndA (Pointer/object):: (undocumented)
info (csric02Info/object):: (undocumented)
pBufferSizeInBytes (Pointer/object):: (undocumented)

hip.hipsparse.hipsparseCcsric02_bufferSize(handle, int m, int nnz, descrA, csrSortedValA, csrSortedRowPtrA, csrSortedColIndA, info, pBufferSizeInBytes)#

(No short description, might be part of a group.)

Args:

handle (Pointer/object):: (undocumented)
m (int):: (undocumented)
nnz (int):: (undocumented)
descrA (Pointer/object):: (undocumented)
csrSortedValA (float2/object):: (undocumented)
csrSortedRowPtrA (Pointer/object):: (undocumented)
csrSortedColIndA (Pointer/object):: (undocumented)
info (csric02Info/object):: (undocumented)
pBufferSizeInBytes (Pointer/object):: (undocumented)

hip.hipsparse.hipsparseZcsric02_bufferSize(handle, int m, int nnz, descrA, csrSortedValA, csrSortedRowPtrA, csrSortedColIndA, info, pBufferSizeInBytes)#

(No short description, might be part of a group.)

Args:

handle (Pointer/object):: (undocumented)
m (int):: (undocumented)
nnz (int):: (undocumented)
descrA (Pointer/object):: (undocumented)
csrSortedValA (double2/object):: (undocumented)
csrSortedRowPtrA (Pointer/object):: (undocumented)
csrSortedColIndA (Pointer/object):: (undocumented)
info (csric02Info/object):: (undocumented)
pBufferSizeInBytes (Pointer/object):: (undocumented)

hip.hipsparse.hipsparseScsric02_bufferSizeExt(handle, int m, int nnz, descrA, csrSortedValA, csrSortedRowPtrA, csrSortedColIndA, info, pBufferSizeInBytes)#

Incomplete Cholesky factorization with 0 fill-ins and no pivoting using CSR storage format

hipsparseXcsric02_bufferSizeExt returns the size of the temporary storage buffer in bytes that is required by hipsparseXcsric02_analysis() and hipsparseXcsric02().

Args:

handle (Pointer/object):: (undocumented)
m (int):: (undocumented)
nnz (int):: (undocumented)
descrA (Pointer/object):: (undocumented)
csrSortedValA (Pointer/object):: (undocumented)
csrSortedRowPtrA (Pointer/object):: (undocumented)
csrSortedColIndA (Pointer/object):: (undocumented)
info (csric02Info/object):: (undocumented)
pBufferSizeInBytes (Pointer/object):: (undocumented)

hip.hipsparse.hipsparseDcsric02_bufferSizeExt(handle, int m, int nnz, descrA, csrSortedValA, csrSortedRowPtrA, csrSortedColIndA, info, pBufferSizeInBytes)#

(No short description, might be part of a group.)

Args:

handle (Pointer/object):: (undocumented)
m (int):: (undocumented)
nnz (int):: (undocumented)
descrA (Pointer/object):: (undocumented)
csrSortedValA (Pointer/object):: (undocumented)
csrSortedRowPtrA (Pointer/object):: (undocumented)
csrSortedColIndA (Pointer/object):: (undocumented)
info (csric02Info/object):: (undocumented)
pBufferSizeInBytes (Pointer/object):: (undocumented)

hip.hipsparse.hipsparseCcsric02_bufferSizeExt(handle, int m, int nnz, descrA, csrSortedValA, csrSortedRowPtrA, csrSortedColIndA, info, pBufferSizeInBytes)#

(No short description, might be part of a group.)

Args:

handle (Pointer/object):: (undocumented)
m (int):: (undocumented)
nnz (int):: (undocumented)
descrA (Pointer/object):: (undocumented)
csrSortedValA (float2/object):: (undocumented)
csrSortedRowPtrA (Pointer/object):: (undocumented)
csrSortedColIndA (Pointer/object):: (undocumented)
info (csric02Info/object):: (undocumented)
pBufferSizeInBytes (Pointer/object):: (undocumented)

hip.hipsparse.hipsparseZcsric02_bufferSizeExt(handle, int m, int nnz, descrA, csrSortedValA, csrSortedRowPtrA, csrSortedColIndA, info, pBufferSizeInBytes)#

(No short description, might be part of a group.)

Args:

handle (Pointer/object):: (undocumented)
m (int):: (undocumented)
nnz (int):: (undocumented)
descrA (Pointer/object):: (undocumented)
csrSortedValA (double2/object):: (undocumented)
csrSortedRowPtrA (Pointer/object):: (undocumented)
csrSortedColIndA (Pointer/object):: (undocumented)
info (csric02Info/object):: (undocumented)
pBufferSizeInBytes (Pointer/object):: (undocumented)

hip.hipsparse.hipsparseScsric02_analysis(handle, int m, int nnz, descrA, csrSortedValA, csrSortedRowPtrA, csrSortedColIndA, info, policy, pBuffer)#

Incomplete Cholesky factorization with 0 fill-ins and no pivoting using CSR storage format

hipsparseXcsric02_analysis performs the analysis step for hipsparseXcsric02().

Note:

If the matrix sparsity pattern changes, the gathered information will become invalid.

Note:

This function is non blocking and executed asynchronously with respect to the host. It may return before the actual computation has finished.

Args:

handle (Pointer/object):: (undocumented)
m (int):: (undocumented)
nnz (int):: (undocumented)
descrA (Pointer/object):: (undocumented)
csrSortedValA (Pointer/object):: (undocumented)
csrSortedRowPtrA (Pointer/object):: (undocumented)
csrSortedColIndA (Pointer/object):: (undocumented)
info (csric02Info/object):: (undocumented)
policy (hipsparseSolvePolicy_t):: (undocumented)
pBuffer (Pointer/object):: (undocumented)

hip.hipsparse.hipsparseDcsric02_analysis(handle, int m, int nnz, descrA, csrSortedValA, csrSortedRowPtrA, csrSortedColIndA, info, policy, pBuffer)#

(No short description, might be part of a group.)

Args:

handle (Pointer/object):: (undocumented)
m (int):: (undocumented)
nnz (int):: (undocumented)
descrA (Pointer/object):: (undocumented)
csrSortedValA (Pointer/object):: (undocumented)
csrSortedRowPtrA (Pointer/object):: (undocumented)
csrSortedColIndA (Pointer/object):: (undocumented)
info (csric02Info/object):: (undocumented)
policy (hipsparseSolvePolicy_t):: (undocumented)
pBuffer (Pointer/object):: (undocumented)

hip.hipsparse.hipsparseCcsric02_analysis(handle, int m, int nnz, descrA, csrSortedValA, csrSortedRowPtrA, csrSortedColIndA, info, policy, pBuffer)#

(No short description, might be part of a group.)

Args:

handle (Pointer/object):: (undocumented)
m (int):: (undocumented)
nnz (int):: (undocumented)
descrA (Pointer/object):: (undocumented)
csrSortedValA (float2/object):: (undocumented)
csrSortedRowPtrA (Pointer/object):: (undocumented)
csrSortedColIndA (Pointer/object):: (undocumented)
info (csric02Info/object):: (undocumented)
policy (hipsparseSolvePolicy_t):: (undocumented)
pBuffer (Pointer/object):: (undocumented)

hip.hipsparse.hipsparseZcsric02_analysis(handle, int m, int nnz, descrA, csrSortedValA, csrSortedRowPtrA, csrSortedColIndA, info, policy, pBuffer)#

(No short description, might be part of a group.)

Args:

handle (Pointer/object):: (undocumented)
m (int):: (undocumented)
nnz (int):: (undocumented)
descrA (Pointer/object):: (undocumented)
csrSortedValA (double2/object):: (undocumented)
csrSortedRowPtrA (Pointer/object):: (undocumented)
csrSortedColIndA (Pointer/object):: (undocumented)
info (csric02Info/object):: (undocumented)
policy (hipsparseSolvePolicy_t):: (undocumented)
pBuffer (Pointer/object):: (undocumented)

hip.hipsparse.hipsparseScsric02(handle, int m, int nnz, descrA, csrSortedValA_valM, csrSortedRowPtrA, csrSortedColIndA, info, policy, pBuffer)#

Incomplete Cholesky factorization with 0 fill-ins and no pivoting using CSR storage format

hipsparseXcsric02 computes the incomplete Cholesky factorization with 0 fill-ins and no pivoting of a sparse \(m \times m\) CSR matrix \(A\), such that

\[A \approx LL^T\]

Note:

The sparse CSR matrix has to be sorted. This can be achieved by calling hipsparseXcsrsort().

Note:

This function is non blocking and executed asynchronously with respect to the host. It may return before the actual computation has finished.

Args:

handle (Pointer/object):: (undocumented)
m (int):: (undocumented)
nnz (int):: (undocumented)
descrA (Pointer/object):: (undocumented)
csrSortedValA_valM (Pointer/object):: (undocumented)
csrSortedRowPtrA (Pointer/object):: (undocumented)
csrSortedColIndA (Pointer/object):: (undocumented)
info (csric02Info/object):: (undocumented)
policy (hipsparseSolvePolicy_t):: (undocumented)
pBuffer (Pointer/object):: (undocumented)

hip.hipsparse.hipsparseDcsric02(handle, int m, int nnz, descrA, csrSortedValA_valM, csrSortedRowPtrA, csrSortedColIndA, info, policy, pBuffer)#

(No short description, might be part of a group.)

Args:

handle (Pointer/object):: (undocumented)
m (int):: (undocumented)
nnz (int):: (undocumented)
descrA (Pointer/object):: (undocumented)
csrSortedValA_valM (Pointer/object):: (undocumented)
csrSortedRowPtrA (Pointer/object):: (undocumented)
csrSortedColIndA (Pointer/object):: (undocumented)
info (csric02Info/object):: (undocumented)
policy (hipsparseSolvePolicy_t):: (undocumented)
pBuffer (Pointer/object):: (undocumented)

hip.hipsparse.hipsparseCcsric02(handle, int m, int nnz, descrA, csrSortedValA_valM, csrSortedRowPtrA, csrSortedColIndA, info, policy, pBuffer)#

(No short description, might be part of a group.)

Args:

handle (Pointer/object):: (undocumented)
m (int):: (undocumented)
nnz (int):: (undocumented)
descrA (Pointer/object):: (undocumented)
csrSortedValA_valM (float2/object):: (undocumented)
csrSortedRowPtrA (Pointer/object):: (undocumented)
csrSortedColIndA (Pointer/object):: (undocumented)
info (csric02Info/object):: (undocumented)
policy (hipsparseSolvePolicy_t):: (undocumented)
pBuffer (Pointer/object):: (undocumented)

hip.hipsparse.hipsparseZcsric02(handle, int m, int nnz, descrA, csrSortedValA_valM, csrSortedRowPtrA, csrSortedColIndA, info, policy, pBuffer)#

(No short description, might be part of a group.)

Args:

handle (Pointer/object):: (undocumented)
m (int):: (undocumented)
nnz (int):: (undocumented)
descrA (Pointer/object):: (undocumented)
csrSortedValA_valM (double2/object):: (undocumented)
csrSortedRowPtrA (Pointer/object):: (undocumented)
csrSortedColIndA (Pointer/object):: (undocumented)
info (csric02Info/object):: (undocumented)
policy (hipsparseSolvePolicy_t):: (undocumented)
pBuffer (Pointer/object):: (undocumented)

hip.hipsparse.hipsparseSgtsv2_bufferSizeExt(handle, int m, int n, dl, d, du, B, int ldb, pBufferSizeInBytes)#

Tridiagonal solver with pivoting

hipsparseXgtsv2_bufferSize returns the size of the temporary storage buffer in bytes that is required by hipsparseXgtsv2(). The temporary storage buffer must be allocated by the user.

Args:

handle (Pointer/object):: (undocumented)
m (int):: (undocumented)
n (int):: (undocumented)
dl (Pointer/object):: (undocumented)
d (Pointer/object):: (undocumented)
du (Pointer/object):: (undocumented)
B (Pointer/object):: (undocumented)
ldb (int):: (undocumented)
pBufferSizeInBytes (Pointer/object):: (undocumented)

hip.hipsparse.hipsparseDgtsv2_bufferSizeExt(handle, int m, int n, dl, d, du, B, int db, pBufferSizeInBytes)#

(No short description, might be part of a group.)

Args:

handle (Pointer/object):: (undocumented)
m (int):: (undocumented)
n (int):: (undocumented)
dl (Pointer/object):: (undocumented)
d (Pointer/object):: (undocumented)
du (Pointer/object):: (undocumented)
B (Pointer/object):: (undocumented)
db (int):: (undocumented)
pBufferSizeInBytes (Pointer/object):: (undocumented)

hip.hipsparse.hipsparseCgtsv2_bufferSizeExt(handle, int m, int n, dl, d, du, B, int ldb, pBufferSizeInBytes)#

(No short description, might be part of a group.)

Args:

handle (Pointer/object):: (undocumented)
m (int):: (undocumented)
n (int):: (undocumented)
dl (float2/object):: (undocumented)
d (float2/object):: (undocumented)
du (float2/object):: (undocumented)
B (float2/object):: (undocumented)
ldb (int):: (undocumented)
pBufferSizeInBytes (Pointer/object):: (undocumented)

hip.hipsparse.hipsparseZgtsv2_bufferSizeExt(handle, int m, int n, dl, d, du, B, int ldb, pBufferSizeInBytes)#

(No short description, might be part of a group.)

Args:

handle (Pointer/object):: (undocumented)
m (int):: (undocumented)
n (int):: (undocumented)
dl (double2/object):: (undocumented)
d (double2/object):: (undocumented)
du (double2/object):: (undocumented)
B (double2/object):: (undocumented)
ldb (int):: (undocumented)
pBufferSizeInBytes (Pointer/object):: (undocumented)

hip.hipsparse.hipsparseSgtsv2(handle, int m, int n, dl, d, du, B, int ldb, pBuffer)#

Tridiagonal solver with pivoting

hipsparseXgtsv2 solves a tridiagonal system for multiple right hand sides using pivoting.

Note:

This function is non blocking and executed asynchronously with respect to the host. It may return before the actual computation has finished.

Args:

handle (Pointer/object):: (undocumented)
m (int):: (undocumented)
n (int):: (undocumented)
dl (Pointer/object):: (undocumented)
d (Pointer/object):: (undocumented)
du (Pointer/object):: (undocumented)
B (Pointer/object):: (undocumented)
ldb (int):: (undocumented)
pBuffer (Pointer/object):: (undocumented)

hip.hipsparse.hipsparseDgtsv2(handle, int m, int n, dl, d, du, B, int ldb, pBuffer)#

(No short description, might be part of a group.)

Args:

handle (Pointer/object):: (undocumented)
m (int):: (undocumented)
n (int):: (undocumented)
dl (Pointer/object):: (undocumented)
d (Pointer/object):: (undocumented)
du (Pointer/object):: (undocumented)
B (Pointer/object):: (undocumented)
ldb (int):: (undocumented)
pBuffer (Pointer/object):: (undocumented)

hip.hipsparse.hipsparseCgtsv2(handle, int m, int n, dl, d, du, B, int ldb, pBuffer)#

(No short description, might be part of a group.)

Args:

handle (Pointer/object):: (undocumented)
m (int):: (undocumented)
n (int):: (undocumented)
dl (float2/object):: (undocumented)
d (float2/object):: (undocumented)
du (float2/object):: (undocumented)
B (float2/object):: (undocumented)
ldb (int):: (undocumented)
pBuffer (Pointer/object):: (undocumented)

hip.hipsparse.hipsparseZgtsv2(handle, int m, int n, dl, d, du, B, int ldb, pBuffer)#

(No short description, might be part of a group.)

Args:

handle (Pointer/object):: (undocumented)
m (int):: (undocumented)
n (int):: (undocumented)
dl (double2/object):: (undocumented)
d (double2/object):: (undocumented)
du (double2/object):: (undocumented)
B (double2/object):: (undocumented)
ldb (int):: (undocumented)
pBuffer (Pointer/object):: (undocumented)

hip.hipsparse.hipsparseSgtsv2_nopivot_bufferSizeExt(handle, int m, int n, dl, d, du, B, int ldb, pBufferSizeInBytes)#

Tridiagonal solver (no pivoting)

hipsparseXgtsv2_nopivot_bufferSizeExt returns the size of the temporary storage buffer in bytes that is required by hipsparseXgtsv2_nopivot(). The temporary storage buffer must be allocated by the user.

Args:

handle (Pointer/object):: (undocumented)
m (int):: (undocumented)
n (int):: (undocumented)
dl (Pointer/object):: (undocumented)
d (Pointer/object):: (undocumented)
du (Pointer/object):: (undocumented)
B (Pointer/object):: (undocumented)
ldb (int):: (undocumented)
pBufferSizeInBytes (Pointer/object):: (undocumented)

hip.hipsparse.hipsparseDgtsv2_nopivot_bufferSizeExt(handle, int m, int n, dl, d, du, B, int db, pBufferSizeInBytes)#

(No short description, might be part of a group.)

Args:

handle (Pointer/object):: (undocumented)
m (int):: (undocumented)
n (int):: (undocumented)
dl (Pointer/object):: (undocumented)
d (Pointer/object):: (undocumented)
du (Pointer/object):: (undocumented)
B (Pointer/object):: (undocumented)
db (int):: (undocumented)
pBufferSizeInBytes (Pointer/object):: (undocumented)

hip.hipsparse.hipsparseCgtsv2_nopivot_bufferSizeExt(handle, int m, int n, dl, d, du, B, int ldb, pBufferSizeInBytes)#

(No short description, might be part of a group.)

Args:

handle (Pointer/object):: (undocumented)
m (int):: (undocumented)
n (int):: (undocumented)
dl (float2/object):: (undocumented)
d (float2/object):: (undocumented)
du (float2/object):: (undocumented)
B (float2/object):: (undocumented)
ldb (int):: (undocumented)
pBufferSizeInBytes (Pointer/object):: (undocumented)

hip.hipsparse.hipsparseZgtsv2_nopivot_bufferSizeExt(handle, int m, int n, dl, d, du, B, int ldb, pBufferSizeInBytes)#

(No short description, might be part of a group.)

Args:

handle (Pointer/object):: (undocumented)
m (int):: (undocumented)
n (int):: (undocumented)
dl (double2/object):: (undocumented)
d (double2/object):: (undocumented)
du (double2/object):: (undocumented)
B (double2/object):: (undocumented)
ldb (int):: (undocumented)
pBufferSizeInBytes (Pointer/object):: (undocumented)

hip.hipsparse.hipsparseSgtsv2_nopivot(handle, int m, int n, dl, d, du, B, int ldb, pBuffer)#

Tridiagonal solver (no pivoting)

hipsparseXgtsv2_nopivot solves a tridiagonal linear system for multiple right-hand sides

Note:

This function is non blocking and executed asynchronously with respect to the host. It may return before the actual computation has finished.

Args:

handle (Pointer/object):: (undocumented)
m (int):: (undocumented)
n (int):: (undocumented)
dl (Pointer/object):: (undocumented)
d (Pointer/object):: (undocumented)
du (Pointer/object):: (undocumented)
B (Pointer/object):: (undocumented)
ldb (int):: (undocumented)
pBuffer (Pointer/object):: (undocumented)

hip.hipsparse.hipsparseDgtsv2_nopivot(handle, int m, int n, dl, d, du, B, int ldb, pBuffer)#

(No short description, might be part of a group.)

Args:

handle (Pointer/object):: (undocumented)
m (int):: (undocumented)
n (int):: (undocumented)
dl (Pointer/object):: (undocumented)
d (Pointer/object):: (undocumented)
du (Pointer/object):: (undocumented)
B (Pointer/object):: (undocumented)
ldb (int):: (undocumented)
pBuffer (Pointer/object):: (undocumented)

hip.hipsparse.hipsparseCgtsv2_nopivot(handle, int m, int n, dl, d, du, B, int ldb, pBuffer)#

(No short description, might be part of a group.)

Args:

handle (Pointer/object):: (undocumented)
m (int):: (undocumented)
n (int):: (undocumented)
dl (float2/object):: (undocumented)
d (float2/object):: (undocumented)
du (float2/object):: (undocumented)
B (float2/object):: (undocumented)
ldb (int):: (undocumented)
pBuffer (Pointer/object):: (undocumented)

hip.hipsparse.hipsparseZgtsv2_nopivot(handle, int m, int n, dl, d, du, B, int ldb, pBuffer)#

(No short description, might be part of a group.)

Args:

handle (Pointer/object):: (undocumented)
m (int):: (undocumented)
n (int):: (undocumented)
dl (double2/object):: (undocumented)
d (double2/object):: (undocumented)
du (double2/object):: (undocumented)
B (double2/object):: (undocumented)
ldb (int):: (undocumented)
pBuffer (Pointer/object):: (undocumented)

hip.hipsparse.hipsparseSgtsv2StridedBatch_bufferSizeExt(handle, int m, dl, d, du, x, int batchCount, int batchStride, pBufferSizeInBytes)#

Strided Batch tridiagonal solver (no pivoting)

hipsparseXgtsv2StridedBatch_bufferSizeExt returns the size of the temporary storage buffer in bytes that is required by hipsparseXgtsv2StridedBatch(). The temporary storage buffer must be allocated by the user.

Args:

handle (Pointer/object):: (undocumented)
m (int):: (undocumented)
dl (Pointer/object):: (undocumented)
d (Pointer/object):: (undocumented)
du (Pointer/object):: (undocumented)
x (Pointer/object):: (undocumented)
batchCount (int):: (undocumented)
batchStride (int):: (undocumented)
pBufferSizeInBytes (Pointer/object):: (undocumented)

hip.hipsparse.hipsparseDgtsv2StridedBatch_bufferSizeExt(handle, int m, dl, d, du, x, int batchCount, int batchStride, pBufferSizeInBytes)#

(No short description, might be part of a group.)

Args:

handle (Pointer/object):: (undocumented)
m (int):: (undocumented)
dl (Pointer/object):: (undocumented)
d (Pointer/object):: (undocumented)
du (Pointer/object):: (undocumented)
x (Pointer/object):: (undocumented)
batchCount (int):: (undocumented)
batchStride (int):: (undocumented)
pBufferSizeInBytes (Pointer/object):: (undocumented)

hip.hipsparse.hipsparseCgtsv2StridedBatch_bufferSizeExt(handle, int m, dl, d, du, x, int batchCount, int batchStride, pBufferSizeInBytes)#

(No short description, might be part of a group.)

Args:

handle (Pointer/object):: (undocumented)
m (int):: (undocumented)
dl (float2/object):: (undocumented)
d (float2/object):: (undocumented)
du (float2/object):: (undocumented)
x (float2/object):: (undocumented)
batchCount (int):: (undocumented)
batchStride (int):: (undocumented)
pBufferSizeInBytes (Pointer/object):: (undocumented)

hip.hipsparse.hipsparseZgtsv2StridedBatch_bufferSizeExt(handle, int m, dl, d, du, x, int batchCount, int batchStride, pBufferSizeInBytes)#

(No short description, might be part of a group.)

Args:

handle (Pointer/object):: (undocumented)
m (int):: (undocumented)
dl (double2/object):: (undocumented)
d (double2/object):: (undocumented)
du (double2/object):: (undocumented)
x (double2/object):: (undocumented)
batchCount (int):: (undocumented)
batchStride (int):: (undocumented)
pBufferSizeInBytes (Pointer/object):: (undocumented)

hip.hipsparse.hipsparseSgtsv2StridedBatch(handle, int m, dl, d, du, x, int batchCount, int batchStride, pBuffer)#

Strided Batch tridiagonal solver (no pivoting)

hipsparseXgtsv2StridedBatch solves a batched tridiagonal linear system

Note:

This function is non blocking and executed asynchronously with respect to the host. It may return before the actual computation has finished.

Args:

handle (Pointer/object):: (undocumented)
m (int):: (undocumented)
dl (Pointer/object):: (undocumented)
d (Pointer/object):: (undocumented)
du (Pointer/object):: (undocumented)
x (Pointer/object):: (undocumented)
batchCount (int):: (undocumented)
batchStride (int):: (undocumented)
pBuffer (Pointer/object):: (undocumented)

hip.hipsparse.hipsparseDgtsv2StridedBatch(handle, int m, dl, d, du, x, int batchCount, int batchStride, pBuffer)#

(No short description, might be part of a group.)

Args:

handle (Pointer/object):: (undocumented)
m (int):: (undocumented)
dl (Pointer/object):: (undocumented)
d (Pointer/object):: (undocumented)
du (Pointer/object):: (undocumented)
x (Pointer/object):: (undocumented)
batchCount (int):: (undocumented)
batchStride (int):: (undocumented)
pBuffer (Pointer/object):: (undocumented)

hip.hipsparse.hipsparseCgtsv2StridedBatch(handle, int m, dl, d, du, x, int batchCount, int batchStride, pBuffer)#

(No short description, might be part of a group.)

Args:

handle (Pointer/object):: (undocumented)
m (int):: (undocumented)
dl (float2/object):: (undocumented)
d (float2/object):: (undocumented)
du (float2/object):: (undocumented)
x (float2/object):: (undocumented)
batchCount (int):: (undocumented)
batchStride (int):: (undocumented)
pBuffer (Pointer/object):: (undocumented)

hip.hipsparse.hipsparseZgtsv2StridedBatch(handle, int m, dl, d, du, x, int batchCount, int batchStride, pBuffer)#

(No short description, might be part of a group.)

Args:

handle (Pointer/object):: (undocumented)
m (int):: (undocumented)
dl (double2/object):: (undocumented)
d (double2/object):: (undocumented)
du (double2/object):: (undocumented)
x (double2/object):: (undocumented)
batchCount (int):: (undocumented)
batchStride (int):: (undocumented)
pBuffer (Pointer/object):: (undocumented)

hip.hipsparse.hipsparseSgtsvInterleavedBatch_bufferSizeExt(handle, int algo, int m, dl, d, du, x, int batchCount, pBufferSizeInBytes)#

Interleaved Batch tridiagonal solver

hipsparseXgtsvInterleavedBatch_bufferSizeExt returns the size of the temporary storage buffer in bytes that is required by hipsparseXgtsvInterleavedBatch(). The temporary storage buffer must be allocated by the user.

Args:

handle (Pointer/object):: (undocumented)
algo (int):: (undocumented)
m (int):: (undocumented)
dl (Pointer/object):: (undocumented)
d (Pointer/object):: (undocumented)
du (Pointer/object):: (undocumented)
x (Pointer/object):: (undocumented)
batchCount (int):: (undocumented)
pBufferSizeInBytes (Pointer/object):: (undocumented)

hip.hipsparse.hipsparseDgtsvInterleavedBatch_bufferSizeExt(handle, int algo, int m, dl, d, du, x, int batchCount, pBufferSizeInBytes)#

(No short description, might be part of a group.)

Args:

handle (Pointer/object):: (undocumented)
algo (int):: (undocumented)
m (int):: (undocumented)
dl (Pointer/object):: (undocumented)
d (Pointer/object):: (undocumented)
du (Pointer/object):: (undocumented)
x (Pointer/object):: (undocumented)
batchCount (int):: (undocumented)
pBufferSizeInBytes (Pointer/object):: (undocumented)

hip.hipsparse.hipsparseCgtsvInterleavedBatch_bufferSizeExt(handle, int algo, int m, dl, d, du, x, int batchCount, pBufferSizeInBytes)#

(No short description, might be part of a group.)

Args:

handle (Pointer/object):: (undocumented)
algo (int):: (undocumented)
m (int):: (undocumented)
dl (float2/object):: (undocumented)
d (float2/object):: (undocumented)
du (float2/object):: (undocumented)
x (float2/object):: (undocumented)
batchCount (int):: (undocumented)
pBufferSizeInBytes (Pointer/object):: (undocumented)

hip.hipsparse.hipsparseZgtsvInterleavedBatch_bufferSizeExt(handle, int algo, int m, dl, d, du, x, int batchCount, pBufferSizeInBytes)#

(No short description, might be part of a group.)

Args:

handle (Pointer/object):: (undocumented)
algo (int):: (undocumented)
m (int):: (undocumented)
dl (double2/object):: (undocumented)
d (double2/object):: (undocumented)
du (double2/object):: (undocumented)
x (double2/object):: (undocumented)
batchCount (int):: (undocumented)
pBufferSizeInBytes (Pointer/object):: (undocumented)

hip.hipsparse.hipsparseSgtsvInterleavedBatch(handle, int algo, int m, dl, d, du, x, int batchCount, pBuffer)#

Interleaved Batch tridiagonal solver

hipsparseXgtsvInterleavedBatch solves a batched tridiagonal linear system

Note:

This function is non blocking and executed asynchronously with respect to the host. It may return before the actual computation has finished.

Args:

handle (Pointer/object):: (undocumented)
algo (int):: (undocumented)
m (int):: (undocumented)
dl (Pointer/object):: (undocumented)
d (Pointer/object):: (undocumented)
du (Pointer/object):: (undocumented)
x (Pointer/object):: (undocumented)
batchCount (int):: (undocumented)
pBuffer (Pointer/object):: (undocumented)

hip.hipsparse.hipsparseDgtsvInterleavedBatch(handle, int algo, int m, dl, d, du, x, int batchCount, pBuffer)#

(No short description, might be part of a group.)

Args:

handle (Pointer/object):: (undocumented)
algo (int):: (undocumented)
m (int):: (undocumented)
dl (Pointer/object):: (undocumented)
d (Pointer/object):: (undocumented)
du (Pointer/object):: (undocumented)
x (Pointer/object):: (undocumented)
batchCount (int):: (undocumented)
pBuffer (Pointer/object):: (undocumented)

hip.hipsparse.hipsparseCgtsvInterleavedBatch(handle, int algo, int m, dl, d, du, x, int batchCount, pBuffer)#

(No short description, might be part of a group.)

Args:

handle (Pointer/object):: (undocumented)
algo (int):: (undocumented)
m (int):: (undocumented)
dl (float2/object):: (undocumented)
d (float2/object):: (undocumented)
du (float2/object):: (undocumented)
x (float2/object):: (undocumented)
batchCount (int):: (undocumented)
pBuffer (Pointer/object):: (undocumented)

hip.hipsparse.hipsparseZgtsvInterleavedBatch(handle, int algo, int m, dl, d, du, x, int batchCount, pBuffer)#

(No short description, might be part of a group.)

Args:

handle (Pointer/object):: (undocumented)
algo (int):: (undocumented)
m (int):: (undocumented)
dl (double2/object):: (undocumented)
d (double2/object):: (undocumented)
du (double2/object):: (undocumented)
x (double2/object):: (undocumented)
batchCount (int):: (undocumented)
pBuffer (Pointer/object):: (undocumented)

hip.hipsparse.hipsparseSgpsvInterleavedBatch_bufferSizeExt(handle, int algo, int m, ds, dl, d, du, dw, x, int batchCount, pBufferSizeInBytes)#

Interleaved Batch pentadiagonal solver

hipsparseXgpsvInterleavedBatch_bufferSizeExt returns the size of the temporary storage buffer in bytes that is required by hipsparseXgpsvInterleavedBatch(). The temporary storage buffer must be allocated by the user.

Args:

handle (Pointer/object):: (undocumented)
algo (int):: (undocumented)
m (int):: (undocumented)
ds (Pointer/object):: (undocumented)
dl (Pointer/object):: (undocumented)
d (Pointer/object):: (undocumented)
du (Pointer/object):: (undocumented)
dw (Pointer/object):: (undocumented)
x (Pointer/object):: (undocumented)
batchCount (int):: (undocumented)
pBufferSizeInBytes (Pointer/object):: (undocumented)

hip.hipsparse.hipsparseDgpsvInterleavedBatch_bufferSizeExt(handle, int algo, int m, ds, dl, d, du, dw, x, int batchCount, pBufferSizeInBytes)#

(No short description, might be part of a group.)

Args:

handle (Pointer/object):: (undocumented)
algo (int):: (undocumented)
m (int):: (undocumented)
ds (Pointer/object):: (undocumented)
dl (Pointer/object):: (undocumented)
d (Pointer/object):: (undocumented)
du (Pointer/object):: (undocumented)
dw (Pointer/object):: (undocumented)
x (Pointer/object):: (undocumented)
batchCount (int):: (undocumented)
pBufferSizeInBytes (Pointer/object):: (undocumented)

hip.hipsparse.hipsparseCgpsvInterleavedBatch_bufferSizeExt(handle, int algo, int m, ds, dl, d, du, dw, x, int batchCount, pBufferSizeInBytes)#

(No short description, might be part of a group.)

Args:

handle (Pointer/object):: (undocumented)
algo (int):: (undocumented)
m (int):: (undocumented)
ds (float2/object):: (undocumented)
dl (float2/object):: (undocumented)
d (float2/object):: (undocumented)
du (float2/object):: (undocumented)
dw (float2/object):: (undocumented)
x (float2/object):: (undocumented)
batchCount (int):: (undocumented)
pBufferSizeInBytes (Pointer/object):: (undocumented)

hip.hipsparse.hipsparseZgpsvInterleavedBatch_bufferSizeExt(handle, int algo, int m, ds, dl, d, du, dw, x, int batchCount, pBufferSizeInBytes)#

(No short description, might be part of a group.)

Args:

handle (Pointer/object):: (undocumented)
algo (int):: (undocumented)
m (int):: (undocumented)
ds (double2/object):: (undocumented)
dl (double2/object):: (undocumented)
d (double2/object):: (undocumented)
du (double2/object):: (undocumented)
dw (double2/object):: (undocumented)
x (double2/object):: (undocumented)
batchCount (int):: (undocumented)
pBufferSizeInBytes (Pointer/object):: (undocumented)

hip.hipsparse.hipsparseSgpsvInterleavedBatch(handle, int algo, int m, ds, dl, d, du, dw, x, int batchCount, pBuffer)#

Interleaved Batch pentadiagonal solver

hipsparseXgpsvInterleavedBatch solves a batched pentadiagonal linear system

Note:

This function is non blocking and executed asynchronously with respect to the host. It may return before the actual computation has finished.

Args:

handle (Pointer/object):: (undocumented)
algo (int):: (undocumented)
m (int):: (undocumented)
ds (Pointer/object):: (undocumented)
dl (Pointer/object):: (undocumented)
d (Pointer/object):: (undocumented)
du (Pointer/object):: (undocumented)
dw (Pointer/object):: (undocumented)
x (Pointer/object):: (undocumented)
batchCount (int):: (undocumented)
pBuffer (Pointer/object):: (undocumented)

hip.hipsparse.hipsparseDgpsvInterleavedBatch(handle, int algo, int m, ds, dl, d, du, dw, x, int batchCount, pBuffer)#

(No short description, might be part of a group.)

Args:

handle (Pointer/object):: (undocumented)
algo (int):: (undocumented)
m (int):: (undocumented)
ds (Pointer/object):: (undocumented)
dl (Pointer/object):: (undocumented)
d (Pointer/object):: (undocumented)
du (Pointer/object):: (undocumented)
dw (Pointer/object):: (undocumented)
x (Pointer/object):: (undocumented)
batchCount (int):: (undocumented)
pBuffer (Pointer/object):: (undocumented)

hip.hipsparse.hipsparseCgpsvInterleavedBatch(handle, int algo, int m, ds, dl, d, du, dw, x, int batchCount, pBuffer)#

(No short description, might be part of a group.)

Args:

handle (Pointer/object):: (undocumented)
algo (int):: (undocumented)
m (int):: (undocumented)
ds (float2/object):: (undocumented)
dl (float2/object):: (undocumented)
d (float2/object):: (undocumented)
du (float2/object):: (undocumented)
dw (float2/object):: (undocumented)
x (float2/object):: (undocumented)
batchCount (int):: (undocumented)
pBuffer (Pointer/object):: (undocumented)

hip.hipsparse.hipsparseZgpsvInterleavedBatch(handle, int algo, int m, ds, dl, d, du, dw, x, int batchCount, pBuffer)#

(No short description, might be part of a group.)

Args:

handle (Pointer/object):: (undocumented)
algo (int):: (undocumented)
m (int):: (undocumented)
ds (double2/object):: (undocumented)
dl (double2/object):: (undocumented)
d (double2/object):: (undocumented)
du (double2/object):: (undocumented)
dw (double2/object):: (undocumented)
x (double2/object):: (undocumented)
batchCount (int):: (undocumented)
pBuffer (Pointer/object):: (undocumented)

hip.hipsparse.hipsparseSnnz(handle, dirA, int m, int n, descrA, A, int lda, nnzPerRowColumn, nnzTotalDevHostPtr)#

This function computes the number of nonzero elements per row or column and the total number of nonzero elements in a dense matrix.

The routine does support asynchronous execution if the pointer mode is set to device.

Args:

handle (Pointer/object):: (undocumented)
dirA (hipsparseDirection_t):: (undocumented)
m (int):: (undocumented)
n (int):: (undocumented)
descrA (Pointer/object):: (undocumented)
A (Pointer/object):: (undocumented)
lda (int):: (undocumented)
nnzPerRowColumn (Pointer/object):: (undocumented)
nnzTotalDevHostPtr (Pointer/object):: (undocumented)

hip.hipsparse.hipsparseDnnz(handle, dirA, int m, int n, descrA, A, int lda, nnzPerRowColumn, nnzTotalDevHostPtr)#

(No short description, might be part of a group.)

Args:

handle (Pointer/object):: (undocumented)
dirA (hipsparseDirection_t):: (undocumented)
m (int):: (undocumented)
n (int):: (undocumented)
descrA (Pointer/object):: (undocumented)
A (Pointer/object):: (undocumented)
lda (int):: (undocumented)
nnzPerRowColumn (Pointer/object):: (undocumented)
nnzTotalDevHostPtr (Pointer/object):: (undocumented)

hip.hipsparse.hipsparseCnnz(handle, dirA, int m, int n, descrA, A, int lda, nnzPerRowColumn, nnzTotalDevHostPtr)#

(No short description, might be part of a group.)

Args:

handle (Pointer/object):: (undocumented)
dirA (hipsparseDirection_t):: (undocumented)
m (int):: (undocumented)
n (int):: (undocumented)
descrA (Pointer/object):: (undocumented)
A (float2/object):: (undocumented)
lda (int):: (undocumented)
nnzPerRowColumn (Pointer/object):: (undocumented)
nnzTotalDevHostPtr (Pointer/object):: (undocumented)

hip.hipsparse.hipsparseZnnz(handle, dirA, int m, int n, descrA, A, int lda, nnzPerRowColumn, nnzTotalDevHostPtr)#

(No short description, might be part of a group.)

Args:

handle (Pointer/object):: (undocumented)
dirA (hipsparseDirection_t):: (undocumented)
m (int):: (undocumented)
n (int):: (undocumented)
descrA (Pointer/object):: (undocumented)
A (double2/object):: (undocumented)
lda (int):: (undocumented)
nnzPerRowColumn (Pointer/object):: (undocumented)
nnzTotalDevHostPtr (Pointer/object):: (undocumented)

hip.hipsparse.hipsparseSdense2csr(handle, int m, int n, descr, A, int ld, nnz_per_rows, csr_val, csr_row_ptr, csr_col_ind)#

This function converts the matrix A in dense format into a sparse matrix in CSR format. All the parameters are assumed to have been pre-allocated by the user and the arrays are filled in based on nnz_per_row, which can be pre-computed with hipsparseXnnz(). It is executed asynchronously with respect to the host and may return control to the application on the host before the entire result is ready.

Args:

handle (Pointer/object):: (undocumented)
m (int):: (undocumented)
n (int):: (undocumented)
descr (Pointer/object):: (undocumented)
A (Pointer/object):: (undocumented)
ld (int):: (undocumented)
nnz_per_rows (Pointer/object):: (undocumented)
csr_val (Pointer/object):: (undocumented)
csr_row_ptr (Pointer/object):: (undocumented)
csr_col_ind (Pointer/object):: (undocumented)

hip.hipsparse.hipsparseDdense2csr(handle, int m, int n, descr, A, int ld, nnz_per_rows, csr_val, csr_row_ptr, csr_col_ind)#

(No short description, might be part of a group.)

Args:

handle (Pointer/object):: (undocumented)
m (int):: (undocumented)
n (int):: (undocumented)
descr (Pointer/object):: (undocumented)
A (Pointer/object):: (undocumented)
ld (int):: (undocumented)
nnz_per_rows (Pointer/object):: (undocumented)
csr_val (Pointer/object):: (undocumented)
csr_row_ptr (Pointer/object):: (undocumented)
csr_col_ind (Pointer/object):: (undocumented)

hip.hipsparse.hipsparseCdense2csr(handle, int m, int n, descr, A, int ld, nnz_per_rows, csr_val, csr_row_ptr, csr_col_ind)#

(No short description, might be part of a group.)

Args:

handle (Pointer/object):: (undocumented)
m (int):: (undocumented)
n (int):: (undocumented)
descr (Pointer/object):: (undocumented)
A (float2/object):: (undocumented)
ld (int):: (undocumented)
nnz_per_rows (Pointer/object):: (undocumented)
csr_val (float2/object):: (undocumented)
csr_row_ptr (Pointer/object):: (undocumented)
csr_col_ind (Pointer/object):: (undocumented)

hip.hipsparse.hipsparseZdense2csr(handle, int m, int n, descr, A, int ld, nnz_per_rows, csr_val, csr_row_ptr, csr_col_ind)#

(No short description, might be part of a group.)

Args:

handle (Pointer/object):: (undocumented)
m (int):: (undocumented)
n (int):: (undocumented)
descr (Pointer/object):: (undocumented)
A (double2/object):: (undocumented)
ld (int):: (undocumented)
nnz_per_rows (Pointer/object):: (undocumented)
csr_val (double2/object):: (undocumented)
csr_row_ptr (Pointer/object):: (undocumented)
csr_col_ind (Pointer/object):: (undocumented)

hip.hipsparse.hipsparseSpruneDense2csr_bufferSize(handle, int m, int n, A, int lda, threshold, descr, csrVal, csrRowPtr, csrColInd, bufferSize)#

This function computes the the size of the user allocated temporary storage buffer used when converting and pruning a dense matrix to a CSR matrix.

hipsparseXpruneDense2csr_bufferSizeExt returns the size of the temporary storage buffer that is required by hipsparseXpruneDense2csrNnz() and hipsparseXpruneDense2csr(). The temporary storage buffer must be allocated by the user.

Args:

handle (Pointer/object):: (undocumented)
m (int):: (undocumented)
n (int):: (undocumented)
A (Pointer/object):: (undocumented)
lda (int):: (undocumented)
threshold (Pointer/object):: (undocumented)
descr (Pointer/object):: (undocumented)
csrVal (Pointer/object):: (undocumented)
csrRowPtr (Pointer/object):: (undocumented)
csrColInd (Pointer/object):: (undocumented)
bufferSize (Pointer/object):: (undocumented)

hip.hipsparse.hipsparseDpruneDense2csr_bufferSize(handle, int m, int n, A, int lda, threshold, descr, csrVal, csrRowPtr, csrColInd, bufferSize)#

(No short description, might be part of a group.)

Args:

handle (Pointer/object):: (undocumented)
m (int):: (undocumented)
n (int):: (undocumented)
A (Pointer/object):: (undocumented)
lda (int):: (undocumented)
threshold (Pointer/object):: (undocumented)
descr (Pointer/object):: (undocumented)
csrVal (Pointer/object):: (undocumented)
csrRowPtr (Pointer/object):: (undocumented)
csrColInd (Pointer/object):: (undocumented)
bufferSize (Pointer/object):: (undocumented)

hip.hipsparse.hipsparseSpruneDense2csr_bufferSizeExt(handle, int m, int n, A, int lda, threshold, descr, csrVal, csrRowPtr, csrColInd, bufferSize)#

(No short description, might be part of a group.)

Args:

handle (Pointer/object):: (undocumented)
m (int):: (undocumented)
n (int):: (undocumented)
A (Pointer/object):: (undocumented)
lda (int):: (undocumented)
threshold (Pointer/object):: (undocumented)
descr (Pointer/object):: (undocumented)
csrVal (Pointer/object):: (undocumented)
csrRowPtr (Pointer/object):: (undocumented)
csrColInd (Pointer/object):: (undocumented)
bufferSize (Pointer/object):: (undocumented)

hip.hipsparse.hipsparseDpruneDense2csr_bufferSizeExt(handle, int m, int n, A, int lda, threshold, descr, csrVal, csrRowPtr, csrColInd, bufferSize)#

(No short description, might be part of a group.)

Args:

handle (Pointer/object):: (undocumented)
m (int):: (undocumented)
n (int):: (undocumented)
A (Pointer/object):: (undocumented)
lda (int):: (undocumented)
threshold (Pointer/object):: (undocumented)
descr (Pointer/object):: (undocumented)
csrVal (Pointer/object):: (undocumented)
csrRowPtr (Pointer/object):: (undocumented)
csrColInd (Pointer/object):: (undocumented)
bufferSize (Pointer/object):: (undocumented)

hip.hipsparse.hipsparseSpruneDense2csrNnz(handle, int m, int n, A, int lda, threshold, descr, csrRowPtr, nnzTotalDevHostPtr, buffer)#

This function computes the number of nonzero elements per row and the total number of nonzero elements in a dense matrix once elements less than the threshold are pruned from the matrix.

The routine does support asynchronous execution if the pointer mode is set to device.

Args:

handle (Pointer/object):: (undocumented)
m (int):: (undocumented)
n (int):: (undocumented)
A (Pointer/object):: (undocumented)
lda (int):: (undocumented)
threshold (Pointer/object):: (undocumented)
descr (Pointer/object):: (undocumented)
csrRowPtr (Pointer/object):: (undocumented)
nnzTotalDevHostPtr (Pointer/object):: (undocumented)
buffer (Pointer/object):: (undocumented)

hip.hipsparse.hipsparseDpruneDense2csrNnz(handle, int m, int n, A, int lda, threshold, descr, csrRowPtr, nnzTotalDevHostPtr, buffer)#

(No short description, might be part of a group.)

Args:

handle (Pointer/object):: (undocumented)
m (int):: (undocumented)
n (int):: (undocumented)
A (Pointer/object):: (undocumented)
lda (int):: (undocumented)
threshold (Pointer/object):: (undocumented)
descr (Pointer/object):: (undocumented)
csrRowPtr (Pointer/object):: (undocumented)
nnzTotalDevHostPtr (Pointer/object):: (undocumented)
buffer (Pointer/object):: (undocumented)

hip.hipsparse.hipsparseSpruneDense2csr(handle, int m, int n, A, int lda, threshold, descr, csrVal, csrRowPtr, csrColInd, buffer)#

This function converts the matrix A in dense format into a sparse matrix in CSR format while pruning values that are less than the threshold. All the parameters are assumed to have been pre-allocated by the user.

The user first allocates csrRowPtr to have m+1 elements and then calls hipsparseXpruneDense2csrNnz() which fills in the csrRowPtr array and stores the number of elements that are larger than the pruning threshold in nnzTotalDevHostPtr. The user then allocates csrColInd and csrVal to have size nnzTotalDevHostPtr and completes the conversion by calling hipsparseXpruneDense2csr(). A temporary storage buffer is used by both hipsparseXpruneDense2csrNnz() and hipsparseXpruneDense2csr() and must be allocated by the user and whose size is determined by hipsparseXpruneDense2csr_bufferSizeExt(). The routine hipsparseXpruneDense2csr() is executed asynchronously with respect to the host and may return control to the application on the host before the entire result is ready.

Args:

handle (Pointer/object):: (undocumented)
m (int):: (undocumented)
n (int):: (undocumented)
A (Pointer/object):: (undocumented)
lda (int):: (undocumented)
threshold (Pointer/object):: (undocumented)
descr (Pointer/object):: (undocumented)
csrVal (Pointer/object):: (undocumented)
csrRowPtr (Pointer/object):: (undocumented)
csrColInd (Pointer/object):: (undocumented)
buffer (Pointer/object):: (undocumented)

hip.hipsparse.hipsparseDpruneDense2csr(handle, int m, int n, A, int lda, threshold, descr, csrVal, csrRowPtr, csrColInd, buffer)#

(No short description, might be part of a group.)

Args:

handle (Pointer/object):: (undocumented)
m (int):: (undocumented)
n (int):: (undocumented)
A (Pointer/object):: (undocumented)
lda (int):: (undocumented)
threshold (Pointer/object):: (undocumented)
descr (Pointer/object):: (undocumented)
csrVal (Pointer/object):: (undocumented)
csrRowPtr (Pointer/object):: (undocumented)
csrColInd (Pointer/object):: (undocumented)
buffer (Pointer/object):: (undocumented)

hip.hipsparse.hipsparseSpruneDense2csrByPercentage_bufferSize(handle, int m, int n, A, int lda, float percentage, descr, csrVal, csrRowPtr, csrColInd, info, bufferSize)#

This function computes the size of the user allocated temporary storage buffer used when converting and pruning by percentage a dense matrix to a CSR matrix.

When converting and pruning a dense matrix A to a CSR matrix by percentage the following steps are performed. First the user calls hipsparseXpruneDense2csrByPercentage_bufferSize which determines the size of the temporary storage buffer. Once determined, this buffer must be allocated by the user. Next the user allocates the csr_row_ptr array to have m+1 elements and calls hipsparseXpruneDense2csrNnzByPercentage. Finally the user finishes the conversion by allocating the csr_col_ind and csr_val arrays (whos size is determined by the value at nnz_total_dev_host_ptr) and calling hipsparseXpruneDense2csrByPercentage.

The pruning by percentage works by first sorting the absolute values of the dense matrix A. We then determine a position in this sorted array by

\[pos = ceil(m*n*(percentage/100)) - 1 pos = min(pos, m*n-1) pos = max(pos, 0) threshold = sorted_A[pos]\]

Args:

handle (Pointer/object):: (undocumented)
m (int):: (undocumented)
n (int):: (undocumented)
A (Pointer/object):: (undocumented)
lda (int):: (undocumented)
percentage (float/int):: (undocumented)
descr (Pointer/object):: (undocumented)
csrVal (Pointer/object):: (undocumented)
csrRowPtr (Pointer/object):: (undocumented)
csrColInd (Pointer/object):: (undocumented)
info (pruneInfo/object):: (undocumented)
bufferSize (Pointer/object):: (undocumented)

hip.hipsparse.hipsparseDpruneDense2csrByPercentage_bufferSize(handle, int m, int n, A, int lda, double percentage, descr, csrVal, csrRowPtr, csrColInd, info, bufferSize)#

(No short description, might be part of a group.)

Args:

handle (Pointer/object):: (undocumented)
m (int):: (undocumented)
n (int):: (undocumented)
A (Pointer/object):: (undocumented)
lda (int):: (undocumented)
percentage (float/int):: (undocumented)
descr (Pointer/object):: (undocumented)
csrVal (Pointer/object):: (undocumented)
csrRowPtr (Pointer/object):: (undocumented)
csrColInd (Pointer/object):: (undocumented)
info (pruneInfo/object):: (undocumented)
bufferSize (Pointer/object):: (undocumented)

hip.hipsparse.hipsparseSpruneDense2csrByPercentage_bufferSizeExt(handle, int m, int n, A, int lda, float percentage, descr, csrVal, csrRowPtr, csrColInd, info, bufferSize)#

This function computes the size of the user allocated temporary storage buffer used when converting and pruning by percentage a dense matrix to a CSR matrix.

When converting and pruning a dense matrix A to a CSR matrix by percentage the following steps are performed. First the user calls hipsparseXpruneDense2csrByPercentage_bufferSizeExt which determines the size of the temporary storage buffer. Once determined, this buffer must be allocated by the user. Next the user allocates the csr_row_ptr array to have m+1 elements and calls hipsparseXpruneDense2csrNnzByPercentage. Finally the user finishes the conversion by allocating the csr_col_ind and csr_val arrays (whos size is determined by the value at nnz_total_dev_host_ptr) and calling hipsparseXpruneDense2csrByPercentage.

The pruning by percentage works by first sorting the absolute values of the dense matrix A. We then determine a position in this sorted array by

\[pos = ceil(m*n*(percentage/100)) - 1 pos = min(pos, m*n-1) pos = max(pos, 0) threshold = sorted_A[pos]\]

Args:

handle (Pointer/object):: (undocumented)
m (int):: (undocumented)
n (int):: (undocumented)
A (Pointer/object):: (undocumented)
lda (int):: (undocumented)
percentage (float/int):: (undocumented)
descr (Pointer/object):: (undocumented)
csrVal (Pointer/object):: (undocumented)
csrRowPtr (Pointer/object):: (undocumented)
csrColInd (Pointer/object):: (undocumented)
info (pruneInfo/object):: (undocumented)
bufferSize (Pointer/object):: (undocumented)

hip.hipsparse.hipsparseDpruneDense2csrByPercentage_bufferSizeExt(handle, int m, int n, A, int lda, double percentage, descr, csrVal, csrRowPtr, csrColInd, info, bufferSize)#

(No short description, might be part of a group.)

Args:

handle (Pointer/object):: (undocumented)
m (int):: (undocumented)
n (int):: (undocumented)
A (Pointer/object):: (undocumented)
lda (int):: (undocumented)
percentage (float/int):: (undocumented)
descr (Pointer/object):: (undocumented)
csrVal (Pointer/object):: (undocumented)
csrRowPtr (Pointer/object):: (undocumented)
csrColInd (Pointer/object):: (undocumented)
info (pruneInfo/object):: (undocumented)
bufferSize (Pointer/object):: (undocumented)

hip.hipsparse.hipsparseSpruneDense2csrNnzByPercentage(handle, int m, int n, A, int lda, float percentage, descr, csrRowPtr, nnzTotalDevHostPtr, info, buffer)#

This function computes the number of nonzero elements per row and the total number of nonzero elements in a dense matrix when converting and pruning by percentage a dense matrix to a CSR matrix.

When converting and pruning a dense matrix A to a CSR matrix by percentage the following steps are performed. First the user calls hipsparseXpruneDense2csrByPercentage_bufferSize which determines the size of the temporary storage buffer. Once determined, this buffer must be allocated by the user. Next the user allocates the csr_row_ptr array to have m+1 elements and calls hipsparseXpruneDense2csrNnzByPercentage. Finally the user finishes the conversion by allocating the csr_col_ind and csr_val arrays (whos size is determined by the value at nnz_total_dev_host_ptr) and calling hipsparseXpruneDense2csrByPercentage.

The pruning by percentage works by first sorting the absolute values of the dense matrix A. We then determine a position in this sorted array by

\[pos = ceil(m*n*(percentage/100)) - 1 pos = min(pos, m*n-1) pos = max(pos, 0) threshold = sorted_A[pos]\]

Args:

handle (Pointer/object):: (undocumented)
m (int):: (undocumented)
n (int):: (undocumented)
A (Pointer/object):: (undocumented)
lda (int):: (undocumented)
percentage (float/int):: (undocumented)
descr (Pointer/object):: (undocumented)
csrRowPtr (Pointer/object):: (undocumented)
nnzTotalDevHostPtr (Pointer/object):: (undocumented)
info (pruneInfo/object):: (undocumented)
buffer (Pointer/object):: (undocumented)

hip.hipsparse.hipsparseDpruneDense2csrNnzByPercentage(handle, int m, int n, A, int lda, double percentage, descr, csrRowPtr, nnzTotalDevHostPtr, info, buffer)#

(No short description, might be part of a group.)

Args:

handle (Pointer/object):: (undocumented)
m (int):: (undocumented)
n (int):: (undocumented)
A (Pointer/object):: (undocumented)
lda (int):: (undocumented)
percentage (float/int):: (undocumented)
descr (Pointer/object):: (undocumented)
csrRowPtr (Pointer/object):: (undocumented)
nnzTotalDevHostPtr (Pointer/object):: (undocumented)
info (pruneInfo/object):: (undocumented)
buffer (Pointer/object):: (undocumented)

hip.hipsparse.hipsparseSpruneDense2csrByPercentage(handle, int m, int n, A, int lda, float percentage, descr, csrVal, csrRowPtr, csrColInd, info, buffer)#

This function computes the number of nonzero elements per row and the total number of nonzero elements in a dense matrix when converting and pruning by percentage a dense matrix to a CSR matrix.

When converting and pruning a dense matrix A to a CSR matrix by percentage the following steps are performed. First the user calls hipsparseXpruneDense2csrByPercentage_bufferSize which determines the size of the temporary storage buffer. Once determined, this buffer must be allocated by the user. Next the user allocates the csr_row_ptr array to have m+1 elements and calls hipsparseXpruneDense2csrNnzByPercentage. Finally the user finishes the conversion by allocating the csr_col_ind and csr_val arrays (whos size is determined by the value at nnz_total_dev_host_ptr) and calling hipsparseXpruneDense2csrByPercentage.

The pruning by percentage works by first sorting the absolute values of the dense matrix A. We then determine a position in this sorted array by

\[pos = ceil(m*n*(percentage/100)) - 1 pos = min(pos, m*n-1) pos = max(pos, 0) threshold = sorted_A[pos]\]

Args:

handle (Pointer/object):: (undocumented)
m (int):: (undocumented)
n (int):: (undocumented)
A (Pointer/object):: (undocumented)
lda (int):: (undocumented)
percentage (float/int):: (undocumented)
descr (Pointer/object):: (undocumented)
csrVal (Pointer/object):: (undocumented)
csrRowPtr (Pointer/object):: (undocumented)
csrColInd (Pointer/object):: (undocumented)
info (pruneInfo/object):: (undocumented)
buffer (Pointer/object):: (undocumented)

hip.hipsparse.hipsparseDpruneDense2csrByPercentage(handle, int m, int n, A, int lda, double percentage, descr, csrVal, csrRowPtr, csrColInd, info, buffer)#

(No short description, might be part of a group.)

Args:

handle (Pointer/object):: (undocumented)
m (int):: (undocumented)
n (int):: (undocumented)
A (Pointer/object):: (undocumented)
lda (int):: (undocumented)
percentage (float/int):: (undocumented)
descr (Pointer/object):: (undocumented)
csrVal (Pointer/object):: (undocumented)
csrRowPtr (Pointer/object):: (undocumented)
csrColInd (Pointer/object):: (undocumented)
info (pruneInfo/object):: (undocumented)
buffer (Pointer/object):: (undocumented)

hip.hipsparse.hipsparseSdense2csc(handle, int m, int n, descr, A, int ld, nnz_per_columns, csc_val, csc_row_ind, csc_col_ptr)#

This function converts the matrix A in dense format into a sparse matrix in CSC format. All the parameters are assumed to have been pre-allocated by the user and the arrays are filled in based on nnz_per_columns, which can be pre-computed with hipsparseXnnz(). It is executed asynchronously with respect to the host and may return control to the application on the host before the entire result is ready.

Args:

handle (Pointer/object):: (undocumented)
m (int):: (undocumented)
n (int):: (undocumented)
descr (Pointer/object):: (undocumented)
A (Pointer/object):: (undocumented)
ld (int):: (undocumented)
nnz_per_columns (Pointer/object):: (undocumented)
csc_val (Pointer/object):: (undocumented)
csc_row_ind (Pointer/object):: (undocumented)
csc_col_ptr (Pointer/object):: (undocumented)

hip.hipsparse.hipsparseDdense2csc(handle, int m, int n, descr, A, int ld, nnz_per_columns, csc_val, csc_row_ind, csc_col_ptr)#

(No short description, might be part of a group.)

Args:

handle (Pointer/object):: (undocumented)
m (int):: (undocumented)
n (int):: (undocumented)
descr (Pointer/object):: (undocumented)
A (Pointer/object):: (undocumented)
ld (int):: (undocumented)
nnz_per_columns (Pointer/object):: (undocumented)
csc_val (Pointer/object):: (undocumented)
csc_row_ind (Pointer/object):: (undocumented)
csc_col_ptr (Pointer/object):: (undocumented)

hip.hipsparse.hipsparseCdense2csc(handle, int m, int n, descr, A, int ld, nnz_per_columns, csc_val, csc_row_ind, csc_col_ptr)#

(No short description, might be part of a group.)

Args:

handle (Pointer/object):: (undocumented)
m (int):: (undocumented)
n (int):: (undocumented)
descr (Pointer/object):: (undocumented)
A (float2/object):: (undocumented)
ld (int):: (undocumented)
nnz_per_columns (Pointer/object):: (undocumented)
csc_val (float2/object):: (undocumented)
csc_row_ind (Pointer/object):: (undocumented)
csc_col_ptr (Pointer/object):: (undocumented)

hip.hipsparse.hipsparseZdense2csc(handle, int m, int n, descr, A, int ld, nnz_per_columns, csc_val, csc_row_ind, csc_col_ptr)#

(No short description, might be part of a group.)

Args:

handle (Pointer/object):: (undocumented)
m (int):: (undocumented)
n (int):: (undocumented)
descr (Pointer/object):: (undocumented)
A (double2/object):: (undocumented)
ld (int):: (undocumented)
nnz_per_columns (Pointer/object):: (undocumented)
csc_val (double2/object):: (undocumented)
csc_row_ind (Pointer/object):: (undocumented)
csc_col_ptr (Pointer/object):: (undocumented)

hip.hipsparse.hipsparseScsr2dense(handle, int m, int n, descr, csr_val, csr_row_ptr, csr_col_ind, A, int ld)#

This function converts the sparse matrix in CSR format into a dense matrix. It is executed asynchronously with respect to the host and may return control to the application on the host before the entire result is ready.

Args:

handle (Pointer/object):: (undocumented)
m (int):: (undocumented)
n (int):: (undocumented)
descr (Pointer/object):: (undocumented)
csr_val (Pointer/object):: (undocumented)
csr_row_ptr (Pointer/object):: (undocumented)
csr_col_ind (Pointer/object):: (undocumented)
A (Pointer/object):: (undocumented)
ld (int):: (undocumented)

hip.hipsparse.hipsparseDcsr2dense(handle, int m, int n, descr, csr_val, csr_row_ptr, csr_col_ind, A, int ld)#

(No short description, might be part of a group.)

Args:

handle (Pointer/object):: (undocumented)
m (int):: (undocumented)
n (int):: (undocumented)
descr (Pointer/object):: (undocumented)
csr_val (Pointer/object):: (undocumented)
csr_row_ptr (Pointer/object):: (undocumented)
csr_col_ind (Pointer/object):: (undocumented)
A (Pointer/object):: (undocumented)
ld (int):: (undocumented)

hip.hipsparse.hipsparseCcsr2dense(handle, int m, int n, descr, csr_val, csr_row_ptr, csr_col_ind, A, int ld)#

(No short description, might be part of a group.)

Args:

handle (Pointer/object):: (undocumented)
m (int):: (undocumented)
n (int):: (undocumented)
descr (Pointer/object):: (undocumented)
csr_val (float2/object):: (undocumented)
csr_row_ptr (Pointer/object):: (undocumented)
csr_col_ind (Pointer/object):: (undocumented)
A (float2/object):: (undocumented)
ld (int):: (undocumented)

hip.hipsparse.hipsparseZcsr2dense(handle, int m, int n, descr, csr_val, csr_row_ptr, csr_col_ind, A, int ld)#

(No short description, might be part of a group.)

Args:

handle (Pointer/object):: (undocumented)
m (int):: (undocumented)
n (int):: (undocumented)
descr (Pointer/object):: (undocumented)
csr_val (double2/object):: (undocumented)
csr_row_ptr (Pointer/object):: (undocumented)
csr_col_ind (Pointer/object):: (undocumented)
A (double2/object):: (undocumented)
ld (int):: (undocumented)

hip.hipsparse.hipsparseScsc2dense(handle, int m, int n, descr, csc_val, csc_row_ind, csc_col_ptr, A, int ld)#

This function converts the sparse matrix in CSC format into a dense matrix. It is executed asynchronously with respect to the host and may return control to the application on the host before the entire result is ready.

Args:

handle (Pointer/object):: (undocumented)
m (int):: (undocumented)
n (int):: (undocumented)
descr (Pointer/object):: (undocumented)
csc_val (Pointer/object):: (undocumented)
csc_row_ind (Pointer/object):: (undocumented)
csc_col_ptr (Pointer/object):: (undocumented)
A (Pointer/object):: (undocumented)
ld (int):: (undocumented)

hip.hipsparse.hipsparseDcsc2dense(handle, int m, int n, descr, csc_val, csc_row_ind, csc_col_ptr, A, int ld)#

(No short description, might be part of a group.)

Args:

handle (Pointer/object):: (undocumented)
m (int):: (undocumented)
n (int):: (undocumented)
descr (Pointer/object):: (undocumented)
csc_val (Pointer/object):: (undocumented)
csc_row_ind (Pointer/object):: (undocumented)
csc_col_ptr (Pointer/object):: (undocumented)
A (Pointer/object):: (undocumented)
ld (int):: (undocumented)

hip.hipsparse.hipsparseCcsc2dense(handle, int m, int n, descr, csc_val, csc_row_ind, csc_col_ptr, A, int ld)#

(No short description, might be part of a group.)

Args:

handle (Pointer/object):: (undocumented)
m (int):: (undocumented)
n (int):: (undocumented)
descr (Pointer/object):: (undocumented)
csc_val (float2/object):: (undocumented)
csc_row_ind (Pointer/object):: (undocumented)
csc_col_ptr (Pointer/object):: (undocumented)
A (float2/object):: (undocumented)
ld (int):: (undocumented)

hip.hipsparse.hipsparseZcsc2dense(handle, int m, int n, descr, csc_val, csc_row_ind, csc_col_ptr, A, int ld)#

(No short description, might be part of a group.)

Args:

handle (Pointer/object):: (undocumented)
m (int):: (undocumented)
n (int):: (undocumented)
descr (Pointer/object):: (undocumented)
csc_val (double2/object):: (undocumented)
csc_row_ind (Pointer/object):: (undocumented)
csc_col_ptr (Pointer/object):: (undocumented)
A (double2/object):: (undocumented)
ld (int):: (undocumented)

hip.hipsparse.hipsparseXcsr2bsrNnz(handle, dirA, int m, int n, descrA, csrRowPtrA, csrColIndA, int blockDim, descrC, bsrRowPtrC, bsrNnzb)#

This function computes the number of nonzero block columns per row and the total number of nonzero blocks in a sparse BSR matrix given a sparse CSR matrix as input.

The routine does support asynchronous execution if the pointer mode is set to device.

Args:

handle (Pointer/object):: (undocumented)
dirA (hipsparseDirection_t):: (undocumented)
m (int):: (undocumented)
n (int):: (undocumented)
descrA (Pointer/object):: (undocumented)
csrRowPtrA (Pointer/object):: (undocumented)
csrColIndA (Pointer/object):: (undocumented)
blockDim (int):: (undocumented)
descrC (Pointer/object):: (undocumented)
bsrRowPtrC (Pointer/object):: (undocumented)
bsrNnzb (Pointer/object):: (undocumented)

hip.hipsparse.hipsparseSnnz_compress(handle, int m, descrA, csrValA, csrRowPtrA, nnzPerRow, nnzC, float tol)#

(No short description, might be part of a group.)

Given a sparse CSR matrix and a non-negative tolerance, this function computes how many entries would be left in each row of the matrix if elements less than the tolerance were removed. It also computes the total number of remaining elements in the matrix.

Args:

handle (Pointer/object):: (undocumented)
m (int):: (undocumented)
descrA (Pointer/object):: (undocumented)
csrValA (Pointer/object):: (undocumented)
csrRowPtrA (Pointer/object):: (undocumented)
nnzPerRow (Pointer/object):: (undocumented)
nnzC (Pointer/object):: (undocumented)
tol (float/int):: (undocumented)

hip.hipsparse.hipsparseDnnz_compress(handle, int m, descrA, csrValA, csrRowPtrA, nnzPerRow, nnzC, double tol)#

(No short description, might be part of a group.)

Args:

handle (Pointer/object):: (undocumented)
m (int):: (undocumented)
descrA (Pointer/object):: (undocumented)
csrValA (Pointer/object):: (undocumented)
csrRowPtrA (Pointer/object):: (undocumented)
nnzPerRow (Pointer/object):: (undocumented)
nnzC (Pointer/object):: (undocumented)
tol (float/int):: (undocumented)

hip.hipsparse.hipsparseCnnz_compress(handle, int m, descrA, csrValA, csrRowPtrA, nnzPerRow, nnzC, tol)#

(No short description, might be part of a group.)

Args:

handle (Pointer/object):: (undocumented)
m (int):: (undocumented)
descrA (Pointer/object):: (undocumented)
csrValA (float2/object):: (undocumented)
csrRowPtrA (Pointer/object):: (undocumented)
nnzPerRow (Pointer/object):: (undocumented)
nnzC (Pointer/object):: (undocumented)
tol (float2):: (undocumented)

hip.hipsparse.hipsparseZnnz_compress(handle, int m, descrA, csrValA, csrRowPtrA, nnzPerRow, nnzC, tol)#

(No short description, might be part of a group.)

Args:

handle (Pointer/object):: (undocumented)
m (int):: (undocumented)
descrA (Pointer/object):: (undocumented)
csrValA (double2/object):: (undocumented)
csrRowPtrA (Pointer/object):: (undocumented)
nnzPerRow (Pointer/object):: (undocumented)
nnzC (Pointer/object):: (undocumented)
tol (double2):: (undocumented)

hip.hipsparse.hipsparseXcsr2coo(handle, csrRowPtr, int nnz, int m, cooRowInd, idxBase)#

Convert a sparse CSR matrix into a sparse COO matrix

hipsparseXcsr2coo converts the CSR array containing the row offsets, that point to the start of every row, into a COO array of row indices.

Note:

It can also be used to convert a CSC array containing the column offsets into a COO array of column indices.

Note:

This function is non blocking and executed asynchronously with respect to the host. It may return before the actual computation has finished.

Args:

handle (Pointer/object):: (undocumented)
csrRowPtr (Pointer/object):: (undocumented)
nnz (int):: (undocumented)
m (int):: (undocumented)
cooRowInd (Pointer/object):: (undocumented)
idxBase (hipsparseIndexBase_t):: (undocumented)

hip.hipsparse.hipsparseScsr2csc(handle, int m, int n, int nnz, csrSortedVal, csrSortedRowPtr, csrSortedColInd, cscSortedVal, cscSortedRowInd, cscSortedColPtr, copyValues, idxBase)#

Convert a sparse CSR matrix into a sparse CSC matrix

hipsparseXcsr2csc converts a CSR matrix into a CSC matrix. hipsparseXcsr2csc can also be used to convert a CSC matrix into a CSR matrix. copy_values decides whether csc_val is being filled during conversion (HIPSPARSE_ACTION_NUMERIC ) or not (HIPSPARSE_ACTION_SYMBOLIC ).

Note:

The resulting matrix can also be seen as the transpose of the input matrix.

Note:

This function is non blocking and executed asynchronously with respect to the host. It may return before the actual computation has finished.

Args:

handle (Pointer/object):: (undocumented)
m (int):: (undocumented)
n (int):: (undocumented)
nnz (int):: (undocumented)
csrSortedVal (Pointer/object):: (undocumented)
csrSortedRowPtr (Pointer/object):: (undocumented)
csrSortedColInd (Pointer/object):: (undocumented)
cscSortedVal (Pointer/object):: (undocumented)
cscSortedRowInd (Pointer/object):: (undocumented)
cscSortedColPtr (Pointer/object):: (undocumented)
copyValues (hipsparseAction_t):: (undocumented)
idxBase (hipsparseIndexBase_t):: (undocumented)

hip.hipsparse.hipsparseDcsr2csc(handle, int m, int n, int nnz, csrSortedVal, csrSortedRowPtr, csrSortedColInd, cscSortedVal, cscSortedRowInd, cscSortedColPtr, copyValues, idxBase)#

(No short description, might be part of a group.)

Args:

handle (Pointer/object):: (undocumented)
m (int):: (undocumented)
n (int):: (undocumented)
nnz (int):: (undocumented)
csrSortedVal (Pointer/object):: (undocumented)
csrSortedRowPtr (Pointer/object):: (undocumented)
csrSortedColInd (Pointer/object):: (undocumented)
cscSortedVal (Pointer/object):: (undocumented)
cscSortedRowInd (Pointer/object):: (undocumented)
cscSortedColPtr (Pointer/object):: (undocumented)
copyValues (hipsparseAction_t):: (undocumented)
idxBase (hipsparseIndexBase_t):: (undocumented)

hip.hipsparse.hipsparseCcsr2csc(handle, int m, int n, int nnz, csrSortedVal, csrSortedRowPtr, csrSortedColInd, cscSortedVal, cscSortedRowInd, cscSortedColPtr, copyValues, idxBase)#

(No short description, might be part of a group.)

Args:

handle (Pointer/object):: (undocumented)
m (int):: (undocumented)
n (int):: (undocumented)
nnz (int):: (undocumented)
csrSortedVal (float2/object):: (undocumented)
csrSortedRowPtr (Pointer/object):: (undocumented)
csrSortedColInd (Pointer/object):: (undocumented)
cscSortedVal (float2/object):: (undocumented)
cscSortedRowInd (Pointer/object):: (undocumented)
cscSortedColPtr (Pointer/object):: (undocumented)
copyValues (hipsparseAction_t):: (undocumented)
idxBase (hipsparseIndexBase_t):: (undocumented)

hip.hipsparse.hipsparseZcsr2csc(handle, int m, int n, int nnz, csrSortedVal, csrSortedRowPtr, csrSortedColInd, cscSortedVal, cscSortedRowInd, cscSortedColPtr, copyValues, idxBase)#

(No short description, might be part of a group.)

Args:

handle (Pointer/object):: (undocumented)
m (int):: (undocumented)
n (int):: (undocumented)
nnz (int):: (undocumented)
csrSortedVal (double2/object):: (undocumented)
csrSortedRowPtr (Pointer/object):: (undocumented)
csrSortedColInd (Pointer/object):: (undocumented)
cscSortedVal (double2/object):: (undocumented)
cscSortedRowInd (Pointer/object):: (undocumented)
cscSortedColPtr (Pointer/object):: (undocumented)
copyValues (hipsparseAction_t):: (undocumented)
idxBase (hipsparseIndexBase_t):: (undocumented)

class hip.hipsparse.hipsparseCsr2CscAlg_t(value)#

Bases: _hipsparseCsr2CscAlg_t__Base

Attributes:

HIPSPARSE_CSR2CSC_ALG_DEFAULT:: (undocumented)
HIPSPARSE_CSR2CSC_ALG1:: (undocumented)
HIPSPARSE_CSR2CSC_ALG2:: (undocumented)

conjugate()#: Returns self, the complex conjugate of any int.

bit_length()#

Number of bits necessary to represent self in binary.

>>> bin(37)
'0b100101'
>>> (37).bit_length()
6

bit_count()#

Number of ones in the binary representation of the absolute value of self.

Also known as the population count.

>>> bin(13)
'0b1101'
>>> (13).bit_count()
3

to_bytes(length, byteorder, *, signed=False)#

Return an array of bytes representing an integer.

length: Length of bytes object to use. An OverflowError is raised if the integer is not representable with the given number of bytes.
byteorder: The byte order used to represent the integer. If byteorder is ‘big’, the most significant byte is at the beginning of the byte array. If byteorder is ‘little’, the most significant byte is at the end of the byte array. To request the native byte order of the host system, use `sys.byteorder’ as the byte order value.
signed: Determines whether two’s complement is used to represent the integer. If signed is False and a negative integer is given, an OverflowError is raised.

from_bytes(byteorder, *, signed=False)#

Return the integer represented by the given array of bytes.

bytes: Holds the array of bytes to convert. The argument must either support the buffer protocol or be an iterable object producing bytes. Bytes and bytearray are examples of built-in objects that support the buffer protocol.
byteorder: The byte order used to represent the integer. If byteorder is ‘big’, the most significant byte is at the beginning of the byte array. If byteorder is ‘little’, the most significant byte is at the end of the byte array. To request the native byte order of the host system, use `sys.byteorder’ as the byte order value.
signed: Indicates whether two’s complement is used to represent the integer.

as_integer_ratio()#

Return integer ratio.

Return a pair of integers, whose ratio is exactly equal to the original int and with a positive denominator.

>>> (10).as_integer_ratio()
(10, 1)
>>> (-10).as_integer_ratio()
(-10, 1)
>>> (0).as_integer_ratio()
(0, 1)

real#: the real part of a complex number

imag#: the imaginary part of a complex number

numerator#: the numerator of a rational number in lowest terms

denominator#: the denominator of a rational number in lowest terms

static ctypes_type()#: The type of the enum constants as ctypes type.

HIPSPARSE_CSR2CSC_ALG_DEFAULT = 0#

HIPSPARSE_CSR2CSC_ALG1 = 1#

HIPSPARSE_CSR2CSC_ALG2 = 2#

hip.hipsparse.hipsparseCsr2cscEx2_bufferSize(handle, int m, int n, int nnz, csrVal, csrRowPtr, csrColInd, cscVal, cscColPtr, cscRowInd, valType, copyValues, idxBase, alg, bufferSize)#

This function computes the size of the user allocated temporary storage buffer used when converting a sparse CSR matrix into a sparse CSC matrix.

hipsparseCsr2cscEx2_bufferSize calculates the required user allocated temporary buffer needed by hipsparseCsr2cscEx2 to convert a CSR matrix into a CSC matrix. hipsparseCsr2cscEx2 can also be used to convert a CSC matrix into a CSR matrix. copy_values decides whether csc_val is being filled during conversion (HIPSPARSE_ACTION_NUMERIC ) or not (HIPSPARSE_ACTION_SYMBOLIC ).

Note:

The resulting matrix can also be seen as the transpose of the input matrix.

Note:

This function is non blocking and executed asynchronously with respect to the host. It may return before the actual computation has finished.

Args:

handle (Pointer/object):: (undocumented)
m (int):: (undocumented)
n (int):: (undocumented)
nnz (int):: (undocumented)
csrVal (Pointer/object):: (undocumented)
csrRowPtr (Pointer/object):: (undocumented)
csrColInd (Pointer/object):: (undocumented)
cscVal (Pointer/object):: (undocumented)
cscColPtr (Pointer/object):: (undocumented)
cscRowInd (Pointer/object):: (undocumented)
valType (hipDataType):: (undocumented)
copyValues (hipsparseAction_t):: (undocumented)
idxBase (hipsparseIndexBase_t):: (undocumented)
alg (hipsparseCsr2CscAlg_t):: (undocumented)
bufferSize (Pointer/object):: (undocumented)

hip.hipsparse.hipsparseCsr2cscEx2(handle, int m, int n, int nnz, csrVal, csrRowPtr, csrColInd, cscVal, cscColPtr, cscRowInd, valType, copyValues, idxBase, alg, buffer)#

Convert a sparse CSR matrix into a sparse CSC matrix

hipsparseCsr2cscEx2 converts a CSR matrix into a CSC matrix. hipsparseCsr2cscEx2 can also be used to convert a CSC matrix into a CSR matrix. copy_values decides whether csc_val is being filled during conversion (HIPSPARSE_ACTION_NUMERIC ) or not (HIPSPARSE_ACTION_SYMBOLIC ).

Note:

The resulting matrix can also be seen as the transpose of the input matrix.

Note:

This function is non blocking and executed asynchronously with respect to the host. It may return before the actual computation has finished.

Args:

handle (Pointer/object):: (undocumented)
m (int):: (undocumented)
n (int):: (undocumented)
nnz (int):: (undocumented)
csrVal (Pointer/object):: (undocumented)
csrRowPtr (Pointer/object):: (undocumented)
csrColInd (Pointer/object):: (undocumented)
cscVal (Pointer/object):: (undocumented)
cscColPtr (Pointer/object):: (undocumented)
cscRowInd (Pointer/object):: (undocumented)
valType (hipDataType):: (undocumented)
copyValues (hipsparseAction_t):: (undocumented)
idxBase (hipsparseIndexBase_t):: (undocumented)
alg (hipsparseCsr2CscAlg_t):: (undocumented)
buffer (Pointer/object):: (undocumented)

hip.hipsparse.hipsparseScsr2hyb(handle, int m, int n, descrA, csrSortedValA, csrSortedRowPtrA, csrSortedColIndA, hybA, int userEllWidth, partitionType)#

Convert a sparse CSR matrix into a sparse HYB matrix

hipsparseXcsr2hyb converts a CSR matrix into a HYB matrix. It is assumed that hyb has been initialized with hipsparseCreateHybMat().

Note:

This function requires a significant amount of storage for the HYB matrix, depending on the matrix structure.

Note:

This function is non blocking and executed asynchronously with respect to the host. It may return before the actual computation has finished.

Args:

handle (Pointer/object):: (undocumented)
m (int):: (undocumented)
n (int):: (undocumented)
descrA (Pointer/object):: (undocumented)
csrSortedValA (Pointer/object):: (undocumented)
csrSortedRowPtrA (Pointer/object):: (undocumented)
csrSortedColIndA (Pointer/object):: (undocumented)
hybA (Pointer/object):: (undocumented)
userEllWidth (int):: (undocumented)
partitionType (hipsparseHybPartition_t):: (undocumented)

hip.hipsparse.hipsparseDcsr2hyb(handle, int m, int n, descrA, csrSortedValA, csrSortedRowPtrA, csrSortedColIndA, hybA, int userEllWidth, partitionType)#

(No short description, might be part of a group.)

Args:

handle (Pointer/object):: (undocumented)
m (int):: (undocumented)
n (int):: (undocumented)
descrA (Pointer/object):: (undocumented)
csrSortedValA (Pointer/object):: (undocumented)
csrSortedRowPtrA (Pointer/object):: (undocumented)
csrSortedColIndA (Pointer/object):: (undocumented)
hybA (Pointer/object):: (undocumented)
userEllWidth (int):: (undocumented)
partitionType (hipsparseHybPartition_t):: (undocumented)

hip.hipsparse.hipsparseCcsr2hyb(handle, int m, int n, descrA, csrSortedValA, csrSortedRowPtrA, csrSortedColIndA, hybA, int userEllWidth, partitionType)#

(No short description, might be part of a group.)

Args:

handle (Pointer/object):: (undocumented)
m (int):: (undocumented)
n (int):: (undocumented)
descrA (Pointer/object):: (undocumented)
csrSortedValA (float2/object):: (undocumented)
csrSortedRowPtrA (Pointer/object):: (undocumented)
csrSortedColIndA (Pointer/object):: (undocumented)
hybA (Pointer/object):: (undocumented)
userEllWidth (int):: (undocumented)
partitionType (hipsparseHybPartition_t):: (undocumented)

hip.hipsparse.hipsparseZcsr2hyb(handle, int m, int n, descrA, csrSortedValA, csrSortedRowPtrA, csrSortedColIndA, hybA, int userEllWidth, partitionType)#

(No short description, might be part of a group.)

Args:

handle (Pointer/object):: (undocumented)
m (int):: (undocumented)
n (int):: (undocumented)
descrA (Pointer/object):: (undocumented)
csrSortedValA (double2/object):: (undocumented)
csrSortedRowPtrA (Pointer/object):: (undocumented)
csrSortedColIndA (Pointer/object):: (undocumented)
hybA (Pointer/object):: (undocumented)
userEllWidth (int):: (undocumented)
partitionType (hipsparseHybPartition_t):: (undocumented)

hip.hipsparse.hipsparseSgebsr2gebsc_bufferSize(handle, int mb, int nb, int nnzb, bsr_val, bsr_row_ptr, bsr_col_ind, int row_block_dim, int col_block_dim, p_buffer_size)#

Convert a sparse GEneral BSR matrix into a sparse GEneral BSC matrix

hipsparseXgebsr2gebsc_bufferSize returns the size of the temporary storage buffer required by hipsparseXgebsr2gebsc(). The temporary storage buffer must be allocated by the user.

Args:

handle (Pointer/object):: (undocumented)
mb (int):: (undocumented)
nb (int):: (undocumented)
nnzb (int):: (undocumented)
bsr_val (Pointer/object):: (undocumented)
bsr_row_ptr (Pointer/object):: (undocumented)
bsr_col_ind (Pointer/object):: (undocumented)
row_block_dim (int):: (undocumented)
col_block_dim (int):: (undocumented)
p_buffer_size (Pointer/object):: (undocumented)

hip.hipsparse.hipsparseDgebsr2gebsc_bufferSize(handle, int mb, int nb, int nnzb, bsr_val, bsr_row_ptr, bsr_col_ind, int row_block_dim, int col_block_dim, p_buffer_size)#

(No short description, might be part of a group.)

Args:

handle (Pointer/object):: (undocumented)
mb (int):: (undocumented)
nb (int):: (undocumented)
nnzb (int):: (undocumented)
bsr_val (Pointer/object):: (undocumented)
bsr_row_ptr (Pointer/object):: (undocumented)
bsr_col_ind (Pointer/object):: (undocumented)
row_block_dim (int):: (undocumented)
col_block_dim (int):: (undocumented)
p_buffer_size (Pointer/object):: (undocumented)

hip.hipsparse.hipsparseCgebsr2gebsc_bufferSize(handle, int mb, int nb, int nnzb, bsr_val, bsr_row_ptr, bsr_col_ind, int row_block_dim, int col_block_dim, p_buffer_size)#

(No short description, might be part of a group.)

Args:

handle (Pointer/object):: (undocumented)
mb (int):: (undocumented)
nb (int):: (undocumented)
nnzb (int):: (undocumented)
bsr_val (float2/object):: (undocumented)
bsr_row_ptr (Pointer/object):: (undocumented)
bsr_col_ind (Pointer/object):: (undocumented)
row_block_dim (int):: (undocumented)
col_block_dim (int):: (undocumented)
p_buffer_size (Pointer/object):: (undocumented)

hip.hipsparse.hipsparseZgebsr2gebsc_bufferSize(handle, int mb, int nb, int nnzb, bsr_val, bsr_row_ptr, bsr_col_ind, int row_block_dim, int col_block_dim, p_buffer_size)#

(No short description, might be part of a group.)

Args:

handle (Pointer/object):: (undocumented)
mb (int):: (undocumented)
nb (int):: (undocumented)
nnzb (int):: (undocumented)
bsr_val (double2/object):: (undocumented)
bsr_row_ptr (Pointer/object):: (undocumented)
bsr_col_ind (Pointer/object):: (undocumented)
row_block_dim (int):: (undocumented)
col_block_dim (int):: (undocumented)
p_buffer_size (Pointer/object):: (undocumented)

hip.hipsparse.hipsparseSgebsr2gebsc(handle, int mb, int nb, int nnzb, bsr_val, bsr_row_ptr, bsr_col_ind, int row_block_dim, int col_block_dim, bsc_val, bsc_row_ind, bsc_col_ptr, copy_values, idx_base, temp_buffer)#

Convert a sparse GEneral BSR matrix into a sparse GEneral BSC matrix

hipsparseXgebsr2gebsc converts a GEneral BSR matrix into a GEneral BSC matrix. hipsparseXgebsr2gebsc can also be used to convert a GEneral BSC matrix into a GEneral BSR matrix. copy_values decides whether bsc_val is being filled during conversion (HIPSPARSE_ACTION_NUMERIC ) or not (HIPSPARSE_ACTION_SYMBOLIC ).

hipsparseXgebsr2gebsc requires extra temporary storage buffer that has to be allocated by the user. Storage buffer size can be determined by hipsparseXgebsr2gebsc_bufferSize().

Note:

The resulting matrix can also be seen as the transpose of the input matrix.

Note:

This function is non blocking and executed asynchronously with respect to the host. It may return before the actual computation has finished.

Args:

handle (Pointer/object):: (undocumented)
mb (int):: (undocumented)
nb (int):: (undocumented)
nnzb (int):: (undocumented)
bsr_val (Pointer/object):: (undocumented)
bsr_row_ptr (Pointer/object):: (undocumented)
bsr_col_ind (Pointer/object):: (undocumented)
row_block_dim (int):: (undocumented)
col_block_dim (int):: (undocumented)
bsc_val (Pointer/object):: (undocumented)
bsc_row_ind (Pointer/object):: (undocumented)
bsc_col_ptr (Pointer/object):: (undocumented)
copy_values (hipsparseAction_t):: (undocumented)
idx_base (hipsparseIndexBase_t):: (undocumented)
temp_buffer (Pointer/object):: (undocumented)

hip.hipsparse.hipsparseDgebsr2gebsc(handle, int mb, int nb, int nnzb, bsr_val, bsr_row_ptr, bsr_col_ind, int row_block_dim, int col_block_dim, bsc_val, bsc_row_ind, bsc_col_ptr, copy_values, idx_base, temp_buffer)#

(No short description, might be part of a group.)

Args:

handle (Pointer/object):: (undocumented)
mb (int):: (undocumented)
nb (int):: (undocumented)
nnzb (int):: (undocumented)
bsr_val (Pointer/object):: (undocumented)
bsr_row_ptr (Pointer/object):: (undocumented)
bsr_col_ind (Pointer/object):: (undocumented)
row_block_dim (int):: (undocumented)
col_block_dim (int):: (undocumented)
bsc_val (Pointer/object):: (undocumented)
bsc_row_ind (Pointer/object):: (undocumented)
bsc_col_ptr (Pointer/object):: (undocumented)
copy_values (hipsparseAction_t):: (undocumented)
idx_base (hipsparseIndexBase_t):: (undocumented)
temp_buffer (Pointer/object):: (undocumented)

hip.hipsparse.hipsparseCgebsr2gebsc(handle, int mb, int nb, int nnzb, bsr_val, bsr_row_ptr, bsr_col_ind, int row_block_dim, int col_block_dim, bsc_val, bsc_row_ind, bsc_col_ptr, copy_values, idx_base, temp_buffer)#

(No short description, might be part of a group.)

Args:

handle (Pointer/object):: (undocumented)
mb (int):: (undocumented)
nb (int):: (undocumented)
nnzb (int):: (undocumented)
bsr_val (float2/object):: (undocumented)
bsr_row_ptr (Pointer/object):: (undocumented)
bsr_col_ind (Pointer/object):: (undocumented)
row_block_dim (int):: (undocumented)
col_block_dim (int):: (undocumented)
bsc_val (float2/object):: (undocumented)
bsc_row_ind (Pointer/object):: (undocumented)
bsc_col_ptr (Pointer/object):: (undocumented)
copy_values (hipsparseAction_t):: (undocumented)
idx_base (hipsparseIndexBase_t):: (undocumented)
temp_buffer (Pointer/object):: (undocumented)

hip.hipsparse.hipsparseZgebsr2gebsc(handle, int mb, int nb, int nnzb, bsr_val, bsr_row_ptr, bsr_col_ind, int row_block_dim, int col_block_dim, bsc_val, bsc_row_ind, bsc_col_ptr, copy_values, idx_base, temp_buffer)#

(No short description, might be part of a group.)

Args:

handle (Pointer/object):: (undocumented)
mb (int):: (undocumented)
nb (int):: (undocumented)
nnzb (int):: (undocumented)
bsr_val (double2/object):: (undocumented)
bsr_row_ptr (Pointer/object):: (undocumented)
bsr_col_ind (Pointer/object):: (undocumented)
row_block_dim (int):: (undocumented)
col_block_dim (int):: (undocumented)
bsc_val (double2/object):: (undocumented)
bsc_row_ind (Pointer/object):: (undocumented)
bsc_col_ptr (Pointer/object):: (undocumented)
copy_values (hipsparseAction_t):: (undocumented)
idx_base (hipsparseIndexBase_t):: (undocumented)
temp_buffer (Pointer/object):: (undocumented)

hip.hipsparse.hipsparseScsr2gebsr_bufferSize(handle, dir, int m, int n, csr_descr, csr_val, csr_row_ptr, csr_col_ind, int row_block_dim, int col_block_dim, p_buffer_size)#

hipsparseXcsr2gebsr_bufferSize returns the size of the temporary buffer that is required by hipsparseXcsr2gebcsrNnz and hipsparseXcsr2gebcsr. The temporary storage buffer must be allocated by the user.

This function computes the number of nonzero block columns per row and the total number of nonzero blocks in a sparse GEneral BSR matrix given a sparse CSR matrix as input.

The routine does support asynchronous execution if the pointer mode is set to device.

Args:

handle (Pointer/object):: (undocumented)
dir (hipsparseDirection_t):: (undocumented)
m (int):: (undocumented)
n (int):: (undocumented)
csr_descr (Pointer/object):: (undocumented)
csr_val (Pointer/object):: (undocumented)
csr_row_ptr (Pointer/object):: (undocumented)
csr_col_ind (Pointer/object):: (undocumented)
row_block_dim (int):: (undocumented)
col_block_dim (int):: (undocumented)
p_buffer_size (Pointer/object):: (undocumented)

hip.hipsparse.hipsparseDcsr2gebsr_bufferSize(handle, dir, int m, int n, csr_descr, csr_val, csr_row_ptr, csr_col_ind, int row_block_dim, int col_block_dim, p_buffer_size)#

(No short description, might be part of a group.)

Args:

handle (Pointer/object):: (undocumented)
dir (hipsparseDirection_t):: (undocumented)
m (int):: (undocumented)
n (int):: (undocumented)
csr_descr (Pointer/object):: (undocumented)
csr_val (Pointer/object):: (undocumented)
csr_row_ptr (Pointer/object):: (undocumented)
csr_col_ind (Pointer/object):: (undocumented)
row_block_dim (int):: (undocumented)
col_block_dim (int):: (undocumented)
p_buffer_size (Pointer/object):: (undocumented)

hip.hipsparse.hipsparseCcsr2gebsr_bufferSize(handle, dir, int m, int n, csr_descr, csr_val, csr_row_ptr, csr_col_ind, int row_block_dim, int col_block_dim, p_buffer_size)#

(No short description, might be part of a group.)

Args:

handle (Pointer/object):: (undocumented)
dir (hipsparseDirection_t):: (undocumented)
m (int):: (undocumented)
n (int):: (undocumented)
csr_descr (Pointer/object):: (undocumented)
csr_val (float2/object):: (undocumented)
csr_row_ptr (Pointer/object):: (undocumented)
csr_col_ind (Pointer/object):: (undocumented)
row_block_dim (int):: (undocumented)
col_block_dim (int):: (undocumented)
p_buffer_size (Pointer/object):: (undocumented)

hip.hipsparse.hipsparseZcsr2gebsr_bufferSize(handle, dir, int m, int n, csr_descr, csr_val, csr_row_ptr, csr_col_ind, int row_block_dim, int col_block_dim, p_buffer_size)#

(No short description, might be part of a group.)

Args:

handle (Pointer/object):: (undocumented)
dir (hipsparseDirection_t):: (undocumented)
m (int):: (undocumented)
n (int):: (undocumented)
csr_descr (Pointer/object):: (undocumented)
csr_val (double2/object):: (undocumented)
csr_row_ptr (Pointer/object):: (undocumented)
csr_col_ind (Pointer/object):: (undocumented)
row_block_dim (int):: (undocumented)
col_block_dim (int):: (undocumented)
p_buffer_size (Pointer/object):: (undocumented)

hip.hipsparse.hipsparseXcsr2gebsrNnz(handle, dir, int m, int n, csr_descr, csr_row_ptr, csr_col_ind, bsr_descr, bsr_row_ptr, int row_block_dim, int col_block_dim, bsr_nnz_devhost, p_buffer)#

This function computes the number of nonzero block columns per row and the total number of nonzero blocks in a sparse GEneral BSR matrix given a sparse CSR matrix as input.

Args:

handle (Pointer/object):: (undocumented)
dir (hipsparseDirection_t):: (undocumented)
m (int):: (undocumented)
n (int):: (undocumented)
csr_descr (Pointer/object):: (undocumented)
csr_row_ptr (Pointer/object):: (undocumented)
csr_col_ind (Pointer/object):: (undocumented)
bsr_descr (Pointer/object):: (undocumented)
bsr_row_ptr (Pointer/object):: (undocumented)
row_block_dim (int):: (undocumented)
col_block_dim (int):: (undocumented)
bsr_nnz_devhost (Pointer/object):: (undocumented)
p_buffer (Pointer/object):: (undocumented)

hip.hipsparse.hipsparseScsr2gebsr(handle, dir, int m, int n, csr_descr, csr_val, csr_row_ptr, csr_col_ind, bsr_descr, bsr_val, bsr_row_ptr, bsr_col_ind, int row_block_dim, int col_block_dim, p_buffer)#

Convert a sparse CSR matrix into a sparse GEneral BSR matrix

hipsparseXcsr2gebsr converts a CSR matrix into a GEneral BSR matrix. It is assumed, that bsr_val, bsr_col_ind and bsr_row_ptr are allocated. Allocation size for bsr_row_ptr is computed as mb+1 where mb is the number of block rows in the GEneral BSR matrix. Allocation size for bsr_val and bsr_col_ind is computed using csr2gebsr_nnz() which also fills in bsr_row_ptr.

Args:

handle (Pointer/object):: (undocumented)
dir (hipsparseDirection_t):: (undocumented)
m (int):: (undocumented)
n (int):: (undocumented)
csr_descr (Pointer/object):: (undocumented)
csr_val (Pointer/object):: (undocumented)
csr_row_ptr (Pointer/object):: (undocumented)
csr_col_ind (Pointer/object):: (undocumented)
bsr_descr (Pointer/object):: (undocumented)
bsr_val (Pointer/object):: (undocumented)
bsr_row_ptr (Pointer/object):: (undocumented)
bsr_col_ind (Pointer/object):: (undocumented)
row_block_dim (int):: (undocumented)
col_block_dim (int):: (undocumented)
p_buffer (Pointer/object):: (undocumented)

hip.hipsparse.hipsparseDcsr2gebsr(handle, dir, int m, int n, csr_descr, csr_val, csr_row_ptr, csr_col_ind, bsr_descr, bsr_val, bsr_row_ptr, bsr_col_ind, int row_block_dim, int col_block_dim, p_buffer)#

(No short description, might be part of a group.)

Args:

handle (Pointer/object):: (undocumented)
dir (hipsparseDirection_t):: (undocumented)
m (int):: (undocumented)
n (int):: (undocumented)
csr_descr (Pointer/object):: (undocumented)
csr_val (Pointer/object):: (undocumented)
csr_row_ptr (Pointer/object):: (undocumented)
csr_col_ind (Pointer/object):: (undocumented)
bsr_descr (Pointer/object):: (undocumented)
bsr_val (Pointer/object):: (undocumented)
bsr_row_ptr (Pointer/object):: (undocumented)
bsr_col_ind (Pointer/object):: (undocumented)
row_block_dim (int):: (undocumented)
col_block_dim (int):: (undocumented)
p_buffer (Pointer/object):: (undocumented)

hip.hipsparse.hipsparseCcsr2gebsr(handle, dir, int m, int n, csr_descr, csr_val, csr_row_ptr, csr_col_ind, bsr_descr, bsr_val, bsr_row_ptr, bsr_col_ind, int row_block_dim, int col_block_dim, p_buffer)#

(No short description, might be part of a group.)

Args:

handle (Pointer/object):: (undocumented)
dir (hipsparseDirection_t):: (undocumented)
m (int):: (undocumented)
n (int):: (undocumented)
csr_descr (Pointer/object):: (undocumented)
csr_val (float2/object):: (undocumented)
csr_row_ptr (Pointer/object):: (undocumented)
csr_col_ind (Pointer/object):: (undocumented)
bsr_descr (Pointer/object):: (undocumented)
bsr_val (float2/object):: (undocumented)
bsr_row_ptr (Pointer/object):: (undocumented)
bsr_col_ind (Pointer/object):: (undocumented)
row_block_dim (int):: (undocumented)
col_block_dim (int):: (undocumented)
p_buffer (Pointer/object):: (undocumented)

hip.hipsparse.hipsparseZcsr2gebsr(handle, dir, int m, int n, csr_descr, csr_val, csr_row_ptr, csr_col_ind, bsr_descr, bsr_val, bsr_row_ptr, bsr_col_ind, int row_block_dim, int col_block_dim, p_buffer)#

(No short description, might be part of a group.)

Args:

handle (Pointer/object):: (undocumented)
dir (hipsparseDirection_t):: (undocumented)
m (int):: (undocumented)
n (int):: (undocumented)
csr_descr (Pointer/object):: (undocumented)
csr_val (double2/object):: (undocumented)
csr_row_ptr (Pointer/object):: (undocumented)
csr_col_ind (Pointer/object):: (undocumented)
bsr_descr (Pointer/object):: (undocumented)
bsr_val (double2/object):: (undocumented)
bsr_row_ptr (Pointer/object):: (undocumented)
bsr_col_ind (Pointer/object):: (undocumented)
row_block_dim (int):: (undocumented)
col_block_dim (int):: (undocumented)
p_buffer (Pointer/object):: (undocumented)

hip.hipsparse.hipsparseScsr2bsr(handle, dirA, int m, int n, descrA, csrValA, csrRowPtrA, csrColIndA, int blockDim, descrC, bsrValC, bsrRowPtrC, bsrColIndC)#

Convert a sparse CSR matrix into a sparse BSR matrix

hipsparseXcsr2bsr converts a CSR matrix into a BSR matrix. It is assumed, that bsr_val, bsr_col_ind and bsr_row_ptr are allocated. Allocation size for bsr_row_ptr is computed as mb+1 where mb is the number of block rows in the BSR matrix. Allocation size for bsr_val and bsr_col_ind is computed using csr2bsr_nnz() which also fills in bsr_row_ptr.

hipsparseXcsr2bsr requires extra temporary storage that is allocated internally if block_dim>16

Args:

handle (Pointer/object):: (undocumented)
dirA (hipsparseDirection_t):: (undocumented)
m (int):: (undocumented)
n (int):: (undocumented)
descrA (Pointer/object):: (undocumented)
csrValA (Pointer/object):: (undocumented)
csrRowPtrA (Pointer/object):: (undocumented)
csrColIndA (Pointer/object):: (undocumented)
blockDim (int):: (undocumented)
descrC (Pointer/object):: (undocumented)
bsrValC (Pointer/object):: (undocumented)
bsrRowPtrC (Pointer/object):: (undocumented)
bsrColIndC (Pointer/object):: (undocumented)

hip.hipsparse.hipsparseDcsr2bsr(handle, dirA, int m, int n, descrA, csrValA, csrRowPtrA, csrColIndA, int blockDim, descrC, bsrValC, bsrRowPtrC, bsrColIndC)#

(No short description, might be part of a group.)

Args:

handle (Pointer/object):: (undocumented)
dirA (hipsparseDirection_t):: (undocumented)
m (int):: (undocumented)
n (int):: (undocumented)
descrA (Pointer/object):: (undocumented)
csrValA (Pointer/object):: (undocumented)
csrRowPtrA (Pointer/object):: (undocumented)
csrColIndA (Pointer/object):: (undocumented)
blockDim (int):: (undocumented)
descrC (Pointer/object):: (undocumented)
bsrValC (Pointer/object):: (undocumented)
bsrRowPtrC (Pointer/object):: (undocumented)
bsrColIndC (Pointer/object):: (undocumented)

hip.hipsparse.hipsparseCcsr2bsr(handle, dirA, int m, int n, descrA, csrValA, csrRowPtrA, csrColIndA, int blockDim, descrC, bsrValC, bsrRowPtrC, bsrColIndC)#

(No short description, might be part of a group.)

Args:

handle (Pointer/object):: (undocumented)
dirA (hipsparseDirection_t):: (undocumented)
m (int):: (undocumented)
n (int):: (undocumented)
descrA (Pointer/object):: (undocumented)
csrValA (float2/object):: (undocumented)
csrRowPtrA (Pointer/object):: (undocumented)
csrColIndA (Pointer/object):: (undocumented)
blockDim (int):: (undocumented)
descrC (Pointer/object):: (undocumented)
bsrValC (float2/object):: (undocumented)
bsrRowPtrC (Pointer/object):: (undocumented)
bsrColIndC (Pointer/object):: (undocumented)

hip.hipsparse.hipsparseZcsr2bsr(handle, dirA, int m, int n, descrA, csrValA, csrRowPtrA, csrColIndA, int blockDim, descrC, bsrValC, bsrRowPtrC, bsrColIndC)#

(No short description, might be part of a group.)

Args:

handle (Pointer/object):: (undocumented)
dirA (hipsparseDirection_t):: (undocumented)
m (int):: (undocumented)
n (int):: (undocumented)
descrA (Pointer/object):: (undocumented)
csrValA (double2/object):: (undocumented)
csrRowPtrA (Pointer/object):: (undocumented)
csrColIndA (Pointer/object):: (undocumented)
blockDim (int):: (undocumented)
descrC (Pointer/object):: (undocumented)
bsrValC (double2/object):: (undocumented)
bsrRowPtrC (Pointer/object):: (undocumented)
bsrColIndC (Pointer/object):: (undocumented)

hip.hipsparse.hipsparseSbsr2csr(handle, dirA, int mb, int nb, descrA, bsrValA, bsrRowPtrA, bsrColIndA, int blockDim, descrC, csrValC, csrRowPtrC, csrColIndC)#

Convert a sparse BSR matrix into a sparse CSR matrix

hipsparseXbsr2csr converts a BSR matrix into a CSR matrix. It is assumed, that csr_val, csr_col_ind and csr_row_ptr are allocated. Allocation size for csr_row_ptr is computed by the number of block rows multiplied by the block dimension plus one. Allocation for csr_val and csr_col_ind is computed by the the number of blocks in the BSR matrix multiplied by the block dimension squared.

Note:

This function is non blocking and executed asynchronously with respect to the host. It may return before the actual computation has finished.

Args:

handle (Pointer/object):: (undocumented)
dirA (hipsparseDirection_t):: (undocumented)
mb (int):: (undocumented)
nb (int):: (undocumented)
descrA (Pointer/object):: (undocumented)
bsrValA (Pointer/object):: (undocumented)
bsrRowPtrA (Pointer/object):: (undocumented)
bsrColIndA (Pointer/object):: (undocumented)
blockDim (int):: (undocumented)
descrC (Pointer/object):: (undocumented)
csrValC (Pointer/object):: (undocumented)
csrRowPtrC (Pointer/object):: (undocumented)
csrColIndC (Pointer/object):: (undocumented)

hip.hipsparse.hipsparseDbsr2csr(handle, dirA, int mb, int nb, descrA, bsrValA, bsrRowPtrA, bsrColIndA, int blockDim, descrC, csrValC, csrRowPtrC, csrColIndC)#

(No short description, might be part of a group.)

Args:

handle (Pointer/object):: (undocumented)
dirA (hipsparseDirection_t):: (undocumented)
mb (int):: (undocumented)
nb (int):: (undocumented)
descrA (Pointer/object):: (undocumented)
bsrValA (Pointer/object):: (undocumented)
bsrRowPtrA (Pointer/object):: (undocumented)
bsrColIndA (Pointer/object):: (undocumented)
blockDim (int):: (undocumented)
descrC (Pointer/object):: (undocumented)
csrValC (Pointer/object):: (undocumented)
csrRowPtrC (Pointer/object):: (undocumented)
csrColIndC (Pointer/object):: (undocumented)

hip.hipsparse.hipsparseCbsr2csr(handle, dirA, int mb, int nb, descrA, bsrValA, bsrRowPtrA, bsrColIndA, int blockDim, descrC, csrValC, csrRowPtrC, csrColIndC)#

(No short description, might be part of a group.)

Args:

handle (Pointer/object):: (undocumented)
dirA (hipsparseDirection_t):: (undocumented)
mb (int):: (undocumented)
nb (int):: (undocumented)
descrA (Pointer/object):: (undocumented)
bsrValA (float2/object):: (undocumented)
bsrRowPtrA (Pointer/object):: (undocumented)
bsrColIndA (Pointer/object):: (undocumented)
blockDim (int):: (undocumented)
descrC (Pointer/object):: (undocumented)
csrValC (float2/object):: (undocumented)
csrRowPtrC (Pointer/object):: (undocumented)
csrColIndC (Pointer/object):: (undocumented)

hip.hipsparse.hipsparseZbsr2csr(handle, dirA, int mb, int nb, descrA, bsrValA, bsrRowPtrA, bsrColIndA, int blockDim, descrC, csrValC, csrRowPtrC, csrColIndC)#

(No short description, might be part of a group.)

Args:

handle (Pointer/object):: (undocumented)
dirA (hipsparseDirection_t):: (undocumented)
mb (int):: (undocumented)
nb (int):: (undocumented)
descrA (Pointer/object):: (undocumented)
bsrValA (double2/object):: (undocumented)
bsrRowPtrA (Pointer/object):: (undocumented)
bsrColIndA (Pointer/object):: (undocumented)
blockDim (int):: (undocumented)
descrC (Pointer/object):: (undocumented)
csrValC (double2/object):: (undocumented)
csrRowPtrC (Pointer/object):: (undocumented)
csrColIndC (Pointer/object):: (undocumented)

hip.hipsparse.hipsparseSgebsr2csr(handle, dirA, int mb, int nb, descrA, bsrValA, bsrRowPtrA, bsrColIndA, int rowBlockDim, int colBlockDim, descrC, csrValC, csrRowPtrC, csrColIndC)#

Convert a sparse general BSR matrix into a sparse CSR matrix

hipsparseXgebsr2csr converts a BSR matrix into a CSR matrix. It is assumed, that csr_val, csr_col_ind and csr_row_ptr are allocated. Allocation size for csr_row_ptr is computed by the number of block rows multiplied by the block dimension plus one. Allocation for csr_val and csr_col_ind is computed by the the number of blocks in the BSR matrix multiplied by the product of the block dimensions.

Note:

This function is non blocking and executed asynchronously with respect to the host. It may return before the actual computation has finished.

Args:

handle (Pointer/object):: (undocumented)
dirA (hipsparseDirection_t):: (undocumented)
mb (int):: (undocumented)
nb (int):: (undocumented)
descrA (Pointer/object):: (undocumented)
bsrValA (Pointer/object):: (undocumented)
bsrRowPtrA (Pointer/object):: (undocumented)
bsrColIndA (Pointer/object):: (undocumented)
rowBlockDim (int):: (undocumented)
colBlockDim (int):: (undocumented)
descrC (Pointer/object):: (undocumented)
csrValC (Pointer/object):: (undocumented)
csrRowPtrC (Pointer/object):: (undocumented)
csrColIndC (Pointer/object):: (undocumented)

hip.hipsparse.hipsparseDgebsr2csr(handle, dirA, int mb, int nb, descrA, bsrValA, bsrRowPtrA, bsrColIndA, int rowBlockDim, int colBlockDim, descrC, csrValC, csrRowPtrC, csrColIndC)#

(No short description, might be part of a group.)

Args:

handle (Pointer/object):: (undocumented)
dirA (hipsparseDirection_t):: (undocumented)
mb (int):: (undocumented)
nb (int):: (undocumented)
descrA (Pointer/object):: (undocumented)
bsrValA (Pointer/object):: (undocumented)
bsrRowPtrA (Pointer/object):: (undocumented)
bsrColIndA (Pointer/object):: (undocumented)
rowBlockDim (int):: (undocumented)
colBlockDim (int):: (undocumented)
descrC (Pointer/object):: (undocumented)
csrValC (Pointer/object):: (undocumented)
csrRowPtrC (Pointer/object):: (undocumented)
csrColIndC (Pointer/object):: (undocumented)

hip.hipsparse.hipsparseCgebsr2csr(handle, dirA, int mb, int nb, descrA, bsrValA, bsrRowPtrA, bsrColIndA, int rowBlockDim, int colBlockDim, descrC, csrValC, csrRowPtrC, csrColIndC)#

(No short description, might be part of a group.)

Args:

handle (Pointer/object):: (undocumented)
dirA (hipsparseDirection_t):: (undocumented)
mb (int):: (undocumented)
nb (int):: (undocumented)
descrA (Pointer/object):: (undocumented)
bsrValA (float2/object):: (undocumented)
bsrRowPtrA (Pointer/object):: (undocumented)
bsrColIndA (Pointer/object):: (undocumented)
rowBlockDim (int):: (undocumented)
colBlockDim (int):: (undocumented)
descrC (Pointer/object):: (undocumented)
csrValC (float2/object):: (undocumented)
csrRowPtrC (Pointer/object):: (undocumented)
csrColIndC (Pointer/object):: (undocumented)

hip.hipsparse.hipsparseZgebsr2csr(handle, dirA, int mb, int nb, descrA, bsrValA, bsrRowPtrA, bsrColIndA, int rowBlockDim, int colBlockDim, descrC, csrValC, csrRowPtrC, csrColIndC)#

(No short description, might be part of a group.)

Args:

handle (Pointer/object):: (undocumented)
dirA (hipsparseDirection_t):: (undocumented)
mb (int):: (undocumented)
nb (int):: (undocumented)
descrA (Pointer/object):: (undocumented)
bsrValA (double2/object):: (undocumented)
bsrRowPtrA (Pointer/object):: (undocumented)
bsrColIndA (Pointer/object):: (undocumented)
rowBlockDim (int):: (undocumented)
colBlockDim (int):: (undocumented)
descrC (Pointer/object):: (undocumented)
csrValC (double2/object):: (undocumented)
csrRowPtrC (Pointer/object):: (undocumented)
csrColIndC (Pointer/object):: (undocumented)

hip.hipsparse.hipsparseScsr2csr_compress(handle, int m, int n, descrA, csrValA, csrColIndA, csrRowPtrA, int nnzA, nnzPerRow, csrValC, csrColIndC, csrRowPtrC, float tol)#

Convert a sparse CSR matrix into a compressed sparse CSR matrix

hipsparseXcsr2csr_compress converts a CSR matrix into a compressed CSR matrix by removing entries in the input CSR matrix that are below a non-negative threshold tol

Note:

In the case of complex matrices only the magnitude of the real part of tol is used.

Args:

handle (Pointer/object):: (undocumented)
m (int):: (undocumented)
n (int):: (undocumented)
descrA (Pointer/object):: (undocumented)
csrValA (Pointer/object):: (undocumented)
csrColIndA (Pointer/object):: (undocumented)
csrRowPtrA (Pointer/object):: (undocumented)
nnzA (int):: (undocumented)
nnzPerRow (Pointer/object):: (undocumented)
csrValC (Pointer/object):: (undocumented)
csrColIndC (Pointer/object):: (undocumented)
csrRowPtrC (Pointer/object):: (undocumented)
tol (float/int):: (undocumented)

hip.hipsparse.hipsparseDcsr2csr_compress(handle, int m, int n, descrA, csrValA, csrColIndA, csrRowPtrA, int nnzA, nnzPerRow, csrValC, csrColIndC, csrRowPtrC, double tol)#

(No short description, might be part of a group.)

Args:

handle (Pointer/object):: (undocumented)
m (int):: (undocumented)
n (int):: (undocumented)
descrA (Pointer/object):: (undocumented)
csrValA (Pointer/object):: (undocumented)
csrColIndA (Pointer/object):: (undocumented)
csrRowPtrA (Pointer/object):: (undocumented)
nnzA (int):: (undocumented)
nnzPerRow (Pointer/object):: (undocumented)
csrValC (Pointer/object):: (undocumented)
csrColIndC (Pointer/object):: (undocumented)
csrRowPtrC (Pointer/object):: (undocumented)
tol (float/int):: (undocumented)

hip.hipsparse.hipsparseCcsr2csr_compress(handle, int m, int n, descrA, csrValA, csrColIndA, csrRowPtrA, int nnzA, nnzPerRow, csrValC, csrColIndC, csrRowPtrC, tol)#

(No short description, might be part of a group.)

Args:

handle (Pointer/object):: (undocumented)
m (int):: (undocumented)
n (int):: (undocumented)
descrA (Pointer/object):: (undocumented)
csrValA (float2/object):: (undocumented)
csrColIndA (Pointer/object):: (undocumented)
csrRowPtrA (Pointer/object):: (undocumented)
nnzA (int):: (undocumented)
nnzPerRow (Pointer/object):: (undocumented)
csrValC (float2/object):: (undocumented)
csrColIndC (Pointer/object):: (undocumented)
csrRowPtrC (Pointer/object):: (undocumented)
tol (float2):: (undocumented)

hip.hipsparse.hipsparseZcsr2csr_compress(handle, int m, int n, descrA, csrValA, csrColIndA, csrRowPtrA, int nnzA, nnzPerRow, csrValC, csrColIndC, csrRowPtrC, tol)#

(No short description, might be part of a group.)

Args:

handle (Pointer/object):: (undocumented)
m (int):: (undocumented)
n (int):: (undocumented)
descrA (Pointer/object):: (undocumented)
csrValA (double2/object):: (undocumented)
csrColIndA (Pointer/object):: (undocumented)
csrRowPtrA (Pointer/object):: (undocumented)
nnzA (int):: (undocumented)
nnzPerRow (Pointer/object):: (undocumented)
csrValC (double2/object):: (undocumented)
csrColIndC (Pointer/object):: (undocumented)
csrRowPtrC (Pointer/object):: (undocumented)
tol (double2):: (undocumented)

hip.hipsparse.hipsparseSpruneCsr2csr_bufferSize(handle, int m, int n, int nnzA, descrA, csrValA, csrRowPtrA, csrColIndA, threshold, descrC, csrValC, csrRowPtrC, csrColIndC, bufferSize)#

Convert and prune sparse CSR matrix into a sparse CSR matrix

hipsparseXpruneCsr2csr_bufferSize returns the size of the temporary buffer that is required by hipsparseXpruneCsr2csrNnz and hipsparseXpruneCsr2csr. The temporary storage buffer must be allocated by the user.

Args:

handle (Pointer/object):: (undocumented)
m (int):: (undocumented)
n (int):: (undocumented)
nnzA (int):: (undocumented)
descrA (Pointer/object):: (undocumented)
csrValA (Pointer/object):: (undocumented)
csrRowPtrA (Pointer/object):: (undocumented)
csrColIndA (Pointer/object):: (undocumented)
threshold (Pointer/object):: (undocumented)
descrC (Pointer/object):: (undocumented)
csrValC (Pointer/object):: (undocumented)
csrRowPtrC (Pointer/object):: (undocumented)
csrColIndC (Pointer/object):: (undocumented)
bufferSize (Pointer/object):: (undocumented)

hip.hipsparse.hipsparseDpruneCsr2csr_bufferSize(handle, int m, int n, int nnzA, descrA, csrValA, csrRowPtrA, csrColIndA, threshold, descrC, csrValC, csrRowPtrC, csrColIndC, bufferSize)#

(No short description, might be part of a group.)

Args:

handle (Pointer/object):: (undocumented)
m (int):: (undocumented)
n (int):: (undocumented)
nnzA (int):: (undocumented)
descrA (Pointer/object):: (undocumented)
csrValA (Pointer/object):: (undocumented)
csrRowPtrA (Pointer/object):: (undocumented)
csrColIndA (Pointer/object):: (undocumented)
threshold (Pointer/object):: (undocumented)
descrC (Pointer/object):: (undocumented)
csrValC (Pointer/object):: (undocumented)
csrRowPtrC (Pointer/object):: (undocumented)
csrColIndC (Pointer/object):: (undocumented)
bufferSize (Pointer/object):: (undocumented)

hip.hipsparse.hipsparseSpruneCsr2csr_bufferSizeExt(handle, int m, int n, int nnzA, descrA, csrValA, csrRowPtrA, csrColIndA, threshold, descrC, csrValC, csrRowPtrC, csrColIndC, bufferSize)#

Convert and prune sparse CSR matrix into a sparse CSR matrix

hipsparseXpruneCsr2csr_bufferSizeExt returns the size of the temporary buffer that is required by hipsparseXpruneCsr2csrNnz and hipsparseXpruneCsr2csr. The temporary storage buffer must be allocated by the user.

Args:

handle (Pointer/object):: (undocumented)
m (int):: (undocumented)
n (int):: (undocumented)
nnzA (int):: (undocumented)
descrA (Pointer/object):: (undocumented)
csrValA (Pointer/object):: (undocumented)
csrRowPtrA (Pointer/object):: (undocumented)
csrColIndA (Pointer/object):: (undocumented)
threshold (Pointer/object):: (undocumented)
descrC (Pointer/object):: (undocumented)
csrValC (Pointer/object):: (undocumented)
csrRowPtrC (Pointer/object):: (undocumented)
csrColIndC (Pointer/object):: (undocumented)
bufferSize (Pointer/object):: (undocumented)

hip.hipsparse.hipsparseDpruneCsr2csr_bufferSizeExt(handle, int m, int n, int nnzA, descrA, csrValA, csrRowPtrA, csrColIndA, threshold, descrC, csrValC, csrRowPtrC, csrColIndC, bufferSize)#

(No short description, might be part of a group.)

Args:

handle (Pointer/object):: (undocumented)
m (int):: (undocumented)
n (int):: (undocumented)
nnzA (int):: (undocumented)
descrA (Pointer/object):: (undocumented)
csrValA (Pointer/object):: (undocumented)
csrRowPtrA (Pointer/object):: (undocumented)
csrColIndA (Pointer/object):: (undocumented)
threshold (Pointer/object):: (undocumented)
descrC (Pointer/object):: (undocumented)
csrValC (Pointer/object):: (undocumented)
csrRowPtrC (Pointer/object):: (undocumented)
csrColIndC (Pointer/object):: (undocumented)
bufferSize (Pointer/object):: (undocumented)

hip.hipsparse.hipsparseSpruneCsr2csrNnz(handle, int m, int n, int nnzA, descrA, csrValA, csrRowPtrA, csrColIndA, threshold, descrC, csrRowPtrC, nnzTotalDevHostPtr, buffer)#

Convert and prune sparse CSR matrix into a sparse CSR matrix

hipsparseXpruneCsr2csrNnz computes the number of nonzero elements per row and the total number of nonzero elements in a sparse CSR matrix once elements less than the threshold are pruned from the matrix.

Note:

The routine does support asynchronous execution if the pointer mode is set to device.

Args:

handle (Pointer/object):: (undocumented)
m (int):: (undocumented)
n (int):: (undocumented)
nnzA (int):: (undocumented)
descrA (Pointer/object):: (undocumented)
csrValA (Pointer/object):: (undocumented)
csrRowPtrA (Pointer/object):: (undocumented)
csrColIndA (Pointer/object):: (undocumented)
threshold (Pointer/object):: (undocumented)
descrC (Pointer/object):: (undocumented)
csrRowPtrC (Pointer/object):: (undocumented)
nnzTotalDevHostPtr (Pointer/object):: (undocumented)
buffer (Pointer/object):: (undocumented)

hip.hipsparse.hipsparseDpruneCsr2csrNnz(handle, int m, int n, int nnzA, descrA, csrValA, csrRowPtrA, csrColIndA, threshold, descrC, csrRowPtrC, nnzTotalDevHostPtr, buffer)#

(No short description, might be part of a group.)

Args:

handle (Pointer/object):: (undocumented)
m (int):: (undocumented)
n (int):: (undocumented)
nnzA (int):: (undocumented)
descrA (Pointer/object):: (undocumented)
csrValA (Pointer/object):: (undocumented)
csrRowPtrA (Pointer/object):: (undocumented)
csrColIndA (Pointer/object):: (undocumented)
threshold (Pointer/object):: (undocumented)
descrC (Pointer/object):: (undocumented)
csrRowPtrC (Pointer/object):: (undocumented)
nnzTotalDevHostPtr (Pointer/object):: (undocumented)
buffer (Pointer/object):: (undocumented)

hip.hipsparse.hipsparseSpruneCsr2csr(handle, int m, int n, int nnzA, descrA, csrValA, csrRowPtrA, csrColIndA, threshold, descrC, csrValC, csrRowPtrC, csrColIndC, buffer)#

Convert and prune sparse CSR matrix into a sparse CSR matrix

This function converts the sparse CSR matrix A into a sparse CSR matrix C by pruning values in A that are less than the threshold. All the parameters are assumed to have been pre-allocated by the user. The user first calls hipsparseXpruneCsr2csr_bufferSize() to determine the size of the buffer used by hipsparseXpruneCsr2csrNnz() and hipsparseXpruneCsr2csr() which the user then allocates. The user then allocates csr_row_ptr_C to have m+1 elements and then calls hipsparseXpruneCsr2csrNnz() which fills in the csr_row_ptr_C array stores then number of elements that are larger than the pruning threshold in nnz_total_dev_host_ptr. The user then calls hipsparseXpruneCsr2csr() to complete the conversion. It is executed asynchronously with respect to the host and may return control to the application on the host before the entire result is ready.

Args:

handle (Pointer/object):: (undocumented)
m (int):: (undocumented)
n (int):: (undocumented)
nnzA (int):: (undocumented)
descrA (Pointer/object):: (undocumented)
csrValA (Pointer/object):: (undocumented)
csrRowPtrA (Pointer/object):: (undocumented)
csrColIndA (Pointer/object):: (undocumented)
threshold (Pointer/object):: (undocumented)
descrC (Pointer/object):: (undocumented)
csrValC (Pointer/object):: (undocumented)
csrRowPtrC (Pointer/object):: (undocumented)
csrColIndC (Pointer/object):: (undocumented)
buffer (Pointer/object):: (undocumented)

hip.hipsparse.hipsparseDpruneCsr2csr(handle, int m, int n, int nnzA, descrA, csrValA, csrRowPtrA, csrColIndA, threshold, descrC, csrValC, csrRowPtrC, csrColIndC, buffer)#

(No short description, might be part of a group.)

Args:

handle (Pointer/object):: (undocumented)
m (int):: (undocumented)
n (int):: (undocumented)
nnzA (int):: (undocumented)
descrA (Pointer/object):: (undocumented)
csrValA (Pointer/object):: (undocumented)
csrRowPtrA (Pointer/object):: (undocumented)
csrColIndA (Pointer/object):: (undocumented)
threshold (Pointer/object):: (undocumented)
descrC (Pointer/object):: (undocumented)
csrValC (Pointer/object):: (undocumented)
csrRowPtrC (Pointer/object):: (undocumented)
csrColIndC (Pointer/object):: (undocumented)
buffer (Pointer/object):: (undocumented)

hip.hipsparse.hipsparseSpruneCsr2csrByPercentage_bufferSize(handle, int m, int n, int nnzA, descrA, csrValA, csrRowPtrA, csrColIndA, float percentage, descrC, csrValC, csrRowPtrC, csrColIndC, info, bufferSize)#

Convert and prune by percentage a sparse CSR matrix into a sparse CSR matrix

hipsparseXpruneCsr2csrByPercentage_bufferSize returns the size of the temporary buffer that is required by hipsparseXpruneCsr2csrNnzByPercentage. The temporary storage buffer must be allocated by the user.

Args:

handle (Pointer/object):: (undocumented)
m (int):: (undocumented)
n (int):: (undocumented)
nnzA (int):: (undocumented)
descrA (Pointer/object):: (undocumented)
csrValA (Pointer/object):: (undocumented)
csrRowPtrA (Pointer/object):: (undocumented)
csrColIndA (Pointer/object):: (undocumented)
percentage (float/int):: (undocumented)
descrC (Pointer/object):: (undocumented)
csrValC (Pointer/object):: (undocumented)
csrRowPtrC (Pointer/object):: (undocumented)
csrColIndC (Pointer/object):: (undocumented)
info (pruneInfo/object):: (undocumented)
bufferSize (Pointer/object):: (undocumented)

hip.hipsparse.hipsparseDpruneCsr2csrByPercentage_bufferSize(handle, int m, int n, int nnzA, descrA, csrValA, csrRowPtrA, csrColIndA, double percentage, descrC, csrValC, csrRowPtrC, csrColIndC, info, bufferSize)#

(No short description, might be part of a group.)

Args:

handle (Pointer/object):: (undocumented)
m (int):: (undocumented)
n (int):: (undocumented)
nnzA (int):: (undocumented)
descrA (Pointer/object):: (undocumented)
csrValA (Pointer/object):: (undocumented)
csrRowPtrA (Pointer/object):: (undocumented)
csrColIndA (Pointer/object):: (undocumented)
percentage (float/int):: (undocumented)
descrC (Pointer/object):: (undocumented)
csrValC (Pointer/object):: (undocumented)
csrRowPtrC (Pointer/object):: (undocumented)
csrColIndC (Pointer/object):: (undocumented)
info (pruneInfo/object):: (undocumented)
bufferSize (Pointer/object):: (undocumented)

hip.hipsparse.hipsparseSpruneCsr2csrByPercentage_bufferSizeExt(handle, int m, int n, int nnzA, descrA, csrValA, csrRowPtrA, csrColIndA, float percentage, descrC, csrValC, csrRowPtrC, csrColIndC, info, bufferSize)#

Convert and prune by percentage a sparse CSR matrix into a sparse CSR matrix

hipsparseXpruneCsr2csrByPercentage_bufferSizeExt returns the size of the temporary buffer that is required by hipsparseXpruneCsr2csrNnzByPercentage. The temporary storage buffer must be allocated by the user.

Args:

handle (Pointer/object):: (undocumented)
m (int):: (undocumented)
n (int):: (undocumented)
nnzA (int):: (undocumented)
descrA (Pointer/object):: (undocumented)
csrValA (Pointer/object):: (undocumented)
csrRowPtrA (Pointer/object):: (undocumented)
csrColIndA (Pointer/object):: (undocumented)
percentage (float/int):: (undocumented)
descrC (Pointer/object):: (undocumented)
csrValC (Pointer/object):: (undocumented)
csrRowPtrC (Pointer/object):: (undocumented)
csrColIndC (Pointer/object):: (undocumented)
info (pruneInfo/object):: (undocumented)
bufferSize (Pointer/object):: (undocumented)

hip.hipsparse.hipsparseDpruneCsr2csrByPercentage_bufferSizeExt(handle, int m, int n, int nnzA, descrA, csrValA, csrRowPtrA, csrColIndA, double percentage, descrC, csrValC, csrRowPtrC, csrColIndC, info, bufferSize)#

(No short description, might be part of a group.)

Args:

handle (Pointer/object):: (undocumented)
m (int):: (undocumented)
n (int):: (undocumented)
nnzA (int):: (undocumented)
descrA (Pointer/object):: (undocumented)
csrValA (Pointer/object):: (undocumented)
csrRowPtrA (Pointer/object):: (undocumented)
csrColIndA (Pointer/object):: (undocumented)
percentage (float/int):: (undocumented)
descrC (Pointer/object):: (undocumented)
csrValC (Pointer/object):: (undocumented)
csrRowPtrC (Pointer/object):: (undocumented)
csrColIndC (Pointer/object):: (undocumented)
info (pruneInfo/object):: (undocumented)
bufferSize (Pointer/object):: (undocumented)

hip.hipsparse.hipsparseSpruneCsr2csrNnzByPercentage(handle, int m, int n, int nnzA, descrA, csrValA, csrRowPtrA, csrColIndA, float percentage, descrC, csrRowPtrC, nnzTotalDevHostPtr, info, buffer)#

Convert and prune by percentage a sparse CSR matrix into a sparse CSR matrix

hipsparseXpruneCsr2csrNnzByPercentage computes the number of nonzero elements per row and the total number of nonzero elements in a sparse CSR matrix once elements less than the threshold are pruned from the matrix.

Note:

The routine does support asynchronous execution if the pointer mode is set to device.

Args:

handle (Pointer/object):: (undocumented)
m (int):: (undocumented)
n (int):: (undocumented)
nnzA (int):: (undocumented)
descrA (Pointer/object):: (undocumented)
csrValA (Pointer/object):: (undocumented)
csrRowPtrA (Pointer/object):: (undocumented)
csrColIndA (Pointer/object):: (undocumented)
percentage (float/int):: (undocumented)
descrC (Pointer/object):: (undocumented)
csrRowPtrC (Pointer/object):: (undocumented)
nnzTotalDevHostPtr (Pointer/object):: (undocumented)
info (pruneInfo/object):: (undocumented)
buffer (Pointer/object):: (undocumented)

hip.hipsparse.hipsparseDpruneCsr2csrNnzByPercentage(handle, int m, int n, int nnzA, descrA, csrValA, csrRowPtrA, csrColIndA, double percentage, descrC, csrRowPtrC, nnzTotalDevHostPtr, info, buffer)#

(No short description, might be part of a group.)

Args:

handle (Pointer/object):: (undocumented)
m (int):: (undocumented)
n (int):: (undocumented)
nnzA (int):: (undocumented)
descrA (Pointer/object):: (undocumented)
csrValA (Pointer/object):: (undocumented)
csrRowPtrA (Pointer/object):: (undocumented)
csrColIndA (Pointer/object):: (undocumented)
percentage (float/int):: (undocumented)
descrC (Pointer/object):: (undocumented)
csrRowPtrC (Pointer/object):: (undocumented)
nnzTotalDevHostPtr (Pointer/object):: (undocumented)
info (pruneInfo/object):: (undocumented)
buffer (Pointer/object):: (undocumented)

hip.hipsparse.hipsparseSpruneCsr2csrByPercentage(handle, int m, int n, int nnzA, descrA, csrValA, csrRowPtrA, csrColIndA, float percentage, descrC, csrValC, csrRowPtrC, csrColIndC, info, buffer)#

Convert and prune by percentage a sparse CSR matrix into a sparse CSR matrix

This function converts the sparse CSR matrix A into a sparse CSR matrix C by pruning values in A that are less than the threshold. All the parameters are assumed to have been pre-allocated by the user. The user first calls hipsparseXpruneCsr2csr_bufferSize() to determine the size of the buffer used by hipsparseXpruneCsr2csrNnz() and hipsparseXpruneCsr2csr() which the user then allocates. The user then allocates csr_row_ptr_C to have m+1 elements and then calls hipsparseXpruneCsr2csrNnz() which fills in the csr_row_ptr_C array stores then number of elements that are larger than the pruning threshold in nnz_total_dev_host_ptr. The user then calls hipsparseXpruneCsr2csr() to complete the conversion. It is executed asynchronously with respect to the host and may return control to the application on the host before the entire result is ready.

Args:

handle (Pointer/object):: (undocumented)
m (int):: (undocumented)
n (int):: (undocumented)
nnzA (int):: (undocumented)
descrA (Pointer/object):: (undocumented)
csrValA (Pointer/object):: (undocumented)
csrRowPtrA (Pointer/object):: (undocumented)
csrColIndA (Pointer/object):: (undocumented)
percentage (float/int):: (undocumented)
descrC (Pointer/object):: (undocumented)
csrValC (Pointer/object):: (undocumented)
csrRowPtrC (Pointer/object):: (undocumented)
csrColIndC (Pointer/object):: (undocumented)
info (pruneInfo/object):: (undocumented)
buffer (Pointer/object):: (undocumented)

hip.hipsparse.hipsparseDpruneCsr2csrByPercentage(handle, int m, int n, int nnzA, descrA, csrValA, csrRowPtrA, csrColIndA, double percentage, descrC, csrValC, csrRowPtrC, csrColIndC, info, buffer)#

(No short description, might be part of a group.)

Args:

handle (Pointer/object):: (undocumented)
m (int):: (undocumented)
n (int):: (undocumented)
nnzA (int):: (undocumented)
descrA (Pointer/object):: (undocumented)
csrValA (Pointer/object):: (undocumented)
csrRowPtrA (Pointer/object):: (undocumented)
csrColIndA (Pointer/object):: (undocumented)
percentage (float/int):: (undocumented)
descrC (Pointer/object):: (undocumented)
csrValC (Pointer/object):: (undocumented)
csrRowPtrC (Pointer/object):: (undocumented)
csrColIndC (Pointer/object):: (undocumented)
info (pruneInfo/object):: (undocumented)
buffer (Pointer/object):: (undocumented)

hip.hipsparse.hipsparseShyb2csr(handle, descrA, hybA, csrSortedValA, csrSortedRowPtrA, csrSortedColIndA)#

Convert a sparse HYB matrix into a sparse CSR matrix

hipsparseXhyb2csr converts a HYB matrix into a CSR matrix.

Note:

This function is non blocking and executed asynchronously with respect to the host. It may return before the actual computation has finished.

Args:

handle (Pointer/object):: (undocumented)
descrA (Pointer/object):: (undocumented)
hybA (Pointer/object):: (undocumented)
csrSortedValA (Pointer/object):: (undocumented)
csrSortedRowPtrA (Pointer/object):: (undocumented)
csrSortedColIndA (Pointer/object):: (undocumented)

hip.hipsparse.hipsparseDhyb2csr(handle, descrA, hybA, csrSortedValA, csrSortedRowPtrA, csrSortedColIndA)#

(No short description, might be part of a group.)

Args:

handle (Pointer/object):: (undocumented)
descrA (Pointer/object):: (undocumented)
hybA (Pointer/object):: (undocumented)
csrSortedValA (Pointer/object):: (undocumented)
csrSortedRowPtrA (Pointer/object):: (undocumented)
csrSortedColIndA (Pointer/object):: (undocumented)

hip.hipsparse.hipsparseChyb2csr(handle, descrA, hybA, csrSortedValA, csrSortedRowPtrA, csrSortedColIndA)#

(No short description, might be part of a group.)

Args:

handle (Pointer/object):: (undocumented)
descrA (Pointer/object):: (undocumented)
hybA (Pointer/object):: (undocumented)
csrSortedValA (float2/object):: (undocumented)
csrSortedRowPtrA (Pointer/object):: (undocumented)
csrSortedColIndA (Pointer/object):: (undocumented)

hip.hipsparse.hipsparseZhyb2csr(handle, descrA, hybA, csrSortedValA, csrSortedRowPtrA, csrSortedColIndA)#

(No short description, might be part of a group.)

Args:

handle (Pointer/object):: (undocumented)
descrA (Pointer/object):: (undocumented)
hybA (Pointer/object):: (undocumented)
csrSortedValA (double2/object):: (undocumented)
csrSortedRowPtrA (Pointer/object):: (undocumented)
csrSortedColIndA (Pointer/object):: (undocumented)

hip.hipsparse.hipsparseXcoo2csr(handle, cooRowInd, int nnz, int m, csrRowPtr, idxBase)#

Convert a sparse COO matrix into a sparse CSR matrix

hipsparseXcoo2csr converts the COO array containing the row indices into a CSR array of row offsets, that point to the start of every row. It is assumed that the COO row index array is sorted.

Note:

It can also be used, to convert a COO array containing the column indices into a CSC array of column offsets, that point to the start of every column. Then, it is assumed that the COO column index array is sorted, instead.

Note:

This function is non blocking and executed asynchronously with respect to the host. It may return before the actual computation has finished.

Args:

handle (Pointer/object):: (undocumented)
cooRowInd (Pointer/object):: (undocumented)
nnz (int):: (undocumented)
m (int):: (undocumented)
csrRowPtr (Pointer/object):: (undocumented)
idxBase (hipsparseIndexBase_t):: (undocumented)

hip.hipsparse.hipsparseCreateIdentityPermutation(handle, int n, p)#

Create the identity map

hipsparseCreateIdentityPermutation stores the identity map in p, such that \(p = 0:1:(n-1)\).

for(i = 0; i < n; ++i)
{
    p[i] = i;
}

Note:

This function is non blocking and executed asynchronously with respect to the host. It may return before the actual computation has finished.

Args:

handle (Pointer/object):: (undocumented)
n (int):: (undocumented)
p (Pointer/object):: (undocumented)

hip.hipsparse.hipsparseXcsrsort_bufferSizeExt(handle, int m, int n, int nnz, csrRowPtr, csrColInd, pBufferSizeInBytes)#

Sort a sparse CSR matrix

hipsparseXcsrsort_bufferSizeExt returns the size of the temporary storage buffer in bytes required by hipsparseXcsrsort(). The temporary storage buffer must be allocated by the user.

Args:

handle (Pointer/object):: (undocumented)
m (int):: (undocumented)
n (int):: (undocumented)
nnz (int):: (undocumented)
csrRowPtr (Pointer/object):: (undocumented)
csrColInd (Pointer/object):: (undocumented)
pBufferSizeInBytes (Pointer/object):: (undocumented)

hip.hipsparse.hipsparseXcsrsort(handle, int m, int n, int nnz, descrA, csrRowPtr, csrColInd, P, pBuffer)#

Sort a sparse CSR matrix

hipsparseXcsrsort sorts a matrix in CSR format. The sorted permutation vector perm can be used to obtain sorted csr_val array. In this case, perm must be initialized as the identity permutation, see hipsparseCreateIdentityPermutation().

hipsparseXcsrsort requires extra temporary storage buffer that has to be allocated by the user. Storage buffer size can be determined by hipsparseXcsrsort_bufferSizeExt().

Note:

perm can be NULL if a sorted permutation vector is not required.

Note:

This function is non blocking and executed asynchronously with respect to the host. It may return before the actual computation has finished.

Args:

handle (Pointer/object):: (undocumented)
m (int):: (undocumented)
n (int):: (undocumented)
nnz (int):: (undocumented)
descrA (Pointer/object):: (undocumented)
csrRowPtr (Pointer/object):: (undocumented)
csrColInd (Pointer/object):: (undocumented)
P (Pointer/object):: (undocumented)
pBuffer (Pointer/object):: (undocumented)

hip.hipsparse.hipsparseXcscsort_bufferSizeExt(handle, int m, int n, int nnz, cscColPtr, cscRowInd, pBufferSizeInBytes)#

Sort a sparse CSC matrix

hipsparseXcscsort_bufferSizeExt returns the size of the temporary storage buffer in bytes required by hipsparseXcscsort(). The temporary storage buffer must be allocated by the user.

Args:

handle (Pointer/object):: (undocumented)
m (int):: (undocumented)
n (int):: (undocumented)
nnz (int):: (undocumented)
cscColPtr (Pointer/object):: (undocumented)
cscRowInd (Pointer/object):: (undocumented)
pBufferSizeInBytes (Pointer/object):: (undocumented)

hip.hipsparse.hipsparseXcscsort(handle, int m, int n, int nnz, descrA, cscColPtr, cscRowInd, P, pBuffer)#

Sort a sparse CSC matrix

hipsparseXcscsort sorts a matrix in CSC format. The sorted permutation vector perm can be used to obtain sorted csc_val array. In this case, perm must be initialized as the identity permutation, see hipsparseCreateIdentityPermutation().

hipsparseXcscsort requires extra temporary storage buffer that has to be allocated by the user. Storage buffer size can be determined by hipsparseXcscsort_bufferSizeExt().

Note:

perm can be NULL if a sorted permutation vector is not required.

Note:

This function is non blocking and executed asynchronously with respect to the host. It may return before the actual computation has finished.

Args:

handle (Pointer/object):: (undocumented)
m (int):: (undocumented)
n (int):: (undocumented)
nnz (int):: (undocumented)
descrA (Pointer/object):: (undocumented)
cscColPtr (Pointer/object):: (undocumented)
cscRowInd (Pointer/object):: (undocumented)
P (Pointer/object):: (undocumented)
pBuffer (Pointer/object):: (undocumented)

hip.hipsparse.hipsparseXcoosort_bufferSizeExt(handle, int m, int n, int nnz, cooRows, cooCols, pBufferSizeInBytes)#

Sort a sparse COO matrix

hipsparseXcoosort_bufferSizeExt returns the size of the temporary storage buffer in bytes required by hipsparseXcoosort(). The temporary storage buffer must be allocated by the user.

Args:

handle (Pointer/object):: (undocumented)
m (int):: (undocumented)
n (int):: (undocumented)
nnz (int):: (undocumented)
cooRows (Pointer/object):: (undocumented)
cooCols (Pointer/object):: (undocumented)
pBufferSizeInBytes (Pointer/object):: (undocumented)

hip.hipsparse.hipsparseXcoosortByRow(handle, int m, int n, int nnz, cooRows, cooCols, P, pBuffer)#

Sort a sparse COO matrix by row

hipsparseXcoosortByRow sorts a matrix in COO format by row. The sorted permutation vector perm can be used to obtain sorted coo_val array. In this case, perm must be initialized as the identity permutation, see hipsparseCreateIdentityPermutation().

hipsparseXcoosortByRow requires extra temporary storage buffer that has to be allocated by the user. Storage buffer size can be determined by hipsparseXcoosort_bufferSizeExt().

Note:

perm can be NULL if a sorted permutation vector is not required.

Note:

This function is non blocking and executed asynchronously with respect to the host. It may return before the actual computation has finished.

Args:

handle (Pointer/object):: (undocumented)
m (int):: (undocumented)
n (int):: (undocumented)
nnz (int):: (undocumented)
cooRows (Pointer/object):: (undocumented)
cooCols (Pointer/object):: (undocumented)
P (Pointer/object):: (undocumented)
pBuffer (Pointer/object):: (undocumented)

hip.hipsparse.hipsparseXcoosortByColumn(handle, int m, int n, int nnz, cooRows, cooCols, P, pBuffer)#

Sort a sparse COO matrix by column

hipsparseXcoosortByColumn sorts a matrix in COO format by column. The sorted permutation vector perm can be used to obtain sorted coo_val array. In this case, perm must be initialized as the identity permutation, see hipsparseCreateIdentityPermutation().

hipsparseXcoosortByColumn requires extra temporary storage buffer that has to be allocated by the user. Storage buffer size can be determined by hipsparseXcoosort_bufferSizeExt().

Note:

perm can be NULL if a sorted permutation vector is not required.

Note:

This function is non blocking and executed asynchronously with respect to the host. It may return before the actual computation has finished.

Args:

handle (Pointer/object):: (undocumented)
m (int):: (undocumented)
n (int):: (undocumented)
nnz (int):: (undocumented)
cooRows (Pointer/object):: (undocumented)
cooCols (Pointer/object):: (undocumented)
P (Pointer/object):: (undocumented)
pBuffer (Pointer/object):: (undocumented)

hip.hipsparse.hipsparseSgebsr2gebsr_bufferSize(handle, dirA, int mb, int nb, int nnzb, descrA, bsrValA, bsrRowPtrA, bsrColIndA, int rowBlockDimA, int colBlockDimA, int rowBlockDimC, int colBlockDimC, bufferSize)#

This function computes the the size of the user allocated temporary storage buffer used when converting a sparse general BSR matrix to another sparse general BSR matrix.

hipsparseXgebsr2gebsr_bufferSize returns the size of the temporary storage buffer that is required by hipsparseXgebsr2gebsrNnz() and hipsparseXgebsr2gebsr(). The temporary storage buffer must be allocated by the user.

Args:

handle (Pointer/object):: (undocumented)
dirA (hipsparseDirection_t):: (undocumented)
mb (int):: (undocumented)
nb (int):: (undocumented)
nnzb (int):: (undocumented)
descrA (Pointer/object):: (undocumented)
bsrValA (Pointer/object):: (undocumented)
bsrRowPtrA (Pointer/object):: (undocumented)
bsrColIndA (Pointer/object):: (undocumented)
rowBlockDimA (int):: (undocumented)
colBlockDimA (int):: (undocumented)
rowBlockDimC (int):: (undocumented)
colBlockDimC (int):: (undocumented)
bufferSize (Pointer/object):: (undocumented)

hip.hipsparse.hipsparseDgebsr2gebsr_bufferSize(handle, dirA, int mb, int nb, int nnzb, descrA, bsrValA, bsrRowPtrA, bsrColIndA, int rowBlockDimA, int colBlockDimA, int rowBlockDimC, int colBlockDimC, bufferSize)#

(No short description, might be part of a group.)

Args:

handle (Pointer/object):: (undocumented)
dirA (hipsparseDirection_t):: (undocumented)
mb (int):: (undocumented)
nb (int):: (undocumented)
nnzb (int):: (undocumented)
descrA (Pointer/object):: (undocumented)
bsrValA (Pointer/object):: (undocumented)
bsrRowPtrA (Pointer/object):: (undocumented)
bsrColIndA (Pointer/object):: (undocumented)
rowBlockDimA (int):: (undocumented)
colBlockDimA (int):: (undocumented)
rowBlockDimC (int):: (undocumented)
colBlockDimC (int):: (undocumented)
bufferSize (Pointer/object):: (undocumented)

hip.hipsparse.hipsparseCgebsr2gebsr_bufferSize(handle, dirA, int mb, int nb, int nnzb, descrA, bsrValA, bsrRowPtrA, bsrColIndA, int rowBlockDimA, int colBlockDimA, int rowBlockDimC, int colBlockDimC, bufferSize)#

(No short description, might be part of a group.)

Args:

handle (Pointer/object):: (undocumented)
dirA (hipsparseDirection_t):: (undocumented)
mb (int):: (undocumented)
nb (int):: (undocumented)
nnzb (int):: (undocumented)
descrA (Pointer/object):: (undocumented)
bsrValA (float2/object):: (undocumented)
bsrRowPtrA (Pointer/object):: (undocumented)
bsrColIndA (Pointer/object):: (undocumented)
rowBlockDimA (int):: (undocumented)
colBlockDimA (int):: (undocumented)
rowBlockDimC (int):: (undocumented)
colBlockDimC (int):: (undocumented)
bufferSize (Pointer/object):: (undocumented)

hip.hipsparse.hipsparseZgebsr2gebsr_bufferSize(handle, dirA, int mb, int nb, int nnzb, descrA, bsrValA, bsrRowPtrA, bsrColIndA, int rowBlockDimA, int colBlockDimA, int rowBlockDimC, int colBlockDimC, bufferSize)#

(No short description, might be part of a group.)

Args:

handle (Pointer/object):: (undocumented)
dirA (hipsparseDirection_t):: (undocumented)
mb (int):: (undocumented)
nb (int):: (undocumented)
nnzb (int):: (undocumented)
descrA (Pointer/object):: (undocumented)
bsrValA (double2/object):: (undocumented)
bsrRowPtrA (Pointer/object):: (undocumented)
bsrColIndA (Pointer/object):: (undocumented)
rowBlockDimA (int):: (undocumented)
colBlockDimA (int):: (undocumented)
rowBlockDimC (int):: (undocumented)
colBlockDimC (int):: (undocumented)
bufferSize (Pointer/object):: (undocumented)

hip.hipsparse.hipsparseXgebsr2gebsrNnz(handle, dirA, int mb, int nb, int nnzb, descrA, bsrRowPtrA, bsrColIndA, int rowBlockDimA, int colBlockDimA, descrC, bsrRowPtrC, int rowBlockDimC, int colBlockDimC, nnzTotalDevHostPtr, buffer)#

This function is used when converting a general BSR sparse matrix A to another general BSR sparse matrix C. Specifically, this function determines the number of non-zero blocks that will exist in C (stored using either a host or device pointer), and computes the row pointer array for C.

The routine does support asynchronous execution.

Args:

handle (Pointer/object):: (undocumented)
dirA (hipsparseDirection_t):: (undocumented)
mb (int):: (undocumented)
nb (int):: (undocumented)
nnzb (int):: (undocumented)
descrA (Pointer/object):: (undocumented)
bsrRowPtrA (Pointer/object):: (undocumented)
bsrColIndA (Pointer/object):: (undocumented)
rowBlockDimA (int):: (undocumented)
colBlockDimA (int):: (undocumented)
descrC (Pointer/object):: (undocumented)
bsrRowPtrC (Pointer/object):: (undocumented)
rowBlockDimC (int):: (undocumented)
colBlockDimC (int):: (undocumented)
nnzTotalDevHostPtr (Pointer/object):: (undocumented)
buffer (Pointer/object):: (undocumented)

hip.hipsparse.hipsparseSgebsr2gebsr(handle, dirA, int mb, int nb, int nnzb, descrA, bsrValA, bsrRowPtrA, bsrColIndA, int rowBlockDimA, int colBlockDimA, descrC, bsrValC, bsrRowPtrC, bsrColIndC, int rowBlockDimC, int colBlockDimC, buffer)#

This function converts the general BSR sparse matrix A to another general BSR sparse matrix C.

The conversion uses three steps. First, the user calls hipsparseXgebsr2gebsr_bufferSize() to determine the size of the required temporary storage buffer. The user then allocates this buffer. Secondly, the user then allocates mb_C+1 integers for the row pointer array for C where mb_C=(m+row_block_dim_C-1)/row_block_dim_C. The user then calls hipsparseXgebsr2gebsrNnz() to fill in the row pointer array for C ( bsr_row_ptr_C ) and determine the number of non-zero blocks that will exist in C. Finally, the user allocates space for the colimn indices array of C to have nnzb_C elements and space for the values array of C to have nnzb_C*roc_block_dim_C*col_block_dim_C and then calls hipsparseXgebsr2gebsr() to complete the conversion.

Args:

handle (Pointer/object):: (undocumented)
dirA (hipsparseDirection_t):: (undocumented)
mb (int):: (undocumented)
nb (int):: (undocumented)
nnzb (int):: (undocumented)
descrA (Pointer/object):: (undocumented)
bsrValA (Pointer/object):: (undocumented)
bsrRowPtrA (Pointer/object):: (undocumented)
bsrColIndA (Pointer/object):: (undocumented)
rowBlockDimA (int):: (undocumented)
colBlockDimA (int):: (undocumented)
descrC (Pointer/object):: (undocumented)
bsrValC (Pointer/object):: (undocumented)
bsrRowPtrC (Pointer/object):: (undocumented)
bsrColIndC (Pointer/object):: (undocumented)
rowBlockDimC (int):: (undocumented)
colBlockDimC (int):: (undocumented)
buffer (Pointer/object):: (undocumented)

hip.hipsparse.hipsparseDgebsr2gebsr(handle, dirA, int mb, int nb, int nnzb, descrA, bsrValA, bsrRowPtrA, bsrColIndA, int rowBlockDimA, int colBlockDimA, descrC, bsrValC, bsrRowPtrC, bsrColIndC, int rowBlockDimC, int colBlockDimC, buffer)#

(No short description, might be part of a group.)

Args:

handle (Pointer/object):: (undocumented)
dirA (hipsparseDirection_t):: (undocumented)
mb (int):: (undocumented)
nb (int):: (undocumented)
nnzb (int):: (undocumented)
descrA (Pointer/object):: (undocumented)
bsrValA (Pointer/object):: (undocumented)
bsrRowPtrA (Pointer/object):: (undocumented)
bsrColIndA (Pointer/object):: (undocumented)
rowBlockDimA (int):: (undocumented)
colBlockDimA (int):: (undocumented)
descrC (Pointer/object):: (undocumented)
bsrValC (Pointer/object):: (undocumented)
bsrRowPtrC (Pointer/object):: (undocumented)
bsrColIndC (Pointer/object):: (undocumented)
rowBlockDimC (int):: (undocumented)
colBlockDimC (int):: (undocumented)
buffer (Pointer/object):: (undocumented)

hip.hipsparse.hipsparseCgebsr2gebsr(handle, dirA, int mb, int nb, int nnzb, descrA, bsrValA, bsrRowPtrA, bsrColIndA, int rowBlockDimA, int colBlockDimA, descrC, bsrValC, bsrRowPtrC, bsrColIndC, int rowBlockDimC, int colBlockDimC, buffer)#

(No short description, might be part of a group.)

Args:

handle (Pointer/object):: (undocumented)
dirA (hipsparseDirection_t):: (undocumented)
mb (int):: (undocumented)
nb (int):: (undocumented)
nnzb (int):: (undocumented)
descrA (Pointer/object):: (undocumented)
bsrValA (float2/object):: (undocumented)
bsrRowPtrA (Pointer/object):: (undocumented)
bsrColIndA (Pointer/object):: (undocumented)
rowBlockDimA (int):: (undocumented)
colBlockDimA (int):: (undocumented)
descrC (Pointer/object):: (undocumented)
bsrValC (float2/object):: (undocumented)
bsrRowPtrC (Pointer/object):: (undocumented)
bsrColIndC (Pointer/object):: (undocumented)
rowBlockDimC (int):: (undocumented)
colBlockDimC (int):: (undocumented)
buffer (Pointer/object):: (undocumented)

hip.hipsparse.hipsparseZgebsr2gebsr(handle, dirA, int mb, int nb, int nnzb, descrA, bsrValA, bsrRowPtrA, bsrColIndA, int rowBlockDimA, int colBlockDimA, descrC, bsrValC, bsrRowPtrC, bsrColIndC, int rowBlockDimC, int colBlockDimC, buffer)#

(No short description, might be part of a group.)

Args:

handle (Pointer/object):: (undocumented)
dirA (hipsparseDirection_t):: (undocumented)
mb (int):: (undocumented)
nb (int):: (undocumented)
nnzb (int):: (undocumented)
descrA (Pointer/object):: (undocumented)
bsrValA (double2/object):: (undocumented)
bsrRowPtrA (Pointer/object):: (undocumented)
bsrColIndA (Pointer/object):: (undocumented)
rowBlockDimA (int):: (undocumented)
colBlockDimA (int):: (undocumented)
descrC (Pointer/object):: (undocumented)
bsrValC (double2/object):: (undocumented)
bsrRowPtrC (Pointer/object):: (undocumented)
bsrColIndC (Pointer/object):: (undocumented)
rowBlockDimC (int):: (undocumented)
colBlockDimC (int):: (undocumented)
buffer (Pointer/object):: (undocumented)

hip.hipsparse.hipsparseScsru2csr_bufferSizeExt(handle, int m, int n, int nnz, csrVal, csrRowPtr, csrColInd, info, pBufferSizeInBytes)#

This function calculates the amount of temporary storage in bytes required for hipsparseXcsru2csr() and hipsparseXcsr2csru().

Args:

handle (Pointer/object):: (undocumented)
m (int):: (undocumented)
n (int):: (undocumented)
nnz (int):: (undocumented)
csrVal (Pointer/object):: (undocumented)
csrRowPtr (Pointer/object):: (undocumented)
csrColInd (Pointer/object):: (undocumented)
info (csru2csrInfo/object):: (undocumented)
pBufferSizeInBytes (Pointer/object):: (undocumented)

hip.hipsparse.hipsparseDcsru2csr_bufferSizeExt(handle, int m, int n, int nnz, csrVal, csrRowPtr, csrColInd, info, pBufferSizeInBytes)#

(No short description, might be part of a group.)

Args:

handle (Pointer/object):: (undocumented)
m (int):: (undocumented)
n (int):: (undocumented)
nnz (int):: (undocumented)
csrVal (Pointer/object):: (undocumented)
csrRowPtr (Pointer/object):: (undocumented)
csrColInd (Pointer/object):: (undocumented)
info (csru2csrInfo/object):: (undocumented)
pBufferSizeInBytes (Pointer/object):: (undocumented)

hip.hipsparse.hipsparseCcsru2csr_bufferSizeExt(handle, int m, int n, int nnz, csrVal, csrRowPtr, csrColInd, info, pBufferSizeInBytes)#

(No short description, might be part of a group.)

Args:

handle (Pointer/object):: (undocumented)
m (int):: (undocumented)
n (int):: (undocumented)
nnz (int):: (undocumented)
csrVal (float2/object):: (undocumented)
csrRowPtr (Pointer/object):: (undocumented)
csrColInd (Pointer/object):: (undocumented)
info (csru2csrInfo/object):: (undocumented)
pBufferSizeInBytes (Pointer/object):: (undocumented)

hip.hipsparse.hipsparseZcsru2csr_bufferSizeExt(handle, int m, int n, int nnz, csrVal, csrRowPtr, csrColInd, info, pBufferSizeInBytes)#

(No short description, might be part of a group.)

Args:

handle (Pointer/object):: (undocumented)
m (int):: (undocumented)
n (int):: (undocumented)
nnz (int):: (undocumented)
csrVal (double2/object):: (undocumented)
csrRowPtr (Pointer/object):: (undocumented)
csrColInd (Pointer/object):: (undocumented)
info (csru2csrInfo/object):: (undocumented)
pBufferSizeInBytes (Pointer/object):: (undocumented)

hip.hipsparse.hipsparseScsru2csr(handle, int m, int n, int nnz, descrA, csrVal, csrRowPtr, csrColInd, info, pBuffer)#

This function converts unsorted CSR format to sorted CSR format. The required temporary storage has to be allocated by the user.

Args:

handle (Pointer/object):: (undocumented)
m (int):: (undocumented)
n (int):: (undocumented)
nnz (int):: (undocumented)
descrA (Pointer/object):: (undocumented)
csrVal (Pointer/object):: (undocumented)
csrRowPtr (Pointer/object):: (undocumented)
csrColInd (Pointer/object):: (undocumented)
info (csru2csrInfo/object):: (undocumented)
pBuffer (Pointer/object):: (undocumented)

hip.hipsparse.hipsparseDcsru2csr(handle, int m, int n, int nnz, descrA, csrVal, csrRowPtr, csrColInd, info, pBuffer)#

(No short description, might be part of a group.)

Args:

handle (Pointer/object):: (undocumented)
m (int):: (undocumented)
n (int):: (undocumented)
nnz (int):: (undocumented)
descrA (Pointer/object):: (undocumented)
csrVal (Pointer/object):: (undocumented)
csrRowPtr (Pointer/object):: (undocumented)
csrColInd (Pointer/object):: (undocumented)
info (csru2csrInfo/object):: (undocumented)
pBuffer (Pointer/object):: (undocumented)

hip.hipsparse.hipsparseCcsru2csr(handle, int m, int n, int nnz, descrA, csrVal, csrRowPtr, csrColInd, info, pBuffer)#

(No short description, might be part of a group.)

Args:

handle (Pointer/object):: (undocumented)
m (int):: (undocumented)
n (int):: (undocumented)
nnz (int):: (undocumented)
descrA (Pointer/object):: (undocumented)
csrVal (float2/object):: (undocumented)
csrRowPtr (Pointer/object):: (undocumented)
csrColInd (Pointer/object):: (undocumented)
info (csru2csrInfo/object):: (undocumented)
pBuffer (Pointer/object):: (undocumented)

hip.hipsparse.hipsparseZcsru2csr(handle, int m, int n, int nnz, descrA, csrVal, csrRowPtr, csrColInd, info, pBuffer)#

(No short description, might be part of a group.)

Args:

handle (Pointer/object):: (undocumented)
m (int):: (undocumented)
n (int):: (undocumented)
nnz (int):: (undocumented)
descrA (Pointer/object):: (undocumented)
csrVal (double2/object):: (undocumented)
csrRowPtr (Pointer/object):: (undocumented)
csrColInd (Pointer/object):: (undocumented)
info (csru2csrInfo/object):: (undocumented)
pBuffer (Pointer/object):: (undocumented)

hip.hipsparse.hipsparseScsr2csru(handle, int m, int n, int nnz, descrA, csrVal, csrRowPtr, csrColInd, info, pBuffer)#

This function converts sorted CSR format to unsorted CSR format. The required temporary storage has to be allocated by the user.

Args:

handle (Pointer/object):: (undocumented)
m (int):: (undocumented)
n (int):: (undocumented)
nnz (int):: (undocumented)
descrA (Pointer/object):: (undocumented)
csrVal (Pointer/object):: (undocumented)
csrRowPtr (Pointer/object):: (undocumented)
csrColInd (Pointer/object):: (undocumented)
info (csru2csrInfo/object):: (undocumented)
pBuffer (Pointer/object):: (undocumented)

hip.hipsparse.hipsparseDcsr2csru(handle, int m, int n, int nnz, descrA, csrVal, csrRowPtr, csrColInd, info, pBuffer)#

(No short description, might be part of a group.)

Args:

handle (Pointer/object):: (undocumented)
m (int):: (undocumented)
n (int):: (undocumented)
nnz (int):: (undocumented)
descrA (Pointer/object):: (undocumented)
csrVal (Pointer/object):: (undocumented)
csrRowPtr (Pointer/object):: (undocumented)
csrColInd (Pointer/object):: (undocumented)
info (csru2csrInfo/object):: (undocumented)
pBuffer (Pointer/object):: (undocumented)

hip.hipsparse.hipsparseCcsr2csru(handle, int m, int n, int nnz, descrA, csrVal, csrRowPtr, csrColInd, info, pBuffer)#

(No short description, might be part of a group.)

Args:

handle (Pointer/object):: (undocumented)
m (int):: (undocumented)
n (int):: (undocumented)
nnz (int):: (undocumented)
descrA (Pointer/object):: (undocumented)
csrVal (float2/object):: (undocumented)
csrRowPtr (Pointer/object):: (undocumented)
csrColInd (Pointer/object):: (undocumented)
info (csru2csrInfo/object):: (undocumented)
pBuffer (Pointer/object):: (undocumented)

hip.hipsparse.hipsparseZcsr2csru(handle, int m, int n, int nnz, descrA, csrVal, csrRowPtr, csrColInd, info, pBuffer)#

(No short description, might be part of a group.)

Args:

handle (Pointer/object):: (undocumented)
m (int):: (undocumented)
n (int):: (undocumented)
nnz (int):: (undocumented)
descrA (Pointer/object):: (undocumented)
csrVal (double2/object):: (undocumented)
csrRowPtr (Pointer/object):: (undocumented)
csrColInd (Pointer/object):: (undocumented)
info (csru2csrInfo/object):: (undocumented)
pBuffer (Pointer/object):: (undocumented)

hip.hipsparse.hipsparseScsrcolor(handle, int m, int nnz, descrA, csrValA, csrRowPtrA, csrColIndA, fractionToColor, ncolors, coloring, reordering, info)#

Coloring of the adjacency graph of the matrix \(A\) stored in the CSR format.

hipsparseXcsrcolor performs the coloring of the undirected graph represented by the (symmetric) sparsity pattern of the matrix \(A\) stored in CSR format. Graph coloring is a way of coloring the nodes of a graph such that no two adjacent nodes are of the same color. The fraction_to_color is a parameter to only color a given percentage of the graph nodes, the remaining uncolored nodes receive distinct new colors. The optional reordering array is a permutation array such that unknowns of the same color are grouped. The matrix \(A\) must be stored as a general matrix with a symmetric sparsity pattern, and if the matrix \(A\) is non-symmetric then the user is responsible to provide the symmetric part \(\frac{A+A^T}{2}\).

Args:

handle (Pointer/object):: (undocumented)
m (int):: (undocumented)
nnz (int):: (undocumented)
descrA (Pointer/object):: (undocumented)
csrValA (Pointer/object):: (undocumented)
csrRowPtrA (Pointer/object):: (undocumented)
csrColIndA (Pointer/object):: (undocumented)
fractionToColor (Pointer/object):: (undocumented)
ncolors (Pointer/object):: (undocumented)
coloring (Pointer/object):: (undocumented)
reordering (Pointer/object):: (undocumented)
info (Pointer/object):: (undocumented)

hip.hipsparse.hipsparseDcsrcolor(handle, int m, int nnz, descrA, csrValA, csrRowPtrA, csrColIndA, fractionToColor, ncolors, coloring, reordering, info)#

(No short description, might be part of a group.)

Args:

handle (Pointer/object):: (undocumented)
m (int):: (undocumented)
nnz (int):: (undocumented)
descrA (Pointer/object):: (undocumented)
csrValA (Pointer/object):: (undocumented)
csrRowPtrA (Pointer/object):: (undocumented)
csrColIndA (Pointer/object):: (undocumented)
fractionToColor (Pointer/object):: (undocumented)
ncolors (Pointer/object):: (undocumented)
coloring (Pointer/object):: (undocumented)
reordering (Pointer/object):: (undocumented)
info (Pointer/object):: (undocumented)

hip.hipsparse.hipsparseCcsrcolor(handle, int m, int nnz, descrA, csrValA, csrRowPtrA, csrColIndA, fractionToColor, ncolors, coloring, reordering, info)#

(No short description, might be part of a group.)

Args:

handle (Pointer/object):: (undocumented)
m (int):: (undocumented)
nnz (int):: (undocumented)
descrA (Pointer/object):: (undocumented)
csrValA (float2/object):: (undocumented)
csrRowPtrA (Pointer/object):: (undocumented)
csrColIndA (Pointer/object):: (undocumented)
fractionToColor (Pointer/object):: (undocumented)
ncolors (Pointer/object):: (undocumented)
coloring (Pointer/object):: (undocumented)
reordering (Pointer/object):: (undocumented)
info (Pointer/object):: (undocumented)

hip.hipsparse.hipsparseZcsrcolor(handle, int m, int nnz, descrA, csrValA, csrRowPtrA, csrColIndA, fractionToColor, ncolors, coloring, reordering, info)#

(No short description, might be part of a group.)

Args:

handle (Pointer/object):: (undocumented)
m (int):: (undocumented)
nnz (int):: (undocumented)
descrA (Pointer/object):: (undocumented)
csrValA (double2/object):: (undocumented)
csrRowPtrA (Pointer/object):: (undocumented)
csrColIndA (Pointer/object):: (undocumented)
fractionToColor (Pointer/object):: (undocumented)
ncolors (Pointer/object):: (undocumented)
coloring (Pointer/object):: (undocumented)
reordering (Pointer/object):: (undocumented)
info (Pointer/object):: (undocumented)

class hip.hipsparse.hipsparseSpGEMMDescr#

Bases: Pointer

Python wrapper for cdef class chipsparse.hipsparseSpGEMMDescr.

If this type is initialized via its __init__ method, it allocates a member of the underlying C type and destroys it again if the wrapper type is deallocated.

This type also serves as adapter when appearing as argument type in a function signature. In this case, the type can further be initialized from a number of Python objects:

None:

This will set the self._ptr attribute to NULL.
int:

Interprets the integer value as pointer address and writes it to self._ptr. No ownership is transferred.
ctypes.c_void_p:

Takes the pointer address pyobj.value and writes it to self._ptr. No ownership is transferred.
object that implements the CUDA Array Interface protocol:

Takes the integer-valued pointer address, i.e. the first entry of the data tuple from pyobj’s member __cuda_array_interface__ and writes it to self._ptr.
object that implements the Python buffer protocol:

If the object represents a simple contiguous array, writes the Py_buffer associated with pyobj to self._py_buffer, sets the self._py_buffer_acquired flag to True, and writes self._py_buffer.buf to the data pointer self._ptr.
hip._util.types.Pointer:

Takes the pointer address pyobj._ptr and writes it to self._ptr. No ownership is transferred.

Type checks are performed in the above order.

C Attributes:

_ptr (C type void *, protected):: Stores a pointer to the data of the original Python object.
_is_ptr_owner (C type bint, protected):: If this wrapper is the owner of the underlying data.
_py_buffer (C type ``Py_buffer`, protected):: Stores a pointer to the data of the original Python object.
_py_buffer_acquired (C type bint, protected):: Stores a pointer to the data of the original Python object.

static PROPERTIES()#

__getitem__(key, /)#: Return self[key].

__init__()#

Constructor.

Args:

pyobj (object):: See the class description Pointer for information about accepted types for pyobj. Defaults to None.

Raises:

TypeError: If the input object pyobj is not of the right type.

as_c_void_p(self)#: Returns the data’s address as ctypes.c_void_p Note:

Implemented as function to not collide with autogenerated property names.

createRef(self) → Pointer#

Creates are reference to this pointer.

Returns a Pointer that stores the address of this `~.Pointer’s data pointer.

Note:: No ownership information is transferred.

static fromObj(pyobj)#

Creates a hipsparseSpGEMMDescr from a Python object.

Derives a hipsparseSpGEMMDescr from the given Python object pyobj. In case pyobj is itself an hipsparseSpGEMMDescr reference, this method returns it directly. No new hipsparseSpGEMMDescr is created in this case.

is_ptr_null#: If data pointer is NULL.

class hip.hipsparse.hipsparseSpSVDescr#

Bases: Pointer

Python wrapper for cdef class chipsparse.hipsparseSpSVDescr.

If this type is initialized via its __init__ method, it allocates a member of the underlying C type and destroys it again if the wrapper type is deallocated.

This type also serves as adapter when appearing as argument type in a function signature. In this case, the type can further be initialized from a number of Python objects:

None:

This will set the self._ptr attribute to NULL.
int:

Interprets the integer value as pointer address and writes it to self._ptr. No ownership is transferred.
ctypes.c_void_p:

Takes the pointer address pyobj.value and writes it to self._ptr. No ownership is transferred.
object that implements the CUDA Array Interface protocol:

Takes the integer-valued pointer address, i.e. the first entry of the data tuple from pyobj’s member __cuda_array_interface__ and writes it to self._ptr.
object that implements the Python buffer protocol:

If the object represents a simple contiguous array, writes the Py_buffer associated with pyobj to self._py_buffer, sets the self._py_buffer_acquired flag to True, and writes self._py_buffer.buf to the data pointer self._ptr.
hip._util.types.Pointer:

Takes the pointer address pyobj._ptr and writes it to self._ptr. No ownership is transferred.

Type checks are performed in the above order.

C Attributes:

_ptr (C type void *, protected):: Stores a pointer to the data of the original Python object.
_is_ptr_owner (C type bint, protected):: If this wrapper is the owner of the underlying data.
_py_buffer (C type ``Py_buffer`, protected):: Stores a pointer to the data of the original Python object.
_py_buffer_acquired (C type bint, protected):: Stores a pointer to the data of the original Python object.

static PROPERTIES()#

__getitem__(key, /)#: Return self[key].

__init__()#

Constructor.

Args:

pyobj (object):: See the class description Pointer for information about accepted types for pyobj. Defaults to None.

Raises:

TypeError: If the input object pyobj is not of the right type.

as_c_void_p(self)#: Returns the data’s address as ctypes.c_void_p Note:

Implemented as function to not collide with autogenerated property names.

createRef(self) → Pointer#

Creates are reference to this pointer.

Returns a Pointer that stores the address of this `~.Pointer’s data pointer.

Note:: No ownership information is transferred.

static fromObj(pyobj)#

Creates a hipsparseSpSVDescr from a Python object.

Derives a hipsparseSpSVDescr from the given Python object pyobj. In case pyobj is itself an hipsparseSpSVDescr reference, this method returns it directly. No new hipsparseSpSVDescr is created in this case.

is_ptr_null#: If data pointer is NULL.

class hip.hipsparse.hipsparseSpSMDescr#

Bases: Pointer

Python wrapper for cdef class chipsparse.hipsparseSpSMDescr.

If this type is initialized via its __init__ method, it allocates a member of the underlying C type and destroys it again if the wrapper type is deallocated.

This type also serves as adapter when appearing as argument type in a function signature. In this case, the type can further be initialized from a number of Python objects:

None:

This will set the self._ptr attribute to NULL.
int:

Interprets the integer value as pointer address and writes it to self._ptr. No ownership is transferred.
ctypes.c_void_p:

Takes the pointer address pyobj.value and writes it to self._ptr. No ownership is transferred.
object that implements the CUDA Array Interface protocol:

Takes the integer-valued pointer address, i.e. the first entry of the data tuple from pyobj’s member __cuda_array_interface__ and writes it to self._ptr.
object that implements the Python buffer protocol:

If the object represents a simple contiguous array, writes the Py_buffer associated with pyobj to self._py_buffer, sets the self._py_buffer_acquired flag to True, and writes self._py_buffer.buf to the data pointer self._ptr.
hip._util.types.Pointer:

Takes the pointer address pyobj._ptr and writes it to self._ptr. No ownership is transferred.

Type checks are performed in the above order.

C Attributes:

_ptr (C type void *, protected):: Stores a pointer to the data of the original Python object.
_is_ptr_owner (C type bint, protected):: If this wrapper is the owner of the underlying data.
_py_buffer (C type ``Py_buffer`, protected):: Stores a pointer to the data of the original Python object.
_py_buffer_acquired (C type bint, protected):: Stores a pointer to the data of the original Python object.

static PROPERTIES()#

__getitem__(key, /)#: Return self[key].

__init__()#

Constructor.

Args:

pyobj (object):: See the class description Pointer for information about accepted types for pyobj. Defaults to None.

Raises:

TypeError: If the input object pyobj is not of the right type.

as_c_void_p(self)#: Returns the data’s address as ctypes.c_void_p Note:

Implemented as function to not collide with autogenerated property names.

createRef(self) → Pointer#

Creates are reference to this pointer.

Returns a Pointer that stores the address of this `~.Pointer’s data pointer.

Note:: No ownership information is transferred.

static fromObj(pyobj)#

Creates a hipsparseSpSMDescr from a Python object.

Derives a hipsparseSpSMDescr from the given Python object pyobj. In case pyobj is itself an hipsparseSpSMDescr reference, this method returns it directly. No new hipsparseSpSMDescr is created in this case.

is_ptr_null#: If data pointer is NULL.

hip.hipsparse.hipsparseSpGEMMDescr_t#: alias of hipsparseSpGEMMDescr

hip.hipsparse.hipsparseSpSVDescr_t#: alias of hipsparseSpSVDescr

hip.hipsparse.hipsparseSpSMDescr_t#: alias of hipsparseSpSMDescr

class hip.hipsparse.hipsparseFormat_t(value)#

Bases: _hipsparseFormat_t__Base

Attributes:

HIPSPARSE_FORMAT_CSR:: (undocumented)
HIPSPARSE_FORMAT_CSC:: (undocumented)
HIPSPARSE_FORMAT_COO:: (undocumented)
HIPSPARSE_FORMAT_COO_AOS:: (undocumented)
HIPSPARSE_FORMAT_BLOCKED_ELL:: (undocumented)

conjugate()#: Returns self, the complex conjugate of any int.

bit_length()#

Number of bits necessary to represent self in binary.

>>> bin(37)
'0b100101'
>>> (37).bit_length()
6

bit_count()#

Number of ones in the binary representation of the absolute value of self.

Also known as the population count.

>>> bin(13)
'0b1101'
>>> (13).bit_count()
3

to_bytes(length, byteorder, *, signed=False)#

Return an array of bytes representing an integer.

length: Length of bytes object to use. An OverflowError is raised if the integer is not representable with the given number of bytes.
byteorder: The byte order used to represent the integer. If byteorder is ‘big’, the most significant byte is at the beginning of the byte array. If byteorder is ‘little’, the most significant byte is at the end of the byte array. To request the native byte order of the host system, use `sys.byteorder’ as the byte order value.
signed: Determines whether two’s complement is used to represent the integer. If signed is False and a negative integer is given, an OverflowError is raised.

from_bytes(byteorder, *, signed=False)#

Return the integer represented by the given array of bytes.

bytes: Holds the array of bytes to convert. The argument must either support the buffer protocol or be an iterable object producing bytes. Bytes and bytearray are examples of built-in objects that support the buffer protocol.
byteorder: The byte order used to represent the integer. If byteorder is ‘big’, the most significant byte is at the beginning of the byte array. If byteorder is ‘little’, the most significant byte is at the end of the byte array. To request the native byte order of the host system, use `sys.byteorder’ as the byte order value.
signed: Indicates whether two’s complement is used to represent the integer.

as_integer_ratio()#

Return integer ratio.

Return a pair of integers, whose ratio is exactly equal to the original int and with a positive denominator.

>>> (10).as_integer_ratio()
(10, 1)
>>> (-10).as_integer_ratio()
(-10, 1)
>>> (0).as_integer_ratio()
(0, 1)

real#: the real part of a complex number

imag#: the imaginary part of a complex number

numerator#: the numerator of a rational number in lowest terms

denominator#: the denominator of a rational number in lowest terms

static ctypes_type()#: The type of the enum constants as ctypes type.

HIPSPARSE_FORMAT_CSR = 1#

HIPSPARSE_FORMAT_CSC = 2#

HIPSPARSE_FORMAT_COO = 3#

HIPSPARSE_FORMAT_COO_AOS = 4#

HIPSPARSE_FORMAT_BLOCKED_ELL = 5#

class hip.hipsparse.hipsparseOrder_t(value)#

Bases: _hipsparseOrder_t__Base

Attributes:

HIPSPARSE_ORDER_COLUMN:: (undocumented)
HIPSPARSE_ORDER_COL:: Column major
HIPSPARSE_ORDER_ROW:: Row major

conjugate()#: Returns self, the complex conjugate of any int.

bit_length()#

Number of bits necessary to represent self in binary.

>>> bin(37)
'0b100101'
>>> (37).bit_length()
6

bit_count()#

Number of ones in the binary representation of the absolute value of self.

Also known as the population count.

>>> bin(13)
'0b1101'
>>> (13).bit_count()
3

to_bytes(length, byteorder, *, signed=False)#

Return an array of bytes representing an integer.

length: Length of bytes object to use. An OverflowError is raised if the integer is not representable with the given number of bytes.
byteorder: The byte order used to represent the integer. If byteorder is ‘big’, the most significant byte is at the beginning of the byte array. If byteorder is ‘little’, the most significant byte is at the end of the byte array. To request the native byte order of the host system, use `sys.byteorder’ as the byte order value.
signed: Determines whether two’s complement is used to represent the integer. If signed is False and a negative integer is given, an OverflowError is raised.

from_bytes(byteorder, *, signed=False)#

Return the integer represented by the given array of bytes.

bytes: Holds the array of bytes to convert. The argument must either support the buffer protocol or be an iterable object producing bytes. Bytes and bytearray are examples of built-in objects that support the buffer protocol.
byteorder: The byte order used to represent the integer. If byteorder is ‘big’, the most significant byte is at the beginning of the byte array. If byteorder is ‘little’, the most significant byte is at the end of the byte array. To request the native byte order of the host system, use `sys.byteorder’ as the byte order value.
signed: Indicates whether two’s complement is used to represent the integer.

as_integer_ratio()#

Return integer ratio.

Return a pair of integers, whose ratio is exactly equal to the original int and with a positive denominator.

>>> (10).as_integer_ratio()
(10, 1)
>>> (-10).as_integer_ratio()
(-10, 1)
>>> (0).as_integer_ratio()
(0, 1)

real#: the real part of a complex number

imag#: the imaginary part of a complex number

numerator#: the numerator of a rational number in lowest terms

denominator#: the denominator of a rational number in lowest terms

static ctypes_type()#: The type of the enum constants as ctypes type.

HIPSPARSE_ORDER_COLUMN = 1#

HIPSPARSE_ORDER_COL = 1#

HIPSPARSE_ORDER_ROW = 2#

class hip.hipsparse.hipsparseIndexType_t(value)#

Bases: _hipsparseIndexType_t__Base

Attributes:

HIPSPARSE_INDEX_16U:: 16 bit unsigned integer indices
HIPSPARSE_INDEX_32I:: 32 bit signed integer indices
HIPSPARSE_INDEX_64I:: 64 bit signed integer indices

conjugate()#: Returns self, the complex conjugate of any int.

bit_length()#

Number of bits necessary to represent self in binary.

>>> bin(37)
'0b100101'
>>> (37).bit_length()
6

bit_count()#

Number of ones in the binary representation of the absolute value of self.

Also known as the population count.

>>> bin(13)
'0b1101'
>>> (13).bit_count()
3

to_bytes(length, byteorder, *, signed=False)#

Return an array of bytes representing an integer.

length: Length of bytes object to use. An OverflowError is raised if the integer is not representable with the given number of bytes.
byteorder: The byte order used to represent the integer. If byteorder is ‘big’, the most significant byte is at the beginning of the byte array. If byteorder is ‘little’, the most significant byte is at the end of the byte array. To request the native byte order of the host system, use `sys.byteorder’ as the byte order value.
signed: Determines whether two’s complement is used to represent the integer. If signed is False and a negative integer is given, an OverflowError is raised.

from_bytes(byteorder, *, signed=False)#

Return the integer represented by the given array of bytes.

bytes: Holds the array of bytes to convert. The argument must either support the buffer protocol or be an iterable object producing bytes. Bytes and bytearray are examples of built-in objects that support the buffer protocol.
byteorder: The byte order used to represent the integer. If byteorder is ‘big’, the most significant byte is at the beginning of the byte array. If byteorder is ‘little’, the most significant byte is at the end of the byte array. To request the native byte order of the host system, use `sys.byteorder’ as the byte order value.
signed: Indicates whether two’s complement is used to represent the integer.

as_integer_ratio()#

Return integer ratio.

Return a pair of integers, whose ratio is exactly equal to the original int and with a positive denominator.

>>> (10).as_integer_ratio()
(10, 1)
>>> (-10).as_integer_ratio()
(-10, 1)
>>> (0).as_integer_ratio()
(0, 1)

real#: the real part of a complex number

imag#: the imaginary part of a complex number

numerator#: the numerator of a rational number in lowest terms

denominator#: the denominator of a rational number in lowest terms

static ctypes_type()#: The type of the enum constants as ctypes type.

HIPSPARSE_INDEX_16U = 1#

HIPSPARSE_INDEX_32I = 2#

HIPSPARSE_INDEX_64I = 3#

class hip.hipsparse.hipsparseSpMVAlg_t(value)#

Bases: _hipsparseSpMVAlg_t__Base

Attributes:

HIPSPARSE_MV_ALG_DEFAULT:: (undocumented)
HIPSPARSE_COOMV_ALG:: (undocumented)
HIPSPARSE_CSRMV_ALG1:: (undocumented)
HIPSPARSE_CSRMV_ALG2:: (undocumented)
HIPSPARSE_SPMV_ALG_DEFAULT:: (undocumented)
HIPSPARSE_SPMV_COO_ALG1:: (undocumented)
HIPSPARSE_SPMV_CSR_ALG1:: (undocumented)
HIPSPARSE_SPMV_CSR_ALG2:: (undocumented)
HIPSPARSE_SPMV_COO_ALG2:: (undocumented)

conjugate()#: Returns self, the complex conjugate of any int.

bit_length()#

Number of bits necessary to represent self in binary.

>>> bin(37)
'0b100101'
>>> (37).bit_length()
6

bit_count()#

Number of ones in the binary representation of the absolute value of self.

Also known as the population count.

>>> bin(13)
'0b1101'
>>> (13).bit_count()
3

to_bytes(length, byteorder, *, signed=False)#

Return an array of bytes representing an integer.

length: Length of bytes object to use. An OverflowError is raised if the integer is not representable with the given number of bytes.
byteorder: The byte order used to represent the integer. If byteorder is ‘big’, the most significant byte is at the beginning of the byte array. If byteorder is ‘little’, the most significant byte is at the end of the byte array. To request the native byte order of the host system, use `sys.byteorder’ as the byte order value.
signed: Determines whether two’s complement is used to represent the integer. If signed is False and a negative integer is given, an OverflowError is raised.

from_bytes(byteorder, *, signed=False)#

Return the integer represented by the given array of bytes.

bytes: Holds the array of bytes to convert. The argument must either support the buffer protocol or be an iterable object producing bytes. Bytes and bytearray are examples of built-in objects that support the buffer protocol.
byteorder: The byte order used to represent the integer. If byteorder is ‘big’, the most significant byte is at the beginning of the byte array. If byteorder is ‘little’, the most significant byte is at the end of the byte array. To request the native byte order of the host system, use `sys.byteorder’ as the byte order value.
signed: Indicates whether two’s complement is used to represent the integer.

as_integer_ratio()#

Return integer ratio.

Return a pair of integers, whose ratio is exactly equal to the original int and with a positive denominator.

>>> (10).as_integer_ratio()
(10, 1)
>>> (-10).as_integer_ratio()
(-10, 1)
>>> (0).as_integer_ratio()
(0, 1)

real#: the real part of a complex number

imag#: the imaginary part of a complex number

numerator#: the numerator of a rational number in lowest terms

denominator#: the denominator of a rational number in lowest terms

static ctypes_type()#: The type of the enum constants as ctypes type.

HIPSPARSE_MV_ALG_DEFAULT = 0#

HIPSPARSE_COOMV_ALG = 1#

HIPSPARSE_CSRMV_ALG1 = 2#

HIPSPARSE_CSRMV_ALG2 = 3#

HIPSPARSE_SPMV_ALG_DEFAULT = 0#

HIPSPARSE_SPMV_COO_ALG1 = 1#

HIPSPARSE_SPMV_CSR_ALG1 = 2#

HIPSPARSE_SPMV_CSR_ALG2 = 3#

HIPSPARSE_SPMV_COO_ALG2 = 4#

class hip.hipsparse.hipsparseSpMMAlg_t(value)#

Bases: _hipsparseSpMMAlg_t__Base

Attributes:

HIPSPARSE_MM_ALG_DEFAULT:: (undocumented)
HIPSPARSE_COOMM_ALG1:: (undocumented)
HIPSPARSE_COOMM_ALG2:: (undocumented)
HIPSPARSE_COOMM_ALG3:: (undocumented)
HIPSPARSE_CSRMM_ALG1:: (undocumented)
HIPSPARSE_SPMM_ALG_DEFAULT:: (undocumented)
HIPSPARSE_SPMM_COO_ALG1:: (undocumented)
HIPSPARSE_SPMM_COO_ALG2:: (undocumented)
HIPSPARSE_SPMM_COO_ALG3:: (undocumented)
HIPSPARSE_SPMM_COO_ALG4:: (undocumented)
HIPSPARSE_SPMM_CSR_ALG1:: (undocumented)
HIPSPARSE_SPMM_CSR_ALG2:: (undocumented)
HIPSPARSE_SPMM_CSR_ALG3:: (undocumented)
HIPSPARSE_SPMM_BLOCKED_ELL_ALG1:: (undocumented)

conjugate()#: Returns self, the complex conjugate of any int.

bit_length()#

Number of bits necessary to represent self in binary.

>>> bin(37)
'0b100101'
>>> (37).bit_length()
6

bit_count()#

Number of ones in the binary representation of the absolute value of self.

Also known as the population count.

>>> bin(13)
'0b1101'
>>> (13).bit_count()
3

to_bytes(length, byteorder, *, signed=False)#

Return an array of bytes representing an integer.

length: Length of bytes object to use. An OverflowError is raised if the integer is not representable with the given number of bytes.
byteorder: The byte order used to represent the integer. If byteorder is ‘big’, the most significant byte is at the beginning of the byte array. If byteorder is ‘little’, the most significant byte is at the end of the byte array. To request the native byte order of the host system, use `sys.byteorder’ as the byte order value.
signed: Determines whether two’s complement is used to represent the integer. If signed is False and a negative integer is given, an OverflowError is raised.

from_bytes(byteorder, *, signed=False)#

Return the integer represented by the given array of bytes.

bytes: Holds the array of bytes to convert. The argument must either support the buffer protocol or be an iterable object producing bytes. Bytes and bytearray are examples of built-in objects that support the buffer protocol.
byteorder: The byte order used to represent the integer. If byteorder is ‘big’, the most significant byte is at the beginning of the byte array. If byteorder is ‘little’, the most significant byte is at the end of the byte array. To request the native byte order of the host system, use `sys.byteorder’ as the byte order value.
signed: Indicates whether two’s complement is used to represent the integer.

as_integer_ratio()#

Return integer ratio.

Return a pair of integers, whose ratio is exactly equal to the original int and with a positive denominator.

>>> (10).as_integer_ratio()
(10, 1)
>>> (-10).as_integer_ratio()
(-10, 1)
>>> (0).as_integer_ratio()
(0, 1)

real#: the real part of a complex number

imag#: the imaginary part of a complex number

numerator#: the numerator of a rational number in lowest terms

denominator#: the denominator of a rational number in lowest terms

static ctypes_type()#: The type of the enum constants as ctypes type.

HIPSPARSE_MM_ALG_DEFAULT = 0#

HIPSPARSE_COOMM_ALG1 = 1#

HIPSPARSE_COOMM_ALG2 = 2#

HIPSPARSE_COOMM_ALG3 = 3#

HIPSPARSE_CSRMM_ALG1 = 4#

HIPSPARSE_SPMM_ALG_DEFAULT = 0#

HIPSPARSE_SPMM_COO_ALG1 = 1#

HIPSPARSE_SPMM_COO_ALG2 = 2#

HIPSPARSE_SPMM_COO_ALG3 = 3#

HIPSPARSE_SPMM_COO_ALG4 = 5#

HIPSPARSE_SPMM_CSR_ALG1 = 4#

HIPSPARSE_SPMM_CSR_ALG2 = 6#

HIPSPARSE_SPMM_CSR_ALG3 = 12#

HIPSPARSE_SPMM_BLOCKED_ELL_ALG1 = 13#

class hip.hipsparse.hipsparseSparseToDenseAlg_t(value)#

Bases: _hipsparseSparseToDenseAlg_t__Base

Attributes:

HIPSPARSE_SPARSETODENSE_ALG_DEFAULT:: (undocumented)

conjugate()#: Returns self, the complex conjugate of any int.

bit_length()#

Number of bits necessary to represent self in binary.

>>> bin(37)
'0b100101'
>>> (37).bit_length()
6

bit_count()#

Number of ones in the binary representation of the absolute value of self.

Also known as the population count.

>>> bin(13)
'0b1101'
>>> (13).bit_count()
3

to_bytes(length, byteorder, *, signed=False)#

Return an array of bytes representing an integer.

length: Length of bytes object to use. An OverflowError is raised if the integer is not representable with the given number of bytes.
byteorder: The byte order used to represent the integer. If byteorder is ‘big’, the most significant byte is at the beginning of the byte array. If byteorder is ‘little’, the most significant byte is at the end of the byte array. To request the native byte order of the host system, use `sys.byteorder’ as the byte order value.
signed: Determines whether two’s complement is used to represent the integer. If signed is False and a negative integer is given, an OverflowError is raised.

from_bytes(byteorder, *, signed=False)#

Return the integer represented by the given array of bytes.

bytes: Holds the array of bytes to convert. The argument must either support the buffer protocol or be an iterable object producing bytes. Bytes and bytearray are examples of built-in objects that support the buffer protocol.
byteorder: The byte order used to represent the integer. If byteorder is ‘big’, the most significant byte is at the beginning of the byte array. If byteorder is ‘little’, the most significant byte is at the end of the byte array. To request the native byte order of the host system, use `sys.byteorder’ as the byte order value.
signed: Indicates whether two’s complement is used to represent the integer.

as_integer_ratio()#

Return integer ratio.

Return a pair of integers, whose ratio is exactly equal to the original int and with a positive denominator.

>>> (10).as_integer_ratio()
(10, 1)
>>> (-10).as_integer_ratio()
(-10, 1)
>>> (0).as_integer_ratio()
(0, 1)

real#: the real part of a complex number

imag#: the imaginary part of a complex number

numerator#: the numerator of a rational number in lowest terms

denominator#: the denominator of a rational number in lowest terms

static ctypes_type()#: The type of the enum constants as ctypes type.

HIPSPARSE_SPARSETODENSE_ALG_DEFAULT = 0#

class hip.hipsparse.hipsparseDenseToSparseAlg_t(value)#

Bases: _hipsparseDenseToSparseAlg_t__Base

Attributes:

HIPSPARSE_DENSETOSPARSE_ALG_DEFAULT:: (undocumented)

conjugate()#: Returns self, the complex conjugate of any int.

bit_length()#

Number of bits necessary to represent self in binary.

>>> bin(37)
'0b100101'
>>> (37).bit_length()
6

bit_count()#

Number of ones in the binary representation of the absolute value of self.

Also known as the population count.

>>> bin(13)
'0b1101'
>>> (13).bit_count()
3

to_bytes(length, byteorder, *, signed=False)#

Return an array of bytes representing an integer.

length: Length of bytes object to use. An OverflowError is raised if the integer is not representable with the given number of bytes.
byteorder: The byte order used to represent the integer. If byteorder is ‘big’, the most significant byte is at the beginning of the byte array. If byteorder is ‘little’, the most significant byte is at the end of the byte array. To request the native byte order of the host system, use `sys.byteorder’ as the byte order value.
signed: Determines whether two’s complement is used to represent the integer. If signed is False and a negative integer is given, an OverflowError is raised.

from_bytes(byteorder, *, signed=False)#

Return the integer represented by the given array of bytes.

bytes: Holds the array of bytes to convert. The argument must either support the buffer protocol or be an iterable object producing bytes. Bytes and bytearray are examples of built-in objects that support the buffer protocol.
byteorder: The byte order used to represent the integer. If byteorder is ‘big’, the most significant byte is at the beginning of the byte array. If byteorder is ‘little’, the most significant byte is at the end of the byte array. To request the native byte order of the host system, use `sys.byteorder’ as the byte order value.
signed: Indicates whether two’s complement is used to represent the integer.

as_integer_ratio()#

Return integer ratio.

Return a pair of integers, whose ratio is exactly equal to the original int and with a positive denominator.

>>> (10).as_integer_ratio()
(10, 1)
>>> (-10).as_integer_ratio()
(-10, 1)
>>> (0).as_integer_ratio()
(0, 1)

real#: the real part of a complex number

imag#: the imaginary part of a complex number

numerator#: the numerator of a rational number in lowest terms

denominator#: the denominator of a rational number in lowest terms

static ctypes_type()#: The type of the enum constants as ctypes type.

HIPSPARSE_DENSETOSPARSE_ALG_DEFAULT = 0#

class hip.hipsparse.hipsparseSDDMMAlg_t(value)#

Bases: _hipsparseSDDMMAlg_t__Base

Attributes:

HIPSPARSE_SDDMM_ALG_DEFAULT:: (undocumented)

conjugate()#: Returns self, the complex conjugate of any int.

bit_length()#

Number of bits necessary to represent self in binary.

>>> bin(37)
'0b100101'
>>> (37).bit_length()
6

bit_count()#

Number of ones in the binary representation of the absolute value of self.

Also known as the population count.

>>> bin(13)
'0b1101'
>>> (13).bit_count()
3

to_bytes(length, byteorder, *, signed=False)#

Return an array of bytes representing an integer.

length: Length of bytes object to use. An OverflowError is raised if the integer is not representable with the given number of bytes.
byteorder: The byte order used to represent the integer. If byteorder is ‘big’, the most significant byte is at the beginning of the byte array. If byteorder is ‘little’, the most significant byte is at the end of the byte array. To request the native byte order of the host system, use `sys.byteorder’ as the byte order value.
signed: Determines whether two’s complement is used to represent the integer. If signed is False and a negative integer is given, an OverflowError is raised.

from_bytes(byteorder, *, signed=False)#

Return the integer represented by the given array of bytes.

bytes: Holds the array of bytes to convert. The argument must either support the buffer protocol or be an iterable object producing bytes. Bytes and bytearray are examples of built-in objects that support the buffer protocol.
byteorder: The byte order used to represent the integer. If byteorder is ‘big’, the most significant byte is at the beginning of the byte array. If byteorder is ‘little’, the most significant byte is at the end of the byte array. To request the native byte order of the host system, use `sys.byteorder’ as the byte order value.
signed: Indicates whether two’s complement is used to represent the integer.

as_integer_ratio()#

Return integer ratio.

Return a pair of integers, whose ratio is exactly equal to the original int and with a positive denominator.

>>> (10).as_integer_ratio()
(10, 1)
>>> (-10).as_integer_ratio()
(-10, 1)
>>> (0).as_integer_ratio()
(0, 1)

real#: the real part of a complex number

imag#: the imaginary part of a complex number

numerator#: the numerator of a rational number in lowest terms

denominator#: the denominator of a rational number in lowest terms

static ctypes_type()#: The type of the enum constants as ctypes type.

HIPSPARSE_SDDMM_ALG_DEFAULT = 0#

class hip.hipsparse.hipsparseSpSVAlg_t(value)#

Bases: _hipsparseSpSVAlg_t__Base

Attributes:

HIPSPARSE_SPSV_ALG_DEFAULT:: (undocumented)

conjugate()#: Returns self, the complex conjugate of any int.

bit_length()#

Number of bits necessary to represent self in binary.

>>> bin(37)
'0b100101'
>>> (37).bit_length()
6

bit_count()#

Number of ones in the binary representation of the absolute value of self.

Also known as the population count.

>>> bin(13)
'0b1101'
>>> (13).bit_count()
3

to_bytes(length, byteorder, *, signed=False)#

Return an array of bytes representing an integer.

length: Length of bytes object to use. An OverflowError is raised if the integer is not representable with the given number of bytes.
byteorder: The byte order used to represent the integer. If byteorder is ‘big’, the most significant byte is at the beginning of the byte array. If byteorder is ‘little’, the most significant byte is at the end of the byte array. To request the native byte order of the host system, use `sys.byteorder’ as the byte order value.
signed: Determines whether two’s complement is used to represent the integer. If signed is False and a negative integer is given, an OverflowError is raised.

from_bytes(byteorder, *, signed=False)#

Return the integer represented by the given array of bytes.

bytes: Holds the array of bytes to convert. The argument must either support the buffer protocol or be an iterable object producing bytes. Bytes and bytearray are examples of built-in objects that support the buffer protocol.
byteorder: The byte order used to represent the integer. If byteorder is ‘big’, the most significant byte is at the beginning of the byte array. If byteorder is ‘little’, the most significant byte is at the end of the byte array. To request the native byte order of the host system, use `sys.byteorder’ as the byte order value.
signed: Indicates whether two’s complement is used to represent the integer.

as_integer_ratio()#

Return integer ratio.

Return a pair of integers, whose ratio is exactly equal to the original int and with a positive denominator.

>>> (10).as_integer_ratio()
(10, 1)
>>> (-10).as_integer_ratio()
(-10, 1)
>>> (0).as_integer_ratio()
(0, 1)

real#: the real part of a complex number

imag#: the imaginary part of a complex number

numerator#: the numerator of a rational number in lowest terms

denominator#: the denominator of a rational number in lowest terms

static ctypes_type()#: The type of the enum constants as ctypes type.

HIPSPARSE_SPSV_ALG_DEFAULT = 0#

class hip.hipsparse.hipsparseSpSMAlg_t(value)#

Bases: _hipsparseSpSMAlg_t__Base

Attributes:

HIPSPARSE_SPSM_ALG_DEFAULT:: (undocumented)

conjugate()#: Returns self, the complex conjugate of any int.

bit_length()#

Number of bits necessary to represent self in binary.

>>> bin(37)
'0b100101'
>>> (37).bit_length()
6

bit_count()#

Number of ones in the binary representation of the absolute value of self.

Also known as the population count.

>>> bin(13)
'0b1101'
>>> (13).bit_count()
3

to_bytes(length, byteorder, *, signed=False)#

Return an array of bytes representing an integer.

length: Length of bytes object to use. An OverflowError is raised if the integer is not representable with the given number of bytes.
byteorder: The byte order used to represent the integer. If byteorder is ‘big’, the most significant byte is at the beginning of the byte array. If byteorder is ‘little’, the most significant byte is at the end of the byte array. To request the native byte order of the host system, use `sys.byteorder’ as the byte order value.
signed: Determines whether two’s complement is used to represent the integer. If signed is False and a negative integer is given, an OverflowError is raised.

from_bytes(byteorder, *, signed=False)#

Return the integer represented by the given array of bytes.

bytes: Holds the array of bytes to convert. The argument must either support the buffer protocol or be an iterable object producing bytes. Bytes and bytearray are examples of built-in objects that support the buffer protocol.
byteorder: The byte order used to represent the integer. If byteorder is ‘big’, the most significant byte is at the beginning of the byte array. If byteorder is ‘little’, the most significant byte is at the end of the byte array. To request the native byte order of the host system, use `sys.byteorder’ as the byte order value.
signed: Indicates whether two’s complement is used to represent the integer.

as_integer_ratio()#

Return integer ratio.

Return a pair of integers, whose ratio is exactly equal to the original int and with a positive denominator.

>>> (10).as_integer_ratio()
(10, 1)
>>> (-10).as_integer_ratio()
(-10, 1)
>>> (0).as_integer_ratio()
(0, 1)

real#: the real part of a complex number

imag#: the imaginary part of a complex number

numerator#: the numerator of a rational number in lowest terms

denominator#: the denominator of a rational number in lowest terms

static ctypes_type()#: The type of the enum constants as ctypes type.

HIPSPARSE_SPSM_ALG_DEFAULT = 0#

class hip.hipsparse.hipsparseSpMatAttribute_t(value)#

Bases: _hipsparseSpMatAttribute_t__Base

Attributes:

HIPSPARSE_SPMAT_FILL_MODE:: Fill mode attribute
HIPSPARSE_SPMAT_DIAG_TYPE:: Diag type attribute

conjugate()#: Returns self, the complex conjugate of any int.

bit_length()#

Number of bits necessary to represent self in binary.

>>> bin(37)
'0b100101'
>>> (37).bit_length()
6

bit_count()#

Number of ones in the binary representation of the absolute value of self.

Also known as the population count.

>>> bin(13)
'0b1101'
>>> (13).bit_count()
3

to_bytes(length, byteorder, *, signed=False)#

Return an array of bytes representing an integer.

length: Length of bytes object to use. An OverflowError is raised if the integer is not representable with the given number of bytes.
byteorder: The byte order used to represent the integer. If byteorder is ‘big’, the most significant byte is at the beginning of the byte array. If byteorder is ‘little’, the most significant byte is at the end of the byte array. To request the native byte order of the host system, use `sys.byteorder’ as the byte order value.
signed: Determines whether two’s complement is used to represent the integer. If signed is False and a negative integer is given, an OverflowError is raised.

from_bytes(byteorder, *, signed=False)#

Return the integer represented by the given array of bytes.

bytes: Holds the array of bytes to convert. The argument must either support the buffer protocol or be an iterable object producing bytes. Bytes and bytearray are examples of built-in objects that support the buffer protocol.
byteorder: The byte order used to represent the integer. If byteorder is ‘big’, the most significant byte is at the beginning of the byte array. If byteorder is ‘little’, the most significant byte is at the end of the byte array. To request the native byte order of the host system, use `sys.byteorder’ as the byte order value.
signed: Indicates whether two’s complement is used to represent the integer.

as_integer_ratio()#

Return integer ratio.

Return a pair of integers, whose ratio is exactly equal to the original int and with a positive denominator.

>>> (10).as_integer_ratio()
(10, 1)
>>> (-10).as_integer_ratio()
(-10, 1)
>>> (0).as_integer_ratio()
(0, 1)

real#: the real part of a complex number

imag#: the imaginary part of a complex number

numerator#: the numerator of a rational number in lowest terms

denominator#: the denominator of a rational number in lowest terms

static ctypes_type()#: The type of the enum constants as ctypes type.

HIPSPARSE_SPMAT_FILL_MODE = 0#

HIPSPARSE_SPMAT_DIAG_TYPE = 1#

class hip.hipsparse.hipsparseSpGEMMAlg_t(value)#

Bases: _hipsparseSpGEMMAlg_t__Base

Attributes:

HIPSPARSE_SPGEMM_DEFAULT:: (undocumented)
HIPSPARSE_SPGEMM_CSR_ALG_DETERMINISTIC:: (undocumented)
HIPSPARSE_SPGEMM_CSR_ALG_NONDETERMINISTIC:: (undocumented)
HIPSPARSE_SPGEMM_ALG1:: (undocumented)
HIPSPARSE_SPGEMM_ALG2:: (undocumented)
HIPSPARSE_SPGEMM_ALG3:: (undocumented)

conjugate()#: Returns self, the complex conjugate of any int.

bit_length()#

Number of bits necessary to represent self in binary.

>>> bin(37)
'0b100101'
>>> (37).bit_length()
6

bit_count()#

Number of ones in the binary representation of the absolute value of self.

Also known as the population count.

>>> bin(13)
'0b1101'
>>> (13).bit_count()
3

to_bytes(length, byteorder, *, signed=False)#

Return an array of bytes representing an integer.

length: Length of bytes object to use. An OverflowError is raised if the integer is not representable with the given number of bytes.
byteorder: The byte order used to represent the integer. If byteorder is ‘big’, the most significant byte is at the beginning of the byte array. If byteorder is ‘little’, the most significant byte is at the end of the byte array. To request the native byte order of the host system, use `sys.byteorder’ as the byte order value.
signed: Determines whether two’s complement is used to represent the integer. If signed is False and a negative integer is given, an OverflowError is raised.

from_bytes(byteorder, *, signed=False)#

Return the integer represented by the given array of bytes.

bytes: Holds the array of bytes to convert. The argument must either support the buffer protocol or be an iterable object producing bytes. Bytes and bytearray are examples of built-in objects that support the buffer protocol.
byteorder: The byte order used to represent the integer. If byteorder is ‘big’, the most significant byte is at the beginning of the byte array. If byteorder is ‘little’, the most significant byte is at the end of the byte array. To request the native byte order of the host system, use `sys.byteorder’ as the byte order value.
signed: Indicates whether two’s complement is used to represent the integer.

as_integer_ratio()#

Return integer ratio.

Return a pair of integers, whose ratio is exactly equal to the original int and with a positive denominator.

>>> (10).as_integer_ratio()
(10, 1)
>>> (-10).as_integer_ratio()
(-10, 1)
>>> (0).as_integer_ratio()
(0, 1)

real#: the real part of a complex number

imag#: the imaginary part of a complex number

numerator#: the numerator of a rational number in lowest terms

denominator#: the denominator of a rational number in lowest terms

static ctypes_type()#: The type of the enum constants as ctypes type.

HIPSPARSE_SPGEMM_DEFAULT = 0#

HIPSPARSE_SPGEMM_CSR_ALG_DETERMINISTIC = 1#

HIPSPARSE_SPGEMM_CSR_ALG_NONDETERMINISTIC = 2#

HIPSPARSE_SPGEMM_ALG1 = 3#

HIPSPARSE_SPGEMM_ALG2 = 4#

HIPSPARSE_SPGEMM_ALG3 = 5#

hip.hipsparse.hipsparseCreateSpVec(spVecDescr, long size, long nnz, indices, values, idxType, idxBase, valueType)#

(No short description, might be part of a group.)

Args:

spVecDescr (Pointer/object):: (undocumented)
size (int):: (undocumented)
nnz (int):: (undocumented)
indices (Pointer/object):: (undocumented)
values (Pointer/object):: (undocumented)
idxType (hipsparseIndexType_t):: (undocumented)
idxBase (hipsparseIndexBase_t):: (undocumented)
valueType (hipDataType):: (undocumented)

hip.hipsparse.hipsparseCreateConstSpVec(spVecDescr, long size, long nnz, indices, values, idxType, idxBase, valueType)#

(No short description, might be part of a group.)

Args:

spVecDescr (Pointer/object):: (undocumented)
size (int):: (undocumented)
nnz (int):: (undocumented)
indices (Pointer/object):: (undocumented)
values (Pointer/object):: (undocumented)
idxType (hipsparseIndexType_t):: (undocumented)
idxBase (hipsparseIndexBase_t):: (undocumented)
valueType (hipDataType):: (undocumented)

hip.hipsparse.hipsparseDestroySpVec(spVecDescr)#

(No short description, might be part of a group.)

Args:

spVecDescr (Pointer/object):: (undocumented)

hip.hipsparse.hipsparseSpVecGet(spVecDescr, size, nnz, indices, values, idxType, idxBase, valueType)#

(No short description, might be part of a group.)

Args:

spVecDescr (Pointer/object):: (undocumented)
size (Pointer/object):: (undocumented)
nnz (Pointer/object):: (undocumented)
indices (Pointer/object):: (undocumented)
values (Pointer/object):: (undocumented)
idxType (Pointer/object):: (undocumented)
idxBase (Pointer/object):: (undocumented)
valueType (Pointer/object):: (undocumented)

hip.hipsparse.hipsparseConstSpVecGet(spVecDescr, size, nnz, indices, values, idxType, idxBase, valueType)#

(No short description, might be part of a group.)

Args:

spVecDescr (Pointer/object):: (undocumented)
size (Pointer/object):: (undocumented)
nnz (Pointer/object):: (undocumented)
indices (Pointer/object):: (undocumented)
values (Pointer/object):: (undocumented)
idxType (Pointer/object):: (undocumented)
idxBase (Pointer/object):: (undocumented)
valueType (Pointer/object):: (undocumented)

hip.hipsparse.hipsparseSpVecGetIndexBase(spVecDescr, idxBase)#

(No short description, might be part of a group.)

Args:

spVecDescr (Pointer/object):: (undocumented)
idxBase (Pointer/object):: (undocumented)

hip.hipsparse.hipsparseSpVecGetValues(spVecDescr, values)#

(No short description, might be part of a group.)

Args:

spVecDescr (Pointer/object):: (undocumented)
values (Pointer/object):: (undocumented)

hip.hipsparse.hipsparseConstSpVecGetValues(spVecDescr, values)#

(No short description, might be part of a group.)

Args:

spVecDescr (Pointer/object):: (undocumented)
values (Pointer/object):: (undocumented)

hip.hipsparse.hipsparseSpVecSetValues(spVecDescr, values)#

(No short description, might be part of a group.)

Args:

spVecDescr (Pointer/object):: (undocumented)
values (Pointer/object):: (undocumented)

hip.hipsparse.hipsparseCreateCoo(spMatDescr, long rows, long cols, long nnz, cooRowInd, cooColInd, cooValues, cooIdxType, idxBase, valueType)#

(No short description, might be part of a group.)

Args:

spMatDescr (Pointer/object):: (undocumented)
rows (int):: (undocumented)
cols (int):: (undocumented)
nnz (int):: (undocumented)
cooRowInd (Pointer/object):: (undocumented)
cooColInd (Pointer/object):: (undocumented)
cooValues (Pointer/object):: (undocumented)
cooIdxType (hipsparseIndexType_t):: (undocumented)
idxBase (hipsparseIndexBase_t):: (undocumented)
valueType (hipDataType):: (undocumented)

hip.hipsparse.hipsparseCreateConstCoo(spMatDescr, long rows, long cols, long nnz, cooRowInd, cooColInd, cooValues, cooIdxType, idxBase, valueType)#

(No short description, might be part of a group.)

Args:

spMatDescr (Pointer/object):: (undocumented)
rows (int):: (undocumented)
cols (int):: (undocumented)
nnz (int):: (undocumented)
cooRowInd (Pointer/object):: (undocumented)
cooColInd (Pointer/object):: (undocumented)
cooValues (Pointer/object):: (undocumented)
cooIdxType (hipsparseIndexType_t):: (undocumented)
idxBase (hipsparseIndexBase_t):: (undocumented)
valueType (hipDataType):: (undocumented)

hip.hipsparse.hipsparseCreateCooAoS(spMatDescr, long rows, long cols, long nnz, cooInd, cooValues, cooIdxType, idxBase, valueType)#

(No short description, might be part of a group.)

Args:

spMatDescr (Pointer/object):: (undocumented)
rows (int):: (undocumented)
cols (int):: (undocumented)
nnz (int):: (undocumented)
cooInd (Pointer/object):: (undocumented)
cooValues (Pointer/object):: (undocumented)
cooIdxType (hipsparseIndexType_t):: (undocumented)
idxBase (hipsparseIndexBase_t):: (undocumented)
valueType (hipDataType):: (undocumented)

hip.hipsparse.hipsparseCreateCsr(spMatDescr, long rows, long cols, long nnz, csrRowOffsets, csrColInd, csrValues, csrRowOffsetsType, csrColIndType, idxBase, valueType)#

(No short description, might be part of a group.)

Args:

spMatDescr (Pointer/object):: (undocumented)
rows (int):: (undocumented)
cols (int):: (undocumented)
nnz (int):: (undocumented)
csrRowOffsets (Pointer/object):: (undocumented)
csrColInd (Pointer/object):: (undocumented)
csrValues (Pointer/object):: (undocumented)
csrRowOffsetsType (hipsparseIndexType_t):: (undocumented)
csrColIndType (hipsparseIndexType_t):: (undocumented)
idxBase (hipsparseIndexBase_t):: (undocumented)
valueType (hipDataType):: (undocumented)

hip.hipsparse.hipsparseCreateConstCsr(spMatDescr, long rows, long cols, long nnz, csrRowOffsets, csrColInd, csrValues, csrRowOffsetsType, csrColIndType, idxBase, valueType)#

(No short description, might be part of a group.)

Args:

spMatDescr (Pointer/object):: (undocumented)
rows (int):: (undocumented)
cols (int):: (undocumented)
nnz (int):: (undocumented)
csrRowOffsets (Pointer/object):: (undocumented)
csrColInd (Pointer/object):: (undocumented)
csrValues (Pointer/object):: (undocumented)
csrRowOffsetsType (hipsparseIndexType_t):: (undocumented)
csrColIndType (hipsparseIndexType_t):: (undocumented)
idxBase (hipsparseIndexBase_t):: (undocumented)
valueType (hipDataType):: (undocumented)

hip.hipsparse.hipsparseCreateCsc(spMatDescr, long rows, long cols, long nnz, cscColOffsets, cscRowInd, cscValues, cscColOffsetsType, cscRowIndType, idxBase, valueType)#

(No short description, might be part of a group.)

Args:

spMatDescr (Pointer/object):: (undocumented)
rows (int):: (undocumented)
cols (int):: (undocumented)
nnz (int):: (undocumented)
cscColOffsets (Pointer/object):: (undocumented)
cscRowInd (Pointer/object):: (undocumented)
cscValues (Pointer/object):: (undocumented)
cscColOffsetsType (hipsparseIndexType_t):: (undocumented)
cscRowIndType (hipsparseIndexType_t):: (undocumented)
idxBase (hipsparseIndexBase_t):: (undocumented)
valueType (hipDataType):: (undocumented)

hip.hipsparse.hipsparseCreateConstCsc(spMatDescr, long rows, long cols, long nnz, cscColOffsets, cscRowInd, cscValues, cscColOffsetsType, cscRowIndType, idxBase, valueType)#

(No short description, might be part of a group.)

Args:

spMatDescr (Pointer/object):: (undocumented)
rows (int):: (undocumented)
cols (int):: (undocumented)
nnz (int):: (undocumented)
cscColOffsets (Pointer/object):: (undocumented)
cscRowInd (Pointer/object):: (undocumented)
cscValues (Pointer/object):: (undocumented)
cscColOffsetsType (hipsparseIndexType_t):: (undocumented)
cscRowIndType (hipsparseIndexType_t):: (undocumented)
idxBase (hipsparseIndexBase_t):: (undocumented)
valueType (hipDataType):: (undocumented)

hip.hipsparse.hipsparseCreateBlockedEll(spMatDescr, long rows, long cols, long ellBlockSize, long ellCols, ellColInd, ellValue, ellIdxType, idxBase, valueType)#

(No short description, might be part of a group.)

Args:

spMatDescr (Pointer/object):: (undocumented)
rows (int):: (undocumented)
cols (int):: (undocumented)
ellBlockSize (int):: (undocumented)
ellCols (int):: (undocumented)
ellColInd (Pointer/object):: (undocumented)
ellValue (Pointer/object):: (undocumented)
ellIdxType (hipsparseIndexType_t):: (undocumented)
idxBase (hipsparseIndexBase_t):: (undocumented)
valueType (hipDataType):: (undocumented)

hip.hipsparse.hipsparseCreateConstBlockedEll(spMatDescr, long rows, long cols, long ellBlockSize, long ellCols, ellColInd, ellValue, ellIdxType, idxBase, valueType)#

(No short description, might be part of a group.)

Args:

spMatDescr (Pointer/object):: (undocumented)
rows (int):: (undocumented)
cols (int):: (undocumented)
ellBlockSize (int):: (undocumented)
ellCols (int):: (undocumented)
ellColInd (Pointer/object):: (undocumented)
ellValue (Pointer/object):: (undocumented)
ellIdxType (hipsparseIndexType_t):: (undocumented)
idxBase (hipsparseIndexBase_t):: (undocumented)
valueType (hipDataType):: (undocumented)

hip.hipsparse.hipsparseDestroySpMat(spMatDescr)#

(No short description, might be part of a group.)

Args:

spMatDescr (Pointer/object):: (undocumented)

hip.hipsparse.hipsparseCooGet(spMatDescr, rows, cols, nnz, cooRowInd, cooColInd, cooValues, idxType, idxBase, valueType)#

(No short description, might be part of a group.)

Args:

spMatDescr (Pointer/object):: (undocumented)
rows (Pointer/object):: (undocumented)
cols (Pointer/object):: (undocumented)
nnz (Pointer/object):: (undocumented)
cooRowInd (Pointer/object):: (undocumented)
cooColInd (Pointer/object):: (undocumented)
cooValues (Pointer/object):: (undocumented)
idxType (Pointer/object):: (undocumented)
idxBase (Pointer/object):: (undocumented)
valueType (Pointer/object):: (undocumented)

hip.hipsparse.hipsparseConstCooGet(spMatDescr, rows, cols, nnz, cooRowInd, cooColInd, cooValues, idxType, idxBase, valueType)#

(No short description, might be part of a group.)

Args:

spMatDescr (Pointer/object):: (undocumented)
rows (Pointer/object):: (undocumented)
cols (Pointer/object):: (undocumented)
nnz (Pointer/object):: (undocumented)
cooRowInd (Pointer/object):: (undocumented)
cooColInd (Pointer/object):: (undocumented)
cooValues (Pointer/object):: (undocumented)
idxType (Pointer/object):: (undocumented)
idxBase (Pointer/object):: (undocumented)
valueType (Pointer/object):: (undocumented)

hip.hipsparse.hipsparseCooAoSGet(spMatDescr, rows, cols, nnz, cooInd, cooValues, idxType, idxBase, valueType)#

(No short description, might be part of a group.)

Args:

spMatDescr (Pointer/object):: (undocumented)
rows (Pointer/object):: (undocumented)
cols (Pointer/object):: (undocumented)
nnz (Pointer/object):: (undocumented)
cooInd (Pointer/object):: (undocumented)
cooValues (Pointer/object):: (undocumented)
idxType (Pointer/object):: (undocumented)
idxBase (Pointer/object):: (undocumented)
valueType (Pointer/object):: (undocumented)

hip.hipsparse.hipsparseCsrGet(spMatDescr, rows, cols, nnz, csrRowOffsets, csrColInd, csrValues, csrRowOffsetsType, csrColIndType, idxBase, valueType)#

(No short description, might be part of a group.)

Args:

spMatDescr (Pointer/object):: (undocumented)
rows (Pointer/object):: (undocumented)
cols (Pointer/object):: (undocumented)
nnz (Pointer/object):: (undocumented)
csrRowOffsets (Pointer/object):: (undocumented)
csrColInd (Pointer/object):: (undocumented)
csrValues (Pointer/object):: (undocumented)
csrRowOffsetsType (Pointer/object):: (undocumented)
csrColIndType (Pointer/object):: (undocumented)
idxBase (Pointer/object):: (undocumented)
valueType (Pointer/object):: (undocumented)

hip.hipsparse.hipsparseConstCsrGet(spMatDescr, rows, cols, nnz, csrRowOffsets, csrColInd, csrValues, csrRowOffsetsType, csrColIndType, idxBase, valueType)#

(No short description, might be part of a group.)

Args:

spMatDescr (Pointer/object):: (undocumented)
rows (Pointer/object):: (undocumented)
cols (Pointer/object):: (undocumented)
nnz (Pointer/object):: (undocumented)
csrRowOffsets (Pointer/object):: (undocumented)
csrColInd (Pointer/object):: (undocumented)
csrValues (Pointer/object):: (undocumented)
csrRowOffsetsType (Pointer/object):: (undocumented)
csrColIndType (Pointer/object):: (undocumented)
idxBase (Pointer/object):: (undocumented)
valueType (Pointer/object):: (undocumented)

hip.hipsparse.hipsparseBlockedEllGet(spMatDescr, rows, cols, ellBlockSize, ellCols, ellColInd, ellValue, ellIdxType, idxBase, valueType)#

(No short description, might be part of a group.)

Args:

spMatDescr (Pointer/object):: (undocumented)
rows (Pointer/object):: (undocumented)
cols (Pointer/object):: (undocumented)
ellBlockSize (Pointer/object):: (undocumented)
ellCols (Pointer/object):: (undocumented)
ellColInd (Pointer/object):: (undocumented)
ellValue (Pointer/object):: (undocumented)
ellIdxType (Pointer/object):: (undocumented)
idxBase (Pointer/object):: (undocumented)
valueType (Pointer/object):: (undocumented)

hip.hipsparse.hipsparseConstBlockedEllGet(spMatDescr, rows, cols, ellBlockSize, ellCols, ellColInd, ellValue, ellIdxType, idxBase, valueType)#

(No short description, might be part of a group.)

Args:

spMatDescr (Pointer/object):: (undocumented)
rows (Pointer/object):: (undocumented)
cols (Pointer/object):: (undocumented)
ellBlockSize (Pointer/object):: (undocumented)
ellCols (Pointer/object):: (undocumented)
ellColInd (Pointer/object):: (undocumented)
ellValue (Pointer/object):: (undocumented)
ellIdxType (Pointer/object):: (undocumented)
idxBase (Pointer/object):: (undocumented)
valueType (Pointer/object):: (undocumented)

hip.hipsparse.hipsparseCsrSetPointers(spMatDescr, csrRowOffsets, csrColInd, csrValues)#

(No short description, might be part of a group.)

Args:

spMatDescr (Pointer/object):: (undocumented)
csrRowOffsets (Pointer/object):: (undocumented)
csrColInd (Pointer/object):: (undocumented)
csrValues (Pointer/object):: (undocumented)

hip.hipsparse.hipsparseCscSetPointers(spMatDescr, cscColOffsets, cscRowInd, cscValues)#

(No short description, might be part of a group.)

Args:

spMatDescr (Pointer/object):: (undocumented)
cscColOffsets (Pointer/object):: (undocumented)
cscRowInd (Pointer/object):: (undocumented)
cscValues (Pointer/object):: (undocumented)

hip.hipsparse.hipsparseCooSetPointers(spMatDescr, cooRowInd, cooColInd, cooValues)#

(No short description, might be part of a group.)

Args:

spMatDescr (Pointer/object):: (undocumented)
cooRowInd (Pointer/object):: (undocumented)
cooColInd (Pointer/object):: (undocumented)
cooValues (Pointer/object):: (undocumented)

hip.hipsparse.hipsparseSpMatGetSize(spMatDescr, rows, cols, nnz)#

(No short description, might be part of a group.)

Args:

spMatDescr (Pointer/object):: (undocumented)
rows (Pointer/object):: (undocumented)
cols (Pointer/object):: (undocumented)
nnz (Pointer/object):: (undocumented)

hip.hipsparse.hipsparseSpMatGetFormat(spMatDescr, format)#

(No short description, might be part of a group.)

Args:

spMatDescr (Pointer/object):: (undocumented)
format (Pointer/object):: (undocumented)

hip.hipsparse.hipsparseSpMatGetIndexBase(spMatDescr, idxBase)#

(No short description, might be part of a group.)

Args:

spMatDescr (Pointer/object):: (undocumented)
idxBase (Pointer/object):: (undocumented)

hip.hipsparse.hipsparseSpMatGetValues(spMatDescr, values)#

(No short description, might be part of a group.)

Args:

spMatDescr (Pointer/object):: (undocumented)
values (Pointer/object):: (undocumented)

hip.hipsparse.hipsparseConstSpMatGetValues(spMatDescr, values)#

(No short description, might be part of a group.)

Args:

spMatDescr (Pointer/object):: (undocumented)
values (Pointer/object):: (undocumented)

hip.hipsparse.hipsparseSpMatSetValues(spMatDescr, values)#

(No short description, might be part of a group.)

Args:

spMatDescr (Pointer/object):: (undocumented)
values (Pointer/object):: (undocumented)

hip.hipsparse.hipsparseSpMatGetStridedBatch(spMatDescr, batchCount)#

(No short description, might be part of a group.)

Args:

spMatDescr (Pointer/object):: (undocumented)
batchCount (Pointer/object):: (undocumented)

hip.hipsparse.hipsparseSpMatSetStridedBatch(spMatDescr, int batchCount)#

(No short description, might be part of a group.)

Args:

spMatDescr (Pointer/object):: (undocumented)
batchCount (int):: (undocumented)

hip.hipsparse.hipsparseCooSetStridedBatch(spMatDescr, int batchCount, long batchStride)#

(No short description, might be part of a group.)

Args:

spMatDescr (Pointer/object):: (undocumented)
batchCount (int):: (undocumented)
batchStride (int):: (undocumented)

hip.hipsparse.hipsparseCsrSetStridedBatch(spMatDescr, int batchCount, long offsetsBatchStride, long columnsValuesBatchStride)#

(No short description, might be part of a group.)

Args:

spMatDescr (Pointer/object):: (undocumented)
batchCount (int):: (undocumented)
offsetsBatchStride (int):: (undocumented)
columnsValuesBatchStride (int):: (undocumented)

hip.hipsparse.hipsparseSpMatGetAttribute(spMatDescr, attribute, data, unsigned long dataSize)#

(No short description, might be part of a group.)

Args:

spMatDescr (Pointer/object):: (undocumented)
attribute (hipsparseSpMatAttribute_t):: (undocumented)
data (Pointer/object):: (undocumented)
dataSize (int):: (undocumented)

hip.hipsparse.hipsparseSpMatSetAttribute(spMatDescr, attribute, data, unsigned long dataSize)#

(No short description, might be part of a group.)

Args:

spMatDescr (Pointer/object):: (undocumented)
attribute (hipsparseSpMatAttribute_t):: (undocumented)
data (Pointer/object):: (undocumented)
dataSize (int):: (undocumented)

hip.hipsparse.hipsparseCreateDnVec(dnVecDescr, long size, values, valueType)#

(No short description, might be part of a group.)

Args:

dnVecDescr (Pointer/object):: (undocumented)
size (int):: (undocumented)
values (Pointer/object):: (undocumented)
valueType (hipDataType):: (undocumented)

hip.hipsparse.hipsparseCreateConstDnVec(dnVecDescr, long size, values, valueType)#

(No short description, might be part of a group.)

Args:

dnVecDescr (Pointer/object):: (undocumented)
size (int):: (undocumented)
values (Pointer/object):: (undocumented)
valueType (hipDataType):: (undocumented)

hip.hipsparse.hipsparseDestroyDnVec(dnVecDescr)#

(No short description, might be part of a group.)

Args:

dnVecDescr (Pointer/object):: (undocumented)

hip.hipsparse.hipsparseDnVecGet(dnVecDescr, size, values, valueType)#

(No short description, might be part of a group.)

Args:

dnVecDescr (Pointer/object):: (undocumented)
size (Pointer/object):: (undocumented)
values (Pointer/object):: (undocumented)
valueType (Pointer/object):: (undocumented)

hip.hipsparse.hipsparseConstDnVecGet(dnVecDescr, size, values, valueType)#

(No short description, might be part of a group.)

Args:

dnVecDescr (Pointer/object):: (undocumented)
size (Pointer/object):: (undocumented)
values (Pointer/object):: (undocumented)
valueType (Pointer/object):: (undocumented)

hip.hipsparse.hipsparseDnVecGetValues(dnVecDescr, values)#

(No short description, might be part of a group.)

Args:

dnVecDescr (Pointer/object):: (undocumented)
values (Pointer/object):: (undocumented)

hip.hipsparse.hipsparseConstDnVecGetValues(dnVecDescr, values)#

(No short description, might be part of a group.)

Args:

dnVecDescr (Pointer/object):: (undocumented)
values (Pointer/object):: (undocumented)

hip.hipsparse.hipsparseDnVecSetValues(dnVecDescr, values)#

(No short description, might be part of a group.)

Args:

dnVecDescr (Pointer/object):: (undocumented)
values (Pointer/object):: (undocumented)

hip.hipsparse.hipsparseCreateDnMat(dnMatDescr, long rows, long cols, long ld, values, valueType, order)#

(No short description, might be part of a group.)

Args:

dnMatDescr (Pointer/object):: (undocumented)
rows (int):: (undocumented)
cols (int):: (undocumented)
ld (int):: (undocumented)
values (Pointer/object):: (undocumented)
valueType (hipDataType):: (undocumented)
order (hipsparseOrder_t):: (undocumented)

hip.hipsparse.hipsparseCreateConstDnMat(dnMatDescr, long rows, long cols, long ld, values, valueType, order)#

(No short description, might be part of a group.)

Args:

dnMatDescr (Pointer/object):: (undocumented)
rows (int):: (undocumented)
cols (int):: (undocumented)
ld (int):: (undocumented)
values (Pointer/object):: (undocumented)
valueType (hipDataType):: (undocumented)
order (hipsparseOrder_t):: (undocumented)

hip.hipsparse.hipsparseDestroyDnMat(dnMatDescr)#

(No short description, might be part of a group.)

Args:

dnMatDescr (Pointer/object):: (undocumented)

hip.hipsparse.hipsparseDnMatGet(dnMatDescr, rows, cols, ld, values, valueType, order)#

(No short description, might be part of a group.)

Args:

dnMatDescr (Pointer/object):: (undocumented)
rows (Pointer/object):: (undocumented)
cols (Pointer/object):: (undocumented)
ld (Pointer/object):: (undocumented)
values (Pointer/object):: (undocumented)
valueType (Pointer/object):: (undocumented)
order (Pointer/object):: (undocumented)

hip.hipsparse.hipsparseConstDnMatGet(dnMatDescr, rows, cols, ld, values, valueType, order)#

(No short description, might be part of a group.)

Args:

dnMatDescr (Pointer/object):: (undocumented)
rows (Pointer/object):: (undocumented)
cols (Pointer/object):: (undocumented)
ld (Pointer/object):: (undocumented)
values (Pointer/object):: (undocumented)
valueType (Pointer/object):: (undocumented)
order (Pointer/object):: (undocumented)

hip.hipsparse.hipsparseDnMatGetValues(dnMatDescr, values)#

(No short description, might be part of a group.)

Args:

dnMatDescr (Pointer/object):: (undocumented)
values (Pointer/object):: (undocumented)

hip.hipsparse.hipsparseConstDnMatGetValues(dnMatDescr, values)#

(No short description, might be part of a group.)

Args:

dnMatDescr (Pointer/object):: (undocumented)
values (Pointer/object):: (undocumented)

hip.hipsparse.hipsparseDnMatSetValues(dnMatDescr, values)#

(No short description, might be part of a group.)

Args:

dnMatDescr (Pointer/object):: (undocumented)
values (Pointer/object):: (undocumented)

hip.hipsparse.hipsparseDnMatGetStridedBatch(dnMatDescr, batchCount, batchStride)#

(No short description, might be part of a group.)

Args:

dnMatDescr (Pointer/object):: (undocumented)
batchCount (Pointer/object):: (undocumented)
batchStride (Pointer/object):: (undocumented)

hip.hipsparse.hipsparseDnMatSetStridedBatch(dnMatDescr, int batchCount, long batchStride)#

(No short description, might be part of a group.)

Args:

dnMatDescr (Pointer/object):: (undocumented)
batchCount (int):: (undocumented)
batchStride (int):: (undocumented)

hip.hipsparse.hipsparseAxpby(handle, alpha, vecX, beta, vecY)#

(No short description, might be part of a group.)

Args:

handle (Pointer/object):: (undocumented)
alpha (Pointer/object):: (undocumented)
vecX (Pointer/object):: (undocumented)
beta (Pointer/object):: (undocumented)
vecY (Pointer/object):: (undocumented)

hip.hipsparse.hipsparseGather(handle, vecY, vecX)#

(No short description, might be part of a group.)

Args:

handle (Pointer/object):: (undocumented)
vecY (Pointer/object):: (undocumented)
vecX (Pointer/object):: (undocumented)

hip.hipsparse.hipsparseScatter(handle, vecX, vecY)#

(No short description, might be part of a group.)

Args:

handle (Pointer/object):: (undocumented)
vecX (Pointer/object):: (undocumented)
vecY (Pointer/object):: (undocumented)

hip.hipsparse.hipsparseRot(handle, c_coeff, s_coeff, vecX, vecY)#

(No short description, might be part of a group.)

Args:

handle (Pointer/object):: (undocumented)
c_coeff (Pointer/object):: (undocumented)
s_coeff (Pointer/object):: (undocumented)
vecX (Pointer/object):: (undocumented)
vecY (Pointer/object):: (undocumented)

hip.hipsparse.hipsparseSparseToDense_bufferSize(handle, matA, matB, alg, bufferSize)#

(No short description, might be part of a group.)

Args:

handle (Pointer/object):: (undocumented)
matA (Pointer/object):: (undocumented)
matB (Pointer/object):: (undocumented)
alg (hipsparseSparseToDenseAlg_t):: (undocumented)
bufferSize (Pointer/object):: (undocumented)

hip.hipsparse.hipsparseSparseToDense(handle, matA, matB, alg, externalBuffer)#

(No short description, might be part of a group.)

Args:

handle (Pointer/object):: (undocumented)
matA (Pointer/object):: (undocumented)
matB (Pointer/object):: (undocumented)
alg (hipsparseSparseToDenseAlg_t):: (undocumented)
externalBuffer (Pointer/object):: (undocumented)

hip.hipsparse.hipsparseDenseToSparse_bufferSize(handle, matA, matB, alg, bufferSize)#

(No short description, might be part of a group.)

Args:

handle (Pointer/object):: (undocumented)
matA (Pointer/object):: (undocumented)
matB (Pointer/object):: (undocumented)
alg (hipsparseDenseToSparseAlg_t):: (undocumented)
bufferSize (Pointer/object):: (undocumented)

hip.hipsparse.hipsparseDenseToSparse_analysis(handle, matA, matB, alg, externalBuffer)#

(No short description, might be part of a group.)

Args:

handle (Pointer/object):: (undocumented)
matA (Pointer/object):: (undocumented)
matB (Pointer/object):: (undocumented)
alg (hipsparseDenseToSparseAlg_t):: (undocumented)
externalBuffer (Pointer/object):: (undocumented)

hip.hipsparse.hipsparseDenseToSparse_convert(handle, matA, matB, alg, externalBuffer)#

(No short description, might be part of a group.)

Args:

handle (Pointer/object):: (undocumented)
matA (Pointer/object):: (undocumented)
matB (Pointer/object):: (undocumented)
alg (hipsparseDenseToSparseAlg_t):: (undocumented)
externalBuffer (Pointer/object):: (undocumented)

hip.hipsparse.hipsparseSpVV_bufferSize(handle, opX, vecX, vecY, result, computeType, bufferSize)#

(No short description, might be part of a group.)

Args:

handle (Pointer/object):: (undocumented)
opX (hipsparseOperation_t):: (undocumented)
vecX (Pointer/object):: (undocumented)
vecY (Pointer/object):: (undocumented)
result (Pointer/object):: (undocumented)
computeType (hipDataType):: (undocumented)
bufferSize (Pointer/object):: (undocumented)

hip.hipsparse.hipsparseSpVV(handle, opX, vecX, vecY, result, computeType, externalBuffer)#

(No short description, might be part of a group.)

Args:

handle (Pointer/object):: (undocumented)
opX (hipsparseOperation_t):: (undocumented)
vecX (Pointer/object):: (undocumented)
vecY (Pointer/object):: (undocumented)
result (Pointer/object):: (undocumented)
computeType (hipDataType):: (undocumented)
externalBuffer (Pointer/object):: (undocumented)

hip.hipsparse.hipsparseSpMV_bufferSize(handle, opA, alpha, matA, vecX, beta, vecY, computeType, alg, bufferSize)#

(No short description, might be part of a group.)

Args:

handle (Pointer/object):: (undocumented)
opA (hipsparseOperation_t):: (undocumented)
alpha (Pointer/object):: (undocumented)
matA (Pointer/object):: (undocumented)
vecX (Pointer/object):: (undocumented)
beta (Pointer/object):: (undocumented)
vecY (Pointer/object):: (undocumented)
computeType (hipDataType):: (undocumented)
alg (hipsparseSpMVAlg_t):: (undocumented)
bufferSize (Pointer/object):: (undocumented)

hip.hipsparse.hipsparseSpMV_preprocess(handle, opA, alpha, matA, vecX, beta, vecY, computeType, alg, externalBuffer)#

(No short description, might be part of a group.)

Args:

handle (Pointer/object):: (undocumented)
opA (hipsparseOperation_t):: (undocumented)
alpha (Pointer/object):: (undocumented)
matA (Pointer/object):: (undocumented)
vecX (Pointer/object):: (undocumented)
beta (Pointer/object):: (undocumented)
vecY (Pointer/object):: (undocumented)
computeType (hipDataType):: (undocumented)
alg (hipsparseSpMVAlg_t):: (undocumented)
externalBuffer (Pointer/object):: (undocumented)

hip.hipsparse.hipsparseSpMV(handle, opA, alpha, matA, vecX, beta, vecY, computeType, alg, externalBuffer)#

(No short description, might be part of a group.)

Args:

handle (Pointer/object):: (undocumented)
opA (hipsparseOperation_t):: (undocumented)
alpha (Pointer/object):: (undocumented)
matA (Pointer/object):: (undocumented)
vecX (Pointer/object):: (undocumented)
beta (Pointer/object):: (undocumented)
vecY (Pointer/object):: (undocumented)
computeType (hipDataType):: (undocumented)
alg (hipsparseSpMVAlg_t):: (undocumented)
externalBuffer (Pointer/object):: (undocumented)

hip.hipsparse.hipsparseSpMM_bufferSize(handle, opA, opB, alpha, matA, matB, beta, matC, computeType, alg, bufferSize)#

(No short description, might be part of a group.)

Args:

handle (Pointer/object):: (undocumented)
opA (hipsparseOperation_t):: (undocumented)
opB (hipsparseOperation_t):: (undocumented)
alpha (Pointer/object):: (undocumented)
matA (Pointer/object):: (undocumented)
matB (Pointer/object):: (undocumented)
beta (Pointer/object):: (undocumented)
matC (Pointer/object):: (undocumented)
computeType (hipDataType):: (undocumented)
alg (hipsparseSpMMAlg_t):: (undocumented)
bufferSize (Pointer/object):: (undocumented)

hip.hipsparse.hipsparseSpMM_preprocess(handle, opA, opB, alpha, matA, matB, beta, matC, computeType, alg, externalBuffer)#

(No short description, might be part of a group.)

Args:

handle (Pointer/object):: (undocumented)
opA (hipsparseOperation_t):: (undocumented)
opB (hipsparseOperation_t):: (undocumented)
alpha (Pointer/object):: (undocumented)
matA (Pointer/object):: (undocumented)
matB (Pointer/object):: (undocumented)
beta (Pointer/object):: (undocumented)
matC (Pointer/object):: (undocumented)
computeType (hipDataType):: (undocumented)
alg (hipsparseSpMMAlg_t):: (undocumented)
externalBuffer (Pointer/object):: (undocumented)

hip.hipsparse.hipsparseSpMM(handle, opA, opB, alpha, matA, matB, beta, matC, computeType, alg, externalBuffer)#

(No short description, might be part of a group.)

Args:

handle (Pointer/object):: (undocumented)
opA (hipsparseOperation_t):: (undocumented)
opB (hipsparseOperation_t):: (undocumented)
alpha (Pointer/object):: (undocumented)
matA (Pointer/object):: (undocumented)
matB (Pointer/object):: (undocumented)
beta (Pointer/object):: (undocumented)
matC (Pointer/object):: (undocumented)
computeType (hipDataType):: (undocumented)
alg (hipsparseSpMMAlg_t):: (undocumented)
externalBuffer (Pointer/object):: (undocumented)

hip.hipsparse.hipsparseSpGEMM_createDescr()#

(No short description, might be part of a group.)

Returns:

A tuple of size 1 that contains (in that order):

descr (hipsparseSpGEMMDescr):
(undocumented)

hip.hipsparse.hipsparseSpGEMM_destroyDescr(descr)#

(No short description, might be part of a group.)

Args:

descr (hipsparseSpGEMMDescr/object):: (undocumented)

hip.hipsparse.hipsparseSpGEMM_workEstimation(handle, opA, opB, alpha, matA, matB, beta, matC, computeType, alg, spgemmDescr, bufferSize1, externalBuffer1)#

(No short description, might be part of a group.)

Args:

handle (Pointer/object):: (undocumented)
opA (hipsparseOperation_t):: (undocumented)
opB (hipsparseOperation_t):: (undocumented)
alpha (Pointer/object):: (undocumented)
matA (Pointer/object):: (undocumented)
matB (Pointer/object):: (undocumented)
beta (Pointer/object):: (undocumented)
matC (Pointer/object):: (undocumented)
computeType (hipDataType):: (undocumented)
alg (hipsparseSpGEMMAlg_t):: (undocumented)
spgemmDescr (hipsparseSpGEMMDescr/object):: (undocumented)
bufferSize1 (Pointer/object):: (undocumented)
externalBuffer1 (Pointer/object):: (undocumented)

hip.hipsparse.hipsparseSpGEMM_compute(handle, opA, opB, alpha, matA, matB, beta, matC, computeType, alg, spgemmDescr, bufferSize2, externalBuffer2)#

(No short description, might be part of a group.)

Args:

handle (Pointer/object):: (undocumented)
opA (hipsparseOperation_t):: (undocumented)
opB (hipsparseOperation_t):: (undocumented)
alpha (Pointer/object):: (undocumented)
matA (Pointer/object):: (undocumented)
matB (Pointer/object):: (undocumented)
beta (Pointer/object):: (undocumented)
matC (Pointer/object):: (undocumented)
computeType (hipDataType):: (undocumented)
alg (hipsparseSpGEMMAlg_t):: (undocumented)
spgemmDescr (hipsparseSpGEMMDescr/object):: (undocumented)
bufferSize2 (Pointer/object):: (undocumented)
externalBuffer2 (Pointer/object):: (undocumented)

hip.hipsparse.hipsparseSpGEMM_copy(handle, opA, opB, alpha, matA, matB, beta, matC, computeType, alg, spgemmDescr)#

(No short description, might be part of a group.)

Args:

handle (Pointer/object):: (undocumented)
opA (hipsparseOperation_t):: (undocumented)
opB (hipsparseOperation_t):: (undocumented)
alpha (Pointer/object):: (undocumented)
matA (Pointer/object):: (undocumented)
matB (Pointer/object):: (undocumented)
beta (Pointer/object):: (undocumented)
matC (Pointer/object):: (undocumented)
computeType (hipDataType):: (undocumented)
alg (hipsparseSpGEMMAlg_t):: (undocumented)
spgemmDescr (hipsparseSpGEMMDescr/object):: (undocumented)

hip.hipsparse.hipsparseSpGEMMreuse_workEstimation(handle, opA, opB, matA, matB, matC, alg, spgemmDescr, bufferSize1, externalBuffer1)#

(No short description, might be part of a group.)

Args:

handle (Pointer/object):: (undocumented)
opA (hipsparseOperation_t):: (undocumented)
opB (hipsparseOperation_t):: (undocumented)
matA (Pointer/object):: (undocumented)
matB (Pointer/object):: (undocumented)
matC (Pointer/object):: (undocumented)
alg (hipsparseSpGEMMAlg_t):: (undocumented)
spgemmDescr (hipsparseSpGEMMDescr/object):: (undocumented)
bufferSize1 (Pointer/object):: (undocumented)
externalBuffer1 (Pointer/object):: (undocumented)

hip.hipsparse.hipsparseSpGEMMreuse_nnz(handle, opA, opB, matA, matB, matC, alg, spgemmDescr, bufferSize2, externalBuffer2, bufferSize3, externalBuffer3, bufferSize4, externalBuffer4)#

(No short description, might be part of a group.)

Args:

handle (Pointer/object):: (undocumented)
opA (hipsparseOperation_t):: (undocumented)
opB (hipsparseOperation_t):: (undocumented)
matA (Pointer/object):: (undocumented)
matB (Pointer/object):: (undocumented)
matC (Pointer/object):: (undocumented)
alg (hipsparseSpGEMMAlg_t):: (undocumented)
spgemmDescr (hipsparseSpGEMMDescr/object):: (undocumented)
bufferSize2 (Pointer/object):: (undocumented)
externalBuffer2 (Pointer/object):: (undocumented)
bufferSize3 (Pointer/object):: (undocumented)
externalBuffer3 (Pointer/object):: (undocumented)
bufferSize4 (Pointer/object):: (undocumented)
externalBuffer4 (Pointer/object):: (undocumented)

hip.hipsparse.hipsparseSpGEMMreuse_compute(handle, opA, opB, alpha, matA, matB, beta, matC, computeType, alg, spgemmDescr)#

(No short description, might be part of a group.)

Args:

handle (Pointer/object):: (undocumented)
opA (hipsparseOperation_t):: (undocumented)
opB (hipsparseOperation_t):: (undocumented)
alpha (Pointer/object):: (undocumented)
matA (Pointer/object):: (undocumented)
matB (Pointer/object):: (undocumented)
beta (Pointer/object):: (undocumented)
matC (Pointer/object):: (undocumented)
computeType (hipDataType):: (undocumented)
alg (hipsparseSpGEMMAlg_t):: (undocumented)
spgemmDescr (hipsparseSpGEMMDescr/object):: (undocumented)

hip.hipsparse.hipsparseSpGEMMreuse_copy(handle, opA, opB, matA, matB, matC, alg, spgemmDescr, bufferSize5, externalBuffer5)#

(No short description, might be part of a group.)

Args:

handle (Pointer/object):: (undocumented)
opA (hipsparseOperation_t):: (undocumented)
opB (hipsparseOperation_t):: (undocumented)
matA (Pointer/object):: (undocumented)
matB (Pointer/object):: (undocumented)
matC (Pointer/object):: (undocumented)
alg (hipsparseSpGEMMAlg_t):: (undocumented)
spgemmDescr (hipsparseSpGEMMDescr/object):: (undocumented)
bufferSize5 (Pointer/object):: (undocumented)
externalBuffer5 (Pointer/object):: (undocumented)

hip.hipsparse.hipsparseSDDMM_bufferSize(handle, opA, opB, alpha, A, B, beta, C, computeType, alg, bufferSize)#

(No short description, might be part of a group.)

Args:

handle (Pointer/object):: (undocumented)
opA (hipsparseOperation_t):: (undocumented)
opB (hipsparseOperation_t):: (undocumented)
alpha (Pointer/object):: (undocumented)
A (Pointer/object):: (undocumented)
B (Pointer/object):: (undocumented)
beta (Pointer/object):: (undocumented)
C (Pointer/object):: (undocumented)
computeType (hipDataType):: (undocumented)
alg (hipsparseSDDMMAlg_t):: (undocumented)
bufferSize (Pointer/object):: (undocumented)

hip.hipsparse.hipsparseSDDMM_preprocess(handle, opA, opB, alpha, A, B, beta, C, computeType, alg, tempBuffer)#

(No short description, might be part of a group.)

Args:

handle (Pointer/object):: (undocumented)
opA (hipsparseOperation_t):: (undocumented)
opB (hipsparseOperation_t):: (undocumented)
alpha (Pointer/object):: (undocumented)
A (Pointer/object):: (undocumented)
B (Pointer/object):: (undocumented)
beta (Pointer/object):: (undocumented)
C (Pointer/object):: (undocumented)
computeType (hipDataType):: (undocumented)
alg (hipsparseSDDMMAlg_t):: (undocumented)
tempBuffer (Pointer/object):: (undocumented)

hip.hipsparse.hipsparseSDDMM(handle, opA, opB, alpha, A, B, beta, C, computeType, alg, tempBuffer)#

(No short description, might be part of a group.)

Args:

handle (Pointer/object):: (undocumented)
opA (hipsparseOperation_t):: (undocumented)
opB (hipsparseOperation_t):: (undocumented)
alpha (Pointer/object):: (undocumented)
A (Pointer/object):: (undocumented)
B (Pointer/object):: (undocumented)
beta (Pointer/object):: (undocumented)
C (Pointer/object):: (undocumented)
computeType (hipDataType):: (undocumented)
alg (hipsparseSDDMMAlg_t):: (undocumented)
tempBuffer (Pointer/object):: (undocumented)

hip.hipsparse.hipsparseSpSV_createDescr()#

(No short description, might be part of a group.)

Returns:

A tuple of size 1 that contains (in that order):

descr (hipsparseSpSVDescr):
(undocumented)

hip.hipsparse.hipsparseSpSV_destroyDescr(descr)#

(No short description, might be part of a group.)

Args:

descr (hipsparseSpSVDescr/object):: (undocumented)

hip.hipsparse.hipsparseSpSV_bufferSize(handle, opA, alpha, matA, x, y, computeType, alg, spsvDescr, bufferSize)#

(No short description, might be part of a group.)

Args:

handle (Pointer/object):: (undocumented)
opA (hipsparseOperation_t):: (undocumented)
alpha (Pointer/object):: (undocumented)
matA (Pointer/object):: (undocumented)
x (Pointer/object):: (undocumented)
y (Pointer/object):: (undocumented)
computeType (hipDataType):: (undocumented)
alg (hipsparseSpSVAlg_t):: (undocumented)
spsvDescr (hipsparseSpSVDescr/object):: (undocumented)
bufferSize (Pointer/object):: (undocumented)

hip.hipsparse.hipsparseSpSV_analysis(handle, opA, alpha, matA, x, y, computeType, alg, spsvDescr, externalBuffer)#

(No short description, might be part of a group.)

Args:

handle (Pointer/object):: (undocumented)
opA (hipsparseOperation_t):: (undocumented)
alpha (Pointer/object):: (undocumented)
matA (Pointer/object):: (undocumented)
x (Pointer/object):: (undocumented)
y (Pointer/object):: (undocumented)
computeType (hipDataType):: (undocumented)
alg (hipsparseSpSVAlg_t):: (undocumented)
spsvDescr (hipsparseSpSVDescr/object):: (undocumented)
externalBuffer (Pointer/object):: (undocumented)

hip.hipsparse.hipsparseSpSV_solve(handle, opA, alpha, matA, x, y, computeType, alg, spsvDescr)#

(No short description, might be part of a group.)

Args:

handle (Pointer/object):: (undocumented)
opA (hipsparseOperation_t):: (undocumented)
alpha (Pointer/object):: (undocumented)
matA (Pointer/object):: (undocumented)
x (Pointer/object):: (undocumented)
y (Pointer/object):: (undocumented)
computeType (hipDataType):: (undocumented)
alg (hipsparseSpSVAlg_t):: (undocumented)
spsvDescr (hipsparseSpSVDescr/object):: (undocumented)

hip.hipsparse.hipsparseSpSM_createDescr()#

(No short description, might be part of a group.)

Returns:

A tuple of size 1 that contains (in that order):

descr (hipsparseSpSMDescr):
(undocumented)

hip.hipsparse.hipsparseSpSM_destroyDescr(descr)#

(No short description, might be part of a group.)

Args:

descr (hipsparseSpSMDescr/object):: (undocumented)

hip.hipsparse.hipsparseSpSM_bufferSize(handle, opA, opB, alpha, matA, matB, matC, computeType, alg, spsmDescr, bufferSize)#

(No short description, might be part of a group.)

Args:

handle (Pointer/object):: (undocumented)
opA (hipsparseOperation_t):: (undocumented)
opB (hipsparseOperation_t):: (undocumented)
alpha (Pointer/object):: (undocumented)
matA (Pointer/object):: (undocumented)
matB (Pointer/object):: (undocumented)
matC (Pointer/object):: (undocumented)
computeType (hipDataType):: (undocumented)
alg (hipsparseSpSMAlg_t):: (undocumented)
spsmDescr (hipsparseSpSMDescr/object):: (undocumented)
bufferSize (Pointer/object):: (undocumented)

hip.hipsparse.hipsparseSpSM_analysis(handle, opA, opB, alpha, matA, matB, matC, computeType, alg, spsmDescr, externalBuffer)#

(No short description, might be part of a group.)

Args:

handle (Pointer/object):: (undocumented)
opA (hipsparseOperation_t):: (undocumented)
opB (hipsparseOperation_t):: (undocumented)
alpha (Pointer/object):: (undocumented)
matA (Pointer/object):: (undocumented)
matB (Pointer/object):: (undocumented)
matC (Pointer/object):: (undocumented)
computeType (hipDataType):: (undocumented)
alg (hipsparseSpSMAlg_t):: (undocumented)
spsmDescr (hipsparseSpSMDescr/object):: (undocumented)
externalBuffer (Pointer/object):: (undocumented)

hip.hipsparse.hipsparseSpSM_solve(handle, opA, opB, alpha, matA, matB, matC, computeType, alg, spsmDescr, externalBuffer)#

(No short description, might be part of a group.)

Args:

handle (Pointer/object):: (undocumented)
opA (hipsparseOperation_t):: (undocumented)
opB (hipsparseOperation_t):: (undocumented)
alpha (Pointer/object):: (undocumented)
matA (Pointer/object):: (undocumented)
matB (Pointer/object):: (undocumented)
matC (Pointer/object):: (undocumented)
computeType (hipDataType):: (undocumented)
alg (hipsparseSpSMAlg_t):: (undocumented)
spsmDescr (hipsparseSpSMDescr/object):: (undocumented)
externalBuffer (Pointer/object):: (undocumented)

hip.hipsparse

Contents

hip.hipsparse#