/// <summary>
        /// Creates a new CudaSparseMatrixDescriptor
        /// </summary>
        public CudaSparseMatrixDescriptor(cusparseMatrixType matrixType, cusparseFillMode fillMode, cusparseDiagType diagType, cusparseIndexBase indexBase)
        {
            _descr = new cusparseMatDescr();
            res = CudaSparseNativeMethods.cusparseCreateMatDescr(ref _descr);
            Debug.WriteLine(String.Format("{0:G}, {1}: {2}", DateTime.Now, "cusparseCreateMatDescr", res));
            if (res != cusparseStatus.Success)
				throw new CudaSparseException(res);
			SetMatType(matrixType);
			SetMatFillMode(fillMode);
			SetMatDiagType(diagType);
			SetMatIndexBase(indexBase);
        }

 public CUSPARSEStatus CusparseDdoti(cusparseHandle handle, int nnz, IntPtr xVal, IntPtr xInd, IntPtr y, ref double resultHost, cusparseIndexBase idxBase)
 {
     return cusparseDdoti(handle, nnz, xVal, xInd, y, ref resultHost, idxBase);
 }

		public static extern cusparseStatus cusparseZgemvi(cusparseContext handle,
									cusparseOperation transA,
									int m,
									int n,
									CUdeviceptr alpha, /* host or device pointer */
									CUdeviceptr A,
									int lda,
									int nnz,
									CUdeviceptr xVal,
									CUdeviceptr xInd,
									CUdeviceptr beta, /* host or device pointer */
									CUdeviceptr y,
									cusparseIndexBase idxBase,
									CUdeviceptr pBuffer);

		public static extern cusparseStatus cusparseSroti(cusparseContext handle, int nnz, CUdeviceptr xVal, CUdeviceptr xInd, CUdeviceptr y, ref float c, ref float s, cusparseIndexBase idxBase);

		public static extern cusparseStatus cusparseXcsr2coo(cusparseContext handle, CUdeviceptr csrRowPtr, int nnz, int m, CUdeviceptr cooRowInd, cusparseIndexBase idxBase);

		public static extern cusparseStatus cusparseZdotci(cusparseContext handle, int nnz, CUdeviceptr xVal, CUdeviceptr xInd, CUdeviceptr y, CUdeviceptr resultDevHostPtr, cusparseIndexBase idxBase);

		public static extern cusparseStatus cusparseZaxpyi(cusparseContext handle, int nnz, CUdeviceptr alpha, CUdeviceptr xVal, CUdeviceptr xInd, CUdeviceptr y, cusparseIndexBase idxBase);

		public static extern cusparseStatus cusparseSetMatIndexBase(cusparseMatDescr descrA, cusparseIndexBase indexBase);

 /// <summary>
 /// Multiplies the vector x in sparse format by the constant alpha and adds
 /// the result to the vector y in dense format.
 /// y = alpha * x + y
 /// </summary>
 /// <param name="alpha">constant multiplier.</param>
 /// <param name="vectorx">non-zero values of vector x.</param>
 /// <param name="indexx">indices corresponding to non‐zero values of vector x.</param>
 /// <param name="vectory">initial vector in dense format.</param>
 /// <param name="nnz">number of elements of the vector x (set to 0 for all elements).</param>
 /// <param name="ibase">The index base.</param>
 public abstract void AXPY(ref float alpha, float[] vectorx, int[] indexx, float[] vectory, int nnz = 0, cusparseIndexBase ibase = cusparseIndexBase.Zero);

 /// <summary>
 /// Converts the array containing the compressed row pointers (corresponding to CSR format) into an array of uncompressed row indices ( corresponding to COO format).
 /// It can also be used to convert the array containing the compressed column pointers (corresponding to CSC format) into an array of uncompressed column indices (corresponding to COO format).
 /// </summary>
 /// <param name="nnz">number of non-zeros of the matrix in COO format; this is also the length of array cooRow</param>
 /// <param name="m">number of rows of the matrix A; m must be at least zero.</param>
 /// <param name="csrRow">array of compressed row pointers.</param>
 /// <param name="cooRow">array of umcompressed row indices.</param>
 /// <param name="idxBase">base index.</param>
 public abstract void CSR2COO(int nnz, int m, int[] csrRow, int[] cooRow, cusparseIndexBase idxBase = cusparseIndexBase.Zero);

 /// <summary>
 /// Converts the matrix in CSR format defined with the three arrays csrVal, csrRow and csrCol into matrix A in CSC format defined by array cscVal, cscRow, cscCol.
 /// The resultng matrix can also be seen as the transpose of the original sparse matrix. This routine can also be used to convert a matrix in CSC format into a matrix in CSR format.
 /// </summary>
 /// <param name="m">number of rows of the matrix A; m must be at least zero.</param>
 /// <param name="n">number of columns of the matrix A; n must be at least zero.</param>
 /// <param name="nnz">number of non-zero elements of matrix A.</param>
 /// <param name="csrVal">array of nnz elements, where nnz is the number of non-zero elements and can be obtained from csrRow[m] - csrRow[0].</param>
 /// <param name="csrRow">array of m+1 indices.</param>
 /// <param name="csrCol">array of nnz column indices.</param>
 /// <param name="cscVal">array of nnz elements, where nnz is the number of non-zero elements and can be obtained from csrCol[n] - csrCol[0]. if copyValues is non-zero, updated array.</param>
 /// <param name="cscRow">updated array of nnz row indices.</param>
 /// <param name="cscCol">updated array of n+1 index elements.</param>
 /// <param name="copyValues">if Symbloic, cscVal array is not filled.</param>
 /// <param name="bs">base index.</param>
 public abstract void CSR2CSC(int m, int n, int nnz, double[] csrVal, int[] csrRow, int[] csrCol, double[] cscVal, int[] cscRow, int[] cscCol, cusparseAction copyValues = cusparseAction.Numeric, cusparseIndexBase bs = cusparseIndexBase.Zero);

 private static extern CUSPARSEStatus cusparseSetMatIndexBase(cusparseMatDescr descrA, cusparseIndexBase ibase);

 public CUSPARSEStatus CusparseDsctr(cusparseHandle handle, int nnz, IntPtr xVal, IntPtr xInd, IntPtr y, cusparseIndexBase ibase)
 {
     return cusparseDsctr(handle, nnz, xVal, xInd, y, ibase);
 }

 public CUSPARSEStatus CusparseDroti(cusparseHandle handle, int nnz, IntPtr xVal, IntPtr xInd, IntPtr y, ref double c, ref double s, cusparseIndexBase idxBase)
 {
     return cusparseDroti_v2(handle, nnz, xVal, xInd, y, ref c, ref s, idxBase);
 }

 public CUSPARSEStatus CusparseDgthrz(cusparseHandle handle, int nnz, IntPtr y, IntPtr xVal, IntPtr xInd, cusparseIndexBase ibase)
 {
     return cusparseDgthrz(handle, nnz, y, xVal, xInd, ibase);
 }

		/// <summary>
		/// Sets matrix index base
		/// </summary>
		/// <param name="indexBase"></param>
		public void SetMatIndexBase(cusparseIndexBase indexBase)
		{
			res = CudaSparseNativeMethods.cusparseSetMatIndexBase(_descr, indexBase);
			Debug.WriteLine(String.Format("{0:G}, {1}: {2}", DateTime.Now, "cusparseSetMatIndexBase", res));
			if (res != cusparseStatus.Success)
				throw new CudaSparseException(res);
		}

 /// <summary>
 /// Returns the dot product of a vector x in sparse format and vector y in dense format.
 /// For i = 0 to n-1
 ///     result += x[i] * y[i]
 /// </summary>
 /// <param name="vectorx">non-zero values of vector x.</param>
 /// <param name="indexx">indices corresponding to non-zero values of vector x.</param>
 /// <param name="vectory">vector in dense format.</param>
 /// <param name="n">number of non-zero elements of the vector x (set to 0 for all non-zero elements).</param>
 /// <param name="ibase">The index base.</param>
 /// <returns>result.</returns>
 public abstract float DOT(float[] vectorx, int[] indexx, float[] vectory, int n = 0, cusparseIndexBase ibase = cusparseIndexBase.Zero);

		public static extern cusparseStatus cusparseCaxpyi(cusparseContext handle, int nnz, ref cuFloatComplex alpha, CUdeviceptr xVal, CUdeviceptr xInd, CUdeviceptr y, cusparseIndexBase idxBase);

		public static extern cusparseStatus cusparseCdoti(cusparseContext handle, int nnz, CUdeviceptr xVal, CUdeviceptr xInd, CUdeviceptr y, ref cuFloatComplex resultDevHostPtr, cusparseIndexBase idxBase);

 /// <summary>
 /// Gathers the elements of the vector y listed by the index array indexx into the array vectorx, and zeroes those elements in the vector y.
 /// x[i] = y[i]
 /// y[i] = 0
 /// </summary>
 /// <param name="vectory">vector in dense format, of size greater than or equal to max(indexx)-idxBase+1.</param>
 /// <param name="vectorx">pre-allocated array in device memory of size greater than or equal to nnz.</param>
 /// <param name="indexx">indices corresponding to non-zero values of vector x.</param>
 /// <param name="nnz">number of non-zero elements of the vector x (set to 0 for all non-zero elements).</param>
 /// <param name="ibase">The index base.</param>
 public abstract void GTHRZ(float[] vectory, float[] vectorx, int[] indexx, int nnz = 0, cusparseIndexBase ibase = cusparseIndexBase.Zero);