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

Решение дифференциального уравнения Риккати методом Эйлера - C++

Войти
Регистрация
Восстановить пароль
Другие темы раздела
C++ программа вычисления значений функции в указанном промежутке http://www.cyberforum.ru/cpp-beginners/thread19696.html
завтра уже надо сдавать лабу, а она у меня не пашет( программа вычисления значений функции в указанном промежутке. #include <stdlib.h> #include <string.h> #include <stdio.h> long double func (float x,int n) { long double r,z,g,q,y,t,f; int b;
C++ Описать рекурсивную функцию, находящая максимум из разницы элементов, которые симметричны средине вектора В общем на Си нужно сделать следующее: Описать рекурсивную функцию max_sim(x,n), которая находит максимум из разницы элементов, которые симметричны средине (x - целочисленный, вектор длины n) С рекурсией не дружу вообще) Может кто помочь?) http://www.cyberforum.ru/cpp-beginners/thread19688.html
Нужно добавить сортировку по афавиту C++
Не могу сделать сортировку по алфавиту , остальная часть работает, есть отдельно сортировка но что то не получается у меня их соеденить. Нужно сделать сортировку по именам пунктов назначения AEROFLOTs.name. Кто знает подскажите пожалуйста, совсем хорошо если с куском кода. #include <string.h> #include <stdio.h> #include <math.h> #include <conio.h> #define N 8 void RGR() {
Вычислить значение ряда по заданным x и N, в трех вариантах C++
cos(x)=x–x^2/2!+x^4/4!-x^6/6!+x^8/8!+...x^N/N! Вычислить значение ряда по заданным x и N, в трех вариантах: с циклами for, while, dowhile
C++ Почему не выполняется один из операторов ввода,помеченые * http://www.cyberforum.ru/cpp-beginners/thread19656.html
Один из операторов ввода при повторной работе практически всегда пропускается #include <stdio.h> #include <iostream> using namespace std; void main () { int i=2,k; char s,s1;
C++ Класс вектор У меня есть задача: Разработать пользовательский тип “ вектор в n-мерном пространстве”. Для разрабатываемого типа обязательно определить: конструктор (или несколько, если необходимо) набор методов “get” и “set” ; операторы + и – для сложения и вычитания векторов с получением нового вектора (суммы или разности); оператора * для вычисления скалярного произведения двух векторов; оператор... подробнее

Показать сообщение отдельно
Shardon
Сообщений: n/a
27.12.2008, 17: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
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
class matrixSumError: public std::exception {
};
class overflouBuffer: public std::exception {
};
class matrixMultipError: public std::exception {
};
class matrixSummError: public std::exception {
};
class matrixFileFail: public std::exception {
};
class matrixBadFile: public std::exception {
};
class matrixFileWriteError: public std::exception {
};
class adamsNotInit: public std::exception {
};
class adamsNoElement: public std::exception {
};
 
class Matrix {
    double *a;
    long r; // количество строк
    long c; // количество колонн
    void callocMatrix(long ir,long jc); // выделяет память под матрицу
    static Matrix buffer[SIZE_OF_BUFFER]; // буфер для матриц
    static long ptr; // указаетль на текущую матрицу в буффере
public:
    Matrix() {
        this->a = 0;
        this->ptr = 0;
        this->r = 0;
        this->c = 0;
    }
    Matrix(char* filename,char sep) {
        read(filename,sep);
    }
    double get(long ir,long jc) const {
        if(this->a) {
            return this->a[this->c*ir+jc];
        }
    }
    void set(long ir,long jc,double value) {
        if(this->a) {
            this->a[ir*this->c+this->r] = value;
        }
    }
    ~Matrix();
    void createNull(const long ir,const long jc);
    void createUnit(const long por);
    void createFromArray(const double *arr,const long ir,const long jc);
    void display() const;
    void cleanBuffer();
    long getRow() const {
        return this->r;
    }
    long getCol() const {
        return this->c;
    }
    void operator = (Matrix &mt);
    Matrix& operator * (const Matrix &mt) const;
    Matrix& operator + (const Matrix &mt) const;
    Matrix& operator - (const Matrix &mt) const;
    Matrix& operator * (const long double x) const;
    void read(const char* filename,const char seporator);
    void write(const char* filename,const bool add = false) const;
    void enter_console();
    void display_vector() const; 
    void write_vector(const char* filename,const double t) const;
    void transp();
    friend Matrix& operator * (const long double x,const Matrix &mt);
};
Matrix Matrix::buffer[SIZE_OF_BUFFER];
long Matrix::ptr;
 
Matrix::~Matrix() {
    if(this->a != 0) {
        delete [] this->a;
    }
    this->a = 0;
}
void Matrix::callocMatrix(const long ir,const long jc) {
    this->a = new double[ir*jc];
    this->c = jc;
    this->r = ir;
}
void Matrix::operator = (Matrix &mt) {
    // помещаем матрицу для присваивания в буффер
    long size = mt.c*mt.r;
    this->buffer[this->ptr].callocMatrix(mt.r,mt.c);
    for(long i=0; i<size; i++) {
        this->buffer[this->ptr].a[i] = mt.a[i];
    }
    // вызываем деструктор для левой матрицы
    this->~Matrix();
    this->callocMatrix(this->buffer[this->ptr].r,this->buffer[this->ptr].c);
    for(long i=0; i<size; i++) {
        this->a[i] = this->buffer[this->ptr].a[i];
    }
    // очищаем буффер
    for(long i=0; i<this->ptr+1; i++) {
        this->buffer[i].~Matrix();
    }
    this->ptr = 0;
}
void Matrix::createNull(long ir,long jc) {
    this->callocMatrix(ir,jc);
    long size = ir*jc;
    for(long i=0; i<size; i++) {
        this->a[i] = 0;
    }
}
void Matrix::display() const {
    std::cout << "Dispaying matrix [" << this->r << "," << this->c << "]:" << std::endl;
    for(long i=0; i<this->r; i++) {
        for(long j=0; j<this->c; j++) {
            std::cout << std::setw(10) << this->a[i*this->c+j] << "; ";
        }
        std::cout << std::endl;
    }
    std::cout << "End of displaing//" << std::endl;
}
void Matrix::display_vector() const {
    for(long j=0; j<this->r; j++) {
        std::cout << std::setw(10) << std::setw(10) << this->a[j] << "| ";
    }
    std::cout << std::endl;
}
void Matrix::write_vector(const char* filename,const double t) const {
    std::ofstream ofile(filename,std::ios::app);
    if(ofile.fail()) {
        throw matrixBadFile();
    }
    ofile << std::setw(10) << t << "; ";
    for(long j=0; j<this->r; j++) {
        ofile << std::setw(15) << std::setw(15) << this->a[j] << "; ";
    }
    ofile << std::endl;
}
void Matrix::createUnit(long por) {
    this->createNull(por,por);
    for(long i=0; i<por; i++) {
        this->a[i*this->c+i] = 1;
    }
}
void Matrix::cleanBuffer() {
    for(long i=0; i<this->ptr; i++) {
        this->buffer[i].~Matrix();
    }
    this->ptr = 0;
}
Matrix& Matrix::operator * (const Matrix &mt) const {
    // проверяем, можно ли умножать матрицы
    if(this->c != mt.r) {
        throw matrixMultipError();
    }
    this->buffer[this->ptr].createNull(this->r,mt.c);
    for(long i=0; i<mt.c; i++) {
        for(long j=0; j<this->r; j++) {
            for(long k=0; k<mt.r; k++) {
                this->buffer[this->ptr].a[i*mt.c+j] +=  this->a[i*this->c+k] * mt.a[k*mt.c+j];
            }
        }
    }
    return this->buffer[this->ptr++];
}
Matrix& Matrix::operator + (const Matrix &mt) const {
    if(mt.c != this->c || mt.r != this->r) {
        throw matrixSummError();
    }
    this->buffer[this->ptr].callocMatrix(mt.r,mt.c);
    long size = mt.r*mt.c;
    for(long i=0; i<size; i++) {
        this->buffer[this->ptr].a[i] = this->a[i]+mt.a[i];
    }
    return this->buffer[this->ptr++];
}
Matrix& Matrix::operator - (const Matrix &mt) const {
    if(mt.c != this->c || mt.r != this->r) {
        throw matrixSummError();
    }
    this->buffer[this->ptr].callocMatrix(mt.r,mt.c);
    long size = mt.r*mt.c;
    for(long i=0; i<size; i++) {
        this->buffer[this->ptr].a[i] = this->a[i]-mt.a[i];
    }
    return this->buffer[this->ptr++];
}
void Matrix::createFromArray(const double *arr,const long ir,const long jc) {
    long size = ir*jc;
    this->callocMatrix(ir,jc);
    for(long i=0; i<size; i++) {
        this->a[i] = arr[i];
    }
}
Matrix& Matrix::operator * (const long double x) const {
    this->buffer[this->ptr].callocMatrix(this->r,this->c);
    long size = this->c*this->r;
    for(long i=0; i<size; i++) {
        this->buffer[this->ptr].a[i] = this->a[i]*x;
    }
    return this->buffer[this->ptr++];
}
void Matrix::read(const char* filename,const char seporator) {
    std::ifstream ifile(filename,std::ios::binary);
    if(ifile.fail()) {
        throw matrixFileFail();
    }
    // определяем размер файла
    ifile.seekg(0,std::ios::end);
    long size_of_file = ifile.tellg();
    ifile.seekg(0,std::ios::beg);
    // копируем файл в буффер
    char *buff = new char[size_of_file];
    long count_of_all = 0; // сюда считает общее количество элементов
    long count_of_row = 0; // сюда считаеться общее количество строк
    long i = 0;
    while(!ifile.eof()) {
        char ch;
        ifile.get(ch);
        buff[i] = ch;
        if(buff[i] == seporator) {
            count_of_all++;
        }
        if(buff[i] == '\n') {
            count_of_row++;
        }
        i++;
    }
    buff[i-1] = '\0';
    // закрываем файл
    ifile.close();
    ifile.clear();
    count_of_all--; // учитываем мусор
    count_of_row++; // учитываем то, что последняя строка не имеет в конце \n
    if(count_of_all == 0) { // если разделителей нет, то генерируем исключени
        throw matrixBadFile();
    }
    // вычисляем количество столбцов
    long count_of_col = count_of_all/count_of_row;
    // уничтожаем старую матрицу
    // выделяем память под новую матрицу
    this->callocMatrix(count_of_row,count_of_col);
    i = 0;
    char temp[100]; // сюда попадают элементы
    int temp_ptr = 0;
    // коприуем элементы матрицы в память
    long j = 0;
    while(buff[j] != '\0') {
        if(buff[j] == seporator) {
            temp[temp_ptr] = '\0';
            temp_ptr = 0;
            this->a[i++] = std::atof(temp);
        }
        else {
            temp[temp_ptr++] = buff[j];
            if(temp_ptr > 99) {
                throw matrixBadFile();
            }
        }
        j++;
    }
    //delete [] buff;
}
void Matrix::write(const char* filename,const bool add) const {
    std::ofstream ofile(filename,add ? std::ios::app : std::ios::trunc);
    if(ofile.fail()) {
        throw matrixFileWriteError();
    }
    for(long i=0; i<this->r; i++) {
        for(long j=0; j<this->c; j++) {
            ofile << std::setw(10) << this->a[i*this->c+j] << "; ";
        }
        ofile << std::endl;
    }
}
void Matrix::enter_console() {
    long r_;
    long c_;
    std::cout << "Pleas, enter number of rows:";
    std::cin >> r_;
    std::cout << "Pleas, enter number of colons:";
    std::cin >> c_;
    this->callocMatrix(r_,c_);
    for(long i=0; i<this->c; i++) {
        for(long j=0; j<this->r; j++) {
            std::cout << "Enter element [" << i+1 << "," << j+1 << "]:" << std::endl;
            std::cin >> this->a[i*this->r+j];
        }
    }
}
Matrix& operator * (const long double x,const Matrix &mt) {
    mt.buffer[mt.ptr].callocMatrix(mt.r,mt.c);
    long size = mt.c*mt.r;
    for(long i=0; i<size; i++) {
        mt.buffer[mt.ptr].a[i] = mt.a[i]*x;
    }
    return mt.buffer[mt.ptr++];
}
void Matrix::transp() {
    if(this->c == this->r) {
        double temp;
        for(long i=0; i<this->c; i++) {
            for(long j=i; j<this->r; j++) {
                temp = this->a[i*this->c+j];
                this->a[i*this->c+j] = this->a[j*this->c+i];
                this->a[j*this->c+i] = temp;
            }
        }
    }
    else {
        // матрица не симметрична транспонируем по другму
        Matrix temp;
        temp.callocMatrix(this->c,this->r);
        for(long i=0; i<this->c; i++) {
            for(long j=0; j<this->r; j++) {
                temp.a[i*this->r+j] = a[j*this->c+i];
            }
        }
        *this = temp;
    }
}
 
class Eiler {
    Matrix A;
    Matrix B;
    Matrix Q;
    Matrix x0;
    double E; // точность
    double h; // шаг расчета
    // вычисляемые элементы
    Matrix At;
    Matrix Bt;
    // решение
    Matrix P;
public:
    Eiler() {
        h = 0;
    };
    Eiler(Matrix &A_,Matrix &B_, Matrix &Q_, Matrix &x0_,double E_,double h_) {
        init(A_,B_,Q_,x0_,E_,h_);
    }
 
    void init(Matrix &A_,Matrix &B_, Matrix &Q_,Matrix &x0_,double E_,double h_);
    void calc();
};
 
void Eiler::init(Matrix &A_,Matrix &B_, Matrix &Q_,Matrix &x0_,double E_,double h_) {
    this->A = A_;
    this->B = B_;
    this->Q = Q_;
    this->x0 = x0_;
    this->E = E_;
    this->h = h_;
    this->At = A;
    this->Bt = B;
    At.transp();
    Bt.transp();
}
 
void Eiler::calc() {
    double epsil;
    Matrix prev;
    prev = this->x0;
    long counter = 0;
    bool stop;
    do {
        // вычисляем вектор
        this->P = prev+(prev*A+At*prev-(prev*B)*(Bt*prev)+Q)*h;
        this->P.display();
        // условие остановки вычисления решения
        stop = true;
        if(counter > 1) {
            for(long i=0; i<P.getCol(); i++) {
                for(long j=0; j<P.getRow(); j++) {
                    epsil = (P.get(i,j)-prev.get(i,j))/P.get(i,j);
                    if(epsil < this->E) {
                        stop = false;
                        break;
                    }
                    if(!stop) {
                        break;
                    }
                }
            }
        }
        counter++;
        prev = this->P;
    } while(stop);
}
 
 
int _tmain(int argc, _TCHAR* argv[]) {
    try {
        Matrix A("E:\\A.txt",';');
        Matrix B("E:\\B.txt",';');
        Matrix Q("E:\\Q.txt",';');
        Matrix x0;
        x0.createNull(4,4);
        Eiler el;
        el.init(A,B,Q,x0,0.001,0.001);
        el.calc();
    }
    catch(matrixSummError) {
        std::cout << "Error! Matrix summ error!" << std::endl;
    }
    catch(matrixMultipError) {
        std::cout << "Error! Matrix multiplication error!" << std::endl;
    }
    catch(matrixFileFail) {
        std::cout << "Error! File is fail!" << std::endl;
    }
    catch(std::bad_alloc) {
        std::cout << "Error! No free memory!" << std::endl;
    }
    catch(matrixBadFile) {
        std::cout << "Error! Bad file!" << std::endl;
    }
    catch(matrixFileWriteError) {
        std::cout << "Error! File write error!" << std::endl;
    }
    catch(overflouBuffer) {
        std::cout << "Error! Buffer is overflou!" << std::endl;
    }
    catch(...) {
        std::cout << "Error!" << std::endl;
    }
    system("PAUSE");
    return 0;
}
Насчёт метода Эйлера: попробуй поискать метод Рунге-Кутта 1-го порядка! Там всего 2 формулы нужны....а в уравнении Рикатти это будет система уравнений!

P.S. Это ты мне програмку пишешь! Я просто синтаксиса не знаю нефига!..=(
 
Текущее время: 09:06. Часовой пояс GMT +3.
КиберФорум - форум программистов, компьютерный форум, программирование
Powered by vBulletin® Version 3.8.9
Copyright ©2000 - 2017, vBulletin Solutions, Inc.
Рейтинг@Mail.ru