Форум программистов, компьютерный форум, киберфорум
C# для начинающих
Войти
Регистрация
Восстановить пароль
 
Рейтинг 5.00/76: Рейтинг темы: голосов - 76, средняя оценка - 5.00
18 / 18 / 2
Регистрация: 19.09.2012
Сообщений: 92
1

Реализация метода Гаусса Зейделя

20.12.2012, 01:35. Показов 14066. Ответов 4
Метки нет (Все метки)

Доброго времени суток)
Народ есть у кого реализация метода Гаусса-Зейделя на C#?

Нашел на плюсах) только
C++
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
//Метод Гаусса-Зейделя
void __fastcall TMainForm1::Method_of_Gauss_Zeydel(void)
{
 
 int Iter=0;
 double *X0_temp,*X0,*X1;
 double epsilon=0.1;
 X0_temp=new double[M];
 X0=new double[M];
 X1=new double[M];
 for(int i=0;i<M;i++) X0[i]=random(10)+1.0;
 double Rez=0;
 do
        {
         for(int i=0;i<M;i++)
                {
                 Rez=B[i][0];
                 for(int j=0;j<M;j++)
                        {
                         if(i!=j) Rez-=A[i][j]*X0[j];
                        }
                 X1[i]=(1.0/A[i][i])*Rez;
                 X0_temp[i]=X0[i];
                 X0[i]=X1[i];
                 Rez=B[i][0];
                }
         Iter++;
        }
 while(fabs(X1[0]-X0_temp[0])>epsilon);
 for(int i=0;i<M;i++) X[i][0]=X1[i];
 
 delete [] X0_temp;
 delete [] X0;
 delete [] X1;
 
}
Добавлено через 4 минуты
C#
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
/// <summary>
/// Поиск решения СЛАУ методом Зейделя (итерационный метод)
/// </summary>
/// <param name="mm">Матрица задающая СЛАУ</param>
/// <returns>Вектор решений</returns>
public static Row Zeidel(Matrix mm)
{
    Row x = new Row(mm.rowCount);
    for (int i = 0; i < mm.rowCount; i++)
        x[i] = mm[i, mm.colCount - 1];
 
    Row prev_x = new Row(mm.rowCount);
    bool tmp;
    int counter = 0;
    do
    {
        counter++;
        if (counter > 200)
        {
            for (int i = 0; i < mm.rowCount; i++)
                x[i] = double.NaN;
            MessageBox.Show("Произошло зацикливание");
            return x;
        }
        tmp = true;
        for (int i = 0; i < mm.rowCount; i++)
        {
            double var = 0;
            for (int j = 0; j < mm.rowCount; j++)
                if (i != j)
                    var += mm[i, j] * x[j];
            prev_x[i] = x[i];
 
            x[i] = (mm[i, mm.colCount - 1] - var) / mm[i, i];
            tmp = tmp && (Math.Abs(prev_x[i] - x[i]) < Eps);
        }
    } while (!tmp);
 
    return x;
}
Добавлено через 38 минут
C#
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
/// <summary>
/// Вычисление нормы матрицы ||D||1
/// </summary>
/// <param name="mm">Матрица задающая СЛАУ</param>
/// <returns>Норма матрицы</returns>
public static double MatrixNorma1(Matrix mm)
{
    double max_sum = 0;
    for (int j = 0; j < mm.colCount - 1; j++)
    {
        double sum = 0;
        for (int i = 0; i < mm.rowCount; i++)
            if (i != j)
                sum += Math.Abs(mm[i, j] / mm[i,i]);
        max_sum = Math.Max(sum,max_sum);
    }
    return max_sum;
}
Добавлено через 27 секунд
C#
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
/// <summary>
/// Класс строки матрицы
/// </summary>
public class Row
{
    /// <summary>
    /// Массив элементов
    /// </summary>
    private double[] m;
 
    /// <summary>
    /// Длина массива
    /// </summary>
    public int length;
 
    /// <summary>
    /// Конструктор
    /// </summary>
    /// <param name="length">Длина создаваемого массива</param>
    public Row(int length)
    {
        this.length = length;
        m = new double[length];
    }
 
    /// <summary>
    /// Делает копию класса и данных содержащихся в классе
    /// </summary>
    /// <returns>копия текущего класса</returns>
    public Row Clone()
    {
        Row tmp = new Row(m.Length);
        for (int i = 0; i < m.Length; i++)
            tmp[i] = m[i];
        return tmp;
    }
 
    /// <summary>
    /// производит обмен значений двух элементов массива
    /// </summary>
    /// <param name="i">индекс элемента массива</param>
    /// <param name="j">индекс элемента массива</param>
    public void Exchange(int i, int j)
    {
        double tmp = m[i];
        m[i] = m[j];
        m[j] = tmp;
    }
 
    public static Row operator *(double k, Row t)
    {
        Row tmp = t.Clone();
        for (int i = 0; i < tmp.length; i++)
            tmp[i] = k * tmp[i];
        return tmp;
    }
 
    public static Row operator /(Row t, double k)
    {
        Row tmp = t.Clone();
        for (int i = 0; i < tmp.length; i++)
            tmp[i] = tmp[i]/k;
        return tmp;
    }
 
    public static Row operator -(Row t1, Row t2)
    {
        Row tmp = t1.Clone();
        for (int i = 0; i < t1.length; i++)
            tmp[i] = t1[i] - t2[i];
        return tmp;
    }
 
    public static Row operator +(Row t1, Row t2)
    {
        Row tmp = t1.Clone();
        for (int i = 0; i < t1.length; i++)
            tmp[i] = t1[i] + t2[i];
        return tmp;
    }
 
    public double this[int i]
    {
        set
        {
            m[i] = value;
        }
        get
        {
            return m[i];
        }
    }
 
    public string ToString()
    {
        string s = "";
        for (int i = 0; i < length; i++)
            s += m[i].ToString("F") + " ";
        return s.Trim();
    }
 
}
 
/// <summary>
/// Матрица заданного размера
/// </summary>
public class Matrix
{
    /// <summary>
    /// Массив строк
    /// </summary>
    private Row[] rows;
 
    /// <summary>
    /// Количество строк
    /// </summary>
    public int rowCount;
 
    /// <summary>
    /// Количество столбцов
    /// </summary>
    public int colCount;
 
    public string ToString()
    {
        string s = "";
        for (int i = 0; i < rowCount; i++)
            s += rows[i].ToString() + " \r\n";
        return s.Trim();
    }
 
    /// <summary>
    /// Клонирует матрицу
    /// </summary>
    /// <returns>колнированная матрица</returns>
    public Matrix Clone()
    {
        Matrix tmp = new Matrix(colCount, rowCount);
        for (int i = 0; i < tmp.rowCount; i++)
            tmp[i] = rows[i].Clone();
        return tmp;
    }
 
    /// <summary>
    /// Конструктор
    /// </summary>
    /// <param name="colNum">число столбцов</param>
    /// <param name="rowNum">число строк</param>
    public Matrix(int colNum, int rowNum)
    {
        rows = new Row[rowNum];
        rowCount = rowNum;
        colCount = colNum;
 
        for (int i = 0; i < rowNum; i++)
            rows[i] = new Row(colNum);
    }
 
    /// <summary>
    /// Переставить строки местами
    /// </summary>
    /// <param name="i">номер первой строки</param>
    /// <param name="j">номер второй строки</param>
    public void ExchangeRows(int i, int j)
    {
        Row tmp = rows[i];
        rows[i] = rows[j];
        rows[j] = tmp;
    }
 
    /// <summary>
    /// Переставить колонки местами
    /// </summary>
    /// <param name="c1">номер первой колонки</param>
    /// <param name="c2">номер второй колонки</param>
    public void ExchangeColumns(int c1, int c2)
    {
        for (int i = 0; i < rowCount; i++)
            rows[i].Exchange(c1, c2);
    }
 
    /// <summary>
    /// Обращение к строке матрицы
    /// </summary>
    /// <param name="i">номер строки</param>
    /// <returns>строку матрицы</returns>
    public Row this[int i]
    {
        set
        {
            rows[i] = value;
        }
 
        get
        {
            return rows[i];
        }
    }
 
    /// <summary>
    /// Обращение к элементу матрицы
    /// </summary>
    /// <param name="i">
    /// номер строки в которой расположен элемент</param>
    /// <param name="j">
    /// номер столбца в которой расположен элемент</param>
    /// <returns>значение элемента матрицы</returns>
    public double this[int i, int j]
    {
        set
        {
            rows[i][j] = value;
        }
        get
        {
            return rows[i][j];
        }
    }
}
Добавлено через 20 секунд
C#
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
/// <summary>
/// Класс строки матрицы
/// </summary>
public class Row
{
    /// <summary>
    /// Массив элементов
    /// </summary>
    private double[] m;
 
    /// <summary>
    /// Длина массива
    /// </summary>
    public int length;
 
    /// <summary>
    /// Конструктор
    /// </summary>
    /// <param name="length">Длина создаваемого массива</param>
    public Row(int length)
    {
        this.length = length;
        m = new double[length];
    }
 
    /// <summary>
    /// Делает копию класса и данных содержащихся в классе
    /// </summary>
    /// <returns>копия текущего класса</returns>
    public Row Clone()
    {
        Row tmp = new Row(m.Length);
        for (int i = 0; i < m.Length; i++)
            tmp[i] = m[i];
        return tmp;
    }
 
    /// <summary>
    /// производит обмен значений двух элементов массива
    /// </summary>
    /// <param name="i">индекс элемента массива</param>
    /// <param name="j">индекс элемента массива</param>
    public void Exchange(int i, int j)
    {
        double tmp = m[i];
        m[i] = m[j];
        m[j] = tmp;
    }
 
    public static Row operator *(double k, Row t)
    {
        Row tmp = t.Clone();
        for (int i = 0; i < tmp.length; i++)
            tmp[i] = k * tmp[i];
        return tmp;
    }
 
    public static Row operator /(Row t, double k)
    {
        Row tmp = t.Clone();
        for (int i = 0; i < tmp.length; i++)
            tmp[i] = tmp[i]/k;
        return tmp;
    }
 
    public static Row operator -(Row t1, Row t2)
    {
        Row tmp = t1.Clone();
        for (int i = 0; i < t1.length; i++)
            tmp[i] = t1[i] - t2[i];
        return tmp;
    }
 
    public static Row operator +(Row t1, Row t2)
    {
        Row tmp = t1.Clone();
        for (int i = 0; i < t1.length; i++)
            tmp[i] = t1[i] + t2[i];
        return tmp;
    }
 
    public double this[int i]
    {
        set
        {
            m[i] = value;
        }
        get
        {
            return m[i];
        }
    }
 
    public string ToString()
    {
        string s = "";
        for (int i = 0; i < length; i++)
            s += m[i].ToString("F") + " ";
        return s.Trim();
    }
 
}
 
/// <summary>
/// Матрица заданного размера
/// </summary>
public class Matrix
{
    /// <summary>
    /// Массив строк
    /// </summary>
    private Row[] rows;
 
    /// <summary>
    /// Количество строк
    /// </summary>
    public int rowCount;
 
    /// <summary>
    /// Количество столбцов
    /// </summary>
    public int colCount;
 
    public string ToString()
    {
        string s = "";
        for (int i = 0; i < rowCount; i++)
            s += rows[i].ToString() + " \r\n";
        return s.Trim();
    }
 
    /// <summary>
    /// Клонирует матрицу
    /// </summary>
    /// <returns>колнированная матрица</returns>
    public Matrix Clone()
    {
        Matrix tmp = new Matrix(colCount, rowCount);
        for (int i = 0; i < tmp.rowCount; i++)
            tmp[i] = rows[i].Clone();
        return tmp;
    }
 
    /// <summary>
    /// Конструктор
    /// </summary>
    /// <param name="colNum">число столбцов</param>
    /// <param name="rowNum">число строк</param>
    public Matrix(int colNum, int rowNum)
    {
        rows = new Row[rowNum];
        rowCount = rowNum;
        colCount = colNum;
 
        for (int i = 0; i < rowNum; i++)
            rows[i] = new Row(colNum);
    }
 
    /// <summary>
    /// Переставить строки местами
    /// </summary>
    /// <param name="i">номер первой строки</param>
    /// <param name="j">номер второй строки</param>
    public void ExchangeRows(int i, int j)
    {
        Row tmp = rows[i];
        rows[i] = rows[j];
        rows[j] = tmp;
    }
 
    /// <summary>
    /// Переставить колонки местами
    /// </summary>
    /// <param name="c1">номер первой колонки</param>
    /// <param name="c2">номер второй колонки</param>
    public void ExchangeColumns(int c1, int c2)
    {
        for (int i = 0; i < rowCount; i++)
            rows[i].Exchange(c1, c2);
    }
 
    /// <summary>
    /// Обращение к строке матрицы
    /// </summary>
    /// <param name="i">номер строки</param>
    /// <returns>строку матрицы</returns>
    public Row this[int i]
    {
        set
        {
            rows[i] = value;
        }
 
        get
        {
            return rows[i];
        }
    }
 
    /// <summary>
    /// Обращение к элементу матрицы
    /// </summary>
    /// <param name="i">
    /// номер строки в которой расположен элемент</param>
    /// <param name="j">
    /// номер столбца в которой расположен элемент</param>
    /// <returns>значение элемента матрицы</returns>
    public double this[int i, int j]
    {
        set
        {
            rows[i][j] = value;
        }
        get
        {
            return rows[i][j];
        }
    }
}
__________________
Помощь в написании контрольных, курсовых и дипломных работ здесь
0
Programming
Эксперт
94731 / 64177 / 26122
Регистрация: 12.04.2006
Сообщений: 116,782
20.12.2012, 01:35
Ответы с готовыми решениями:

Методом Гаусса-Зейделя вычислить систему линейных уравнений
Методом Гаусса-Зейделя вычислить с точностью до 0,001 систему линейных уравнений....

Ошибка в реализации метода Зейделя
Подскажите пожалуйста где в коде у меня ошибка. Заранее благодарю. using System; class Class1...

Ускорение/оптимизация метода. Решение СЛАУ методом Гаусса
Здравствуйте. Имеется готовый рабочий алгоритм решения СЛАУ методом прямого(приведение к...

Решение системы линейных уравнений с помощью метода Гаусса
Помогите реализовать данную программу на С#. Здесь описан алгоритм решения системы линейных...

4
2 / 2 / 0
Регистрация: 22.09.2015
Сообщений: 1
22.09.2015, 22:23 2
Реализация итерационного метода Гаусса-Зейделя. В программе численный метод в виде отдельного класса. Класс содержит 2 метода: непосредственно сам алгоритм итерационного метода и проверку на диагональное преобладание. Метод Гаусса-Зейделя находит верные корни при условии, что диагональное преобладание есть, в противном случае результат тоже выдает, но он может быть некорректен.
В методе Main реализован ввод данных с клавиатуры и подстановка рандомных значений, вывод информаци о диагональном преобладании, найденное решение и количество итераций.
Прилагаю блок-схему алгоритма.

C#
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
class Program
    {
        static void Main(string[] args)
        {
            do
            {
                try
                {
                    Console.WriteLine("-----------------------------------------------------------\nSolving systems of linear equations by Gauss-Seidel method\n-----------------------------------------------------------\nEnter dimension of the matrix:");
                    int n = int.Parse(Console.ReadLine());
                    double[,] a = new double[n, n];
                    double[] b = new double[n];
                    double[] x = new double[n]; //нулевые приближения
                    for (int i = 0; i < n; i++)
                    {
                        x[i] = 0;
                    }
 
                    Console.WriteLine("===========================================================\nTo enter data from the keyboard - press 1\nTo enter random data - press 2");
                    int key = int.Parse(Console.ReadLine());
                    switch (key)
                    {
                        case 1:
                            {
                                for (int i = 0; i < n; i++) //ввод коэффицентов
                                {
                                    for (int j = 0; j < n; j++)
                                    {
                                        Console.WriteLine("Enter the element from position [" + (i+1) + "," + (j+1) + "]:");
                                        a[i, j] = double.Parse(Console.ReadLine());
                                    }
                                }
 
                                for (int j = 0; j < n; j++) //ввод значений
                                {
                                    Console.WriteLine("Enter the value from position [" + (j+1) + "]:");
                                    b[j] = double.Parse(Console.ReadLine());
                                }
                            }
                            break;
                        case 2:
                            {
                                Random r = new Random();
                                for (int i = 0; i < n; i++) //ввод коэффицентов
                                {
                                    for (int j = 0; j < n; j++)
                                    {
                                        a[i, j] = r.Next(-50, 50);
                                        Console.WriteLine("The element from position [" + (i+1) + "," + (j+1) + "]: "+a[i,j]);
                                    }
                                }
 
                                for (int j = 0; j < n; j++) //ввод значений
                                {
                                    b[j] = r.Next(-50, 50);
                                    Console.WriteLine("The value from position [" + (j+1) + "]: " + b[j]);
                                }
                            }
                            break;
                        default: Console.WriteLine("Input error.\n===========================================================");
                            break;
                    }
                    Console.WriteLine("===========================================================");
                    GaussZeidel test = new GaussZeidel(a, b, 500, n, x);
                    bool IsDiagonal = test.DiagonallyDominant();
                    if (IsDiagonal==true)
                    {
                        Console.WriteLine("The matrix has the property of diagonal dominance\n===========================================================");
                    }
                    else
                    {
                        Console.WriteLine("The matrix does not have the property of diagonal dominance\n===========================================================");
                    }
                    test.algoritm();
                    for (int j = 0; j < n; j++)
                    {
                        Console.WriteLine("X" + (j+1) + " = " + test.roots[j]); 
                    }
                    Console.WriteLine("The number of iterations: " + test.k + "\n===========================================================\nPress Esc to exit or any key to continue");
                }
                catch (Exception ex)
                {
                    Console.WriteLine(ex.ToString());
                }
            } while (Console.ReadKey().Key != ConsoleKey.Escape);     
        }
    }
C#
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
public class GaussZeidel
    {
            public static double epsilon = 0.01; //точность вычисления
            public int n, k, N; //N -допустимое число итераций, n - размерность квадратной матрицы коэффицентов, k-количество итераций
            public double s, Xi, diff = 1; //s - сумма, величина погрешности
            public double[,] matrix; //матрица коэффицентов
            public double[] value; //матрица значений
            public double[] roots; //матрица корней
            public bool diagonal;
 
            public GaussZeidel(double[,] matrix, double[] value, int N, int n, double[] roots)
            {
                this.matrix = matrix;
                this.N = N;
                this.value = value;
                this.n = n;
                this.roots = roots;
            }
 
            public bool DiagonallyDominant()
            {
                for (int i = 0; i < n; i++ )
                {
                    double sum = 0;
                    for (int j=0; j < n; j++)
                    {
                        if (i !=j)
                        {
                            sum += Math.Abs(matrix[i, j]);
                        }
                    }
                    if (Math.Abs(matrix[i,i])>=sum)
                    {
                        diagonal = true;
                        break;
                    }
                    else
                    {
                        diagonal = false;
                    }
                }
                return diagonal;
            }
 
            public void algoritm()
            {
                k = 0;
                while ((k <= N) && (diff >= epsilon))
                {
                    k = k + 1;
                    for (int i = 0; i < n; i++)
                    {
                        s = 0;
                        for (int j = 0; j < n; j++)
                        {
                            if (i != j)
                            {
                                s += matrix[i, j] * roots[j];
                            }
                        }
                        Xi = (value[i] - s) / matrix[i, i];
                        diff = Math.Abs(Xi - roots[i]);
                        roots[i] = Xi;
                    }
                }
            }
        }
Миниатюры
Реализация метода Гаусса Зейделя  
2
1 / 1 / 0
Регистрация: 05.12.2015
Сообщений: 10
30.10.2016, 15:05 3
Anastas1a, а можешь представить метод в форме?
0
1 / 1 / 0
Регистрация: 05.12.2015
Сообщений: 10
11.11.2016, 23:49 4
Сделал по ним форму но корни не совпадают с корнями, которые считаю(для проверке) в маткаде. Не знаю что и делать уже :С
https://yadi.sk/d/mLJm4fbYyRaGx
1
1 / 1 / 0
Регистрация: 02.12.2017
Сообщений: 52
06.10.2020, 16:17 5
boomman, У вас ещё есть исходники? Яндекс-ссылка не работает...
0
IT_Exp
Эксперт
87844 / 49110 / 22898
Регистрация: 17.06.2006
Сообщений: 92,604
06.10.2020, 16:17

Реализация метода транспозиции C#
как реализовать метод, в котором найденный элемент переставляется на один элемент к голове списка....

Реализация метода интерфейса
Всем доброго времени суток. При попытке запуска выдает ошибку что не реализован метод getLen. я...

Реализация метода расширения
Задание звучит так: К классу Console добавить методы расширения для печати объема оперативной...

Реализация симплекс-метода
Всем привет! Помогите, пожалуйста, встретил статью в Интернете, ниже. Сам новичок в С#, не могу...


Искать еще темы с ответами

Или воспользуйтесь поиском по форуму:
5
Ответ Создать тему
Опции темы

КиберФорум - форум программистов, компьютерный форум, программирование
Powered by vBulletin
Copyright ©2000 - 2022, CyberForum.ru