Форум программистов, компьютерный форум CyberForum.ru

Решение СЛОУ методом Гаусса с выбором главного элемента по строке - C++

Восстановить пароль Регистрация
 
 
Рейтинг: Рейтинг темы: голосов - 27, средняя оценка - 5.00
isu
6 / 0 / 0
Регистрация: 01.10.2012
Сообщений: 64
17.12.2013, 12:13     Решение СЛОУ методом Гаусса с выбором главного элемента по строке #1
Задание:Решение СЛОУ методом Гаусса с выбором главного элемента по строке.Для тестирования решить систему.
Запускается,но вывод получается жуткий,даже проверить тяжело,как поправить бы,пожалуйста)
Вот,что получилось:
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
#include <iostream>
#include <stdio.h>
#include <math.h>
#include <stdio.h>
#include <stdlib.h>
using namespace std;
int main() {
    double array[5][5];
    array[0][0]=2; array[0][1]=-4; array[0][2]=6; array[0][3]=2; array[0][4]=-2; 
    array[1][0]=1; array[1][1]=-2; array[1][2]=1; array[1][3]=-1; array[1][4]=-1; 
    array[2][0]=-1; array[2][1]=3; array[2][2]=-2; array[2][3]=4; array[2][4]=3; 
    array[3][0]=-1; array[3][1]=4; array[3][2]=1; array[3][3]=-3; array[3][4]=2; 
    array[4][0]=1; array[4][1]=-2; array[4][2]=3; array[4][3]=4; array[4][4]=-6; 
    int r,l,i,j,k=0;
    int n=4;
    double x[5];
    double h[5];
    double max,c;
    for(int i=0;i<=n;i++){
        if(i>=1) cout << "\n"; 
        for(int j=0;j<=n;j++){
            cout << "mas"<<++i <<":"<<++j <<": ";i--;j--;
            cout<< array[i][j] << " ";
            
            
        }
    }
    for(int k=0;k<=n;k++){
        cout << n;
        cout << "\n==============";
        max = array[k][0];
        l=1;
            for(i=1;i>n;i++){
                if(array[k][i]>max) {      //Находим максимальный элемнт
                    max = array[k][i];
                    l=i;
                }
            }
    }
    if(l!=k){ // Меняем к-й столбец и столбец с минимальным элементом местами
        cout << "Замена: ";
        cout << "\n max: " << max;
        cout << "\n l: " << l;
        for(i=10;i<=n;i++) h[5]= array[i][k];//Записываем k-й столбец в отдельный массив
        for(i=10;i<=n;i++) array[i][k]= array[i][l];//Вместо k-го столбца помещаем столбец с минимальным                 
     //  элементом
        for(i=10;i<=n;i++) array[i][l]= h[i];//Вместо столбца с минимальным элементом помещаем матрицу h
    }
    
    if(l!=k) {
        for(i=0;i<=n;i++){
            for(j=0;j<=n;j++){
                cout << array[i][j];
            }
 
        }
    }
 
    for(j=0;j<=n;j++){
        array[k][j]=array[k][j]/max;
        for(i=k+1;i<=n;i++){
            max=array[i][k];
            array[i][j]=array[i][j]-max*array[k][j];
        }
        for(i=0;i<=n;i++){
            for(j=1;j<=n;j++){
                cout<< array[i][j];
            }
        }
    }
    cout << "Матрица после прямого хода";
    for(i=0;i<=n;i++){
        for(j=0;j<=n;j++){
            cout <<array[i][j];
        }
    }
    c=0;
    x[n]= array[n][n]/array[n][n];
    for(i=n;i>=n;i--){
        c=0;
        for(j=i;j<=n;j++) c=c+array[i][j]*x[j];
        x[i]=array[i][n]-c;
    }
    cout <<"Ответ\n";
    for(i=0;i<=n;i++){
        cout << x[i]<< "\n";
    }
    cout <<"\n";
    system("pause");
}
Добавлено через 17 часов 33 минуты
актуально
Similar
Эксперт
41792 / 34177 / 6122
Регистрация: 12.04.2006
Сообщений: 57,940
17.12.2013, 12:13     Решение СЛОУ методом Гаусса с выбором главного элемента по строке
Посмотрите здесь:

Метод Гаусса с выбором главного элемента C++
Решение СЛАУ методом Гаусса C++
Найти решение системы линейных уравнений методом Гаусса с выбором главного элемента в столбце C++
Метод Гаусса с выбором главного элемента по строке C++
C++ Исправить код С++ "Метод Гаусса с выбором главного элемента по строке"
После регистрации реклама в сообщениях будет скрыта и будут доступны все возможности форума.
Ev_Hyper
 Аватар для Ev_Hyper
1806 / 1627 / 435
Регистрация: 15.12.2013
Сообщений: 5,790
17.12.2013, 12:24     Решение СЛОУ методом Гаусса с выбором главного элемента по строке #2
У меня вообще выдает ошибку. Вот тут для начала измените
C++
1
for(i=10;i<=n;i++) h[5]= array[i][k];//Записываем k-й столбец в отдельный массив
на это:
C++
1
for(i=10;i<=n;i++) h[i]= array[i][k];//Записываем k-й столбец в отдельный массив
Сам вывод сделайте вот таким:
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
#include <iostream>
#include <stdio.h>
#include <math.h>
#include <stdio.h>
#include <stdlib.h>
using namespace std;
int main() {
    double array[5][5];
    array[0][0]=2; array[0][1]=-4; array[0][2]=6; array[0][3]=2; array[0][4]=-2; 
    array[1][0]=1; array[1][1]=-2; array[1][2]=1; array[1][3]=-1; array[1][4]=-1; 
    array[2][0]=-1; array[2][1]=3; array[2][2]=-2; array[2][3]=4; array[2][4]=3; 
    array[3][0]=-1; array[3][1]=4; array[3][2]=1; array[3][3]=-3; array[3][4]=2; 
    array[4][0]=1; array[4][1]=-2; array[4][2]=3; array[4][3]=4; array[4][4]=-6; 
    int r,l,i,j,k=0;
    int n=4;
    double x[5];
    double h[5];
    double max,c;
    for(int i=0;i<=n;i++){
        if(i>=1) cout << "\n"; 
        for(int j=0;j<=n;j++){
            cout << "mas"<<++i <<":"<<++j <<": ";i--;j--;
            cout<< array[i][j] << " ";
            
            
        }
    }
    for(int k=0;k<=n;k++){
        cout << n;
        cout << "\n==============";
        max = array[k][0];
        l=1;
            for(i=1;i>n;i++){
                if(array[k][i]>max) {      //Находим максимальный элемнт
                    max = array[k][i];
                    l=i;
                }
            }
    }
    if(l!=k){ // Меняем к-й столбец и столбец с минимальным элементом местами
        cout << "Замена: ";
        cout << "\n max: " << max;
        cout << "\n l: " << l;
        for(i=10;i<=n;i++) h[i]= array[i][k];//Записываем k-й столбец в отдельный массив
        for(i=10;i<=n;i++) array[i][k]= array[i][l];//Вместо k-го столбца помещаем столбец с минимальным                 
     //  элементом
        for(i=10;i<=n;i++) array[i][l]= h[i];//Вместо столбца с минимальным элементом помещаем матрицу h
    }
    
    if(l!=k) {
        for(i=0;i<=n;i++){
            for(j=0;j<=n;j++){
                cout << array[i][j]<<" ";
            }
            cout<<endl;
 
        }
    }
 
    for(j=0;j<=n;j++){
        array[k][j]=array[k][j]/max;
        for(i=k+1;i<=n;i++){
            max=array[i][k];
            array[i][j]=array[i][j]-max*array[k][j];
        }
        for(i=0;i<=n;i++){
            for(j=1;j<=n;j++){
                cout<< array[i][j]<<" ";
            }
            cout<<endl;
        }
    }
    cout << "Матрица после прямого хода";
    for(i=0;i<=n;i++){
        for(j=0;j<=n;j++){
            cout <<array[i][j]<<" ";
        }
        cout<<endl;
    }
    c=0;
    x[n]= array[n][n]/array[n][n];
    for(i=n;i>=n;i--){
        c=0;
        for(j=i;j<=n;j++) c=c+array[i][j]*x[j];
        x[i]=array[i][n]-c;
    }
    cout <<"Ответ\n";
    for(i=0;i<=n;i++){
        cout << x[i]<< "\n";
    }
    cout <<"\n";
    system("pause");
}
Добавлено через 37 секунд
Проверку "логики кода" не делал.
igorrr37
 Аватар для igorrr37
1593 / 1221 / 118
Регистрация: 21.12.2010
Сообщений: 1,868
Записей в блоге: 7
17.12.2013, 14:54     Решение СЛОУ методом Гаусса с выбором главного элемента по строке #3
делал давно, но, кажется, это и есть с выбором макс. элемента. Матрицу читает из файла (число строк, число столбцов и сама матрица), пример файла
Bash
1
2
3
4
5
2
3
 
1     2.2   3
3.1   5     6
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
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
#include <iostream>
#include <clocale>
#include <stdlib.h>
#include <iomanip>
#include <string>
#include <cstring>
#include <fstream>
#include <windows.h>
 
// Освобождает память из-под матрицы
template<typename T>
void FreeMemory(T** pmatrix, size_t const rows)
{
    for(size_t i = 0; i < rows; ++i)
    {
        delete[] pmatrix[i];
        pmatrix[i] = 0;
    }
    delete[] pmatrix;
    pmatrix = 0;
}
 
// Выделение памяти под матрицу
template<typename T>
T**& GetMemory(T**& pmatrix, size_t const rows, size_t const columns)
{
    size_t i = 0;
    try
    {
        pmatrix = new T*[rows];
        for(i = 0; i < rows; ++i)
            pmatrix[i] = 0;
        for(i = 0; i < rows; ++i)
            pmatrix[i] = new T[columns];
    }
    catch(std::bad_alloc const& exc)
    {
        std::cerr << "GetMemory: Exception: Неуспешное выделение памяти\n\n";
        FreeMemory(pmatrix, rows);
        throw;
    }
    return pmatrix;
}
 
// Заполняет матрицу из файла
template<typename T>
T**& FillFromFile(std::string const& filepath, T**& pmatrix, size_t& rows, size_t& columns)
{
    try
    {
        std::ifstream ifs(filepath.c_str());
        if(ifs.is_open())
        {
            ifs >> rows >> columns;
            if(!rows || !columns)
                throw "Ошибка чтения файла: !rows || !columns\n";
            GetMemory(pmatrix, rows, columns);
            for(size_t i = 0; i < rows; ++i)
            {
                for(size_t j = 0; j < columns; ++j)
                {
                    ifs >> pmatrix[i][j];
                }
            }
            if(!ifs)
                    throw "Ошибка чтения файла: !ifs\n";
            ifs.close();
        }
        else
            std::cerr << "FillFromFile: неуспешное открытие файла\n";
    }
    catch(char const* e)
    {
        std::cerr << "FillFromFile: Exception: " << e << "\n\n";
        throw;
    }
    return pmatrix;
}
 
// Вывод матрицы в поток
template<typename T>
std::ostream& MatrixToStream(T* const* const pmatrix, size_t const rows, size_t const columns, std::ostream& ost = std::cout)
{
    ost << "\n-------------------------MatrixToStream-------------------------------\n";
    ost << "Размер: " << rows << " x " << columns << "\n";
    for(size_t i = 0; i < rows; ++i)
    {
        for(size_t j = 0; j < columns; ++j)
        {
            ost << std::setw(13) << std::left << pmatrix[i][j];
        }
        ost << "\n\n";
    }
    ost << "\n----------------------------------------------------------------------\n";
    return ost;
}
 
// Умножение массива на число
double* MultiplicationArrayToNumber(double* parray, size_t const columns, double const number)
{
    for(size_t j = 0; j < columns; ++j)
    {
        parray[j] = parray[j] * number;
    }
    return parray;
}
 
// Вычитание массива 2 из массива 1 (они равной длины)
double* SubtractionOfArrays(double* parray1, double* parray2, size_t const columns)
{
    for(size_t j = 0; j < columns; ++j)
    {
        parray1[j] = parray1[j] - parray2[j];
    }
    return parray1;
}
 
// Обмен двух массивов
void SwapArrays(double* parray1, double* parray2, size_t const columns)
{
    double* ptmparray = new double[columns];
    memcpy(ptmparray, parray1, columns * sizeof(double));
    memcpy(parray1, parray2, columns * sizeof(double));
    memcpy(parray2, ptmparray, columns * sizeof(double));
    delete[] ptmparray;
    ptmparray = 0;
}
 
// Поиск строки среди текущей и нижележащих строк, содержащей в заданном столбце максимальный элемент
size_t MaxRowIndex(double** pdmatrix, size_t const rows, size_t const columnindex)
{
    size_t maxrowindex = columnindex, i, j;
    for(i = columnindex + 1; i < rows; ++i)
    {
        if(pdmatrix[i][columnindex] > pdmatrix[columnindex][columnindex])
            maxrowindex = i;
    }
    return maxrowindex;
}
 
// Приведение матрицы к верхнетреугольному виду
size_t MakeTriangularMatrix(double** pdmatrix, size_t const rows, size_t const columns)
{
    size_t rootnumber = rows;
    size_t i = 0, j = 0, k = 0, maxrowindex = 0;
    double* prowcopy = new double[columns];
    for(j = 0; j < rows - 1; ++j)
    {
        maxrowindex = MaxRowIndex(pdmatrix, rows, j);
        if(maxrowindex != j)
            SwapArrays(pdmatrix[maxrowindex], pdmatrix[j], columns);
        if(double(0) != pdmatrix[j][j])
        {
            MultiplicationArrayToNumber(pdmatrix[j], columns, 1 / pdmatrix[j][j]);
            for(i = j + 1; i < rows; ++i)
            {
                memcpy(prowcopy, pdmatrix[j], columns * sizeof(double));
                MultiplicationArrayToNumber(prowcopy, columns, pdmatrix[i][j]);
                SubtractionOfArrays(pdmatrix[i], prowcopy, columns);
            }
        }
    }
    delete[] prowcopy;
    prowcopy = 0;
    // Проверка системы на вырожденность
    for(i = 0; i < rows; ++i)
    {
        bool zerorow = true;
        for(j = 0; j < columns - 1; ++j)
        {
            if(pdmatrix[i][j] != double(0))
            {
                zerorow = false;
                break;
            }
        }
        if(zerorow && pdmatrix[i][columns - 1] != double(0))
        {
            std::cout << "\nCистема НЕСОВМЕСТНА\n\n";
            rootnumber = 0;
            break;
        }
        else if(zerorow && pdmatrix[i][columns - 1] == double(0))
        {
            std::cout << "\nCистема имеет БЕСКОНЕЧНОЕ МНОЖЕСТВО РЕШЕНИЙ\n\n";
            rootnumber = rows + 5;
            break;
        }
    }
    return rootnumber; // Возвращает число корней
}
 
//Вычисляет корни СЛАУ по верхнетреугольной матрице
double* GetRoots(double** pdmatrix, size_t const rows, double* pdroots)
{
    int i = 0, j = 0;
    for(i = rows - 1; i >= 0; --i)
    {
        double sum = 0;
        for(j = rows - 1; j > i; --j)
            sum += pdroots[j] * pdmatrix[i][j];
        pdroots[i] = (pdmatrix[i][rows] - sum) / pdmatrix[i][i];
    }
    return pdroots;
}
 
int main()
{
    setlocale(LC_ALL, "rus");
    std::string const filepath("in.txt"); // файл с матрицей
    size_t rows = 0, columns = 0, i = 0, j = 0;
    double** pdmatrix = 0;
    try
    {
        FillFromFile(filepath, pdmatrix, rows, columns);
        if(rows + 1 == columns)
        {
            std::cout << "\n\nИсходная матрица:\n";
            MatrixToStream(pdmatrix, rows, columns);
            size_t rootnumber = MakeTriangularMatrix(pdmatrix, rows, columns);
            std::cout << "\n\nТреугольная матрица:\n";
            MatrixToStream(pdmatrix, rows, columns);
            if(rows == rootnumber)
            {
                double* pdroots = new double[rows];
                GetRoots(pdmatrix, rows, pdroots);
                std::cout << "\n\nКорни системы:\n\n";
                for(i = 0; i < rows; ++i)
                    std::cout << "X" << i << ": " << pdroots[i] << '\n';
                delete[] pdroots;
                pdroots = 0;
            }
            else
                std::cout << "Матрица вырождена\n";
        }
        else
            std::cerr << "Не соблюдено: rows + 1 == columns\n";
        FreeMemory(pdmatrix, rows);
    }
    catch(...){}
    return 0;
}
isu
6 / 0 / 0
Регистрация: 01.10.2012
Сообщений: 64
18.12.2013, 07:31  [ТС]     Решение СЛОУ методом Гаусса с выбором главного элемента по строке #4
Спасибо)
isu
6 / 0 / 0
Регистрация: 01.10.2012
Сообщений: 64
20.12.2013, 11:38  [ТС]     Решение СЛОУ методом Гаусса с выбором главного элемента по строке #5
а как сделать,чтобы считались матрицы не только 2 на 3,а например,3 на 3?
igorrr37
 Аватар для igorrr37
1593 / 1221 / 118
Регистрация: 21.12.2010
Сообщений: 1,868
Записей в блоге: 7
20.12.2013, 13:07     Решение СЛОУ методом Гаусса с выбором главного элемента по строке #6
просто изменить файл, например
Bash
1
2
3
4
5
6
3
3
 
1     2.2   3
3.1   5     6
15    7     22
isu
6 / 0 / 0
Регистрация: 01.10.2012
Сообщений: 64
21.12.2013, 01:01  [ТС]     Решение СЛОУ методом Гаусса с выбором главного элемента по строке #7
C++
1
if(rows + 1 == columns)
условие же,а если поменять,то catch не хочет цепляться(
igorrr37
 Аватар для igorrr37
1593 / 1221 / 118
Регистрация: 21.12.2010
Сообщений: 1,868
Записей в блоге: 7
21.12.2013, 05:55     Решение СЛОУ методом Гаусса с выбором главного элемента по строке #8
a, точно, число столбцов должно быть равно числу неизвестных плюс столбец свободных членов, т.е. можно или 2х3 или 3х4, а 3х3 нельзя
isu
6 / 0 / 0
Регистрация: 01.10.2012
Сообщений: 64
21.12.2013, 09:31  [ТС]     Решение СЛОУ методом Гаусса с выбором главного элемента по строке #9
а поменять можно как - нибудь,очень надо)
S_el
1907 / 1502 / 296
Регистрация: 15.12.2013
Сообщений: 5,919
21.12.2013, 09:46     Решение СЛОУ методом Гаусса с выбором главного элемента по строке #10
Что очень надо?
azoller
17 / 17 / 1
Регистрация: 03.05.2013
Сообщений: 114
21.12.2013, 10:32     Решение СЛОУ методом Гаусса с выбором главного элемента по строке #11
Можно и 2х2, и 3х3, и 3х4... Как угодно можно. Все зависит от того, как ты будешь реализовывать.
Хочешь, сделай столбец свободных членов в отдельный массив, хочешь, можешь добавить n+1 колонкой к основной матрице размером n. Так что все зависит от того, что творится в твоей голове.
-=ЮрА=-
Заблокирован
Автор FAQ
21.12.2013, 11:10     Решение СЛОУ методом Гаусса с выбором главного элемента по строке #12
Цитата Сообщение от isu Посмотреть сообщение
а поменять можно как - нибудь,очень надо)
- рекомендую воспользоваться этим алгоритмом Методом Гаусса решить систему n линейных алгебраических уравнений
Кликните здесь для просмотра всего текста
Цитата Сообщение от -=ЮрА=- Посмотреть сообщение
Результаты работы
Enter NUM of equations: 5
a[1][1] = 2
a[1][2] = 0
a[1][3] = 0
a[1][4] = -12
a[1][5] = 3
a[2][1] = 0
a[2][2] = 2
a[2][3] = 0
a[2][4] = 3
a[2][5] = 2
a[3][1] = 0
a[3][2] = 0
a[3][3] = 38
a[3][4] = 5
a[3][5] = 7
a[4][1] = -12
a[4][2] = 13
a[4][3] = 5
a[4][4] = 0
a[4][5] = 0
a[5][1] = 3
a[5][2] = 2
a[5][3] = 7
a[5][4] = 0
a[5][5] = 0
b[1] = 22
b[2] = 14
b[3] = 456
b[4] = 0
b[5] = 5
See input
Matrix A:
2.000 0.000 0.000 -12.000 3.000
0.000 2.000 0.000 3.000 2.000
0.000 0.000 38.000 5.000 7.000
-12.000 13.000 5.000 0.000 0.000
3.000 2.000 7.000 0.000 0.000
Vector B:
22.000 14.000 456.000 0.000 5.000
Solving on Gauss method
Forvard Gauss course
Matrix A:
-12.000 13.000 5.000 0.000 0.000
0.000 5.250 8.250 0.000 0.000
0.000 0.000 38.000 5.000 7.000
0.000 0.000 0.000 -11.662 3.474
0.000 0.000 0.000 0.000 3.596
Vector B:
0.000 5.000 456.000 50.794 64.678
Back Gauss course
Matrix A:
-12.000 13.000 5.000 0.000 0.000
0.000 5.250 8.250 0.000 0.000
0.000 0.000 38.000 5.000 7.000
0.000 0.000 0.000 -11.662 3.474
0.000 0.000 0.000 0.000 3.596
Vector B:
0.000 5.000 456.000 50.794 64.678
Results : <- Это ответы
-9.967 -12.491 8.555 1.002 17.987
Press Y for new input


Добавлено через 1 минуту
Вот FAQ с тем же методом http://www.cyberforum.ru/faq/thread4...ml#post2536056


Добавлено через 1 минуту

Не по теме:

Цитата Сообщение от azoller Посмотреть сообщение
Можно и 2х2, и 3х3, и 3х4...
- То что красным не можно методом Гаусса (по крайней мере не полагая один из корней числу от балды), будь внимательным при ответах!

azoller
17 / 17 / 1
Регистрация: 03.05.2013
Сообщений: 114
21.12.2013, 11:52     Решение СЛОУ методом Гаусса с выбором главного элемента по строке #13
-=ЮрА=-, а мне казалось что можно написать алгоритм, обрабатывающий отдельно 3 столбца "основной матрицы" и "столбец свободных членов" в одной и той же матрице.
-=ЮрА=-
Заблокирован
Автор FAQ
21.12.2013, 12:02     Решение СЛОУ методом Гаусса с выбором главного элемента по строке #14
azoller, в математике когда говорят о системе 3-го подразумевают что у неё есть вектор свободных членов т.е есть А[3х3] и В[3х1]. Общепринятый матричный вид СЛАУ А*X = B и следует писать в общеприянтых терминах. Можно реализовать всё что угодно, но искушённому человеку размерность 3х4 явно укажет на непонимание ответчиком сути проблемы поэтому если под такой размерностью подразумевается нечто иное - нужно оговаривать
isu
6 / 0 / 0
Регистрация: 01.10.2012
Сообщений: 64
21.12.2013, 15:30  [ТС]     Решение СЛОУ методом Гаусса с выбором главного элемента по строке #15
чтобы программа и правильные матрицы читала
isu
6 / 0 / 0
Регистрация: 01.10.2012
Сообщений: 64
23.12.2013, 14:01  [ТС]     Решение СЛОУ методом Гаусса с выбором главного элемента по строке #16
Просто не очень хотелось особо вникать в чужой код,думал,что пара строчек только мешают,придется весь алгоритм менять?

Добавлено через 12 часов 8 минут
актуально,хочется уже доделать наконец)
MrGluck
Ворчун
Эксперт С++
 Аватар для MrGluck
4924 / 2667 / 243
Регистрация: 29.11.2010
Сообщений: 7,421
23.12.2013, 15:40     Решение СЛОУ методом Гаусса с выбором главного элемента по строке #17
Цитата Сообщение от -=ЮрА=- Посмотреть сообщение
То что красным не можно методом Гаусса
-=ЮрА=-, почему же? Просто тогда обязательно принимаем одну из переменных за свободный член. Но решаем тем же способом.

Добавлено через 21 секунду
Цитата Сообщение от isu Посмотреть сообщение
актуально,хочется уже доделать наконец)
флаг вам в руки
isu
6 / 0 / 0
Регистрация: 01.10.2012
Сообщений: 64
23.12.2013, 19:10  [ТС]     Решение СЛОУ методом Гаусса с выбором главного элемента по строке #18
Последняя просьба,поправил,теперь работает с матрицами 3х3,проверьте,пожалуйста
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
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
#include "stdafx.h"
#include <iostream>
#include <clocale>
#include <stdlib.h>
#include <iomanip>
#include <string>
#include <cstring>
#include <fstream>
#include <windows.h>
 
// Освобождает память из-под матрицы
template<typename T>
void FreeMemory(T** pmatrix, size_t const rows)
{
    for (size_t i = 0; i < rows; ++i)
    {
        delete[] pmatrix[i];
        pmatrix[i] = 0;
    }
    delete[] pmatrix;
    pmatrix = 0;
}
 
// Выделение памяти под матрицу
template<typename T>
T**& GetMemory(T**& pmatrix, size_t const rows, size_t const columns)
{
    size_t i = 0;
    try
    {
        pmatrix = new T*[rows];
        for (i = 0; i < rows; ++i)
            pmatrix[i] = 0;
        for (i = 0; i < rows; ++i)
            pmatrix[i] = new T[columns];
    }
    catch (std::bad_alloc const& exc)
    {
        std::cerr << "GetMemory: Exception: Неуспешное выделение памяти\n\n";
        FreeMemory(pmatrix, rows);
        throw;
    }
    return pmatrix;
}
 
// Заполняет матрицу из файла
template<typename T>
T**& FillFromFile(std::string const& filepath, T**& pmatrix, size_t& rows, size_t& columns)
{
    try
    {
        std::ifstream ifs(filepath.c_str());
        if (ifs.is_open())
        {
            ifs >> rows >> columns;
            if (!rows || !columns)
                throw "Ошибка чтения файла: !rows || !columns\n";
            GetMemory(pmatrix, rows, columns);
            for (size_t i = 0; i < rows; ++i)
            {
                for (size_t j = 0; j < columns; ++j)
                {
                    ifs >> pmatrix[i][j];
                }
            }
            if (!ifs)
                throw "Ошибка чтения файла: !ifs\n";
            ifs.close();
        }
        else
            std::cerr << "FillFromFile: неуспешное открытие файла\n";
    }
    catch (char const* e)
    {
        std::cerr << "FillFromFile: Exception: " << e << "\n\n";
        throw;
    }
    return pmatrix;
}
 
// Вывод матрицы в поток
template<typename T>
std::ostream& MatrixToStream(T* const* const pmatrix, size_t const rows, size_t const columns, std::ostream& ost = std::cout)
{
    ost << "\n-------------------------MatrixToStream-------------------------------\n";
    ost << "Размер: " << rows << " x " << columns << "\n";
    for (size_t i = 0; i < rows; ++i)
    {
        for (size_t j = 0; j < columns; ++j)
        {
            ost << std::setw(13) << std::left << pmatrix[i][j];
        }
        ost << "\n\n";
    }
    ost << "\n----------------------------------------------------------------------\n";
    return ost;
}
 
// Умножение массива на число
double* MultiplicationArrayToNumber(double* parray, size_t const columns, double const number)
{
    for (size_t j = 0; j < columns; ++j)
    {
        parray[j] = parray[j] * number;
    }
    return parray;
}
 
// Вычитание массива 2 из массива 1 (они равной длины)
double* SubtractionOfArrays(double* parray1, double* parray2, size_t const columns)
{
    for (size_t j = 0; j < columns; ++j)
    {
        parray1[j] = parray1[j] - parray2[j];
    }
    return parray1;
}
 
// Обмен двух массивов
void SwapArrays(double* parray1, double* parray2, size_t const columns)
{
    double* ptmparray = new double[columns];
    memcpy(ptmparray, parray1, columns * sizeof(double));
    memcpy(parray1, parray2, columns * sizeof(double));
    memcpy(parray2, ptmparray, columns * sizeof(double));
    delete[] ptmparray;
    ptmparray = 0;
}
 
// Поиск строки среди текущей и нижележащих строк, содержащей в заданном столбце максимальный элемент
size_t MaxRowIndex(double** pdmatrix, size_t const rows, size_t const columnindex)
{
    size_t maxrowindex = columnindex, i, j;
    for (i = columnindex + 1; i < rows; ++i)
    {
        if (pdmatrix[i][columnindex] > pdmatrix[columnindex][columnindex])
            maxrowindex = i;
    }
    return maxrowindex;
}
 
// Приведение матрицы к верхнетреугольному виду
size_t MakeTriangularMatrix(double** pdmatrix, size_t const rows, size_t const columns)
{
    size_t rootnumber = rows;
    size_t i = 0, j = 0, k = 0, maxrowindex = 0;
    double* prowcopy = new double[columns];
    for (j = 0; j < rows - 1; ++j)
    {
        maxrowindex = MaxRowIndex(pdmatrix, rows, j);
        if (maxrowindex != j)
            SwapArrays(pdmatrix[maxrowindex], pdmatrix[j], columns);
        if (double(0) != pdmatrix[j][j])
        {
            MultiplicationArrayToNumber(pdmatrix[j], columns, 1 / pdmatrix[j][j]);
            for (i = j + 1; i < rows; ++i)
            {
                memcpy(prowcopy, pdmatrix[j], columns * sizeof(double));
                MultiplicationArrayToNumber(prowcopy, columns, pdmatrix[i][j]);
                SubtractionOfArrays(pdmatrix[i], prowcopy, columns);
            }
        }
    }
    delete[] prowcopy;
    prowcopy = 0;
    // Проверка системы на вырожденность
    for (i = 0; i < rows; ++i)
    {
        bool zerorow = true;
        for (j = 0; j < columns - 1; ++j)
        {
            if (pdmatrix[i][j] != double(0))
            {
                zerorow = false;
                break;
            }
        }
        if (zerorow && pdmatrix[i][columns - 1] != double(0))
        {
            std::cout << "\nCистема НЕСОВМЕСТНА\n\n";
            rootnumber = 0;
            break;
        }
        else if (zerorow && pdmatrix[i][columns - 1] == double(0))
        {
            std::cout << "\nCистема имеет БЕСКОНЕЧНОЕ МНОЖЕСТВО РЕШЕНИЙ\n\n";
            rootnumber = rows + 5;
            break;
        }
    }
    return rootnumber; // Возвращает число корней
}
 
//Вычисляет корни СЛАУ по верхнетреугольной матрице
double* GetRoots(double** pdmatrix, size_t const rows, double* pdroots)
{
    int i = 0, j = 0;
    for (i = rows - 1; i >= 0; --i)
    {
        double sum = 0;
        for (j = rows - 1; j > i; --j)
            sum += pdroots[j] * pdmatrix[i][j];
        pdroots[i] = (pdmatrix[i][rows] - sum) / pdmatrix[i][i];
    }
    return pdroots;
}
 
int main()
{
    setlocale(LC_ALL, "rus");
    std::string const filepath("in.txt"); // файл с матрицей
    size_t rows = 0, columns = 0, i = 0, j = 0;
    double** pdmatrix = 0;
    try
    {
        FillFromFile(filepath, pdmatrix, rows, columns);
        if (rows + 0 == columns)
        {
            std::cout << "\n\nИсходная матрица:\n";
            MatrixToStream(pdmatrix, rows, columns);
            size_t rootnumber = MakeTriangularMatrix(pdmatrix, rows, columns);
            std::cout << "\n\nТреугольная матрица:\n";
            MatrixToStream(pdmatrix, rows, columns);
            if (rows == rootnumber)
            {
                double* pdroots = new double[rows];
                GetRoots(pdmatrix, rows, pdroots);
                std::cout << "\n\nКорни системы:\n\n";
                for (i = 0; i < rows; ++i)
                    std::cout << "X" << i << ": " << pdroots[i] << '\n';
                delete[] pdroots;
                pdroots = 0;
            }
            else
                std::cout << "Матрица вырождена\n";
        }
        else
            std::cerr << "Не соблюдено: rows == columns\n";
        FreeMemory(pdmatrix, rows);
    }
    catch (...){}
    return 0;
}
-=ЮрА=-
23.12.2013, 20:56
  #19

Не по теме:

Цитата Сообщение от MrGluck Посмотреть сообщение
-=ЮрА=-, почему же? Просто тогда обязательно принимаем одну из переменных за свободный член. Но решаем тем же способом.
читай внимательно мои ответы[quote="-=ЮрА=-;5532753"]То что красным не можно методом Гаусса (по крайней мере не полагая один из корней числу от балды)

MoreAnswers
Эксперт
37091 / 29110 / 5898
Регистрация: 17.06.2006
Сообщений: 43,301
23.12.2013, 21:25     Решение СЛОУ методом Гаусса с выбором главного элемента по строке
Еще ссылки по теме:

C++ Метод Гаусса с выбором элемента по столбцу
C++ Решение СЛАУ методом Гаусса
Решение матриц Методом Гаусса C++

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

Или воспользуйтесь поиском по форуму:
-=ЮрА=-
Заблокирован
Автор FAQ
23.12.2013, 21:25     Решение СЛОУ методом Гаусса с выбором главного элемента по строке #20
Цитата Сообщение от isu Посмотреть сообщение
Последняя просьба,поправил,теперь работает с матрицами 3х3,проверьте,пожалуйста
3 х 3 отработала при условии что делишь каждую строку на максимальный элемент, 4х4 не считается
Миниатюры
Решение СЛОУ методом Гаусса с выбором главного элемента по строке   Решение СЛОУ методом Гаусса с выбором главного элемента по строке  
Yandex
Объявления
23.12.2013, 21:25     Решение СЛОУ методом Гаусса с выбором главного элемента по строке
Ответ Создать тему
Опции темы

Текущее время: 15:36. Часовой пояс GMT +3.
КиберФорум - форум программистов, компьютерный форум, программирование
Powered by vBulletin® Version 3.8.9
Copyright ©2000 - 2016, vBulletin Solutions, Inc.
Рейтинг@Mail.ru