Wrapper class for cusparseMatDescr handle.
Inheritance: IDisposable
        /// <summary>
        ///
        /// </summary>
        /// <returns></returns>
        public CudaSparseMatrixDescriptor Copy()
        {
            CudaSparseMatrixDescriptor retVal = new CudaSparseMatrixDescriptor();

            res = CudaSparseNativeMethods.cusparseCopyMatDescr(retVal.Descriptor, _descr);
            Debug.WriteLine(String.Format("{0:G}, {1}: {2}", DateTime.Now, "cusparseCopyMatDescr", res));
            if (res != cusparseStatus.Success)
            {
                throw new CudaSparseException(res);
            }
            return(retVal);
        }
		/// <summary>
		/// Symmetric Approximate minimum degree algorithm based on quotient graph.<para/>
		/// This function implements Symmetric Approximate Minimum Degree Algorithm based
		/// on Quotient Graph. It returns a permutation vector p such that A(p,p) would have less
		/// zero fill-in during Cholesky factorization.
		/// </summary>
		/// <param name="n">number of rows and columns of matrix A.</param>
		/// <param name="nnzA">number of nonzeros of matrix A. It is the size of csrValA and csrColIndA.</param>
		/// <param name="descrA">the descriptor of matrix A. The supported matrix type is
		/// CUSPARSE_MATRIX_TYPE_GENERAL. Also, the supported index bases are CUSPARSE_INDEX_BASE_ZERO and CUSPARSE_INDEX_BASE_ONE.</param>
		/// <param name="csrRowPtrA">integer array of n + 1 elements that contains the start of every row and the end of the last row plus one.</param>
		/// <param name="csrColIndA">integer array of nnz (=csrRowPtrA(n) * csrRowPtrA(0)) column indices of the nonzero elements of matrix A.</param>
		/// <param name="p">permutation vector of size n.</param>
		public void CsrsymamdHost(int n, int nnzA, CudaSparseMatrixDescriptor descrA, int[] csrRowPtrA, int[] csrColIndA, int[] p)
		{
			res = CudaSolveNativeMethods.Sparse.cusolverSpXcsrsymamdHost(_handle, n, nnzA, descrA.Descriptor, csrRowPtrA, csrColIndA, p);
			Debug.WriteLine(String.Format("{0:G}, {1}: {2}", DateTime.Now, "cusolverSpXcsrsymamdHost", res));
			if (res != cusolverStatus.Success) throw new CudaSolveException(res);
		}
 /// <summary>
 /// 
 /// </summary>
 /// <returns></returns>
 public CudaSparseMatrixDescriptor Copy()
 {
     CudaSparseMatrixDescriptor retVal = new CudaSparseMatrixDescriptor();
     res = CudaSparseNativeMethods.cusparseCopyMatDescr(retVal.Descriptor, _descr);
     Debug.WriteLine(String.Format("{0:G}, {1}: {2}", DateTime.Now, "cusparseCopyMatDescr", res));
     if (res != cusparseStatus.Success)
         throw new CudaSparseException(res);
     return retVal;
 }
		/// <summary>
		/// This function solves the simple eigenvalue problem A*x=lambda*x by shift-inverse method.
		/// </summary>
		/// <param name="m">number of rows and columns of matrix A.</param>
		/// <param name="nnz">number of nonzeros of matrix A.</param>
		/// <param name="descrA">the descriptor of matrix A. The supported matrix type is
		/// CUSPARSE_MATRIX_TYPE_GENERAL. Also, the supported index bases are CUSPARSE_INDEX_BASE_ZERO and CUSPARSE_INDEX_BASE_ONE.</param>
		/// <param name="csrValA">array of nnz (= csrRowPtrA(n) * csrRowPtrA(0)) nonzero elements of matrix A.</param>
		/// <param name="csrRowPtrA">integer array of n + 1 elements that contains the start of every row and the end of the last row plus one.</param>
		/// <param name="csrColIndA">integer array of nnz (=csrRowPtrA(n) * csrRowPtrA(0)) column indices of the nonzero elements of matrix A.</param>
		/// <param name="mu0">initial guess of eigenvalue.</param>
		/// <param name="x0">initial guess of eigenvector, a vecotr of size m.</param>
		/// <param name="maxite">maximum iterations in shift-inverse method.</param>
		/// <param name="tol">tolerance for convergence.</param>
		/// <param name="mu">approximated eigenvalue nearest mu0 under tolerance.</param>
		/// <param name="x">approximated eigenvector of size m.</param>
		public void Csreigvsi(int m, int nnz, CudaSparseMatrixDescriptor descrA, CudaDeviceVariable<cuDoubleComplex> csrValA, CudaDeviceVariable<int> csrRowPtrA, CudaDeviceVariable<int> csrColIndA, cuDoubleComplex mu0, CudaDeviceVariable<cuDoubleComplex> x0, int maxite, double tol, ref cuDoubleComplex mu, CudaDeviceVariable<cuDoubleComplex> x)
		{
			res = CudaSolveNativeMethods.Sparse.cusolverSpZcsreigvsi(_handle, m, nnz, descrA.Descriptor, csrValA.DevicePointer, csrRowPtrA.DevicePointer, csrColIndA.DevicePointer, mu0, x0.DevicePointer, maxite, tol, ref mu, x.DevicePointer);
			Debug.WriteLine(String.Format("{0:G}, {1}: {2}", DateTime.Now, "cusolverSpZcsreigvsi", res));
			if (res != cusolverStatus.Success) throw new CudaSolveException(res);
		}
		/// <summary/>
		public void CsreigsHost(int m, int nnz, CudaSparseMatrixDescriptor descrA, cuDoubleComplex[] csrValA, int[] csrRowPtrA, int[] csrColIndA, cuDoubleComplex left_bottom_corner, cuDoubleComplex right_upper_corner, ref int num_eigs)
		{
			res = CudaSolveNativeMethods.Sparse.cusolverSpZcsreigsHost(_handle, m, nnz, descrA.Descriptor, csrValA, csrRowPtrA, csrColIndA, left_bottom_corner, right_upper_corner, ref num_eigs);
			Debug.WriteLine(String.Format("{0:G}, {1}: {2}", DateTime.Now, "cusolverSpZcsreigsHost", res));
			if (res != cusolverStatus.Success) throw new CudaSolveException(res);
		}
		/// <summary>
		/// This function solves the following least-square problem x = argmin||A*z-b||
		/// </summary>
		/// <param name="m">number of rows of matrix A.</param>
		/// <param name="n">number of columns of matrix A.</param>
		/// <param name="nnz">number of nonzeros of matrix A.</param>
		/// <param name="descrA">the descriptor of matrix A. The supported matrix type is
		/// CUSPARSE_MATRIX_TYPE_GENERAL. Also, the supported index bases are CUSPARSE_INDEX_BASE_ZERO and CUSPARSE_INDEX_BASE_ONE.</param>
		/// <param name="csrValA">array of nnz (= csrRowPtrA(n) * csrRowPtrA(0)) nonzero elements of matrix A.</param>
		/// <param name="csrRowPtrA">integer array of n + 1 elements that contains the start of every row and the end of the last row plus one.</param>
		/// <param name="csrColIndA">integer array of nnz (=csrRowPtrA(n) * csrRowPtrA(0)) column indices of the nonzero elements of matrix A.</param>
		/// <param name="b">right hand side vector of size m.</param>
		/// <param name="tol">tolerance to decide rank of A.</param>
		/// <param name="rankA">numerical rank of A.</param>
		/// <param name="x">solution vector of size n, x=pinv(A)*b.</param>
		/// <param name="p">a vector of size n, which represents the permuation matrix P satisfying A*P^T=Q*R.</param>
		/// <param name="min_norm">||A*x-b||, x=pinv(A)*b.</param>
		public void CsrlsqvqrHost(int m, int n, int nnz, CudaSparseMatrixDescriptor descrA, cuDoubleComplex[] csrValA, int[] csrRowPtrA, int[] csrColIndA, cuDoubleComplex[] b, double tol, ref int rankA, cuDoubleComplex[] x, int[] p, ref double min_norm)
		{
			res = CudaSolveNativeMethods.Sparse.cusolverSpZcsrlsqvqrHost(_handle, m, n, nnz, descrA.Descriptor, csrValA, csrRowPtrA, csrColIndA, b, tol, ref rankA, x, p, ref min_norm);
			Debug.WriteLine(String.Format("{0:G}, {1}: {2}", DateTime.Now, "cusolverSpZcsrlsqvqrHost", res));
			if (res != cusolverStatus.Success) throw new CudaSolveException(res);
		}
		/// <summary>
		/// This function solves the simple eigenvalue problem A*x=lambda*x by shift-inverse method.
		/// </summary>
		/// <param name="m">number of rows and columns of matrix A.</param>
		/// <param name="nnz">number of nonzeros of matrix A.</param>
		/// <param name="descrA">the descriptor of matrix A. The supported matrix type is
		/// CUSPARSE_MATRIX_TYPE_GENERAL. Also, the supported index bases are CUSPARSE_INDEX_BASE_ZERO and CUSPARSE_INDEX_BASE_ONE.</param>
		/// <param name="csrValA">array of nnz (= csrRowPtrA(n) * csrRowPtrA(0)) nonzero elements of matrix A.</param>
		/// <param name="csrRowPtrA">integer array of n + 1 elements that contains the start of every row and the end of the last row plus one.</param>
		/// <param name="csrColIndA">integer array of nnz (=csrRowPtrA(n) * csrRowPtrA(0)) column indices of the nonzero elements of matrix A.</param>
		/// <param name="mu0">initial guess of eigenvalue.</param>
		/// <param name="x0">initial guess of eigenvector, a vecotr of size m.</param>
		/// <param name="maxite">maximum iterations in shift-inverse method.</param>
		/// <param name="tol">tolerance for convergence.</param>
		/// <param name="mu">approximated eigenvalue nearest mu0 under tolerance.</param>
		/// <param name="x">approximated eigenvector of size m.</param>
		public void CsreigvsiHost(int m, int nnz, CudaSparseMatrixDescriptor descrA, cuDoubleComplex[] csrValA, int[] csrRowPtrA, int[] csrColIndA, cuDoubleComplex mu0, cuDoubleComplex[] x0, int maxite, double tol, ref cuDoubleComplex mu, cuDoubleComplex[] x)
		{
			res = CudaSolveNativeMethods.Sparse.cusolverSpZcsreigvsiHost(_handle, m, nnz, descrA.Descriptor, csrValA, csrRowPtrA, csrColIndA, mu0, x0, maxite, tol, ref mu, x);
			Debug.WriteLine(String.Format("{0:G}, {1}: {2}", DateTime.Now, "cusolverSpZcsreigvsiHost", res));
			if (res != cusolverStatus.Success) throw new CudaSolveException(res);
		}
		/// <summary>
		/// This function solves the linear system A*x=b
		/// </summary>
		/// <param name="m">number of rows and columns of matrix A.</param>
		/// <param name="nnz">number of nonzeros of matrix A.</param>
		/// <param name="descrA">the descriptor of matrix A. The supported matrix type is
		/// CUSPARSE_MATRIX_TYPE_GENERAL. Also, the supported index bases are CUSPARSE_INDEX_BASE_ZERO and CUSPARSE_INDEX_BASE_ONE.</param>
		/// <param name="csrValA">array of nnz (= csrRowPtrA(n) * csrRowPtrA(0)) nonzero elements of matrix A.</param>
		/// <param name="csrRowPtrA">integer array of n + 1 elements that contains the start of every row and the end of the last row plus one.</param>
		/// <param name="csrColIndA">integer array of nnz (=csrRowPtrA(n) * csrRowPtrA(0)) column indices of the nonzero elements of matrix A.</param>
		/// <param name="b">right hand side vector of size m.</param>
		/// <param name="tol">tolerance to decide singularity.</param>
		/// <param name="reorder">no effect.</param>
		/// <param name="x">solution vector of size m, x = inv(A)*b.</param>
		/// <returns>-1 if A is invertible. Otherwise, first index j such that U(j,j)≈0</returns>
		public int CsrlsvcholHost(int m, int nnz, CudaSparseMatrixDescriptor descrA, cuFloatComplex[] csrValA, int[] csrRowPtrA, int[] csrColIndA, cuFloatComplex[] b, float tol, int reorder, cuFloatComplex[] x)
		{
			int singularity = 0;
			res = CudaSolveNativeMethods.Sparse.cusolverSpCcsrlsvcholHost(_handle, m, nnz, descrA.Descriptor, csrValA, csrRowPtrA, csrColIndA, b, tol, reorder, x, ref singularity);
			Debug.WriteLine(String.Format("{0:G}, {1}: {2}", DateTime.Now, "cusolverSpCcsrlsvcholHost", res));
			if (res != cusolverStatus.Success) throw new CudaSolveException(res);
			return singularity;
		}
		/// <summary>
		/// This function solves the linear system A*x=b
		/// </summary>
		/// <param name="m">number of rows and columns of matrix A.</param>
		/// <param name="nnz">number of nonzeros of matrix A.</param>
		/// <param name="descrA">the descriptor of matrix A. The supported matrix type is
		/// CUSPARSE_MATRIX_TYPE_GENERAL. Also, the supported index bases are CUSPARSE_INDEX_BASE_ZERO and CUSPARSE_INDEX_BASE_ONE.</param>
		/// <param name="csrValA">array of nnz (= csrRowPtrA(n) * csrRowPtrA(0)) nonzero elements of matrix A.</param>
		/// <param name="csrRowPtrA">integer array of n + 1 elements that contains the start of every row and the end of the last row plus one.</param>
		/// <param name="csrColIndA">integer array of nnz (=csrRowPtrA(n) * csrRowPtrA(0)) column indices of the nonzero elements of matrix A.</param>
		/// <param name="b">right hand side vector of size m.</param>
		/// <param name="tol">tolerance to decide singularity.</param>
		/// <param name="reorder">no effect.</param>
		/// <param name="x">solution vector of size m, x = inv(A)*b.</param>
		/// <returns>-1 if A is invertible. Otherwise, first index j such that U(j,j)≈0</returns>
		public int Csrlsvchol(int m, int nnz, CudaSparseMatrixDescriptor descrA, CudaDeviceVariable<cuDoubleComplex> csrValA, CudaDeviceVariable<int> csrRowPtrA, CudaDeviceVariable<int> csrColIndA, CudaDeviceVariable<cuDoubleComplex> b, float tol, int reorder, CudaDeviceVariable<cuDoubleComplex> x)
		{
			int singularity = 0;
			res = CudaSolveNativeMethods.Sparse.cusolverSpZcsrlsvchol(_handle, m, nnz, descrA.Descriptor, csrValA.DevicePointer, csrRowPtrA.DevicePointer, csrColIndA.DevicePointer, b.DevicePointer, tol, reorder, x.DevicePointer, ref singularity);
			Debug.WriteLine(String.Format("{0:G}, {1}: {2}", DateTime.Now, "cusolverSpZcsrlsvchol", res));
			if (res != cusolverStatus.Success) throw new CudaSolveException(res);
			return singularity;
		}
		/// <summary>
		/// This function checks if A has symmetric pattern or not. The output parameter issym
		/// reports 1 if A is symmetric; otherwise, it reports 0.
		/// </summary>
		/// <param name="m">number of rows and columns of matrix A.</param>
		/// <param name="nnzA">number of nonzeros of matrix A. It is the size of csrValA and csrColIndA.</param>
		/// <param name="descrA">the descriptor of matrix A. The supported matrix
		/// type is CUSPARSE_MATRIX_TYPE_GENERAL. Also, the supported index bases are CUSPARSE_INDEX_BASE_ZERO and CUSPARSE_INDEX_BASE_ONE.</param>
		/// <param name="csrRowPtrA">integer array of m elements that contains the start of every row.</param>
		/// <param name="csrEndPtrA">integer array of m elements that contains the end of the last row plus one.</param>
		/// <param name="csrColIndA">integer array of nnzAcolumn indices of the nonzero elements of matrix A.</param>
		/// <returns>1 if A is symmetric; 0 otherwise.</returns>
		public int CsrissymHost(int m, int nnzA, CudaSparseMatrixDescriptor descrA, int[] csrRowPtrA, int[] csrEndPtrA, int[] csrColIndA)
		{
			int issym = 0;
			res = CudaSolveNativeMethods.Sparse.cusolverSpXcsrissymHost(_handle, m, nnzA, descrA.Descriptor, csrRowPtrA, csrEndPtrA, csrColIndA, ref issym);
			Debug.WriteLine(String.Format("{0:G}, {1}: {2}", DateTime.Now, "cusolverSpXcsrissymHost", res));
			if (res != cusolverStatus.Success) throw new CudaSolveException(res);
			return issym;
		}
		/// <summary>
		/// The batched sparse QR factorization is used to solve either a set of least-squares
		/// problems or a set of linear systems
		/// </summary>
		/// <param name="m">number of rows of each matrix Aj.</param>
		/// <param name="n">number of columns of each matrix Aj.</param>
		/// <param name="nnz">number of nonzeros of each matrix Aj. It is the size csrColIndA.</param>
		/// <param name="descrA">the descriptor of matrix A. The supported matrix type is
		/// CUSPARSE_MATRIX_TYPE_GENERAL. Also, the supported index bases are CUSPARSE_INDEX_BASE_ZERO and CUSPARSE_INDEX_BASE_ONE.</param>
		/// <param name="csrValA">array of nnzA*batchSize nonzero 
		/// elements of matrices A0, A1, .... All matrices are aggregated one after another.</param>
		/// <param name="csrRowPtrA">integer array of m+1 elements that contains the
		/// start of every row and the end of the last row plus one.</param>
		/// <param name="csrColIndA">integer array of nnzAcolumn indices of the nonzero elements of each matrix Aj.</param>
		/// <param name="b">array of m*batchSize of right-hand-side vectors b0, b1, .... All vectors are aggregated one after another.</param>
		/// <param name="x">array of m*batchSize of solution vectors x0, x1, .... All vectors are aggregated one after another.</param>
		/// <param name="batchSize">number of systems to be solved.</param>
		/// <param name="info">opaque structure for QR factorization.</param>
		/// <param name="pBuffer">buffer allocated by the user, the size is returned
		/// by cusolverSpXcsrqrBufferInfoBatched().</param>
		public void CsrqrsvBatched(int m, int n, int nnz, CudaSparseMatrixDescriptor descrA, CudaDeviceVariable<cuDoubleComplex> csrValA, CudaDeviceVariable<int> csrRowPtrA, CudaDeviceVariable<int> csrColIndA, CudaDeviceVariable<cuDoubleComplex> b, CudaDeviceVariable<cuDoubleComplex> x, int batchSize, CsrQrInfo info, CudaDeviceVariable<byte> pBuffer)
		{
			res = CudaSolveNativeMethods.Sparse.cusolverSpZcsrqrsvBatched(_handle, m, n, nnz, descrA.Descriptor, csrValA.DevicePointer, csrRowPtrA.DevicePointer, csrColIndA.DevicePointer, b.DevicePointer, x.DevicePointer, batchSize, info.Info, pBuffer.DevicePointer);
			Debug.WriteLine(String.Format("{0:G}, {1}: {2}", DateTime.Now, "cusolverSpZcsrqrsvBatched", res));
			if (res != cusolverStatus.Success) throw new CudaSolveException(res);
		}
		/// <summary>
		/// The batched sparse QR factorization is used to solve either a set of least-squares
		/// problems or a set of linear systems
		/// </summary>
		/// <param name="m">number of rows of each matrix Aj.</param>
		/// <param name="n">number of columns of each matrix Aj.</param>
		/// <param name="nnz">number of nonzeros of each matrix Aj. It is the size csrColIndA.</param>
		/// <param name="descrA">the descriptor of matrix A. The supported matrix type is
		/// CUSPARSE_MATRIX_TYPE_GENERAL. Also, the supported index bases are CUSPARSE_INDEX_BASE_ZERO and CUSPARSE_INDEX_BASE_ONE.</param>
		/// <param name="csrVal">array of nnzA*batchSize nonzero 
		/// elements of matrices A0, A1, .... All matrices are aggregated one after another.</param>
		/// <param name="csrRowPtr">integer array of m+1 elements that contains the
		/// start of every row and the end of the last row plus one.</param>
		/// <param name="csrColInd">integer array of nnzAcolumn indices of the nonzero elements of each matrix Aj.</param>
		/// <param name="batchSize">number of systems to be solved.</param>
		/// <param name="info">opaque structure for QR factorization.</param>
		/// <param name="internalDataInBytes">number of bytes of the internal data.</param>
		/// <param name="workspaceInBytes">number of bytes of the buffer in numerical factorization.</param>
		public void CsrqrBufferInfoBatched(int m, int n, int nnz, CudaSparseMatrixDescriptor descrA, CudaDeviceVariable<cuDoubleComplex> csrVal, CudaDeviceVariable<int> csrRowPtr, CudaDeviceVariable<int> csrColInd, int batchSize, CsrQrInfo info, ref SizeT internalDataInBytes, ref SizeT workspaceInBytes)
		{
			res = CudaSolveNativeMethods.Sparse.cusolverSpZcsrqrBufferInfoBatched(_handle, m, n, nnz, descrA.Descriptor, csrVal.DevicePointer, csrRowPtr.DevicePointer, csrColInd.DevicePointer, batchSize, info.Info, ref internalDataInBytes, ref workspaceInBytes);
			Debug.WriteLine(String.Format("{0:G}, {1}: {2}", DateTime.Now, "cusolverSpZcsrqrBufferInfoBatched", res));
			if (res != cusolverStatus.Success) throw new CudaSolveException(res);
		}
		/// <summary>
		/// The batched sparse QR factorization is used to solve either a set of least-squares
		/// problems or a set of linear systems
		/// </summary>
		/// <param name="m">number of rows of each matrix Aj.</param>
		/// <param name="n">number of columns of each matrix Aj.</param>
		/// <param name="nnzA">number of nonzeros of each matrix Aj. It is the size csrColIndA.</param>
		/// <param name="descrA">the descriptor of matrix A. The supported matrix type is
		/// CUSPARSE_MATRIX_TYPE_GENERAL. Also, the supported index bases are CUSPARSE_INDEX_BASE_ZERO and CUSPARSE_INDEX_BASE_ONE.</param>
		/// <param name="csrRowPtrA">integer array of m+1 elements that contains the
		/// start of every row and the end of the last row plus one.</param>
		/// <param name="csrColIndA">integer array of nnzAcolumn indices of the nonzero elements of each matrix Aj.</param>
		/// <param name="info">opaque structure for QR factorization.</param>
		public void CsrqrAnalysisBatched(int m, int n, int nnzA, CudaSparseMatrixDescriptor descrA, CudaDeviceVariable<int> csrRowPtrA, CudaDeviceVariable<int> csrColIndA, CsrQrInfo info)
		{
			res = CudaSolveNativeMethods.Sparse.cusolverSpXcsrqrAnalysisBatched(_handle, m, n, nnzA, descrA.Descriptor, csrRowPtrA.DevicePointer, csrColIndA.DevicePointer, info.Info);
			Debug.WriteLine(String.Format("{0:G}, {1}: {2}", DateTime.Now, "cusolverSpXcsrqrAnalysisBatched", res));
			if (res != cusolverStatus.Success) throw new CudaSolveException(res);
		}
		/// <summary>
		/// Given a left permutation vector p which corresponds to permutation matrix P and a
		/// right permutation vector q which corresponds to permutation matrix Q, this function
		/// computes permutation of matrix A by B = P*A*Q^T
		/// </summary>
		/// <param name="m">number of rows of matrix A.</param>
		/// <param name="n">number of columns of matrix A.</param>
		/// <param name="nnzA">number of nonzeros of matrix A. It is the size of csrValA and csrColIndA.</param>
		/// <param name="descrA">the descriptor of matrix A. The supported matrix type is
		/// CUSPARSE_MATRIX_TYPE_GENERAL. Also, the supported index bases are CUSPARSE_INDEX_BASE_ZERO and CUSPARSE_INDEX_BASE_ONE.</param>
		/// <param name="csrRowPtrA">integer array of n + 1 elements that contains the start of every row and the end of the last row plus one.</param>
		/// <param name="csrColIndA">integer array of nnz (=csrRowPtrA(n) * csrRowPtrA(0)) column indices of the nonzero elements of matrix A.</param>
		/// <param name="p">left permutation vector of size m.</param>
		/// <param name="q">right permutation vector of size n.</param>
		/// <returns>number of bytes of the buffer.</returns>
		public SizeT Csrperm_bufferSizeHost(int m, int n, int nnzA, CudaSparseMatrixDescriptor descrA, int[] csrRowPtrA, int[] csrColIndA, int[] p, int[] q)
		{
			SizeT bufferSizeInBytes = new SizeT();
			res = CudaSolveNativeMethods.Sparse.cusolverSpXcsrperm_bufferSizeHost(_handle, m, n, nnzA, descrA.Descriptor, csrRowPtrA, csrColIndA, p, q, ref bufferSizeInBytes);
			Debug.WriteLine(String.Format("{0:G}, {1}: {2}", DateTime.Now, "cusolverSpXcsrperm_bufferSizeHost", res));
			if (res != cusolverStatus.Success) throw new CudaSolveException(res);
			return bufferSizeInBytes;
		}