Информатика: Функции
Материал из Department of Theoretical and Applied Mechanics
Версия от 00:23, 3 января 2016; Pepper (обсуждение | вклад)
Описание программы: программа позволяет сложить, умножить, возвести одну в степень другой две таблично заданные функции, а также линейно аппроксимировать результат. Чтение и вывод происходит через файл.
Пояснения к алгоритму:
- Прочитанные из файла функции нужно отсортировать.
- Найти совместную область определения, то есть, найти множество пересечения областей определения функций, над которыми совершается операция.
- Создать третью функцию, со следующими свойствами : область определения состоит только из точек, принадлежащих совместной области определения, каждая точка области значений является результатом нужной операции над точкой области значений одной из функций и, либо интерполированной точкой по другой функции, либо, если есть возможность, точным значением из ее области значений.
Скачать можно тут.
1 #include <iostream>
2 #include <math.h>
3 #include <cstring>
4 #include <cmath>
5 #include <malloc.h>
6 #include <fstream>
7
8 using namespace std;
9
10 double base(double x) //базовая функция ( если задавать через шаг и начальный х
11 {
12 return x;
13 }
14
15 struct ap //две одинаковые структуры это нехорошо,коненчо,но зато наглядно...
16 {
17 double k,b;
18 };
19
20 struct fun //один столбик в таблице функции
21 {
22 double x,y;
23 };
24
25 struct sf //структура нужная, для возражеия значений из функции "prepare" класса F
26 {
27 int i1,i2,e1,e2;
28 double glength, gfirstx, glastx;
29 };
30
31 double intr(double x1,double x2,double x,double y1,double y2) // линенейная интерполяция
32 {
33 return ( ((x-x1)/(x2-x1)) * (y2-y1) + y1 );
34 }
35
36 ap aproks(fun b [],int n) //линейная аппроксимация
37 {
38 ap r;
39 double xy = 0,x = 0,y = 0,sqx = 0,xsq = 0;
40 for (int i = 0; i < n; i++) //вычисление коэффицентов
41 {
42 xy += b[i].x*b[i].y;
43 x += b[i].x;
44 y += b[i].y;
45 sqx += b[i].x*b[i].x;
46 xsq += b[i].x;
47 }
48 xsq *= xsq;
49
50 r.k = (n*xy - x*y)/(n*sqx - xsq); //использование формул
51 r.b = (y - r.k*x)/n;
52 return r;
53 }
54
55 class F
56 {
57 private:
58 int length;
59 double firstx, step, lastx;
60 fun *a;
61 public:
62 F(){}
63 F(int l,double f,double s) //конструктор, создающий фунцию по длине,первоиу элементу,шагу по х, y вычисляется по базовой функции
64 {
65 if (l >= 0)
66 a = new fun [l];
67 firstx = f;
68 length = l;
69 step = s;
70 lastx = firstx+(length - 1)*step;
71
72
73 for (int i = 0;i < length; i ++)
74 {
75 a[i].y = base(firstx + i*step);
76 a[i].x = firstx + i*step;
77 }
78
79 }
80
81 F (fun b[],int l) //конструктор для создания фунции с уже известными областями определния и значений
82 {
83 length = l;
84 a = new fun [l];
85 for (int i = 0; i < l;i++)
86 a[i] = b[i];
87
88 for (int i = 0; i < l;i++)
89 for (int j = 0; j < (l - 1); j++)
90 if (a[j].x > a[j + 1].x)
91 {
92 fun tmp = a[j];
93 a[j] = a[j + 1];
94 a[j + 1] = a[j];
95 }
96
97 firstx = a[0].x;
98 lastx = a[length - 1].x;
99 }
100
101 void addpar (double k, double b, int l, fun z[] ) //позволяет создать и заполнить переданным массивом поле объекта класса
102 {
103 a = new fun [l];
104 for (int i = 0; i < l; i++)
105 {
106 a[i].y = k*z[i].x + b;
107 a[i].x = z[i].x;
108 }
109 length = l;
110 }
111
112 double getelx(int i) //возращает значение из поля "х" iого элемента
113 {
114 return a[i].x;
115 }
116
117
118 double getely(int i) //возращает значение из поля "х" iого элемента
119 {
120 return a[i].y;
121 }
122
123 int getlength() //возращает размер области определения функции(в точках)
124 {
125 return length;
126 }
127
128 void FOut() //выводит функцию на экран
129 {
130 cout << " x y" << endl;
131 for (int i = 0;i < length; i ++)
132 cout << " " << a[i].x << " " << a[i].y << endl;
133 cout << endl;
134 }
135
136
137 int pfind(double x)const //возращает либо номер элемента,идущщий перед элементом, большим,чем х; в случае нахождения равного, возращает число, противоположное номеру следующего элемента(иначе может вернуться нуль,а нуль знака не имееет)
138 {
139 for (int i = 0; i < length-1; i++ )
140 {
141 if (((a[i].x < x) && (a[i + 1].x > x)))
142 return (i + 1);
143 else
144 // чтобы иметь возможность проанализировать полученное значение функции,мы должны понимать, было найденно равное или промежуточное значение. "флагом" равных значений является знак минус,но так у нуля нет знака,то приходиться все сдвигать на 1
145 if (a[i].x == x)
146 return -(i + 1);
147 else
148 if (a[i + 1].x == x)
149 return -(i + 2);
150 }
151 // cerr << "fail!!" << endl;
152 return -1;
153 }
154
155 sf prepare(F &x)const //"подготовка" функций к бинарной операции (нахождение совместной области определения
156 {
157 sf r;
158 if (a[0].x > x.a[0].x)
159 {
160 r.gfirstx = a[0].x;
161 r.i1 = 0;
162 r.i1 = 0;
163 double k = x.pfind(a[0].x);
164 if (k < 0)
165 r.i2 = -k - 1;
166 else
167 r.i2 = (k - 1) + 1;
168 }
169 else
170 {
171 r.gfirstx = x.a[0].x;
172 double k = pfind(x.a[0].x);
173 if (k < 0)
174 r.i1 = -k - 1;
175 else
176 r.i1 = (k - 1) + 1;
177 r.i2 = 0;
178 }
179
180 if (a[length - 1].x < x.a[x.length - 1].x)
181 {
182 r.glastx = a[length - 1].x;
183 r.e1 = length - 1;
184 double k = x.pfind(r.glastx);
185 if (k < 0)
186 r.e2 = -k - 1;
187 else
188 r.e2 = (k - 1) - 1;
189 }
190 else
191 {
192 r.glastx = x.a[x.length - 1].x;
193 double k = pfind(r.glastx);
194 if (k < 0)
195 r.e1 = -k - 1;
196 else
197 r.e1 = (k - 1) + 1;
198 r.e2 = x.length - 1;
199 }
200 r.glength = length + x.length - r.i1 - (length - (r.e1 + 1)) - r.i2 - (x.length - (r.e2 + 1));
201
202 return r;
203 }
204
205 void ad (fun b[],int l) //присвоить массиву объекта класса F значения массива b
206 {
207 length = l;
208 a = new fun [l];
209 for (int i = 0; i < l;i++)
210 a[i] = b[i];
211 firstx = a[0].x;
212 lastx = a[length - 1].x;
213 }
214
215 fun *geta() //получения указателя на начало массива в поле класса
216 {
217 return a;
218 }
219
220 F operator +(F &x) const //сложение двух функций
221 {
222 int i1, e1, i2, e2, kk = 0;
223 double gfirstx, glastx, glength;
224
225 if (((x.lastx < firstx) && (x.firstx < firstx)) || ((lastx < x.firstx) && (firstx < x.firstx)))
226 {
227 cout << "Nevozmozhno, prover'te oblasti opredelenia" << endl;
228 F fl(-1,0,0);
229 return fl;
230 }
231 sf r = prepare(x);
232 F tmp(r.glength,r.gfirstx,r.glastx);
233 for (int i = 0; i <= (r.e1 - r.i1); i++)
234 {
235 tmp.a[i].x = a[i + r.i1].x; //поправка,введенная таким образом,чтобы номер,с которого начинается отсчет был первым в новой области определения
236 int ii = x.pfind(tmp.a[i].x);
237 if (ii < 0)
238 tmp.a[i].y = x.a[-ii - 1].y + a[i + r.i1].y;
239 else
240 tmp.a[i].y = intr(x.a[ii - 1].x , x.a[ii + 1].x , tmp.a[i].x , x.a[ii].y , x.a[ii + 1].y) + a[i + r.i1].y;
241 }
242 for (int i = (r.e1 - r.i1 + 1); i <= (r.e2 - r.i2 + (r.e1 - r.i1) + 1) ; i++)
243 {
244 int ii = pfind(x.a[i - (r.e1 - r.i1 + 1) + r.i2].x);
245 if (ii >= 0)
246 {
247 tmp.a[i - kk].x = x.a[i - (r.e1 - r.i1 + 1) + r.i2].x;
248 tmp.a[i - kk].y = intr (a[ii - 1].x , a[(ii - 1) + 1].x , tmp.a[i - kk].x , a[ii - 1].y, a[(ii - 1) + 1].y) + x.a[i - (r.e1 - r.i1 + 1) + r.i2].y;
249 }
250 else
251 {
252 kk++;
253 glength --;
254 tmp.length --;
255 }
256 }
257
258 for (int i = 0; i < glength; i++)
259 for (int j = 0; j < glength - 1; j++)
260 if (tmp.a[j].x > tmp.a[j + 1].x)
261 {
262 fun t = tmp.a[j];
263 tmp.a[j] = tmp.a[j + 1];
264 tmp.a[j + 1] = t;
265 }
266
267 return tmp;
268 }
269
270 F operator *(F & x) const //умножение двух функций
271 {
272 int i1, e1, i2, e2, kk = 0;
273 double gfirstx, glastx, glength;
274
275 if (((x.lastx < firstx) && (x.firstx < firstx)) || ((x.firstx < lastx) && (firstx < x.firstx)))
276 {
277 cout << "Nevozmozhno, prover'te oblasti opredelenia" << endl;
278 F fl(-1,0,0);
279 return fl;
280 }
281
282 sf r = prepare(x);
283 F tmp(r.glength,r.gfirstx,r.glastx);
284
285 for (int i = 0; i <= (r.e1 - r.i1); i++)
286 {
287 tmp.a[i].x = a[i + r.i1].x;
288 int ii = x.pfind(tmp.a[i].x);
289 if (ii < 0)
290 tmp.a[i].y = x.a[-ii - 1].y * a[i + r.i1].y;
291 else
292 tmp.a[i].y = intr(x.a[ii - 1].x , x.a[ii + 1].x , tmp.a[i].x , x.a[ii].y , x.a[ii + 1].y) * a[i + r.i1].y;
293 }
294 for (int i = (r.e1 - r.i1 + 1); i <= (r.e2 - r.i2 + (r.e1 - r.i1) + 1) ; i++)
295 {
296 int ii = pfind(x.a[i - (r.e1 - r.i1 + 1) + r.i2].x);
297 if (ii >= 0)
298 {
299 tmp.a[i - kk].x = x.a[i - (r.e1 - r.i1 + 1) + r.i2].x;
300 tmp.a[i - kk].y = intr (a[ii - 1].x , a[(ii - 1) + 1].x , tmp.a[i - kk].x , a[ii - 1].y, a[(ii - 1) + 1].y) * x.a[i - (r.e1 - r.i1 + 1) + r.i2].y;
301 }
302 else
303 {
304 kk++;
305 glength --;
306 tmp.length --;
307 }
308 }
309
310 for (int i = 0; i < glength; i++)
311 for (int j = 0; j < glength - 1; j++)
312 if (tmp.a[j].x > tmp.a[j + 1].x)
313 {
314 fun t = tmp.a[j];
315 tmp.a[j] = tmp.a[j + 1];
316 tmp.a[j + 1] = t;
317 }
318
319 return tmp;
320 }
321
322 F operator ^(F & x) const //возведение функции слева от оператора в степень функции справа от оператора
323 {
324 int i1, e1, i2, e2, kk = 0;
325 double gfirstx, glastx, glength;
326
327 if (((x.lastx < firstx) && (x.firstx < firstx)) || ((x.firstx < lastx) && (firstx < x.firstx)))
328 {
329 cout << "Nevozmozhno, prover'te oblasti opredelenia" << endl;
330 F fl(-1,0,0);
331 return fl;
332 }
333
334 sf r = prepare(x);
335 F tmp(r.glength,r.gfirstx,r.glastx);
336
337 for (int i = 0; i <= (r.e1 - r.i1); i++)
338 {
339 tmp.a[i].x = a[i + r.i1].x;
340 int ii = x.pfind(tmp.a[i].x);
341 if (ii < 0)
342 tmp.a[i].y = pow(x.a[-ii - 1].y, a[i + r.i1].y);
343 else
344 tmp.a[i].y = pow(intr(x.a[ii - 1].x , x.a[ii + 1].x , tmp.a[i].x , x.a[ii].y , x.a[ii + 1].y), a[i + r.i1].y);
345 }
346 for (int i = (r.e1 - r.i1 + 1); i <= (r.e2 - r.i2 + (r.e1 - r.i1) + 1) ; i++)
347 {
348 int ii = pfind(x.a[i - (r.e1 - r.i1 + 1) + r.i2].x);
349 if (ii >= 0)
350 {
351 tmp.a[i - kk].x = x.a[i - (r.e1 - r.i1 + 1) + r.i2].x;
352 tmp.a[i - kk].y = pow(intr (a[ii - 1].x , a[(ii - 1) + 1].x , tmp.a[i - kk].x , a[ii - 1].y, a[(ii - 1) + 1].y), x.a[i - (r.e1 - r.i1 + 1) + r.i2].y);
353 }
354 else
355 {
356 kk++;
357 glength --;
358 tmp.length --;
359 }
360 }
361
362 for (int i = 0; i < glength; i++)
363 for (int j = 0; j < glength - 1; j++)
364 if (tmp.a[j].x > tmp.a[j + 1].x)
365 {
366 fun t = tmp.a[j];
367 tmp.a[j] = tmp.a[j + 1];
368 tmp.a[j + 1] = t;
369 }
370
371 return tmp;
372 }
373 };
374
375 int main()
376 {
377 /*
378 F f1(5,-2,1.5);
379 F f2(30,-10,0.5);
380 F f3, f4;
381 f1.FOut();
382 f2.FOut();
383 f3 = f1 + f2;
384 f3.FOut();
385 f4 = f1 * f2;
386 f4.FOut();
387 cout << " ________" << endl;
388 */
389 char vc, s[255], ce;
390 ifstream infile;
391 int n;
392 fun *a;
393 F f5,f6,f7,f8,f9;
394
395 while(true)
396 {
397 start :
398 system("cls");
399 cout << "1 - Vvesti 1uu func" << endl;
400 cout << "2 - Vvesti 2uu func" << endl;
401 cout << "3 - Sloshit'" << endl;
402 cout << "4 - Umnozhit'" << endl;
403 cout << "5 - Vozvesti v stepen'" << endl;
404 cout << "6 - Aproximirovat'" << endl;
405 cout << "7 - Zapics' v file func" << endl;
406 cout << "8 - Zapics' v file aprok fun" << endl;
407 cout << "0 - Vihod" << endl;
408 cin >> vc;
409 switch (vc)
410 {
411 case '0':
412 return 0 ;
413 case '1':
414 {
415 system("cls");
416 strcpy(s,"");
417 delete []a;
418 a = NULL;
419 cout << "Vvedite imya fila" << endl;
420 cin >> s;
421 strcat(s, ".txt");
422 infile.open(s);
423 infile >> n;
424 a = new fun [n];
425 for(int i = 0; i < n; i ++)
426 infile >> a[i].x >> a[i].y;
427 f5.ad(a,n);
428 f5.FOut();
429 infile.close();
430 cout << "Nazhmite \"b\" chotibi viti" << endl;
431 cin >> ce;
432 while (true)
433 if (ce == 'b')
434 goto start;
435 }
436 case '2':
437 {
438 system("cls");
439 strcpy(s,"");
440 delete []a;
441 a = NULL;
442 cout << "Vvedite imya fila" << endl;
443 cin >> s;
444 strcat(s, ".txt");
445 infile.open(s);
446 infile >> n;
447 a = new fun[n];
448 for(int i = 0; i < n; i ++)
449 infile >> a[i].x >> a[i].y;
450 f6.ad(a,n);
451 f6.FOut();
452 infile.close();
453 cout << "Nazhmite \"b\" chotibi viti" << endl;
454 cin >> ce;
455 while (true)
456 if (ce == 'b')
457 goto start;
458 }
459 case '3':
460 system("cls");
461 f5.FOut();
462 f6.FOut();
463 f7 = f5 + f6;
464 f7.FOut();
465 cout << "Nazhmite \"b\" chotibi viti" << endl;
466 cin >> ce;
467 while (true)
468 if (ce == 'b')
469 goto start;
470 case '4':
471 system("cls");
472 f5.FOut();
473 f6.FOut();
474 f7 = f5 * f6;
475 f7.FOut();
476 cout << "Nazhmite \"b\" chotibi viti" << endl;
477 cin >> ce;
478 while (true)
479 if (ce == 'b')
480 goto start;
481 case '5':
482 system("cls");
483 f5.FOut();
484 f6.FOut();
485 f7 = f5 ^ f6;
486 f7 = f5 ^ f6;
487 f7.FOut();
488 cout << "Nazhmite \"b\" chotibi viti" << endl;
489 cin >> ce;
490 while (true)
491 if (ce == 'b')
492 goto start;
493 case '6':
494 {
495 system("cls");
496 ap tmp = aproks(f7.geta(), f7.getlength());
497 f8.addpar(tmp.k, tmp.b, f7.getlength(), f7.geta());
498 f8.FOut();
499 cout << "Nazhmite \"b\" chotibi viti" << endl;
500 cin >> ce;
501 while (true)
502 if (ce == 'b')
503 goto start;
504 }
505 case '7':
506 {
507 system("cls");
508 strcpy(s,"");
509 cout << "Vvedite imya fila" << endl;
510 cin >> s;
511 strcat(s, ".txt");
512 ofstream outfile(s);
513 outfile << "x y" << endl;
514 for (int i = 0; i < f7.getlength(); i ++)
515 outfile << f7.getelx(i) << " " << f7.getely(i) << endl;
516
517 cout << "done" << endl;
518 cout << "Nazhmite \"b\" chotibi viti" << endl;
519 cin >> ce;
520 while (true)
521 if (ce == 'b')
522 goto start;
523 }
524 case '8':
525 system("cls");
526 strcpy(s,"");
527 cout << "Vvedite imya fila" << endl;
528 cin >> s;
529 strcat(s, ".txt");
530 ofstream outfile(s);
531 outfile << "x y" << endl;
532 for (int i = 0; i < f8.getlength(); i ++)
533 outfile << f8.getelx(i) << " " << f8.getely(i) << endl;
534 cout << "done" << endl;
535 cout << "Nazhmite \"b\" chotibi viti" << endl;
536 cin >> ce;
537 while (true)
538 if (ce == 'b')
539 goto start;
540 }
541 }
542 return 0;
543 }
Краткое описание алгоритма: Программа ищет совместную область определения для двух заданных пользователем функций. Для каждой из них вводится шаг и первое и последнее значения. После поиска совместной области программа интерполирует две функции и создает третью функцию, в которую сохраняются результаты работы программы, то есть сложение, вычитание, деление и умножение двух изначальных функций.
Инструкция к программе: Введите поочередно первый и последний элементы функций, а также их шаги. После этого введите число, соответствующее желаемому действию (соответствие указано в меню программы).
Посмотреть программу можно здесь
1 #include <iostream>
2 #include <fstream>
3 #include <cstring>
4 #include <stdlib.h>
5
6 using namespace std;
7
8 ofstream outfile;
9
10 struct approx //структура, необходимая для функции линейной интерполяции
11 {
12 double koefficientA, koefficientB;
13 };
14
15 struct dot //структура, содержащая в себе значения координат каждой точки
16 { //по обеим осям
17 double x, y;
18 };
19
20 struct polyana //структура, содержащая номера первого и последнего элемента каждой
21 { //функции и количество элементов каждой из них
22 int a1, a2, b1, b2, k1, k2;
23 };
24
25 struct trees //структура, содержащая номер элемента и логическое значение,
26 { // отвечающее за нужность или не нужность интерполяции
27 bool pol; //при равенстве или неравенстве энных элементов двух функций
28 int n;
29 };
30 //непосредственно функция линейной интерполяции
31 double pentagon (double x1, double x, double x2, double y1, double y2)
32 {
33 return (((x - x1)/(x2- x1))*(y2 - y1) + y1);
34 }
35
36 class stars //класс, позволяющий сохранять дискретные значения функции на
37 { //определенном интервале с определенным шагом
38 private:
39
40 double a; //первое значение функции
41 double b; //последнее значение функции
42 double step; //шаг
43 int length; //длина
44 int k; //счетчик количества элементов
45
46 public:
47
48 dot *massiv;
49 stars (int _k) //конструктор для создания объекта класса - структуры
50 { //с двумя полями по количеству элементов
51 massiv = new dot [_k];
52 k = _k;
53 }
54 stars () {}; //конструктор
55 stars (double _a, double _b, double _step) //конструктор для создания объекта класса через начальный
56 //и коненый элементы с определенным шагом
57 {
58 a = _a;
59 b = _b;
60 step = _step;
61
62 length = _b - _a + 1;
63 k = 0;
64
65 for (int i = _a ; i <= _b ; i += step) //подсчет количества элементов функции
66 {
67 k++;
68 }
69
70 massiv = new dot [k]; //задание функции
71 for (int i = 0 ; i < k ; i++)
72 {
73 massiv[i].x = _a + _step * i;
74 massiv[i].y = i * 5;
75 }
76 }
77
78 void outinfile () //вывод в файл значений функции
79 {
80 outfile.open ("meow", ios :: app);
81
82 outfile << "x" << " " << "y" << endl;
83 for (int i = 0 ; i < k ; i++)
84 {
85 outfile << massiv[i].x << " " << massiv[i].y << endl;
86 }
87 outfile << endl;
88 outfile.close();
89 }
90
91 void out () //вывод на экран значений функции
92 {
93 cout << "x" << " " << "y" << endl;
94 for (int i = 0 ; i < k ; i++)
95 {
96 cout << massiv[i].x << " " << massiv[i].y << endl;
97 }
98 cout << endl;
99 }
100
101 polyana prepare (stars &h) //подготовка совместной области определения для двух функций -
102 { //той части значений множества Х, на которой будут
103 trees del; //производиться вычисления
104 polyana tmp;
105 if (massiv[0].x > h.massiv[0].x) //поиск начала совместной области определения
106 {
107 del = h.love(massiv[0].x);
108 tmp.a2 = del.n + 1;
109 tmp.a1 = 0;
110 }
111 else
112 if (massiv[0].x < h.massiv[0].x)
113 {
114 del = love(h.massiv[0].x);
115 tmp.a2 = 0;
116 tmp.a1 = del.n + 1;
117 }
118 else
119 if (massiv[0].x == h.massiv[0].x)
120 {
121 tmp.a1 = 0;
122 tmp.a2 = 0;
123 };
124
125 if (massiv[k-1].x > h.massiv[k-1].x) //поиск конца совместной области определения
126 {
127 del = h.love(massiv[k-1].x);
128 tmp.b2 = k-1;
129 tmp.b1 = del.n;
130 }
131 else
132 if (massiv[k-1].x < h.massiv[k-1].x)
133 {
134 del = h.love(massiv[k-1].x);
135 tmp.b2 = del.n;
136 tmp.b1 = k-1;
137 }
138 else
139 if (massiv[k-1].x == h.massiv[k-1].x)
140 {
141 tmp.b2 = k-1;
142 tmp.b1 = k-1;
143 };
144
145 tmp.k1 = 0;
146 for (int i = tmp.a1 ; i <= tmp.b1 ; i ++) //подсчет количества элементов первой функции
147 {
148 tmp.k1++;
149 }
150 tmp.k2 = 0;
151 for (int i = tmp.a2 ; i <= tmp.b2 ; i ++) //подсчет количества элементов второй функции
152 {
153 tmp.k2++;
154 }
155 return tmp; //возвращает первые и последние значения обеих функций и
156 } //их количества элементов
157
158 //ПЕРЕГРУЗКА ОПЕРАТОРОВ
159
160 stars operator+ (stars & v) //сложение
161 {
162 polyana tmp = prepare(v);
163 int general = tmp.k1 + tmp.k2; //общее количество элементов обеих функций
164 stars F3(general); //создание объекта класса только по количеству элементов
165 for (int i = 0 ; i < tmp.k1 ; i++) //заполнение первой части окончательного результата
166 {
167 F3.massiv[i].x = massiv[i+tmp.a1].x;
168 trees tiger = v.love(massiv[i+tmp.a1].x);
169 if (tiger.pol == true) //если значения по У в одной точке не совпадают, то интерполировать
170 {
171 F3.massiv[i].y = pentagon (v.massiv[tiger.n].x,
172 F3.massiv[i].x,
173 v.massiv[tiger.n + 1].x,
174 v.massiv[tiger.n].y,
175 v.massiv[tiger.n + 1].y )
176 + massiv[i+tmp.a1].y;
177 }
178 else //иначе, просто сложить значения
179 {
180 F3.massiv[i].y = v.massiv[tiger.n].y + massiv[i+tmp.a1].y;
181 }
182
183 }
184 {
185 for (int i = tmp.k1 ; i < (general) ; i++) //заполнение второй части окончательного результата
186 {
187 F3.massiv[i].x = v.massiv[i + tmp.a2 - tmp.k1].x;
188 trees tiger = love(v.massiv[i + tmp.a2 - tmp.k1].x);
189 if (tiger.pol == true)
190 {
191 F3.massiv[i].y = pentagon (v.massiv[tiger.n].x,
192 F3.massiv[i].x,
193 v.massiv[tiger.n + 1].x,
194 v.massiv[tiger.n].y,
195 v.massiv[tiger.n + 1].y )
196 + v.massiv[i+tmp.a1 - tmp.k1].y;
197 }
198 else
199 F3.massiv[i].y = massiv[tiger.n].y + v.massiv[i+tmp.a2 - tmp.k1].y;
200 }
201
202 for (int i = 0; i < (general); i++) //сортировка
203 {
204 for (int j = 0; j < (general - 1); j ++)
205 {
206 dot temp;
207 if (F3.massiv[j].x > F3.massiv[j + 1].x)
208 {
209 temp = F3.massiv[j];
210 F3.massiv[j] = F3.massiv[j + 1];
211 F3.massiv[j + 1] = temp;
212 }
213 else //если элементы совпадают, то нужно выбросить один из них
214 if (F3.massiv[j].x == F3.massiv[j + 1].x)
215 {
216 int l = j;
217 while (l < general)
218 {
219 F3.massiv[l].x = F3.massiv[l + 1].x;
220 F3.massiv[l].y = F3.massiv[l + 1].y;
221 l++;
222 }
223 general--;
224 }
225 }
226 }
227
228
229 stars normalny (general); //создание элемента класса по длине
230 for (int i = 0; i < (general); i++)
231 {
232 normalny.massiv[i].x = F3.massiv[i].x;
233 normalny.massiv[i].y = F3.massiv[i].y;
234 }
235 a = normalny.massiv[0].x;
236 b = normalny.massiv[general].x;
237 return normalny;
238 }
239 };
240
241 stars operator* (stars & v) //умножение
242 {
243 polyana tmp = prepare(v);
244 int general = tmp.k1 + tmp.k2;
245 stars F3(tmp.k1 + tmp.k2);
246 for (int i = 0 ; i < tmp.k1 ; i++)
247 {
248 F3.massiv[i].x = massiv[i+tmp.a1].x;
249 trees tiger = v.love(massiv[i+tmp.a1].x);
250 if (tiger.pol == true)
251 {
252 F3.massiv[i].y = pentagon (v.massiv[tiger.n].x, F3.massiv[i].x,
253 v.massiv[tiger.n + 1].x, v.massiv[tiger.n].y,
254 v.massiv[tiger.n + 1].y )* (massiv[i+tmp.a1].y);
255 }
256 else
257 {
258 F3.massiv[i].y = v.massiv[tiger.n].y * massiv[i+tmp.a1].y;
259 }
260
261 }
262 {
263 for (int i = tmp.k1 ; i < (general) ; i++)
264 {
265 F3.massiv[i].x = v.massiv[i+tmp.a2 - tmp.k1].x;
266 trees tiger = love(v.massiv[i+tmp.a2 - tmp.k1].x);
267 if (tiger.pol == true)
268 {
269 F3.massiv[i].y = pentagon (v.massiv[tiger.n].x,
270 F3.massiv[i].x,
271 v.massiv[tiger.n + 1].x,
272 v.massiv[tiger.n].y,
273 v.massiv[tiger.n + 1].y )
274 + v.massiv[i+tmp.a1 - tmp.k1].y;
275 }
276 else
277 F3.massiv[i].y = massiv[tiger.n].y + v.massiv[i+tmp.a2 - tmp.k1].y;
278 }
279
280 for (int i= 0; i < (general); i++)
281 {
282 for (int j = 0; j < (general - 1); j ++)
283 {
284 dot temp;
285 if (F3.massiv[j].x > F3.massiv[j+1].x)
286 {
287 temp = F3.massiv[j];
288 F3.massiv[j] = F3.massiv[j+1];
289 F3.massiv[j+1] = temp;
290 }
291 else
292 if (F3.massiv[j].x == F3.massiv[j+1].x)
293 {
294 int l = j;
295 while (l < general)
296 {
297 F3.massiv[j].x = F3.massiv[j+1].x;
298 l++;
299 }
300 general--;
301 }
302 }
303 }
304
305 for (int i = 0 ; i < general ; i++)
306 {
307
308 cout <<F3.massiv[i].x<< ' ' << F3.massiv[i].y <<endl;
309 }
310
311
312 stars normalny(general);
313 for (int i = 0; i < (general); i++)
314 {
315 normalny.massiv[i].x = F3.massiv[i].x;
316 normalny.massiv[i].y = F3.massiv[i].y;
317 }
318 a = normalny.massiv[0].x;
319 b = normalny.massiv[general].x;
320 return normalny;
321 }
322 };
323
324 stars operator- (stars & v) //вычитание
325 {
326 polyana tmp = prepare(v);
327 int general = tmp.k1 + tmp.k2;
328 stars F3(tmp.k1 + tmp.k2);
329 for (int i = 0 ; i < tmp.k1 ; i++)
330 {
331 F3.massiv[i].x = massiv[i+tmp.a1].x;
332 trees tiger = v.love(massiv[i+tmp.a1].x);
333 if (tiger.pol == true)
334 {
335 F3.massiv[i].y = pentagon (v.massiv[tiger.n].x, F3.massiv[i].x,
336 v.massiv[tiger.n + 1].x, v.massiv[tiger.n].y,
337 v.massiv[tiger.n + 1].y )- massiv[i+tmp.a1].y;
338 }
339 else
340 {
341 F3.massiv[i].y = v.massiv[tiger.n].y - massiv[i+tmp.a1].y;
342 }
343
344 }
345 {
346 for (int i = tmp.k1 ; i < (general) ; i++)
347 {
348 F3.massiv[i].x = v.massiv[i+tmp.a2 - tmp.k1].x;
349 trees tiger = love(v.massiv[i+tmp.a2 - tmp.k1].x);
350 if (tiger.pol == true)
351 {
352 F3.massiv[i].y = pentagon (v.massiv[tiger.n].x,
353 F3.massiv[i].x,
354 v.massiv[tiger.n + 1].x,
355 v.massiv[tiger.n].y,
356 v.massiv[tiger.n + 1].y )
357 + v.massiv[i+tmp.a1 - tmp.k1].y;
358 }
359 else
360 F3.massiv[i].y = massiv[tiger.n].y + v.massiv[i+tmp.a2 - tmp.k1].y;
361 }
362
363 for (int i= 0; i < (general); i++)
364 {
365 for (int j = 0; j < (general - 1); j ++)
366 {
367 dot temp;
368 if (F3.massiv[j].x > F3.massiv[j+1].x)
369 {
370 temp = F3.massiv[j];
371 F3.massiv[j] = F3.massiv[j+1];
372 F3.massiv[j+1] = temp;
373 }
374 else
375 if (F3.massiv[j].x == F3.massiv[j+1].x)
376 {
377 int l = j;
378 while (l < general)
379 {
380 F3.massiv[j].x = F3.massiv[j+1].x;
381 l++;
382 }
383 general--;
384 }
385 }
386 }
387
388 for (int i = 0 ; i < general ; i++)
389 {
390
391 cout <<F3.massiv[i].x<< ' ' << F3.massiv[i].y <<endl;
392 }
393
394
395 stars normalny(general);
396 for (int i = 0; i < (general); i++)
397 {
398 normalny.massiv[i].x = F3.massiv[i].x;
399 normalny.massiv[i].y = F3.massiv[i].y;
400 }
401 a = normalny.massiv[0].x;
402 b = normalny.massiv[general].x;
403 return normalny;
404 }
405 };
406
407 stars operator/ (stars & v) //деление
408 {
409 polyana tmp = prepare(v);
410 int general = tmp.k1 + tmp.k2;
411 stars F3(tmp.k1 + tmp.k2);
412 for (int i = 0 ; i < tmp.k1 ; i++)
413 {
414 F3.massiv[i].x = massiv[i+tmp.a1].x;
415 trees tiger = v.love(massiv[i+tmp.a1].x);
416 if (tiger.pol == true)
417 {
418 F3.massiv[i].y = pentagon (v.massiv[tiger.n].x, F3.massiv[i].x,
419 v.massiv[tiger.n + 1].x, v.massiv[tiger.n].y,
420 v.massiv[tiger.n + 1].y )/ (massiv[i+tmp.a1].y);
421 }
422 else
423 {
424 F3.massiv[i].y = (v.massiv[tiger.n].y) / (massiv[i+tmp.a1].y);
425 }
426
427 }
428 {
429 for (int i = tmp.k1 ; i < (general) ; i++)
430 {
431 F3.massiv[i].x = v.massiv[i+tmp.a2 - tmp.k1].x;
432 trees tiger = love(v.massiv[i+tmp.a2 - tmp.k1].x);
433 if (tiger.pol == true)
434 {
435 F3.massiv[i].y = pentagon (v.massiv[tiger.n].x,
436 F3.massiv[i].x,
437 v.massiv[tiger.n + 1].x,
438 v.massiv[tiger.n].y,
439 v.massiv[tiger.n + 1].y )
440 + v.massiv[i+tmp.a1 - tmp.k1].y;
441 }
442 else
443 F3.massiv[i].y = massiv[tiger.n].y + v.massiv[i+tmp.a2 - tmp.k1].y;
444 }
445
446 for (int i= 0; i < (general); i++)
447 {
448 for (int j = 0; j < (general - 1); j ++)
449 {
450 dot temp;
451 if (F3.massiv[j].x > F3.massiv[j+1].x)
452 {
453 temp = F3.massiv[j];
454 F3.massiv[j] = F3.massiv[j+1];
455 F3.massiv[j+1] = temp;
456 }
457 else
458 if (F3.massiv[j].x == F3.massiv[j+1].x)
459 {
460 int l = j;
461 while (l < general)
462 {
463 F3.massiv[j].x = F3.massiv[j+1].x;
464 l++;
465 }
466 general--;
467 }
468 }
469 }
470
471 for (int i = 0 ; i < general ; i++)
472 {
473
474 cout <<F3.massiv[i].x<< ' ' << F3.massiv[i].y <<endl;
475 }
476
477
478 stars normalny(general);
479 for (int i = 0; i < (general); i++)
480 {
481 normalny.massiv[i].x = F3.massiv[i].x;
482 normalny.massiv[i].y = F3.massiv[i].y;
483 }
484 a = normalny.massiv[0].x;
485 b = normalny.massiv[general].x;
486 return normalny;
487 }
488 };
489
490 trees love (double a) //
491 {
492 trees privet;
493 for (int i = 0; i < k; i++ )
494 if ((massiv[i].x < a)&& (a < massiv[i+1].x))
495 {
496 privet.n = i;
497 privet.pol = true;
498 return privet;
499 }
500 else
501 if (massiv[i].x == a)
502 {
503 privet.n = i;
504 privet.pol = false;
505 return privet;
506 }
507 else
508 if (massiv[i+1].x == a)
509 {
510 privet.n = i+1;
511 privet.pol = false;
512 return privet;
513 }
514 }
515
516
517 approx approximate () //функция аппроксимации
518 {
519 approx hey;
520 stars mattafix (double a, double b, double step, int k, int length);
521 double sigmaX = 0;
522 double sigmaY = 0;
523 double sigmaXY = 0;
524 double sigmaXsqrt = 0;
525 for (int i = 0; i < length; i++)
526 {
527 sigmaX += a + step * i;
528 sigmaY += b + i * 5;
529 sigmaXY += (a + step * i)*(b + i * 5);
530 sigmaXsqrt += (a + step * i)*(a + step * i);
531 }
532 hey.koefficientA = ((k * (sigmaXY) - (sigmaX*sigmaY))/(k*sigmaXsqrt - (sigmaX * sigmaX)));
533 hey.koefficientB = ((sigmaY - hey.koefficientA*sigmaX)/k);
534 return hey;
535
536
537 }
538 };
539
540 int main()
541 {
542 int tyu;
543 stars function3;
544 int firstnumber1;
545 int firstnumber2;
546 int lastnumber1;
547 int lastnumber2;
548 int step1;
549 int step2;
550 while (true)
551 {
552
553 cout << "Input 0 - vvedite parametry pervoy funkcii"<< endl;
554 cout << "Input 1 - vvedite parametry vtoroy funkcii"<< endl;
555 cout << "Input 2 - slozhenie"<< endl;
556 cout << "Input 3 - umnozhenie"<< endl;
557 cout << "Input 4 - delenie"<< endl;
558 cout << "Input 5 - vychitanie"<< endl;
559 cout << "Input 6 - aproximate"<< endl;
560 cin >> tyu ;
561
562 switch (tyu)
563 {
564 case 0:
565 { cout << "Vvedite pervy x" << endl;
566 cin >> firstnumber1;
567 cout << "Vvedite posledniy x" << endl;
568 cin >> lastnumber1;
569 cout << "Vvedite shag" << endl;
570 cin >> step1;
571 break;
572 }
573 case 1:
574 {
575 cout << "Vvedite pervy x" << endl;
576 cin >> firstnumber2;
577 cout << "Vvedite posledniy x" << endl;
578 cin >> lastnumber2;
579 cout << "Vvedite shag" << endl;
580 cin >> step2;
581 break;
582 }
583 case 2:
584 {
585 stars function1 (firstnumber1, lastnumber1, step1);
586 function1.out();
587 function1.outinfile ();
588
589 stars function2 (firstnumber2, lastnumber2, step2);
590 function2.out();
591 function2.outinfile ();
592
593 function3 = function1 + function2;
594 function3.out();
595 function3.outinfile ();
596 break;
597 }
598 case 3:
599 {
600 stars function1 (firstnumber1, lastnumber1, step1);
601 function1.out();
602 function1.outinfile ();
603
604 stars function2 (firstnumber2, lastnumber2, step2);
605 function2.out();
606 function2.outinfile ();
607
608 function3 = function1 * function2;
609 function3.out();
610 function3.outinfile ();
611 break;
612 }
613 case 4:
614 {
615 stars function1 (firstnumber1, lastnumber1, step1);
616 function1.out();
617 function1.outinfile ();
618
619 stars function2 (firstnumber2, lastnumber2, step2);
620 function2.out();
621 function2.outinfile ();
622
623 function3 = function1 / function2;
624 function3.out();
625 function3.outinfile ();
626 break;
627 }
628 case 5:
629 {
630
631 stars function1 (firstnumber1, lastnumber1, step1);
632 function1.out();
633 function1.outinfile ();
634
635 stars function2 (firstnumber2, lastnumber2, step2);
636 function2.out();
637 function2.outinfile ();
638
639 function3 = function1 - function2;
640 function3.out();
641 function3.outinfile ();
642 break;
643 }
644 case 6:
645 {
646 approx you;
647 function3.approximate();
648 outfile.open ("meow", ios :: app);
649 outfile << "Y = "<< you.koefficientA <<"* x + "<<you.koefficientB << endl;
650 outfile << endl;
651 outfile.close();
652
653
654 }
655 }
656 }
657 };
