def __init__(self, A, mtype=11, verbose=False):
self.mtype = mtype
self.n = A.shape[0]
# If A is symmetric, store only the upper triangular portion
if mtype in [2, -2, 3, 4, -4, 6]:
A = sp.triu(A, format='csr')
elif mtype in [11, 13]:
A = A.tocsr()
elif mtype == 1:
msg = "mtype = 1 (real and structurally symmetric)"
raise NotImplementedError(msg)
else:
msg = "Invalid mtype: mtype={}".format(mtype)
raise ValueError(msg)
self.a = A.data
self.ia = A.indptr
self.ja = A.indices
self._MKL_a = self.a.ctypes.data_as(POINTER(c_float))
self._MKL_ia = self.ia.ctypes.data_as(POINTER(c_int))
self._MKL_ja = self.ja.ctypes.data_as(POINTER(c_int))
# Hardcode some parameters for now...
self.maxfct = 1
self.mnum = 1
self.perm = 0
if verbose:
self.msglvl = 1
else:
self.msglvl = 0
# Initialize handle to data structure
self.pt = np.zeros(64, np.int64)
self._MKL_pt = self.pt.ctypes.data_as(POINTER(c_longlong))
# Initialize parameters
self.iparm = np.zeros(64, dtype=np.int32)
self._MKL_iparm = self.iparm.ctypes.data_as(POINTER(c_int))
# Initialize pardiso
pardisoinit(self._MKL_pt, byref(c_int(self.mtype)), self._MKL_iparm)
# Set iparm
self.iparm[1] = 3 # Use parallel nested dissection for reordering
self.iparm[23] = 1 # Use parallel factorization
self.iparm[34] = 1 # Zero base indexing
def __init__(self, A, mtype=11, verbose=False):
'''
Parameters
----------
A : scipy.sparse.csr.csr_matrix
sparse matrix in csr format.
mtype : int, optional
flag specifying the matrix type. The possible types are:
- 1 : real and structurally symmetric (not supported)
- 2 : real and symmetric positive definite
- -2 : real and symmetric indefinite
- 3 : complex and structurally symmetric (not supported)
- 4 : complex and Hermitian positive definite
- -4 : complex and Hermitian indefinite
- 6 : complex and symmetric
- 11 : real and nonsymmetric (default)
- 13 : complex and nonsymmetric
verbose : bool, optional
flag for verbose output. Default is False.
Returns
-------
None
'''
self.mtype = mtype
if mtype in [1, 3]:
msg = "mtype = 1/3 - structurally symmetric matrices not supported"
raise NotImplementedError(msg)
elif mtype in [2, -2, 4, -4, 6, 11, 13]:
pass
else:
msg = "Invalid mtype: mtype={}".format(mtype)
raise ValueError(msg)
self.n = A.shape[0]
if mtype in [4, -4, 6, 13]:
# Complex matrix
self.dtype = np.complex128
elif mtype in [2, -2, 11]:
# Real matrix
self.dtype = np.float64
self.ctypes_dtype = ctypeslib.ndpointer(self.dtype)
# If A is symmetric, store only the upper triangular portion
if mtype in [2, -2, 4, -4, 6]:
A = sp.triu(A, format='csr')
elif mtype in [11, 13]:
A = A.tocsr()
if not A.has_sorted_indices:
A.sort_indices()
self.a = A.data
self.ia = A.indptr
self.ja = A.indices
self._MKL_a = self.a.ctypes.data_as(self.ctypes_dtype)
self._MKL_ia = self.ia.ctypes.data_as(POINTER(c_int))
self._MKL_ja = self.ja.ctypes.data_as(POINTER(c_int))
# Hardcode some parameters for now...
self.maxfct = 1
self.mnum = 1
self.perm = 0
if verbose:
self.msglvl = 1
else:
self.msglvl = 0
# Initialize handle to data structure
self.pt = np.zeros(64, np.int64)
self._MKL_pt = self.pt.ctypes.data_as(POINTER(c_longlong))
# Initialize parameters
self.iparm = np.zeros(64, dtype=np.int32)
self._MKL_iparm = self.iparm.ctypes.data_as(POINTER(c_int))
# Initialize pardiso
pardisoinit(self._MKL_pt, byref(c_int(self.mtype)), self._MKL_iparm)
# Set iparm
self.iparm[1] = 3 # Use parallel nested dissection for reordering
self.iparm[23] = 1 # Use parallel factorization
self.iparm[34] = 1 # Zero base indexing
def __init__(self, A, mtype=11, verbose=False):
'''
Parameters
----------
A : scipy.sparse.csr.csr_matrix
sparse matrix in csr format.
mtype : int, optional
flag specifying the matrix type. The possible types are:
- 1 : real and structurally symmetric (not supported)
- 2 : real and symmetric positive definite
- -2 : real and symmetric indefinite
- 3 : complex and structurally symmetric (not supported)
- 4 : complex and Hermitian positive definite
- -4 : complex and Hermitian indefinite
- 6 : complex and symmetric
- 11 : real and nonsymmetric (default)
- 13 : complex and nonsymmetric
verbose : bool, optional
flag for verbose output. Default is False.
Returns
-------
None
'''
self.mtype = mtype
if mtype in [1, 3]:
msg = "mtype = 1/3 - structurally symmetric matrices not supported"
raise NotImplementedError(msg)
elif mtype in [2, -2, 4, -4, 6, 11, 13]:
pass
else:
msg = "Invalid mtype: mtype={}".format(mtype)
raise ValueError(msg)
self.n = A.shape[0]
if mtype in [4, -4, 6, 13]:
# Complex matrix
self.dtype = np.complex128
elif mtype in [2, -2, 11]:
# Real matrix
self.dtype = np.float64
self.ctypes_dtype = ctypeslib.ndpointer(self.dtype)
# If A is symmetric, store only the upper triangular portion
if mtype in [2, -2, 4, -4, 6]:
A = sp.triu(A, format='csr')
elif mtype in [11, 13]:
A = A.tocsr()
if not A.has_sorted_indices:
A.sort_indices()
self.a = A.data
self.ia = A.indptr
self.ja = A.indices
self._MKL_a = self.a.ctypes.data_as(self.ctypes_dtype)
self._MKL_ia = self.ia.ctypes.data_as(POINTER(c_int))
self._MKL_ja = self.ja.ctypes.data_as(POINTER(c_int))
# Hardcode some parameters for now...
self.maxfct = 1
self.mnum = 1
self.perm = 0
if verbose:
self.msglvl = 1
else:
self.msglvl = 0
# Initialize handle to data structure
self.pt = np.zeros(64, np.int64)
self._MKL_pt = self.pt.ctypes.data_as(POINTER(c_longlong))
# Initialize parameters
self.iparm = np.zeros(64, dtype=np.int32)
self._MKL_iparm = self.iparm.ctypes.data_as(POINTER(c_int))
# Initialize pardiso
pardisoinit(self._MKL_pt, byref(c_int(self.mtype)), self._MKL_iparm)
# Set iparm
self.iparm[1] = 3 # Use parallel nested dissection for reordering
self.iparm[23] = 1 # Use parallel factorization
self.iparm[34] = 1 # Zero base indexing
def __init__(self, A, my_iparm2, my_iparm10, my_iparm11, my_iparm13,
my_iparm8, my_iparm21, my_iparm27,
mtype=11, verbose=False, pivoting=False):
self.mtype = mtype
if mtype in [1, 3]:
msg = "mtype = 1/3 - structurally symmetric matrices not supported"
raise NotImplementedError(msg)
elif mtype in [2, -2, 4, -4, 6, 11, 13]:
pass
else:
msg = "Invalid mtype: mtype={}".format(mtype)
raise ValueError(msg)
self.n = A.shape[0]
if mtype in [4, -4, 6, 13]:
# Complex matrix
self.dtype = np.complex128
elif mtype in [2, -2, 11]:
# Real matrix
self.dtype = np.float64
self.ctypes_dtype = ctypeslib.ndpointer(self.dtype)
# If A is symmetric, store only the upper triangular portion
if mtype in [2, -2, 4, -4, 6]:
A = sp.triu(A, format='csr')
elif mtype in [11, 13]:
A = A.tocsr()
if not A.has_sorted_indices:
A.sort_indices()
self.a = A.data
self.ia = A.indptr
self.ja = A.indices
self._MKL_a = self.a.ctypes.data_as(self.ctypes_dtype)
self._MKL_ia = self.ia.ctypes.data_as(POINTER(c_int))
self._MKL_ja = self.ja.ctypes.data_as(POINTER(c_int))
# Hardcode some parameters for now...
self.maxfct = 1
self.mnum = 1
self.perm = 0
if verbose:
self.msglvl = 1
else:
self.msglvl = 0
# Initialize handle to data structure
self.pt = np.zeros(64, np.int64)
self._MKL_pt = self.pt.ctypes.data_as(POINTER(c_longlong))
# Initialize parameters
self.iparm = np.zeros(64, dtype=np.int32)
self._MKL_iparm = self.iparm.ctypes.data_as(POINTER(c_int))
# Initialize pardiso
pardisoinit(self._MKL_pt, byref(c_int(self.mtype)), self._MKL_iparm)
# Set iparm
self.iparm[1] = 3 # Use parallel nested dissection for reordering
self.iparm[23] = 1 # Use parallel factorization
self.iparm[34] = 1 # Zero base indexing
# For constrained systems with highly indefinite symmetric matrices
if pivoting:
self.iparm[1] = my_iparm2
self.iparm[9] = my_iparm10
self.iparm[10] = my_iparm11
self.iparm[12] = my_iparm13
self.iparm[7] = my_iparm8
self.iparm[20] = my_iparm21
self.iparm[26] = my_iparm27