public void Clear()
 {
     m_m = 0;
     m_n = 0;
     m_MatrixBlocks.Clear();
     m_ExplicitMatrix = null;
 }
    public override ExplicitMatrix AsExplicitMatrix()
    {
        if (m_ExplicitMatrix == null || m_ExplicitMatrix.GetM() != m_Size || m_ExplicitMatrix.GetN() != m_Size)
        {
            m_ExplicitMatrix = new ExplicitMatrix(m_Size, m_Size);
        }
        else
        {
            m_ExplicitMatrix.Clear();
        }
        ExplicitMatrix J_Explicit = m_J.AsExplicitMatrix();

        int jn = J_Explicit.GetN();

        for (int i = 0; i < m_Size; ++i)
        {
            for (int j = i; j < m_Size; ++j)
            {
                double x = 0;
                for (int k = 0; k < jn; ++k)
                {
                    double y = J_Explicit.GetValue(i, k);
                    double z = m_W[k] * J_Explicit.GetValue(j, k);
                    x += y * z;
                }
                m_ExplicitMatrix.SetValue(i, j, x);
                m_ExplicitMatrix.SetValue(j, i, x);
            }
        }
        return(m_ExplicitMatrix);
    }
    public override ExplicitMatrix AsExplicitMatrix()
    {
        if (m_ExplicitMatrix == null || m_ExplicitMatrix.GetM() != m_m || m_ExplicitMatrix.GetN() != m_n)
        {
            m_ExplicitMatrix = new ExplicitMatrix(m_m, m_n);
        }
        else
        {
            m_ExplicitMatrix.Clear();
        }
        MatrixBlock curBlock;

        for (int k = 0; k < m_MatrixBlocks.Count; ++k)
        {
            curBlock = m_MatrixBlocks[k];
            int starti  = curBlock.i;
            int startj  = curBlock.j;
            int iLength = starti + curBlock.iLength;
            int jLength = startj + curBlock.jLength;
            for (int i = starti; i < iLength; ++i)
            {
                for (int j = startj; j < jLength; ++j)
                {
                    m_ExplicitMatrix.SetValue(i, j, curBlock.data[(i - starti) * (jLength - startj) + (j - startj)]);
                }
            }
        }
        return(m_ExplicitMatrix);
    }
    public override double Solve(ImplicitMatrix A, double[] x, double[] b, out int out_StepsPerformed)
    {
        ExplicitMatrix B = A.AsExplicitMatrix();
        int            n = A.GetN();

        ClearVectorWithValue(x, 0d);
        int steps2 = 0;

        InitializeOrClear(n);

        for (; steps2 < m_SolverSteps; steps2++)
        {
            for (int i = 0; i < n; i++)
            {
                double sigma = 0;
                for (int j = 0; j < n; j++)
                {
                    if (j != i)
                    {
                        sigma = sigma + B.GetValue(i, j) * x[j];
                    }
                }

                xnext[i] = (b[i] - sigma) / B.GetValue(i, i);
            }
            double d = 0;
            A.MatrixTimesVector(xnext, r);
            for (int i = 0; i < n; i++)
            {
                x[i] = xnext[i];
                d   += (r[i] - b[i]) * (r[i] - b[i]);
            }
            if (d < m_SolverEpsilon)
            {
                break;
            }
        }

        out_StepsPerformed = steps2;
        return(0);
    }