public /**/ double quality()
        {
            return(SpecializedOps_DDRM.qualityTriangular(LU));
        }

        /**
         * a specialized version of solve that avoid additional checks that are not needed.
         */
        public void _solveVectorInternal(double[] vv)
        {
            // Solve L*Y = B
            int ii = 0;

            for (int i = 0; i < n; i++)
            {
                int    ip  = indx[i];
                double sum = vv[ip];
                vv[ip] = vv[i];
                if (ii != 0)
                {
                    //                for( int j = ii-1; j < i; j++ )
                    //                    sum -= dataLU[i* n +j]*vv[j];
                    int index = i * n + ii - 1;
                    for (int j = ii - 1; j < i; j++)
                    {
                        sum -= dataLU[index++] * vv[j];
                    }
                }
                else if (sum != 0.0)
                {
                    ii = i + 1;
                }
                vv[i] = sum;
            }

            // Solve U*X = Y;
            TriangularSolver_DDRM.solveU(dataLU, vv, n);
        }
Esempio n. 2
0
        public static void solveLower(DMatrixRMaj L, DMatrixRMaj B, DMatrixRMaj X, double[] vv)
        {
            int numCols = B.numCols;
            int N       = L.numCols;

            for (int j = 0; j < numCols; j++)
            {
                for (int i = 0; i < N; i++)
                {
                    vv[i] = B.data[i * numCols + j];
                }
                // solve L*y=b storing y in x
                TriangularSolver_DDRM.solveL(L.data, vv, N);

                // solve L^T*x=y
                TriangularSolver_DDRM.solveTranL(L.data, vv, N);
                for (int i = 0; i < N; i++)
                {
                    X.data[i * numCols + j] = vv[i];
                }
            }
        }