C #, Code Haishibei (39) - исходный код C # «метода сопряженных градиентов» для решения «симметричных положительно определенных уравнений».

 

с помощью системы;

namespace Zhou.CSharp.Algorithm
{     /// <summary>     /// Класс LEquations для решения линейных уравнений     /// Оригинальный Zhou Changfa     /// Адаптировано для глубокой путаницы     /// </summary>     public static partial class LEquations     {

        /// <summary>
        /// Метод сопряженных градиентов для решения симметричных положительно определенных уравнений
        /// </summary>
        /// <param name="mtxLECoef">заданная матрица коэффициентов</param>
        /// <param name= "mtxLEConst">указанная постоянная матрица</param>
        /// <param name="mtxResult">Матричный эталонный объект, возвращаемая матрица решения системы уравнений</param>
        /// <param name="eps - контроль точности </param ></return>
        public static void GetRootsetGrad(Matrix mtxLECoef, Matrix mtxLEConst, Matrix mtxResult, double eps)
        {             int i, k;             double alpha, beta, d, e;

            // Количество неизвестных
            int n = mtxLECoef.GetNumColumns();

            // Инициализируем вектор решений
            mtxResult.Init(n, 1);
            double[] x = mtxResult.GetData();

            // Создаем временную матрицу
            Matrix mtxP = new Matrix(n, 1);
            double[] p = mtxP.GetData();

            double[] pDataCoef = mtxLECoef.GetData();
            double[] pDataConst = mtxLEConst.GetData();

            двойной [] r = новый двойной [n];

            для (i = 0; i <= n - 1; i++)
            {                 x[i] = 0,0;                 р[я] = pDataConst[я];                 г[я] = pDataConst[я];             }

            я = 0;
            в то время как (i <= n - 1)
            {                 Matrix mtxS = mtxLECoef.Multiply(mtxP);                 double[] s = mtxS.GetData();

                д = 0,0;
                е = 0,0;
                for (k = 0; k <= n - 1; k++)
                {                     d = d + p[k] * pDataConst[k];                     е = е + р[к] * с[к];                 }

                альфа = д/е;
                for (k = 0; k <= n - 1; k++)
                {                     x[k] = x[k] + alpha * p[k];                 }

                Матрица mtxQ = mtxLECoef.Multiply(mtxResult);
                double[] q = mtxQ.GetData();

                д = 0,0;
                for (k = 0; k <= n - 1; k++)
                {                     r[k] = pDataConst[k] - q[k];                     d = d + r[k] * s[k];                 }

                бета = d / e;
                d = 0,0;
                for (k = 0; k <= n - 1; k++)
                {                     d = d + r[k] * r[k];                 }                 if (Math.Abs(d) < float.Epsilon)                 {                     break;                 }                 // Удовлетворяем точности, решение заканчивается                 d = Math.Sqrt(d);                 if (d < eps)                 {                     break;                 }                 for (k = 0; k <= n - 1; k++ )                 {                     p[k] = r[k] - бета * p[k];                 }
















                я = я + 1;
            }
        }
}

}