Example #1
0
        public SolveResult BiCGSTAB(int n, int nnz, float[] csrValA, int[] csrRowA, int[] csrColA, float[] x, float[] b, float[] ax, float[] r0, float[] r, float[] v, float[] p, float[] s, float[] t, float threshold = 0.000001f, int maxIterate = 1000)
        {
            SolveResult result = new SolveResult();
            float l0 = 1.0f, alpha = 1.0f, w0 = 1.0f;
            float l1, beta, w1;
            float bn = blas.NRM2(b);
            int k = 1;

            float minusOne = 1.0f;
            float one = 1.0f;
            float zero = 0.0f;

            blas.COPY(b, r0);
            sparse.CSRMV(n, n, nnz, ref minusOne, csrValA, csrRowA, csrColA, x, ref one, r0);
            blas.COPY(r0, r);

            SetValue(n, v, 0.0f);
            SetValue(n, p, 0.0f);

            double residual = 0.0;

            while (true)
            {
                l1 = blas.DOT(r0, r);
                beta = (l1 / l0) * (alpha / w0);

                // Update p
                blas.AXPY(-w0, v, p);
                blas.SCAL(beta, p);
                blas.AXPY(1.0f, r, p);

                sparse.CSRMV(n, n, nnz, ref one, csrValA, csrRowA, csrColA, p, ref zero, v);

                // Update v
                alpha = l1 / blas.DOT(r0, v);
                blas.COPY(r, s);
                blas.AXPY(-alpha, v, s);
                sparse.CSRMV(n, n, nnz, ref one, csrValA, csrRowA, csrColA, s, ref zero, t);
                w1 = blas.DOT(t, s) / blas.DOT(t, t);

                // Update x
                blas.AXPY(alpha, p, x);
                blas.AXPY(w1, s, x);

                // Update r
                blas.COPY(s, r);
                blas.AXPY(-w1, t, r);

                //reidual = blas.NRM2(r) / bn;
                residual = blas.NRM2(s);

                if (k > maxIterate)
                {
                    result.IterateCount = k;
                    result.IsSuccess = false;
                    result.LastError = residual;
                    return result;
                }

                if (residual <= threshold)
                {
                    result.IterateCount = k;
                    result.IsSuccess = true;
                    result.LastError = residual;
                    return result;
                }

                k++;

                w0 = w1;
                l0 = l1;
            }
        }
Example #2
0
        public SolveResult CGPreconditioned(
            int n, int nnz, float[] csrValA, int[] csrRowA, int[] csrColA, float[] dx, float[] db,
            float[] csrValICP, int[] csrRowICP, int[] csrColICP,
            float[] dy, float[] dp, float[] domega, float[] zm1, float[] zm2, float[] rm2, float tolerence = 0.0001f, int maxIterate = 300)
        {
            SolveResult result = new SolveResult();

            // Make Incomplete Cholesky Preconditioner.
            gpu.Launch().DefineLower(n, csrRowICP, csrColICP);
            gpu.Launch(n, 1).CopyAIntoH(n, csrValA, csrRowA, csrValICP, csrRowICP);
            gpu.Launch(n, 1).ConstructH(n, csrValICP, csrRowICP);

            cusparseMatDescr descrM = new cusparseMatDescr();
            descrM.MatrixType = cusparseMatrixType.Triangular;
            descrM.FillMode = cusparseFillMode.Lower;
            descrM.IndexBase = cusparseIndexBase.Zero;
            descrM.DiagType = cusparseDiagType.NonUnit;

            cusparseSolveAnalysisInfo info = new cusparseSolveAnalysisInfo();
            sparse.CreateSolveAnalysisInfo(ref info);
            cusparseSolveAnalysisInfo infoTrans = new cusparseSolveAnalysisInfo();
            sparse.CreateSolveAnalysisInfo(ref infoTrans);

            sparse.CSRSV_ANALYSIS(n, nnz, csrValICP, csrRowICP, csrColICP, cusparseOperation.NonTranspose, info, descrM);
            sparse.CSRSV_ANALYSIS(n, nnz, csrValICP, csrRowICP, csrColICP, cusparseOperation.Transpose, infoTrans, descrM);

            int k = 0;
            float r1 = blas.DOT(db, db);
            float alpha, beta;

            float identityFloat = 1.0f;
            float zeroFloat = 0.0f;

            while (true)
            {
                sparse.CSRSV_SOLVE(n, ref identityFloat, csrValICP, csrRowICP, csrColICP, db, dy, cusparseOperation.NonTranspose, info, descrM);
                sparse.CSRSV_SOLVE(n, ref identityFloat, csrValICP, csrRowICP, csrColICP, dy, zm1, cusparseOperation.Transpose, infoTrans, descrM);

                k++;

                if (k == 1)
                {
                    blas.COPY(zm1, dp);
                }
                else
                {
                    beta = blas.DOT(db, zm1) / blas.DOT(rm2, zm2);
                    blas.SCAL(beta, dp);
                    blas.AXPY(1.0f, zm1, dp);
                }

                sparse.CSRMV(n, n, nnz, ref identityFloat, csrValA, csrRowA, csrColA, dp, ref zeroFloat, domega);
                alpha = blas.DOT(db, zm1) / blas.DOT(dp, domega);

                blas.AXPY(alpha, dp, dx);
                blas.COPY(db, rm2);
                blas.COPY(zm1, zm2);
                blas.AXPY(-alpha, domega, db);

                r1 = blas.DOT(db, db);

                if (r1 <= tolerence * tolerence)
                {
                    result.IsSuccess = true;
                    result.IterateCount = k;
                    result.LastError = r1;
                    break;
                }
                if (k > maxIterate)
                {
                    result.IsSuccess = false;
                    result.IterateCount = k;
                    result.LastError = r1;
                    break;
                }
            }

            return result;
        }
Example #3
0
        public SolveResult CG(
            int n, int nnz, double[] csrValA, int[] csrRowA, int[] csrColA,
            double[] dx, double[] db, double[] dp, double[] dAx, double tolerence = 0.00001f, int maxIterate = 300)
        {
            SolveResult result = new SolveResult();
            int k; // Iterate count.
            double a, b, r0, r1;
            double zero = 0.0;
            double one = 1.0;

            if (blas.DOT(db, db) == 0.0)
            {
                SetValue(n, dx, 0);
                result.IsSuccess = true;

                return result;
            }

            sparse.CSRMV(n, n, nnz, ref one, csrValA, csrRowA, csrColA, dx, ref zero, dAx);
            blas.AXPY(-1.0f, dAx, db);

            r1 = blas.DOT(db, db);

            k = 1;
            r0 = 0;

            while (true)
            {
                if (k > 1)
                {
                    b = r1 / r0;
                    blas.SCAL(b, dp);
                    blas.AXPY(1.0f, db, dp);
                }
                else
                {
                    blas.COPY(db, dp);
                }

                sparse.CSRMV(n, n, nnz, ref one, csrValA, csrRowA, csrColA, dp, ref zero, dAx);
                a = r1 / blas.DOT(dp, dAx);
                blas.AXPY(a, dp, dx);
                blas.AXPY(-a, dAx, db);

                r0 = r1;
                r1 = blas.DOT(db, db);

                k++;

                if (r1 <= tolerence * tolerence)
                {
                    result.IsSuccess = true;
                    result.LastError = r1;
                    result.IterateCount = k;
                    break;
                }

                if (k > maxIterate)
                {
                    result.IsSuccess = false;
                    result.LastError = r1;
                    result.IterateCount = k;
                    break;
                }
            }

            return result;
        }
Example #4
0
        public SolveResult BiCGSTAB(int n, int nnz, float[] csrValA, int[] csrRowA, int[] csrColA, float[] x, float[] b, float[] ax, float[] r0, float[] r, float[] v, float[] p, float[] s, float[] t, float threshold = 0.000001f, int maxIterate = 1000)
        {
            SolveResult result = new SolveResult();
            float       l0 = 1.0f, alpha = 1.0f, w0 = 1.0f;
            float       l1, beta, w1;
            float       bn = blas.NRM2(b);
            int         k  = 1;

            float minusOne = 1.0f;
            float one      = 1.0f;
            float zero     = 0.0f;

            blas.COPY(b, r0);
            sparse.CSRMV(n, n, nnz, ref minusOne, csrValA, csrRowA, csrColA, x, ref one, r0);
            blas.COPY(r0, r);

            SetValue(n, v, 0.0f);
            SetValue(n, p, 0.0f);

            double residual = 0.0;

            while (true)
            {
                l1   = blas.DOT(r0, r);
                beta = (l1 / l0) * (alpha / w0);

                // Update p
                blas.AXPY(-w0, v, p);
                blas.SCAL(beta, p);
                blas.AXPY(1.0f, r, p);

                sparse.CSRMV(n, n, nnz, ref one, csrValA, csrRowA, csrColA, p, ref zero, v);

                // Update v
                alpha = l1 / blas.DOT(r0, v);
                blas.COPY(r, s);
                blas.AXPY(-alpha, v, s);
                sparse.CSRMV(n, n, nnz, ref one, csrValA, csrRowA, csrColA, s, ref zero, t);
                w1 = blas.DOT(t, s) / blas.DOT(t, t);

                // Update x
                blas.AXPY(alpha, p, x);
                blas.AXPY(w1, s, x);

                // Update r
                blas.COPY(s, r);
                blas.AXPY(-w1, t, r);

                //reidual = blas.NRM2(r) / bn;
                residual = blas.NRM2(s);

                if (k > maxIterate)
                {
                    result.IterateCount = k;
                    result.IsSuccess    = false;
                    result.LastError    = residual;
                    return(result);
                }

                if (residual <= threshold)
                {
                    result.IterateCount = k;
                    result.IsSuccess    = true;
                    result.LastError    = residual;
                    return(result);
                }

                k++;

                w0 = w1;
                l0 = l1;
            }
        }
Example #5
0
        public SolveResult CGPreconditioned(
            int n, int nnz, float[] csrValA, int[] csrRowA, int[] csrColA, float[] dx, float[] db,
            float[] csrValICP, int[] csrRowICP, int[] csrColICP,
            float[] dy, float[] dp, float[] domega, float[] zm1, float[] zm2, float[] rm2, float tolerence = 0.0001f, int maxIterate = 300)
        {
            SolveResult result = new SolveResult();

            // Make Incomplete Cholesky Preconditioner.
            gpu.Launch().DefineLower(n, csrRowICP, csrColICP);
            gpu.Launch(n, 1).CopyAIntoH(n, csrValA, csrRowA, csrValICP, csrRowICP);
            gpu.Launch(n, 1).ConstructH(n, csrValICP, csrRowICP);

            cusparseMatDescr descrM = new cusparseMatDescr();

            descrM.MatrixType = cusparseMatrixType.Triangular;
            descrM.FillMode   = cusparseFillMode.Lower;
            descrM.IndexBase  = cusparseIndexBase.Zero;
            descrM.DiagType   = cusparseDiagType.NonUnit;

            cusparseSolveAnalysisInfo info = new cusparseSolveAnalysisInfo();

            sparse.CreateSolveAnalysisInfo(ref info);
            cusparseSolveAnalysisInfo infoTrans = new cusparseSolveAnalysisInfo();

            sparse.CreateSolveAnalysisInfo(ref infoTrans);

            sparse.CSRSV_ANALYSIS(n, nnz, csrValICP, csrRowICP, csrColICP, cusparseOperation.NonTranspose, info, descrM);
            sparse.CSRSV_ANALYSIS(n, nnz, csrValICP, csrRowICP, csrColICP, cusparseOperation.Transpose, infoTrans, descrM);

            int   k = 0;
            float r1 = blas.DOT(db, db);
            float alpha, beta;

            float identityFloat = 1.0f;
            float zeroFloat     = 0.0f;

            while (true)
            {
                sparse.CSRSV_SOLVE(n, ref identityFloat, csrValICP, csrRowICP, csrColICP, db, dy, cusparseOperation.NonTranspose, info, descrM);
                sparse.CSRSV_SOLVE(n, ref identityFloat, csrValICP, csrRowICP, csrColICP, dy, zm1, cusparseOperation.Transpose, infoTrans, descrM);

                k++;

                if (k == 1)
                {
                    blas.COPY(zm1, dp);
                }
                else
                {
                    beta = blas.DOT(db, zm1) / blas.DOT(rm2, zm2);
                    blas.SCAL(beta, dp);
                    blas.AXPY(1.0f, zm1, dp);
                }

                sparse.CSRMV(n, n, nnz, ref identityFloat, csrValA, csrRowA, csrColA, dp, ref zeroFloat, domega);
                alpha = blas.DOT(db, zm1) / blas.DOT(dp, domega);

                blas.AXPY(alpha, dp, dx);
                blas.COPY(db, rm2);
                blas.COPY(zm1, zm2);
                blas.AXPY(-alpha, domega, db);

                r1 = blas.DOT(db, db);

                if (r1 <= tolerence * tolerence)
                {
                    result.IsSuccess    = true;
                    result.IterateCount = k;
                    result.LastError    = r1;
                    break;
                }
                if (k > maxIterate)
                {
                    result.IsSuccess    = false;
                    result.IterateCount = k;
                    result.LastError    = r1;
                    break;
                }
            }

            return(result);
        }
Example #6
0
        public SolveResult CG(
            int n, int nnz, double[] csrValA, int[] csrRowA, int[] csrColA,
            double[] dx, double[] db, double[] dp, double[] dAx, double tolerence = 0.00001f, int maxIterate = 300)
        {
            SolveResult result = new SolveResult();
            int         k; // Iterate count.
            double      a, b, r0, r1;
            double      zero = 0.0;
            double      one  = 1.0;

            if (blas.DOT(db, db) == 0.0)
            {
                SetValue(n, dx, 0);
                result.IsSuccess = true;

                return(result);
            }

            sparse.CSRMV(n, n, nnz, ref one, csrValA, csrRowA, csrColA, dx, ref zero, dAx);
            blas.AXPY(-1.0f, dAx, db);

            r1 = blas.DOT(db, db);

            k  = 1;
            r0 = 0;

            while (true)
            {
                if (k > 1)
                {
                    b = r1 / r0;
                    blas.SCAL(b, dp);
                    blas.AXPY(1.0f, db, dp);
                }
                else
                {
                    blas.COPY(db, dp);
                }

                sparse.CSRMV(n, n, nnz, ref one, csrValA, csrRowA, csrColA, dp, ref zero, dAx);
                a = r1 / blas.DOT(dp, dAx);
                blas.AXPY(a, dp, dx);
                blas.AXPY(-a, dAx, db);

                r0 = r1;
                r1 = blas.DOT(db, db);

                k++;

                if (r1 <= tolerence * tolerence)
                {
                    result.IsSuccess    = true;
                    result.LastError    = r1;
                    result.IterateCount = k;
                    break;
                }

                if (k > maxIterate)
                {
                    result.IsSuccess    = false;
                    result.LastError    = r1;
                    result.IterateCount = k;
                    break;
                }
            }

            return(result);
        }