Информатика: Функции — различия между версиями

Материал из Department of Theoretical and Applied Mechanics
Перейти к: навигация, поиск
м
Строка 1: Строка 1:
 +
'''[[Абрамов Игорь]]'''
 +
 +
'''Алгоритм''': функции хранятся в программе как массив точек, заданных с определённым шагом по X на заданном отрезке. Вводить значения функции в программу можно двумя способами: с помощью математических функций из стандартных библиотек, указывая начало и конец отрезка, а также шаг, с которым определена функция, и считывая координаты точек из файла, предварительно считав их количество. Далее с любыми функциями можно производить следующие действия и их комбинации: сложение, вычитание, кубическая интерполяция и линейная аппроксимация. При этом результат каждого из этих действий - новая функция, с которой можно продолжать работу. Функции можно выводить на экран с помощью средств графической библиотеки OpenGL, а также печатать её значения в файл.
 +
 +
'''Инструкция''': пользователь вводит необходимые действия с функциями в функции Display. На данный момент при запуске программы можно увидеть пример её работы: первая функция считывается из файла, интерполируется и выводится на экран. Затем вторая функция вводится из библиотеки math.h интерполируется и выводится на экран. Затем функции суммируются, интерполируются и выводятся на экран. [[:File:Func_Abramov.rar]]
  
 +
Ссылка на скачивание: [http://tm.spbstu.ru/File:Func_Abramov.rar]
 
'''[[Андреева Полина]]'''
 
'''[[Андреева Полина]]'''
  
Строка 284: Строка 290:
 
</div>
 
</div>
  
 +
'''[[Анастасия Бальцер]]'''
  
 +
'''Описание программы''': Программа считывает из файла значения функций и количество точек, затем с ними можно провести следующие действия: сложить, умножить, линейно интерполировать и линейно аппроксимировать. Все результаты выводятся в отдельные файлы.
  
 +
'''Пояснения к работе''': В два текстовые файла занести количество точек и значения абсцисс и ординат функций, который написать в первом и втором пунктах меню, затем выбрать необходимую операцию и ввести имя файла, в который сохранятся полученные значения.
  
 +
Скачать можно  [http://tm.spbstu.ru/Файл:inter.zip тут].
  
  
Строка 606: Строка 616:
 
</div>
 
</div>
  
 +
'''[[Васильева Анастасия]]'''
  
 +
'''Инструкция к программе''':сначала в папке с программой создаются два файла input1 и input2, в которых на первой строчке число точек в функции, а потом в два столбика значения х и у (функции должны быть с одинаковым шагом). Пользователь поочередно выбирает действия: 1 - нужно будет написать имя файла, откуда считывать значения для первой функции (х и у), 2 - для второй функции, 3 - сложение функций, пишем название файла, куда будут записываться значения, 4 - разность, 5 - умножение, 6 - интерполяция функции с шагом 0,5 , получившейся в результате сложения двух начальных,(можно сделать интерполяцию функций, которые получились в результате разности или умножения, но нужно будет в коде в case 6: newf3.Inter(0.5).output() поменять индекс функции и новый шаг), 7 - аппроксимация функции, получившейся в результате сложения двух начальных,(можно сделать аппроксимацию функций, которые получились в результате разности или умножения, но нужно будет в коде в case 7: newf3.Approxy().output() поменять индекс функции), 8 - выход.
  
'''[[Лебедев Станислав]]'''
+
'''Краткое описание алгоритма''':  функции хранятся в программе как массив точек, заданных с определённым шагом по X на заданном отрезке. Вводить значения функции в программу можно считывая координаты точек из файла. Далее с любыми функциями можно производить следующие действия: сложение, вычитание, умножение, интерполяция и аппроксимация. При этом результат каждого из этих действий - новая функция. Результаты выводятся в файл.
 +
Скачать программу можно по ссылке [http://tm.spbstu.ru/Файл:1.zip].
  
'''Описание программы''': программа позволяет сложить, умножить, возвести одну в степень другой две таблично заданные функции, а также линейно аппроксимировать результат. Чтение и вывод происходит через файл.
+
'''[[Гильманов Илья]]'''
  
'''Пояснения к алгоритму''':
+
'''Описание программы''': программа, с помощью которой можно складывать, умножать, вычитать, делить 2-е функции, аппроксимировать,интерполировать.
#  Прочитанные из файла функции нужно отсортировать.
 
#  Найти совместную область определения, то есть, найти множество пересечения областей определения функций, над которыми совершается операция.
 
#  Создать третью функцию, со следующими свойствами : область определения состоит только из точек, принадлежащих совместной области определения, каждая точка области значений является результатом нужной операции над точкой области значений одной из функций и, либо интерполированной точкой по другой функции, либо, если есть возможность, точным значением из ее области значений.
 
  
Скачать можно  [http://tm.spbstu.ru/Файл:Функции.rar тут].
+
'''Суть программы:''' Программа позволяет задать 2 функции с любыми областями определения и любыми множествами значений, интерполировать их на любом шаге, аппроксимировать, а так же сложить 2 существующие функции. Программа написана в классе работы с функциями.
  
 +
'''Инструкция к программе''':
 +
1. Пользователь вводит параметры первой функции
 +
2. Пользователь вводит параметры второй функции
 +
3. Происходит интерполяция первой функции по второй
 +
4. Пользователь выбирает арифметическую операцию
 +
5. При желании пользователь может выполнить аппроксимацию полученного результата
  
<div class="mw-collapsible mw-collapsed" style="width:100%" ><div class="mw-collapsible-content">
+
Скачать можно [[http://mech.spbstu.ru/File:Gilmanov_Func.rar здесь]]
<syntaxhighlight lang="cpp" line start="1" enclose="div">
 
#include <iostream>
 
#include <math.h>
 
#include <cstring>
 
#include <cmath>
 
#include <malloc.h>
 
#include <fstream>
 
  
using namespace std;
+
'''[[Демченко Артём]]'''
  
double base(double x)                                       //базовая функция ( если задавать через шаг и начальный х
+
'''Описание программы''': В программе создается две функции, которые мы можем просуммировать, интерполировать каждую из них и аппроксимировать каждую из них. После каждой операции ( кроме аппроксимации ) значения записываются в файл.
{
+
 
    return x;
+
'''Инструкции''': Запустите программу и выбором одного из трех параметров в меню выберете желаемую операцию. Далее следуйте указаниям из меню.
}
+
 
 +
 
 +
Скачать можно  [http://tm.spbstu.ru/File:MyFunc.zip тут].
 +
 
 +
'''[[Иванова Яна]]'''
 +
 
 +
'''Краткое описание алгоритма''': Программа ищет совместную область определения для двух заданных пользователем функций. Для каждой из них вводится шаг и первое и последнее значения. После поиска совместной области программа интерполирует две функции и создает третью функцию, в которую сохраняются результаты работы программы, то есть сложение, вычитание, деление и умножение двух изначальных функций.
 +
 
 +
'''Инструкция к программе''': Введите поочередно первый и последний элементы функций, а также их шаги. После этого введите число, соответствующее желаемому действию (соответствие указано в меню программы).
 +
 
 +
Посмотреть программу можно [http://tm.spbstu.ru/Файл:main.zip здесь]
 +
 
 +
<div class="mw-collapsible mw-collapsed" style="width:100%" >
 +
<syntaxhighlight lang="cpp" line start="1" enclose="div">
 +
 
 +
#include <iostream>
 +
#include <fstream>
 +
#include <cstring>
 +
#include <stdlib.h>
 +
 
 +
using namespace std;
  
struct ap                                                  //две одинаковые структуры это нехорошо,коненчо,но зато наглядно...
+
ofstream outfile;
{
 
    double k,b;
 
};
 
  
struct fun                                                  //один столбик в таблице функции
+
struct approx                                              //структура, необходимая для функции линейной интерполяции
 
{
 
{
     double x,y;
+
     double koefficientA, koefficientB;
 
};
 
};
  
struct sf                                                  //структура нужная, для возражеия значений из функции "prepare" класса F
+
struct dot                                                  //структура, содержащая в себе значения координат каждой точки
{
+
{                                                           //по обеим осям
    int i1,i2,e1,e2;
+
     double x, y;
     double glength, gfirstx, glastx;
 
 
};
 
};
  
double intr(double x1,double x2,double x,double y1,double y2) // линенейная интерполяция
+
struct polyana                                              //структура, содержащая номера первого и последнего элемента каждой
 +
{                                                          //функции и количество элементов каждой из них
 +
    int a1, a2, b1, b2, k1, k2;
 +
};
 +
 
 +
struct trees                                                //структура, содержащая номер элемента и логическое значение,
 +
{                                                          // отвечающее за нужность или не нужность интерполяции
 +
    bool pol;                                              //при равенстве или неравенстве энных элементов двух функций
 +
    int n;
 +
};
 +
                                                            //непосредственно функция линейной интерполяции
 +
double pentagon (double x1, double x, double x2, double y1, double y2)
 
{
 
{
     return ( ((x-x1)/(x2-x1)) * (y2-y1) + y1 );
+
     return (((x - x1)/(x2- x1))*(y2 - y1) + y1);
 
}
 
}
  
ap aproks(fun b [],int n)                                      //линейная аппроксимация
+
class stars                                                //класс, позволяющий сохранять дискретные значения функции на
{
+
{                                                           //определенном интервале с определенным шагом
     ap r;
+
     private:
    double xy = 0,x = 0,y = 0,sqx = 0,xsq = 0;
+
 
    for (int i = 0; i < n; i++)                                //вычисление коэффицентов
+
        double a;                   //первое значение функции
    {
+
         double b;                   //последнее значение функции
         xy  += b[i].x*b[i].y;
+
         double step;               //шаг
         x  += b[i].x;
+
         int length;                 //длина
         y  += b[i].y;
+
         int k;                     //счетчик количества элементов
         sqx += b[i].x*b[i].x;
 
        xsq += b[i].x;
 
    }
 
    xsq *= xsq;
 
  
     r.k = (n*xy - x*y)/(n*sqx - xsq);                      //использование формул
+
     public:
    r.b = (y - r.k*x)/n;
 
    return r;
 
}
 
  
class F
+
        dot *massiv;
{
+
        stars (int _k)                                      //конструктор для создания объекта класса - структуры
private:
+
        {                                                   //с двумя полями по количеству элементов
    int length;
+
            massiv = new dot [_k];
    double firstx, step, lastx;
+
            k = _k;
    fun *a;
+
        }
public:
+
        stars () {};                                        //конструктор
    F(){}
+
        stars (double _a, double _b, double _step)         //конструктор для создания объекта класса через начальный
    F(int l,double f,double s)                             //конструктор, создающий фунцию по длине,первоиу элементу,шагу по х, y вычисляется по базовой функции
+
                                                            //и коненый элементы с определенным шагом
    {
+
         {
         if (l >= 0)
+
            a = _a;
          a = new fun [l];
+
            b = _b;
        firstx = f;
+
            step = _step;
        length = l;
 
        step = s;
 
        lastx = firstx+(length - 1)*step;
 
  
 +
            length = _b - _a + 1;
 +
            k = 0;
  
        for (int i = 0;i < length; i ++)
+
            for (int i = _a ; i <= _b ; i += step)         //подсчет количества элементов функции
        {
+
            {
            a[i].y = base(firstx + i*step);
+
                k++;
             a[i].x = firstx + i*step;
+
             }
        }
 
 
 
    }
 
  
    F (fun b[],int l)                                  //конструктор для создания фунции с уже известными областями определния и значений
+
            massiv = new dot [k];                           //задание функции
    {
+
            for (int i = 0 ; i < k ; i++)
        length = l;
+
              {
        a = new fun [l];
+
                    massiv[i].x = _a + _step * i;
        for (int i = 0; i < l;i++)
+
                    massiv[i].y = i * 5;
            a[i] = b[i];
+
              }
 +
        }
 +
 
 +
        void outinfile ()                                  //вывод в файл значений функции
 +
        {
 +
            outfile.open ("meow", ios :: app);
  
        for (int i = 0; i < l;i++)
+
            outfile << "x" << "          " << "y" << endl;
             for (int j = 0; j < (l - 1); j++)
+
             for (int i = 0 ; i < k ; i++)
                if (a[j].x > a[j + 1].x)
 
 
                 {
 
                 {
                     fun tmp = a[j];
+
                     outfile << massiv[i].x << "        " << massiv[i].y << endl;
                    a[j] = a[j + 1];
 
                    a[j + 1] = a[j];
 
 
                 }
 
                 }
 +
            outfile << endl;
 +
            outfile.close();
 +
        }
  
         firstx = a[0].x;
+
         void out ()                                         //вывод на экран значений функции
        lastx = a[length - 1].x;
 
    }
 
 
 
    void addpar (double k, double b, int l, fun z[] )                           //позволяет создать и заполнить переданным массивом поле объекта класса
 
    {
 
        a = new fun [l];
 
        for (int i = 0; i < l; i++)
 
 
         {
 
         {
             a[i].y = k*z[i].x + b;
+
             cout << "x" << "          " << "y" << endl;
            a[i].x = z[i].x;
+
            for (int i = 0 ; i < k ; i++)
 +
                {
 +
                    cout << massiv[i].x << "        " << massiv[i].y << endl;
 +
                }
 +
            cout << endl;
 
         }
 
         }
        length = l;
 
    }
 
  
    double getelx(int i)                               //возращает значение из поля "х" iого элемента
+
        polyana prepare (stars &h)                         //подготовка совместной области определения для двух функций -
    {
+
        {                                                  //той части значений множества Х, на которой будут
        return a[i].x;
+
            trees del;                                      //производиться вычисления
    }
+
            polyana tmp;
 +
            if (massiv[0].x > h.massiv[0].x)                //поиск начала совместной области определения
 +
            {
 +
                del = h.love(massiv[0].x);
 +
                tmp.a2 = del.n + 1;
 +
                tmp.a1 = 0;
 +
            }
 +
            else
 +
                if (massiv[0].x < h.massiv[0].x)
 +
                {
 +
                    del = love(h.massiv[0].x);
 +
                    tmp.a2 = 0;
 +
                    tmp.a1 = del.n + 1;
 +
                }
 +
                else
 +
                    if (massiv[0].x == h.massiv[0].x)
 +
                    {
 +
                        tmp.a1 = 0;
 +
                        tmp.a2 = 0;
 +
                    };
  
 +
            if (massiv[k-1].x > h.massiv[k-1].x)            //поиск конца совместной области определения
 +
            {
 +
                del = h.love(massiv[k-1].x);
 +
                tmp.b2 = k-1;
 +
                tmp.b1 = del.n;
 +
            }
 +
            else
 +
                if (massiv[k-1].x < h.massiv[k-1].x)
 +
                {
 +
                    del = h.love(massiv[k-1].x);
 +
                    tmp.b2 = del.n;
 +
                    tmp.b1 = k-1;
 +
                }
 +
                else
 +
                    if (massiv[k-1].x == h.massiv[k-1].x)
 +
                    {
 +
                        tmp.b2 = k-1;
 +
                        tmp.b1 = k-1;
 +
                    };
  
    double getely(int i)                              //возращает значение из поля "х" iого элемента
+
            tmp.k1 = 0;
    {
+
            for (int i = tmp.a1 ; i <= tmp.b1 ; i ++)       //подсчет количества элементов первой функции
        return a[i].y;
+
            {
    }
+
                tmp.k1++;
 
+
            }
    int getlength()                                 //возращает размер области определения функции(в точках)
+
            tmp.k2 = 0;
    {
+
            for (int i = tmp.a2 ; i <= tmp.b2 ; i ++)       //подсчет количества элементов второй функции
        return length;
+
            {
    }
+
                tmp.k2++;
 
+
            }
    void FOut()                                    //выводит функцию на экран
+
            return tmp;                                     //возвращает первые и последние значения обеих функций и
    {
+
        }                                                   //их количества элементов
      cout << "  x        y" << endl;
 
      for (int i = 0;i < length; i ++)
 
          cout << "  " << a[i].x << "        " << a[i].y << endl;
 
      cout << endl;
 
    }
 
  
 +
    //ПЕРЕГРУЗКА ОПЕРАТОРОВ
  
     int pfind(double x)const                        //возращает либо номер элемента,идущщий перед элементом, большим,чем х; в случае нахождения равного, возращает число, противоположное номеру следующего элемента(иначе может вернуться нуль,а нуль знака не имееет)
+
     stars operator+ (stars & v)                             //сложение
 
     {
 
     {
         for (int i = 0; i < length-1; i++ )
+
        polyana tmp = prepare(v);
 +
        int general = tmp.k1 + tmp.k2;                      //общее количество элементов обеих функций
 +
        stars F3(general);                                  //создание объекта класса только по количеству элементов
 +
         for (int i = 0 ; i < tmp.k1 ; i++)                 //заполнение первой части окончательного результата
 
         {
 
         {
             if (((a[i].x < x) && (a[i + 1].x > x)))
+
            F3.massiv[i].x = massiv[i+tmp.a1].x;
                 return (i + 1);
+
            trees tiger = v.love(massiv[i+tmp.a1].x);
 +
             if (tiger.pol == true)                          //если значения по У в одной точке не совпадают, то интерполировать
 +
            {
 +
                F3.massiv[i].y = pentagon (v.massiv[tiger.n].x,
 +
                                          F3.massiv[i].x,
 +
                                          v.massiv[tiger.n + 1].x,
 +
                                          v.massiv[tiger.n].y,
 +
                                          v.massiv[tiger.n + 1].y )
 +
                                          + massiv[i+tmp.a1].y;
 +
            }
 +
            else                                            //иначе, просто сложить значения
 +
            {
 +
                F3.massiv[i].y = v.massiv[tiger.n].y + massiv[i+tmp.a1].y;
 +
            }
 +
 
 +
        }
 +
        {
 +
          for (int i = tmp.k1  ; i < (general) ; i++)      //заполнение второй части окончательного результата
 +
        {
 +
            F3.massiv[i].x = v.massiv[i + tmp.a2 - tmp.k1].x;
 +
            trees tiger = love(v.massiv[i + tmp.a2 - tmp.k1].x);
 +
            if (tiger.pol == true)
 +
            {
 +
                 F3.massiv[i].y = pentagon  (v.massiv[tiger.n].x,
 +
                                            F3.massiv[i].x,
 +
                                            v.massiv[tiger.n + 1].x,
 +
                                            v.massiv[tiger.n].y,
 +
                                            v.massiv[tiger.n + 1].y )
 +
                                            + v.massiv[i+tmp.a1 - tmp.k1].y;
 +
            }
 
             else
 
             else
                 // чтобы иметь возможность проанализировать полученное значение функции,мы должны понимать, было найденно равное или промежуточное значение. "флагом" равных значений является знак минус,но так у нуля нет знака,то приходиться все сдвигать на 1
+
                 F3.massiv[i].y = massiv[tiger.n].y + v.massiv[i+tmp.a2 - tmp.k1].y;
                if (a[i].x == x)
 
                  return -(i + 1);
 
                else
 
                    if (a[i + 1].x == x)
 
                        return -(i + 2);
 
 
         }
 
         }
//        cerr << "fail!!" << endl;
 
        return -1;
 
    }
 
  
    sf prepare(F &x)const                                      //"подготовка" функций к бинарной операции (нахождение совместной области определения
+
        for (int i = 0; i < (general); i++)                  //сортировка
    {
 
        sf r;
 
        if (a[0].x > x.a[0].x)
 
 
         {
 
         {
             r.gfirstx = a[0].x;
+
             for (int j = 0; j < (general - 1); j ++)
            r.i1 = 0;
+
            {
            r.i1 = 0;
+
                dot temp;
            double k = x.pfind(a[0].x);
+
                if (F3.massiv[j].x > F3.massiv[j + 1].x)
            if (k < 0)
+
                {
                r.i2 = -k - 1;
+
                    temp = F3.massiv[j];
            else
+
                    F3.massiv[j] = F3.massiv[j + 1];
                r.i2 = (k - 1) + 1;
+
                    F3.massiv[j + 1] = temp;
 +
                }
 +
                else                                        //если элементы совпадают, то нужно выбросить один из них
 +
                if (F3.massiv[j].x == F3.massiv[j + 1].x)
 +
                {
 +
                    int l = j;
 +
                    while (l < general)
 +
                    {
 +
                        F3.massiv[l].x = F3.massiv[l + 1].x;
 +
                        F3.massiv[l].y = F3.massiv[l + 1].y;
 +
                        l++;
 +
                    }
 +
                    general--;
 +
                }
 +
            }
 
         }
 
         }
         else
+
 
 +
 
 +
         stars normalny (general);                          //создание элемента класса по длине
 +
        for (int i = 0; i < (general); i++)
 
         {
 
         {
             r.gfirstx = x.a[0].x;
+
             normalny.massiv[i].x = F3.massiv[i].x;
            double k = pfind(x.a[0].x);
+
             normalny.massiv[i].y = F3.massiv[i].y;
             if (k < 0)
 
                r.i1 = -k - 1;
 
            else
 
                r.i1 = (k - 1) + 1;
 
            r.i2 = 0;
 
 
         }
 
         }
 +
        a = normalny.massiv[0].x;
 +
        b = normalny.massiv[general].x;
 +
        return normalny;
 +
    }
 +
    };
  
         if (a[length - 1].x < x.a[x.length - 1].x)
+
         stars operator* (stars & v)                        //умножение
 +
    {
 +
        polyana tmp = prepare(v);
 +
        int general = tmp.k1 + tmp.k2;
 +
        stars F3(tmp.k1 + tmp.k2);
 +
        for (int i = 0 ; i < tmp.k1 ; i++)
 
         {
 
         {
             r.glastx = a[length - 1].x;
+
             F3.massiv[i].x = massiv[i+tmp.a1].x;
             r.e1 = length - 1;
+
             trees tiger = v.love(massiv[i+tmp.a1].x);
            double k = x.pfind(r.glastx);
+
             if (tiger.pol == true)
             if (k < 0)
+
            {
                 r.e2 = -k - 1;
+
                 F3.massiv[i].y = pentagon (v.massiv[tiger.n].x,      F3.massiv[i].x,
 +
                                          v.massiv[tiger.n + 1].x,  v.massiv[tiger.n].y,
 +
                                          v.massiv[tiger.n + 1].y )* (massiv[i+tmp.a1].y);
 +
            }
 
             else
 
             else
                 r.e2 = (k - 1) - 1;
+
            {
 +
                 F3.massiv[i].y = v.massiv[tiger.n].y * massiv[i+tmp.a1].y;
 +
            }
 +
 
 
         }
 
         }
        else
 
 
         {
 
         {
             r.glastx = x.a[x.length - 1].x;
+
             for (int i = tmp.k1 ; i < (general) ; i++)
             double k = pfind(r.glastx);
+
        {
             if (k < 0)
+
            F3.massiv[i].x = v.massiv[i+tmp.a2 - tmp.k1].x;
                 r.e1 = -k - 1;
+
             trees tiger = love(v.massiv[i+tmp.a2 - tmp.k1].x);
 +
             if (tiger.pol == true)
 +
            {
 +
                 F3.massiv[i].y = pentagon (v.massiv[tiger.n].x,
 +
                                            F3.massiv[i].x,
 +
                                            v.massiv[tiger.n + 1].x,
 +
                                            v.massiv[tiger.n].y,
 +
                                            v.massiv[tiger.n + 1].y )
 +
                                            + v.massiv[i+tmp.a1 - tmp.k1].y;
 +
            }
 
             else
 
             else
                 r.e1 = (k - 1) + 1;
+
                 F3.massiv[i].y = massiv[tiger.n].y + v.massiv[i+tmp.a2 - tmp.k1].y;
            r.e2 = x.length - 1;
 
 
         }
 
         }
        r.glength = length + x.length - r.i1 - (length - (r.e1 + 1)) - r.i2 - (x.length - (r.e2 + 1));
 
  
        return r;
+
         for (int i= 0; i < (general); i++)
    }
 
 
 
    void ad (fun b[],int l)                                  //присвоить массиву объекта класса F значения массива b
 
    {
 
        length = l;
 
        a = new fun [l];
 
         for (int i = 0; i < l;i++)
 
            a[i] = b[i];
 
        firstx = a[0].x;
 
        lastx = a[length - 1].x;
 
    }
 
 
 
    fun *geta()                                        //получения указателя на начало массива в поле класса
 
    {
 
        return a;
 
    }
 
 
 
    F operator +(F &x) const                              //сложение двух функций
 
    {
 
        int i1, e1, i2, e2, kk = 0;
 
        double gfirstx, glastx, glength;
 
 
 
        if (((x.lastx < firstx) && (x.firstx < firstx)) || ((lastx < x.firstx) && (firstx < x.firstx)))
 
 
         {
 
         {
             cout << "Nevozmozhno, prover'te oblasti opredelenia" << endl;
+
             for (int j = 0; j < (general - 1); j ++)
             F fl(-1,0,0);
+
             {
             return fl;
+
                dot temp;
 +
                if (F3.massiv[j].x > F3.massiv[j+1].x)
 +
                {
 +
                    temp = F3.massiv[j];
 +
                    F3.massiv[j] = F3.massiv[j+1];
 +
                    F3.massiv[j+1] = temp;
 +
                }
 +
                else
 +
                if (F3.massiv[j].x == F3.massiv[j+1].x)
 +
                {
 +
                    int l = j;
 +
                    while (l < general)
 +
                    {
 +
                        F3.massiv[j].x = F3.massiv[j+1].x;
 +
                        l++;
 +
                    }
 +
                    general--;
 +
                }
 +
             }
 
         }
 
         }
        sf r = prepare(x);
+
 
        F tmp(r.glength,r.gfirstx,r.glastx);
+
        for (int i = 0 ; i < general ; i++)
        for (int i = 0; i <= (r.e1 - r.i1); i++)
 
 
         {
 
         {
            tmp.a[i].x = a[i + r.i1].x;            //поправка,введенная таким образом,чтобы номер,с которого начинается отсчет был первым в новой области определения
+
 
             int ii = x.pfind(tmp.a[i].x);
+
             cout <<F3.massiv[i].x<< ' ' << F3.massiv[i].y <<endl;
            if (ii < 0)
 
                tmp.a[i].y = x.a[-ii - 1].y + a[i + r.i1].y;
 
            else
 
                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;
 
 
         }
 
         }
         for (int i = (r.e1 - r.i1 + 1); i <= (r.e2 - r.i2 + (r.e1 - r.i1) + 1) ; i++)
+
 
 +
 
 +
        stars normalny(general);
 +
         for (int i = 0; i < (general); i++)
 
         {
 
         {
             int ii = pfind(x.a[i - (r.e1 - r.i1 + 1) + r.i2].x);
+
             normalny.massiv[i].x = F3.massiv[i].x;
             if (ii >= 0)
+
            normalny.massiv[i].y = F3.massiv[i].y;
 +
        }
 +
        a = normalny.massiv[0].x;
 +
        b = normalny.massiv[general].x;
 +
        return normalny;
 +
    }
 +
    };
 +
 
 +
    stars operator- (stars & v)                            //вычитание
 +
    {
 +
        polyana tmp = prepare(v);
 +
        int general = tmp.k1 + tmp.k2;
 +
        stars F3(tmp.k1 + tmp.k2);
 +
        for (int i = 0 ; i < tmp.k1 ; i++)
 +
        {
 +
            F3.massiv[i].x = massiv[i+tmp.a1].x;
 +
            trees tiger = v.love(massiv[i+tmp.a1].x);
 +
             if (tiger.pol == true)
 
             {
 
             {
                 tmp.a[i - kk].x = x.a[i - (r.e1 - r.i1 + 1) + r.i2].x;
+
                 F3.massiv[i].y = pentagon (v.massiv[tiger.n].x,      F3.massiv[i].x,
                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;
+
                                          v.massiv[tiger.n + 1].x,   v.massiv[tiger.n].y,
 +
                                          v.massiv[tiger.n + 1].y )- massiv[i+tmp.a1].y;
 
             }
 
             }
 
             else
 
             else
 
             {
 
             {
                 kk++;
+
                 F3.massiv[i].y = v.massiv[tiger.n].y - massiv[i+tmp.a1].y;
                glength --;
 
                tmp.length --;
 
 
             }
 
             }
 +
 
         }
 
         }
 
+
        {
        for (int i = 0; i < glength; i++)
+
            for (int i = tmp.k1 ; i < (general) ; i++)
             for (int j = 0; j < glength - 1; j++)
+
        {
             if (tmp.a[j].x > tmp.a[j + 1].x)
+
             F3.massiv[i].x = v.massiv[i+tmp.a2 - tmp.k1].x;
 +
             trees tiger = love(v.massiv[i+tmp.a2 - tmp.k1].x);
 +
            if (tiger.pol == true)
 
             {
 
             {
                 fun t = tmp.a[j];
+
                 F3.massiv[i].y = pentagon (v.massiv[tiger.n].x,
                tmp.a[j] = tmp.a[j + 1];
+
                                            F3.massiv[i].x,
                tmp.a[j + 1] = t;
+
                                            v.massiv[tiger.n + 1].x,
 +
                                            v.massiv[tiger.n].y,
 +
                                            v.massiv[tiger.n + 1].y )
 +
                                            + v.massiv[i+tmp.a1 - tmp.k1].y;
 
             }
 
             }
 +
            else
 +
                F3.massiv[i].y = massiv[tiger.n].y + v.massiv[i+tmp.a2 - tmp.k1].y;
 +
        }
  
         return tmp;
+
         for (int i= 0; i < (general); i++)
}
+
        {
 +
            for (int j = 0; j < (general - 1); j ++)
 +
            {
 +
                dot temp;
 +
                if (F3.massiv[j].x > F3.massiv[j+1].x)
 +
                {
 +
                    temp = F3.massiv[j];
 +
                    F3.massiv[j] = F3.massiv[j+1];
 +
                    F3.massiv[j+1] = temp;
 +
                }
 +
                else
 +
                if (F3.massiv[j].x == F3.massiv[j+1].x)
 +
                {
 +
                    int l = j;
 +
                    while (l < general)
 +
                    {
 +
                        F3.massiv[j].x = F3.massiv[j+1].x;
 +
                        l++;
 +
                    }
 +
                    general--;
 +
                }
 +
            }
 +
        }
  
    F operator *(F & x) const                                        //умножение двух функций
+
        for (int i = 0 ; i < general ; i++)
    {
+
         {
        int i1, e1, i2, e2, kk = 0;
 
         double gfirstx, glastx, glength;
 
  
        if (((x.lastx < firstx) && (x.firstx < firstx)) || ((x.firstx < lastx) && (firstx < x.firstx)))
+
            cout <<F3.massiv[i].x<< ' ' << F3.massiv[i].y <<endl;
        {
 
            cout << "Nevozmozhno, prover'te oblasti opredelenia" << endl;
 
            F fl(-1,0,0);
 
            return fl;
 
 
         }
 
         }
  
        sf r = prepare(x);
 
        F tmp(r.glength,r.gfirstx,r.glastx);
 
  
         for (int i = 0; i <= (r.e1 - r.i1); i++)
+
        stars normalny(general);
 +
         for (int i = 0; i < (general); i++)
 
         {
 
         {
             tmp.a[i].x = a[i + r.i1].x;
+
             normalny.massiv[i].x = F3.massiv[i].x;
            int ii = x.pfind(tmp.a[i].x);
+
             normalny.massiv[i].y = F3.massiv[i].y;
            if (ii < 0)
 
                tmp.a[i].y = x.a[-ii - 1].y * a[i + r.i1].y;
 
             else
 
                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;
 
 
         }
 
         }
         for (int i = (r.e1 - r.i1 + 1); i <= (r.e2 - r.i2 + (r.e1 - r.i1) + 1) ; i++)
+
         a = normalny.massiv[0].x;
 +
        b = normalny.massiv[general].x;
 +
        return normalny;
 +
    }
 +
    };
 +
 
 +
    stars operator/ (stars & v)                            //деление
 +
    {
 +
        polyana tmp = prepare(v);
 +
        int general = tmp.k1 + tmp.k2;
 +
        stars F3(tmp.k1 + tmp.k2);
 +
        for (int i = 0 ; i < tmp.k1 ; i++)
 
         {
 
         {
             int ii = pfind(x.a[i - (r.e1 - r.i1 + 1) + r.i2].x);
+
             F3.massiv[i].x = massiv[i+tmp.a1].x;
             if (ii >= 0)
+
            trees tiger = v.love(massiv[i+tmp.a1].x);
 +
             if (tiger.pol == true)
 
             {
 
             {
                 tmp.a[i - kk].x = x.a[i - (r.e1 - r.i1 + 1) + r.i2].x;
+
                 F3.massiv[i].y = pentagon (v.massiv[tiger.n].x,      F3.massiv[i].x,
                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;
+
                                          v.massiv[tiger.n + 1].x,   v.massiv[tiger.n].y,
 +
                                          v.massiv[tiger.n + 1].y )/ (massiv[i+tmp.a1].y);
 
             }
 
             }
 
             else
 
             else
 
             {
 
             {
                 kk++;
+
                 F3.massiv[i].y = (v.massiv[tiger.n].y) / (massiv[i+tmp.a1].y);
                glength --;
 
                tmp.length --;
 
 
             }
 
             }
 +
 
         }
 
         }
 
+
        {
        for (int i = 0; i < glength; i++)
+
            for (int i = tmp.k1 ; i < (general) ; i++)
             for (int j = 0; j < glength - 1; j++)
+
        {
             if (tmp.a[j].x > tmp.a[j + 1].x)
+
             F3.massiv[i].x = v.massiv[i+tmp.a2 - tmp.k1].x;
 +
             trees tiger = love(v.massiv[i+tmp.a2 - tmp.k1].x);
 +
            if (tiger.pol == true)
 
             {
 
             {
                 fun t = tmp.a[j];
+
                 F3.massiv[i].y = pentagon (v.massiv[tiger.n].x,
                tmp.a[j] = tmp.a[j + 1];
+
                                            F3.massiv[i].x,
                tmp.a[j + 1] = t;
+
                                            v.massiv[tiger.n + 1].x,
 +
                                            v.massiv[tiger.n].y,
 +
                                            v.massiv[tiger.n + 1].y )
 +
                                            + v.massiv[i+tmp.a1 - tmp.k1].y;
 
             }
 
             }
 
+
            else
        return tmp;
+
                F3.massiv[i].y = massiv[tiger.n].y + v.massiv[i+tmp.a2 - tmp.k1].y;
    }
 
 
 
    F operator ^(F & x) const                                  //возведение функции слева от оператора в степень функции справа от оператора
 
    {
 
        int i1, e1, i2, e2, kk = 0;
 
        double gfirstx, glastx, glength;
 
 
 
        if (((x.lastx < firstx) && (x.firstx < firstx)) || ((x.firstx < lastx) && (firstx < x.firstx)))
 
        {
 
            cout << "Nevozmozhno, prover'te oblasti opredelenia" << endl;
 
            F fl(-1,0,0);
 
            return fl;
 
 
         }
 
         }
  
        sf r = prepare(x);
+
         for (int i= 0; i < (general); i++)
        F tmp(r.glength,r.gfirstx,r.glastx);
 
 
 
         for (int i = 0; i <= (r.e1 - r.i1); i++)
 
 
         {
 
         {
             tmp.a[i].x = a[i + r.i1].x;
+
             for (int j = 0; j < (general - 1); j ++)
            int ii = x.pfind(tmp.a[i].x);
+
            {
            if (ii < 0)
+
                dot temp;
                tmp.a[i].y = pow(x.a[-ii - 1].y, a[i + r.i1].y);
+
                if (F3.massiv[j].x > F3.massiv[j+1].x)
            else
+
                {
                 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);
+
                    temp = F3.massiv[j];
 +
                    F3.massiv[j] = F3.massiv[j+1];
 +
                    F3.massiv[j+1] = temp;
 +
                }
 +
                else
 +
                 if (F3.massiv[j].x == F3.massiv[j+1].x)
 +
                {
 +
                    int l = j;
 +
                    while (l < general)
 +
                    {
 +
                        F3.massiv[j].x = F3.massiv[j+1].x;
 +
                        l++;
 +
                    }
 +
                    general--;
 +
                }
 +
            }
 
         }
 
         }
        for (int i = (r.e1 - r.i1 + 1); i <= (r.e2 - r.i2 + (r.e1 - r.i1) + 1) ; i++)
+
 
 +
        for (int i = 0 ; i < general ; i++)
 
         {
 
         {
            int ii = pfind(x.a[i - (r.e1 - r.i1 + 1) + r.i2].x);
+
 
             if (ii >= 0)
+
             cout <<F3.massiv[i].x<< ' ' << F3.massiv[i].y <<endl;
            {
 
                tmp.a[i - kk].x = x.a[i - (r.e1 - r.i1 + 1) + r.i2].x;
 
                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);
 
            }
 
            else
 
            {
 
                kk++;
 
                glength --;
 
                tmp.length --;
 
            }
 
 
         }
 
         }
  
         for (int i = 0; i < glength; i++)
+
 
             for (int j = 0; j < glength - 1; j++)
+
        stars normalny(general);
             if (tmp.a[j].x > tmp.a[j + 1].x)
+
         for (int i = 0; i < (general); i++)
 +
        {
 +
             normalny.massiv[i].x = F3.massiv[i].x;
 +
            normalny.massiv[i].y = F3.massiv[i].y;
 +
        }
 +
        a = normalny.massiv[0].x;
 +
        b = normalny.massiv[general].x;
 +
        return normalny;
 +
    }
 +
    };
 +
 
 +
    trees love (double a)                                  //
 +
    {
 +
        trees privet;
 +
        for (int i = 0; i < k; i++ )
 +
             if ((massiv[i].x < a)&& (a < massiv[i+1].x))
 
             {
 
             {
                 fun t = tmp.a[j];
+
                 privet.n = i;
                 tmp.a[j] = tmp.a[j + 1];
+
                 privet.pol = true;
                 tmp.a[j + 1] = t;
+
                 return privet;
 
             }
 
             }
 +
            else
 +
                if (massiv[i].x == a)
 +
                {
 +
                    privet.n = i;
 +
                    privet.pol = false;
 +
                    return privet;
 +
                }
 +
                else
 +
                if (massiv[i+1].x == a)
 +
                {
 +
                    privet.n = i+1;
 +
                    privet.pol = false;
 +
                    return privet;
 +
                }
 +
    }
  
        return tmp;
 
    }
 
};
 
  
int main()
+
    approx approximate ()                                   //функция аппроксимации
{
 
  /*
 
    F f1(5,-2,1.5);
 
    F f2(30,-10,0.5);
 
    F f3, f4;
 
    f1.FOut();
 
    f2.FOut();
 
    f3 = f1 + f2;
 
    f3.FOut();
 
    f4 = f1 * f2;
 
    f4.FOut();
 
    cout << " ________" << endl;
 
*/
 
    char vc, s[255], ce;
 
    ifstream infile;
 
    int n;
 
    fun *a;
 
    F f5,f6,f7,f8,f9;
 
 
 
    while(true)
 
 
     {
 
     {
    start :
+
        approx hey;
         system("cls");
+
         stars mattafix (double a, double b, double step, int k, int length);
         cout << "1 - Vvesti 1uu func"            << endl;
+
         double sigmaX = 0;
         cout << "2 - Vvesti 2uu func"            << endl;
+
         double sigmaY = 0;
         cout << "3 - Sloshit'"                  << endl;
+
         double sigmaXY = 0;
         cout << "4 - Umnozhit'"                  << endl;
+
         double sigmaXsqrt = 0;
         cout << "5 - Vozvesti v stepen'"        << endl;
+
         for (int i = 0; i < length; i++)
        cout << "6 - Aproximirovat'"            << endl;
 
        cout << "7 - Zapics' v file func"        << endl;
 
        cout << "8 - Zapics' v file aprok fun"  << endl;
 
        cout << "0 - Vihod"                      << endl;
 
        cin  >> vc;
 
        switch (vc)
 
 
         {
 
         {
            case '0':
+
          sigmaX += a + step * i;
                return 0 ;
+
          sigmaY += b + i * 5;
            case '1':
+
          sigmaXY += (a + step * i)*(b + i * 5);
                {
+
          sigmaXsqrt += (a + step * i)*(a + step * i);
                system("cls");
+
        }
                strcpy(s,"");
+
        hey.koefficientA = ((k * (sigmaXY) - (sigmaX*sigmaY))/(k*sigmaXsqrt - (sigmaX * sigmaX)));
                delete []a;
+
        hey.koefficientB = ((sigmaY - hey.koefficientA*sigmaX)/k);
                a = NULL;
+
        return hey;
                cout << "Vvedite imya fila" << endl;
+
 
                cin >> s;
+
 
                strcat(s, ".txt");
+
    }
                infile.open(s);
+
};
                infile >> n;
+
 
                a = new fun [n];
+
int main()
                for(int i = 0; i < n; i ++)
+
{
                    infile >> a[i].x >> a[i].y;
+
    int tyu;
                f5.ad(a,n);
+
    stars function3;
                f5.FOut();
+
    int firstnumber1;
                infile.close();
+
    int firstnumber2;
                cout << "Nazhmite \"b\" chotibi viti" << endl;
+
    int lastnumber1;
                cin >> ce;
+
    int lastnumber2;
                while (true)
+
    int step1;
                if (ce == 'b')
+
    int step2;
                    goto start;
+
    while (true)
                }
+
    {
            case '2':
+
 
                {
+
        cout << "Input 0 - vvedite parametry pervoy funkcii"<< endl;
                system("cls");
+
        cout << "Input 1 - vvedite parametry vtoroy funkcii"<< endl;
                strcpy(s,"");
+
        cout << "Input 2 - slozhenie"<< endl;
                delete []a;
+
        cout << "Input 3 - umnozhenie"<< endl;
                a = NULL;
+
        cout << "Input 4 - delenie"<< endl;
                cout << "Vvedite imya fila" << endl;
+
        cout << "Input 5 - vychitanie"<< endl;
                cin >> s;
+
        cout << "Input 6 - aproximate"<< endl;
                strcat(s, ".txt");
+
        cin >> tyu ;
                infile.open(s);
+
 
                infile >> n;
+
        switch (tyu)
                a = new fun[n];
+
        {
                for(int i = 0; i < n; i ++)
+
             case 0:
                    infile >> a[i].x >> a[i].y;
+
            {  cout << "Vvedite pervy x" << endl;
                f6.ad(a,n);
+
                 cin >> firstnumber1;
                f6.FOut();
+
                 cout << "Vvedite posledniy x" << endl;
                infile.close();
+
                 cin >> lastnumber1;
                cout << "Nazhmite \"b\" chotibi viti" << endl;
+
                 cout << "Vvedite shag" << endl;
                cin >> ce;
+
                 cin >> step1;
                while (true)
+
                 break;
                if (ce == 'b')
+
            }
                    goto start;
+
             case 1:
                }
 
            case '3':
 
                system("cls");
 
                f5.FOut();
 
                f6.FOut();
 
                f7 = f5 + f6;
 
                f7.FOut();
 
                cout << "Nazhmite \"b\" chotibi viti" << endl;
 
                cin >> ce;
 
                while (true)
 
                if (ce == 'b')
 
                    goto start;
 
             case '4':
 
                system("cls");
 
                 f5.FOut();
 
                f6.FOut();
 
                f7 = f5 * f6;
 
                f7.FOut();
 
                 cout << "Nazhmite \"b\" chotibi viti" << endl;
 
                 cin >> ce;
 
                while (true)
 
                if (ce == 'b')
 
                    goto start;
 
            case '5':
 
                system("cls");
 
                f5.FOut();
 
                f6.FOut();
 
                f7 = f5 ^ f6;
 
                f7 = f5 ^ f6;
 
                f7.FOut();
 
                 cout << "Nazhmite \"b\" chotibi viti" << endl;
 
                 cin >> ce;
 
                 while (true)
 
                if (ce == 'b')
 
                    goto start;
 
             case '6':
 
 
             {
 
             {
                 system("cls");
+
                 cout << "Vvedite pervy x" << endl;
                 ap tmp = aproks(f7.geta(), f7.getlength());
+
                 cin >> firstnumber2;
                 f8.addpar(tmp.k, tmp.b, f7.getlength(), f7.geta());
+
                 cout << "Vvedite posledniy x" << endl;
                 f8.FOut();
+
                 cin >> lastnumber2;
                 cout << "Nazhmite \"b\" chotibi viti" << endl;
+
                 cout << "Vvedite shag" << endl;
                 cin >> ce;
+
                 cin >> step2;
                 while (true)
+
                 break;
                if (ce == 'b')
 
                    goto start;
 
 
             }
 
             }
             case '7':
+
             case 2:
 
             {
 
             {
                 system("cls");
+
                 stars function1 (firstnumber1, lastnumber1, step1);
                 strcpy(s,"");
+
                 function1.out();
                 cout << "Vvedite imya fila" << endl;
+
                 function1.outinfile ();
                cin >> s;
+
 
                 strcat(s, ".txt");
+
                 stars function2 (firstnumber2, lastnumber2, step2);
                 ofstream outfile(s);
+
                 function2.out();
                 outfile << "x          y" << endl;
+
                 function2.outinfile ();
                for (int i = 0; i < f7.getlength(); i ++)
 
                    outfile << f7.getelx(i) << "          " << f7.getely(i) << endl;
 
  
                 cout << "done" << endl;
+
                 function3 = function1 + function2;
                 cout << "Nazhmite \"b\" chotibi viti" << endl;
+
                 function3.out();
                cin >> ce;
+
                 function3.outinfile ();
                 while (true)
+
                 break;
                 if (ce == 'b')
 
                    goto start;
 
 
             }
 
             }
             case '8':
+
             case 3:
                system("cls");
+
            {
                 strcpy(s,"");
+
                 stars function1 (firstnumber1, lastnumber1, step1);
                 cout << "Vvedite imya fila" << endl;
+
                 function1.out();
                cin >> s;
+
                 function1.outinfile ();
                strcat(s, ".txt");
 
                ofstream outfile(s);
 
                 outfile << "x          y" << endl;
 
                for (int i = 0; i < f8.getlength(); i ++)
 
                    outfile << f8.getelx(i) << "          " << f8.getely(i) << endl;
 
                cout << "done" << endl;
 
                cout << "Nazhmite \"b\" chotibi viti" << endl;
 
                cin >> ce;
 
                while (true)
 
                if (ce == 'b')
 
                    goto start;
 
        }
 
    }
 
    return 0;
 
}
 
</syntaxhighlight>
 
</div>
 
  
 +
                stars function2 (firstnumber2, lastnumber2, step2);
 +
                function2.out();
 +
                function2.outinfile ();
  
'''[[Иванова Яна]]'''
+
                function3 = function1 * function2;
 +
                function3.out();
 +
                function3.outinfile ();
 +
                break;
 +
            }
 +
            case 4:
 +
            {
 +
                stars function1 (firstnumber1, lastnumber1, step1);
 +
                function1.out();
 +
                function1.outinfile ();
  
'''Краткое описание алгоритма''': Программа ищет совместную область определения для двух заданных пользователем функций. Для каждой из них вводится шаг и первое и последнее значения. После поиска совместной области программа интерполирует две функции и создает третью функцию, в которую сохраняются результаты работы программы, то есть сложение, вычитание, деление и умножение двух изначальных функций.
+
                stars function2 (firstnumber2, lastnumber2, step2);
 +
                function2.out();
 +
                function2.outinfile ();
  
'''Инструкция к программе''': Введите поочередно первый и последний элементы функций, а также их шаги. После этого введите число, соответствующее желаемому действию (соответствие указано в меню программы).
+
                function3 = function1 / function2;
 +
                function3.out();
 +
                function3.outinfile ();
 +
                break;
 +
            }
 +
            case 5:
 +
            {
 +
 
 +
                stars function1 (firstnumber1, lastnumber1, step1);
 +
                function1.out();
 +
                function1.outinfile ();
  
Посмотреть программу можно [http://tm.spbstu.ru/Файл:main.zip здесь]
+
                stars function2 (firstnumber2, lastnumber2, step2);
 +
                function2.out();
 +
                function2.outinfile ();
  
<div class="mw-collapsible mw-collapsed" style="width:100%" >
+
                function3 = function1 - function2;
<syntaxhighlight lang="cpp" line start="1" enclose="div">
+
                function3.out();
 +
                function3.outinfile ();
 +
                break;
 +
            }
 +
            case 6:
 +
                {
 +
                    approx you;
 +
                    function3.approximate();
 +
                    outfile.open ("meow", ios :: app);
 +
                    outfile << "Y = "<< you.koefficientA <<"* x + "<<you.koefficientB << endl;
 +
                    outfile << endl;
 +
                    outfile.close();
  
#include <iostream>
 
#include <fstream>
 
#include <cstring>
 
#include <stdlib.h>
 
  
using namespace std;
+
                }
 +
            }
 +
        }
 +
    };
  
ofstream outfile;
 
  
struct approx                                              //структура, необходимая для функции линейной интерполяции
+
</syntaxhighlight>
{
+
</div>
    double koefficientA, koefficientB;
+
 
};
+
'''[[Капитанюк Светлана]]'''
  
struct dot                                                  //структура, содержащая в себе значения координат каждой точки
+
'''Описание программы:''': программа, позволяющая складывать, вычитать, умножать и делить две функции, заданные на одном интервале, интерполирующая первую функцию по второй и аппроксимирующая результат арифметической операции с заданными пользователем функции. 
{                                                          //по обеим осям
 
    double x, y;
 
};
 
  
struct polyana                                              //структура, содержащая номера первого и последнего элемента каждой
+
Скачать можно  [http://tm.spbstu.ru/File:Function_02.zip тут].
{                                                          //функции и количество элементов каждой из них
 
    int a1, a2, b1, b2, k1, k2;
 
};
 
  
struct trees                                                //структура, содержащая номер элемента и логическое значение,
+
'''[[Киселёв Лев]]'''
{                                                          // отвечающее за нужность или не нужность интерполяции
+
'''Описание программы''':программа позволяет интерполировать и аппроксимировать значения функции, а также складывать две функции, используя перегрузку.
    bool pol;                                              //при равенстве или неравенстве энных элементов двух функций
 
    int n;
 
};
 
                                                            //непосредственно функция линейной интерполяции
 
double pentagon (double x1, double x, double x2, double y1, double y2)
 
{
 
    return (((x - x1)/(x2- x1))*(y2 - y1) + y1);
 
}
 
  
class stars                                                //класс, позволяющий сохранять дискретные значения функции на
+
Скачать можно [[http://mech.spbstu.ru/File:Interpol.rar здесь]]
{                                                          //определенном интервале с определенным шагом
 
    private:
 
  
        double a;                  //первое значение функции
+
'''[[Козловская Анна]]'''
        double b;                  //последнее значение функции
 
        double step;                //шаг
 
        int length;                //длина
 
        int k;                      //счетчик количества элементов
 
  
    public:
+
'''Описание программы''': программа позволяет сложить, умножить, возвести одну в степень другой две таблично заданные функции, а также линейно аппроксимировать результат. Чтение и вывод происходит через файл.
  
        dot *massiv;
+
'''Пояснения к алгоритму''': Программа создаёт и хранит значения двух функций с одинаковом шагом и заданных на одинаковом интервале. Методы позволяют сложить эти две функции,интерполировать одну из них по заданному шагу или апроксимировать методом наименьших квадратов. Данные берутся из файла. При считывании с файла сначала указывается отрезок, потом величина, а потом дискретные значения.
        stars (int _k)                                      //конструктор для создания объекта класса - структуры
 
        {                                                  //с двумя полями по количеству элементов
 
            massiv = new dot [_k];
 
            k = _k;
 
        }
 
        stars () {};                                        //конструктор
 
        stars (double _a, double _b, double _step)          //конструктор для создания объекта класса через начальный
 
                                                            //и коненый элементы с определенным шагом
 
        {
 
            a = _a;
 
            b = _b;
 
            step = _step;
 
  
            length = _b - _a + 1;
 
            k = 0;
 
  
            for (int i = _a ; i <= _b ; i += step)          //подсчет количества элементов функции
+
Скачать можно  [http://tm.spbstu.ru/File:project1.rar тут].
            {
 
                k++;
 
            }
 
  
            massiv = new dot [k];                          //задание функции
+
'''[[Лебедев Станислав]]'''
            for (int i = 0 ; i < k ; i++)
 
              {
 
                    massiv[i].x = _a + _step * i;
 
                    massiv[i].y = i * 5;
 
              }
 
        }
 
  
        void outinfile ()                                  //вывод в файл значений функции
+
'''Описание программы''': программа позволяет сложить, умножить, возвести одну в степень другой две таблично заданные функции, а также линейно аппроксимировать результат. Чтение и вывод происходит через файл.
        {
 
            outfile.open ("meow", ios :: app);
 
  
            outfile << "x" << "          " << "y" << endl;
+
'''Пояснения к алгоритму''':
            for (int i = 0 ; i < k ; i++)
+
#  Прочитанные из файла функции нужно отсортировать.
                {
+
#  Найти совместную область определения, то есть, найти множество пересечения областей определения функций, над которыми совершается операция.
                    outfile << massiv[i].x << "        " << massiv[i].y << endl;
+
#  Создать третью функцию, со следующими свойствами : область определения состоит только из точек, принадлежащих совместной области определения, каждая точка области значений является результатом нужной операции над точкой области значений одной из функций и, либо интерполированной точкой по другой функции, либо, если есть возможность, точным значением из ее области значений.
                }
 
            outfile << endl;
 
            outfile.close();
 
        }
 
  
        void out ()                                        //вывод на экран значений функции
+
Скачать можно  [http://tm.spbstu.ru/Файл:Функции.rar тут].
        {
 
            cout << "x" << "          " << "y" << endl;
 
            for (int i = 0 ; i < k ; i++)
 
                {
 
                    cout << massiv[i].x << "        " << massiv[i].y << endl;
 
                }
 
            cout << endl;
 
        }
 
  
        polyana prepare (stars &h)                          //подготовка совместной области определения для двух функций -
 
        {                                                  //той части значений множества Х, на которой будут
 
            trees del;                                      //производиться вычисления
 
            polyana tmp;
 
            if (massiv[0].x > h.massiv[0].x)                //поиск начала совместной области определения
 
            {
 
                del = h.love(massiv[0].x);
 
                tmp.a2 = del.n + 1;
 
                tmp.a1 = 0;
 
            }
 
            else
 
                if (massiv[0].x < h.massiv[0].x)
 
                {
 
                    del = love(h.massiv[0].x);
 
                    tmp.a2 = 0;
 
                    tmp.a1 = del.n + 1;
 
                }
 
                else
 
                    if (massiv[0].x == h.massiv[0].x)
 
                    {
 
                        tmp.a1 = 0;
 
                        tmp.a2 = 0;
 
                    };
 
  
            if (massiv[k-1].x > h.massiv[k-1].x)            //поиск конца совместной области определения
+
<div class="mw-collapsible mw-collapsed" style="width:100%" ><div class="mw-collapsible-content">
            {
+
<syntaxhighlight lang="cpp" line start="1" enclose="div">
                del = h.love(massiv[k-1].x);
+
#include <iostream>
                tmp.b2 = k-1;
+
#include <math.h>
                tmp.b1 = del.n;
+
#include <cstring>
            }
+
#include <cmath>
            else
+
#include <malloc.h>
                if (massiv[k-1].x < h.massiv[k-1].x)
+
#include <fstream>
                {
 
                    del = h.love(massiv[k-1].x);
 
                    tmp.b2 = del.n;
 
                    tmp.b1 = k-1;
 
                }
 
                else
 
                    if (massiv[k-1].x == h.massiv[k-1].x)
 
                    {
 
                        tmp.b2 = k-1;
 
                        tmp.b1 = k-1;
 
                    };
 
  
            tmp.k1 = 0;
+
using namespace std;
            for (int i = tmp.a1 ; i <= tmp.b1 ; i ++)      //подсчет количества элементов первой функции
 
            {
 
                tmp.k1++;
 
            }
 
            tmp.k2 = 0;
 
            for (int i = tmp.a2 ; i <= tmp.b2 ; i ++)      //подсчет количества элементов второй функции
 
            {
 
                tmp.k2++;
 
            }
 
            return tmp;                                    //возвращает первые и последние значения обеих функций и
 
        }                                                  //их количества элементов
 
  
    //ПЕРЕГРУЗКА ОПЕРАТОРОВ
+
double base(double x)                                        //базовая функция ( если задавать через шаг и начальный х
 +
{
 +
    return x;
 +
}
  
    stars operator+ (stars & v)                            //сложение
+
struct ap                                                  //две одинаковые структуры это нехорошо,коненчо,но зато наглядно...
    {
+
{
        polyana tmp = prepare(v);
+
    double k,b;
        int general = tmp.k1 + tmp.k2;                      //общее количество элементов обеих функций
+
};
        stars F3(general);                                  //создание объекта класса только по количеству элементов
 
        for (int i = 0 ; i < tmp.k1 ; i++)                  //заполнение первой части окончательного результата
 
        {
 
            F3.massiv[i].x = massiv[i+tmp.a1].x;
 
            trees tiger = v.love(massiv[i+tmp.a1].x);
 
            if (tiger.pol == true)                          //если значения по У в одной точке не совпадают, то интерполировать
 
            {
 
                F3.massiv[i].y = pentagon (v.massiv[tiger.n].x,
 
                                          F3.massiv[i].x,
 
                                          v.massiv[tiger.n + 1].x,
 
                                          v.massiv[tiger.n].y,
 
                                          v.massiv[tiger.n + 1].y )
 
                                          + massiv[i+tmp.a1].y;
 
            }
 
            else                                            //иначе, просто сложить значения
 
            {
 
                F3.massiv[i].y = v.massiv[tiger.n].y + massiv[i+tmp.a1].y;
 
            }
 
  
        }
+
struct fun                                                  //один столбик в таблице функции
        {
+
{
          for (int i = tmp.k1  ; i < (general) ; i++)      //заполнение второй части окончательного результата
+
    double x,y;
        {
+
};
            F3.massiv[i].x = v.massiv[i + tmp.a2 - tmp.k1].x;
 
            trees tiger = love(v.massiv[i + tmp.a2 - tmp.k1].x);
 
            if (tiger.pol == true)
 
            {
 
                F3.massiv[i].y = pentagon  (v.massiv[tiger.n].x,
 
                                            F3.massiv[i].x,
 
                                            v.massiv[tiger.n + 1].x,
 
                                            v.massiv[tiger.n].y,
 
                                            v.massiv[tiger.n + 1].y )
 
                                            + v.massiv[i+tmp.a1 - tmp.k1].y;
 
            }
 
            else
 
                F3.massiv[i].y = massiv[tiger.n].y + v.massiv[i+tmp.a2 - tmp.k1].y;
 
        }
 
  
        for (int i = 0; i < (general); i++)                  //сортировка
+
struct sf                                                  //структура нужная, для возражеия значений из функции "prepare" класса F
        {
+
{
            for (int j = 0; j < (general - 1); j ++)
+
    int i1,i2,e1,e2;
            {
+
    double glength, gfirstx, glastx;
                dot temp;
+
};
                if (F3.massiv[j].x > F3.massiv[j + 1].x)
 
                {
 
                    temp = F3.massiv[j];
 
                    F3.massiv[j] = F3.massiv[j + 1];
 
                    F3.massiv[j + 1] = temp;
 
                }
 
                else                                        //если элементы совпадают, то нужно выбросить один из них
 
                if (F3.massiv[j].x == F3.massiv[j + 1].x)
 
                {
 
                    int l = j;
 
                    while (l < general)
 
                    {
 
                        F3.massiv[l].x = F3.massiv[l + 1].x;
 
                        F3.massiv[l].y = F3.massiv[l + 1].y;
 
                        l++;
 
                    }
 
                    general--;
 
                }
 
            }
 
        }
 
  
 +
double intr(double x1,double x2,double x,double y1,double y2)  // линенейная интерполяция
 +
{
 +
    return ( ((x-x1)/(x2-x1)) * (y2-y1) + y1 );
 +
}
  
        stars normalny (general);                          //создание элемента класса по длине
+
ap aproks(fun b [],int n)                                       //линейная аппроксимация
        for (int i = 0; i < (general); i++)
+
{
        {
+
    ap r;
            normalny.massiv[i].x = F3.massiv[i].x;
+
    double xy = 0,x = 0,y = 0,sqx = 0,xsq = 0;
            normalny.massiv[i].y = F3.massiv[i].y;
+
    for (int i = 0; i < n; i++)                                 //вычисление коэффицентов
         }
+
    {
        a = normalny.massiv[0].x;
+
        xy  += b[i].x*b[i].y;
         b = normalny.massiv[general].x;
+
        x  += b[i].x;
        return normalny;
+
        y   += b[i].y;
 +
         sqx += b[i].x*b[i].x;
 +
         xsq += b[i].x;
 
     }
 
     }
     };
+
     xsq *= xsq;
 +
 
 +
    r.k = (n*xy - x*y)/(n*sqx - xsq);                      //использование формул
 +
    r.b = (y - r.k*x)/n;
 +
    return r;
 +
}
  
        stars operator* (stars & v)                         //умножение
+
class F
 +
{
 +
private:
 +
    int length;
 +
    double firstx, step, lastx;
 +
    fun *a;
 +
public:
 +
    F(){}
 +
    F(int l,double f,double s)                              //конструктор, создающий фунцию по длине,первоиу элементу,шагу по х, y вычисляется по базовой функции
 
     {
 
     {
         polyana tmp = prepare(v);
+
         if (l >= 0)
         int general = tmp.k1 + tmp.k2;
+
          a = new fun [l];
         stars F3(tmp.k1 + tmp.k2);
+
        firstx = f;
         for (int i = 0 ; i < tmp.k1 ; i++)
+
        length = l;
 +
         step = s;
 +
         lastx = firstx+(length - 1)*step;
 +
 
 +
 
 +
         for (int i = 0;i < length; i ++)
 
         {
 
         {
             F3.massiv[i].x = massiv[i+tmp.a1].x;
+
             a[i].y = base(firstx + i*step);
            trees tiger = v.love(massiv[i+tmp.a1].x);
+
             a[i].x = firstx + i*step;
             if (tiger.pol == true)
+
        }
            {
+
 
                F3.massiv[i].y = pentagon (v.massiv[tiger.n].x,      F3.massiv[i].x,
+
    }
                                          v.massiv[tiger.n + 1].x,  v.massiv[tiger.n].y,
 
                                          v.massiv[tiger.n + 1].y )* (massiv[i+tmp.a1].y);
 
            }
 
            else
 
            {
 
                F3.massiv[i].y = v.massiv[tiger.n].y * massiv[i+tmp.a1].y;
 
            }
 
  
        }
+
    F (fun b[],int l)                                   //конструктор для создания фунции с уже известными областями определния и значений
        {
+
    {
            for (int i = tmp.k1 ; i < (general) ; i++)
+
        length = l;
        {
+
        a = new fun [l];
            F3.massiv[i].x = v.massiv[i+tmp.a2 - tmp.k1].x;
+
        for (int i = 0; i < l;i++)
            trees tiger = love(v.massiv[i+tmp.a2 - tmp.k1].x);
+
             a[i] = b[i];
            if (tiger.pol == true)
 
            {
 
                F3.massiv[i].y = pentagon (v.massiv[tiger.n].x,
 
                                            F3.massiv[i].x,
 
                                            v.massiv[tiger.n + 1].x,
 
                                            v.massiv[tiger.n].y,
 
                                            v.massiv[tiger.n + 1].y )
 
                                            + v.massiv[i+tmp.a1 - tmp.k1].y;
 
            }
 
             else
 
                F3.massiv[i].y = massiv[tiger.n].y + v.massiv[i+tmp.a2 - tmp.k1].y;
 
        }
 
  
         for (int i= 0; i < (general); i++)
+
         for (int i = 0; i < l;i++)
        {
+
             for (int j = 0; j < (l - 1); j++)
             for (int j = 0; j < (general - 1); j ++)
+
                 if (a[j].x > a[j + 1].x)
            {
+
                 {
                dot temp;
+
                     fun tmp = a[j];
                 if (F3.massiv[j].x > F3.massiv[j+1].x)
+
                     a[j] = a[j + 1];
                 {
+
                     a[j + 1] = a[j];
                     temp = F3.massiv[j];
 
                     F3.massiv[j] = F3.massiv[j+1];
 
                     F3.massiv[j+1] = temp;
 
 
                 }
 
                 }
                else
 
                if (F3.massiv[j].x == F3.massiv[j+1].x)
 
                {
 
                    int l = j;
 
                    while (l < general)
 
                    {
 
                        F3.massiv[j].x = F3.massiv[j+1].x;
 
                        l++;
 
                    }
 
                    general--;
 
                }
 
            }
 
        }
 
  
        for (int i = 0 ; i < general ; i++)
+
        firstx = a[0].x;
 +
        lastx = a[length - 1].x;
 +
    }
 +
 
 +
    void addpar (double k, double b, int l, fun z[] )                          //позволяет создать и заполнить переданным массивом поле объекта класса
 +
    {
 +
        a = new fun [l];
 +
        for (int i = 0; i < l; i++)
 
         {
 
         {
 +
            a[i].y = k*z[i].x + b;
 +
            a[i].x = z[i].x;
 +
        }
 +
        length = l;
 +
    }
  
            cout <<F3.massiv[i].x<< ' ' << F3.massiv[i].y <<endl;
+
    double getelx(int i)                                //возращает значение из поля "х" iого элемента
        }
+
    {
 +
        return a[i].x;
 +
    }
  
  
         stars normalny(general);
+
    double getely(int i)                              //возращает значение из поля "х" iого элемента
         for (int i = 0; i < (general); i++)
+
    {
 +
         return a[i].y;
 +
    }
 +
 
 +
    int getlength()                                 //возращает размер области определения функции(в точках)
 +
    {
 +
        return length;
 +
    }
 +
 
 +
    void FOut()                                    //выводит функцию на экран
 +
    {
 +
      cout << "  x         y" << endl;
 +
      for (int i = 0;i < length; i ++)
 +
          cout << "  " << a[i].x << "        " << a[i].y << endl;
 +
      cout << endl;
 +
    }
 +
 
 +
 
 +
    int pfind(double x)const                        //возращает либо номер элемента,идущщий перед элементом, большим,чем х; в случае нахождения равного, возращает число, противоположное номеру следующего элемента(иначе может вернуться нуль,а нуль знака не имееет)
 +
    {
 +
        for (int i = 0; i < length-1; i++ )
 
         {
 
         {
             normalny.massiv[i].x = F3.massiv[i].x;
+
             if (((a[i].x < x) && (a[i + 1].x > x)))
             normalny.massiv[i].y = F3.massiv[i].y;
+
                return (i + 1);
 +
             else
 +
                // чтобы иметь возможность проанализировать полученное значение функции,мы должны понимать, было найденно равное или промежуточное значение. "флагом" равных значений является знак минус,но так у нуля нет знака,то приходиться все сдвигать на 1
 +
                if (a[i].x == x)
 +
                  return -(i + 1);
 +
                else
 +
                    if (a[i + 1].x == x)
 +
                        return -(i + 2);
 
         }
 
         }
        a = normalny.massiv[0].x;
+
//        cerr << "fail!!" << endl;
        b = normalny.massiv[general].x;
+
         return -1;
         return normalny;
 
 
     }
 
     }
    };
 
  
     stars operator- (stars & v)                             //вычитание
+
     sf prepare(F &x)const                                      //"подготовка" функций к бинарной операции (нахождение совместной области определения
 
     {
 
     {
         polyana tmp = prepare(v);
+
         sf r;
         int general = tmp.k1 + tmp.k2;
+
         if (a[0].x > x.a[0].x)
        stars F3(tmp.k1 + tmp.k2);
 
        for (int i = 0 ; i < tmp.k1 ; i++)
 
 
         {
 
         {
             F3.massiv[i].x = massiv[i+tmp.a1].x;
+
             r.gfirstx = a[0].x;
             trees tiger = v.love(massiv[i+tmp.a1].x);
+
            r.i1 = 0;
             if (tiger.pol == true)
+
            r.i1 = 0;
            {
+
             double k = x.pfind(a[0].x);
                 F3.massiv[i].y = pentagon (v.massiv[tiger.n].x,      F3.massiv[i].x,
+
             if (k < 0)
                                          v.massiv[tiger.n + 1].x,  v.massiv[tiger.n].y,
+
                 r.i2 = -k - 1;
                                          v.massiv[tiger.n + 1].y )- massiv[i+tmp.a1].y;
 
            }
 
 
             else
 
             else
            {
+
                 r.i2 = (k - 1) + 1;
                 F3.massiv[i].y = v.massiv[tiger.n].y - massiv[i+tmp.a1].y;
 
            }
 
 
 
 
         }
 
         }
 +
        else
 
         {
 
         {
             for (int i = tmp.k1 ; i < (general) ; i++)
+
             r.gfirstx = x.a[0].x;
 +
            double k = pfind(x.a[0].x);
 +
            if (k < 0)
 +
                r.i1 = -k - 1;
 +
            else
 +
                r.i1 = (k - 1) + 1;
 +
            r.i2 = 0;
 +
        }
 +
 
 +
        if (a[length - 1].x < x.a[x.length - 1].x)
 
         {
 
         {
             F3.massiv[i].x = v.massiv[i+tmp.a2 - tmp.k1].x;
+
             r.glastx = a[length - 1].x;
             trees tiger = love(v.massiv[i+tmp.a2 - tmp.k1].x);
+
             r.e1 = length - 1;
             if (tiger.pol == true)
+
            double k = x.pfind(r.glastx);
            {
+
             if (k < 0)
                 F3.massiv[i].y = pentagon (v.massiv[tiger.n].x,
+
                 r.e2 = -k - 1;
                                            F3.massiv[i].x,
 
                                            v.massiv[tiger.n + 1].x,
 
                                            v.massiv[tiger.n].y,
 
                                            v.massiv[tiger.n + 1].y )
 
                                            + v.massiv[i+tmp.a1 - tmp.k1].y;
 
            }
 
 
             else
 
             else
                 F3.massiv[i].y = massiv[tiger.n].y + v.massiv[i+tmp.a2 - tmp.k1].y;
+
                 r.e2 = (k - 1) - 1;
 
         }
 
         }
 
+
         else
         for (int i= 0; i < (general); i++)
 
 
         {
 
         {
             for (int j = 0; j < (general - 1); j ++)
+
             r.glastx = x.a[x.length - 1].x;
            {
+
            double k = pfind(r.glastx);
                dot temp;
+
            if (k < 0)
                if (F3.massiv[j].x > F3.massiv[j+1].x)
+
                r.e1 = -k - 1;
                {
+
            else
                    temp = F3.massiv[j];
+
                 r.e1 = (k - 1) + 1;
                    F3.massiv[j] = F3.massiv[j+1];
+
            r.e2 = x.length - 1;
                    F3.massiv[j+1] = temp;
 
                }
 
                else
 
                 if (F3.massiv[j].x == F3.massiv[j+1].x)
 
                {
 
                    int l = j;
 
                    while (l < general)
 
                    {
 
                        F3.massiv[j].x = F3.massiv[j+1].x;
 
                        l++;
 
                    }
 
                    general--;
 
                }
 
            }
 
 
         }
 
         }
 +
        r.glength = length + x.length - r.i1 - (length - (r.e1 + 1)) - r.i2 - (x.length - (r.e2 + 1));
  
        for (int i = 0 ; i < general ; i++)
+
        return r;
        {
+
    }
  
             cout <<F3.massiv[i].x<< ' ' << F3.massiv[i].y <<endl;
+
    void ad (fun b[],int l)                                  //присвоить массиву объекта класса F значения массива b
        }
+
    {
 +
        length = l;
 +
        a = new fun [l];
 +
        for (int i = 0; i < l;i++)
 +
             a[i] = b[i];
 +
        firstx = a[0].x;
 +
        lastx = a[length - 1].x;
 +
    }
  
 
+
    fun *geta()                                         //получения указателя на начало массива в поле класса
        stars normalny(general);
+
    {
        for (int i = 0; i < (general); i++)
+
         return a;
        {
 
            normalny.massiv[i].x = F3.massiv[i].x;
 
            normalny.massiv[i].y = F3.massiv[i].y;
 
        }
 
         a = normalny.massiv[0].x;
 
        b = normalny.massiv[general].x;
 
        return normalny;
 
 
     }
 
     }
    };
 
  
     stars operator/ (stars & v)                             //деление
+
     F operator +(F &x) const                              //сложение двух функций
 
     {
 
     {
         polyana tmp = prepare(v);
+
         int i1, e1, i2, e2, kk = 0;
         int general = tmp.k1 + tmp.k2;
+
         double gfirstx, glastx, glength;
         stars F3(tmp.k1 + tmp.k2);
+
 
        for (int i = 0 ; i < tmp.k1 ; i++)
+
         if (((x.lastx < firstx) && (x.firstx < firstx)) || ((lastx < x.firstx) && (firstx < x.firstx)))
 
         {
 
         {
             F3.massiv[i].x = massiv[i+tmp.a1].x;
+
             cout << "Nevozmozhno, prover'te oblasti opredelenia" << endl;
             trees tiger = v.love(massiv[i+tmp.a1].x);
+
            F fl(-1,0,0);
             if (tiger.pol == true)
+
            return fl;
 +
        }
 +
        sf r = prepare(x);
 +
        F tmp(r.glength,r.gfirstx,r.glastx);
 +
        for (int i = 0; i <= (r.e1 - r.i1); i++)
 +
        {
 +
            tmp.a[i].x = a[i + r.i1].x;            //поправка,введенная таким образом,чтобы номер,с которого начинается отсчет был первым в новой области определения
 +
            int ii = x.pfind(tmp.a[i].x);
 +
             if (ii < 0)
 +
                tmp.a[i].y = x.a[-ii - 1].y + a[i + r.i1].y;
 +
            else
 +
                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;
 +
        }
 +
        for (int i = (r.e1 - r.i1 + 1); i <= (r.e2 - r.i2 + (r.e1 - r.i1) + 1) ; i++)
 +
        {
 +
            int ii = pfind(x.a[i - (r.e1 - r.i1 + 1) + r.i2].x);
 +
             if (ii >= 0)
 
             {
 
             {
                 F3.massiv[i].y = pentagon (v.massiv[tiger.n].x,      F3.massiv[i].x,
+
                 tmp.a[i - kk].x = x.a[i - (r.e1 - r.i1 + 1) + r.i2].x;
                                          v.massiv[tiger.n + 1].x,   v.massiv[tiger.n].y,
+
                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;
                                          v.massiv[tiger.n + 1].y )/ (massiv[i+tmp.a1].y);
 
 
             }
 
             }
 
             else
 
             else
 
             {
 
             {
                 F3.massiv[i].y = (v.massiv[tiger.n].y) / (massiv[i+tmp.a1].y);
+
                 kk++;
 +
                glength --;
 +
                tmp.length --;
 
             }
 
             }
 +
        }
  
         }
+
         for (int i = 0; i < glength; i++)
        {
+
             for (int j = 0; j < glength - 1; j++)
            for (int i = tmp.k1 ; i < (general) ; i++)
+
             if (tmp.a[j].x > tmp.a[j + 1].x)
        {
 
             F3.massiv[i].x = v.massiv[i+tmp.a2 - tmp.k1].x;
 
             trees tiger = love(v.massiv[i+tmp.a2 - tmp.k1].x);
 
            if (tiger.pol == true)
 
 
             {
 
             {
                 F3.massiv[i].y = pentagon (v.massiv[tiger.n].x,
+
                 fun t = tmp.a[j];
                                            F3.massiv[i].x,
+
                tmp.a[j] = tmp.a[j + 1];
                                            v.massiv[tiger.n + 1].x,
+
                tmp.a[j + 1] = t;
                                            v.massiv[tiger.n].y,
 
                                            v.massiv[tiger.n + 1].y )
 
                                            + v.massiv[i+tmp.a1 - tmp.k1].y;
 
 
             }
 
             }
 +
 +
        return tmp;
 +
}
 +
 +
    F operator *(F & x) const                                        //умножение двух функций
 +
    {
 +
        int i1, e1, i2, e2, kk = 0;
 +
        double gfirstx, glastx, glength;
 +
 +
        if (((x.lastx < firstx) && (x.firstx < firstx)) || ((x.firstx < lastx) && (firstx < x.firstx)))
 +
        {
 +
            cout << "Nevozmozhno, prover'te oblasti opredelenia" << endl;
 +
            F fl(-1,0,0);
 +
            return fl;
 +
        }
 +
 +
        sf r = prepare(x);
 +
        F tmp(r.glength,r.gfirstx,r.glastx);
 +
 +
        for (int i = 0; i <= (r.e1 - r.i1); i++)
 +
        {
 +
            tmp.a[i].x = a[i + r.i1].x;
 +
            int ii = x.pfind(tmp.a[i].x);
 +
            if (ii < 0)
 +
                tmp.a[i].y = x.a[-ii - 1].y * a[i + r.i1].y;
 
             else
 
             else
                 F3.massiv[i].y = massiv[tiger.n].y + v.massiv[i+tmp.a2 - tmp.k1].y;
+
                 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;
 
         }
 
         }
 
+
         for (int i = (r.e1 - r.i1 + 1); i <= (r.e2 - r.i2 + (r.e1 - r.i1) + 1) ; i++)
         for (int i= 0; i < (general); i++)
 
 
         {
 
         {
             for (int j = 0; j < (general - 1); j ++)
+
             int ii = pfind(x.a[i - (r.e1 - r.i1 + 1) + r.i2].x);
 +
            if (ii >= 0)
 
             {
 
             {
                 dot temp;
+
                 tmp.a[i - kk].x = x.a[i - (r.e1 - r.i1 + 1) + r.i2].x;
                if (F3.massiv[j].x > F3.massiv[j+1].x)
+
                 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;
                 {
+
            }
                    temp = F3.massiv[j];
+
            else
                    F3.massiv[j] = F3.massiv[j+1];
+
            {
                    F3.massiv[j+1] = temp;
+
                kk++;
                }
+
                glength --;
                else
+
                 tmp.length --;
                if (F3.massiv[j].x == F3.massiv[j+1].x)
 
                {
 
                    int l = j;
 
                    while (l < general)
 
                    {
 
                        F3.massiv[j].x = F3.massiv[j+1].x;
 
                        l++;
 
                    }
 
                    general--;
 
                 }
 
 
             }
 
             }
 
         }
 
         }
  
        for (int i = 0 ; i < general ; i++)
+
        for (int i = 0; i < glength; i++)
        {
+
            for (int j = 0; j < glength - 1; j++)
 +
            if (tmp.a[j].x > tmp.a[j + 1].x)
 +
            {
 +
                fun t = tmp.a[j];
 +
                tmp.a[j] = tmp.a[j + 1];
 +
                tmp.a[j + 1] = t;
 +
            }
  
            cout <<F3.massiv[i].x<< ' ' << F3.massiv[i].y <<endl;
+
        return tmp;
        }
+
    }
  
 +
    F operator ^(F & x) const                                  //возведение функции слева от оператора в степень функции справа от оператора
 +
    {
 +
        int i1, e1, i2, e2, kk = 0;
 +
        double gfirstx, glastx, glength;
  
         stars normalny(general);
+
         if (((x.lastx < firstx) && (x.firstx < firstx)) || ((x.firstx < lastx) && (firstx < x.firstx)))
        for (int i = 0; i < (general); i++)
 
 
         {
 
         {
             normalny.massiv[i].x = F3.massiv[i].x;
+
             cout << "Nevozmozhno, prover'te oblasti opredelenia" << endl;
             normalny.massiv[i].y = F3.massiv[i].y;
+
             F fl(-1,0,0);
 +
            return fl;
 
         }
 
         }
        a = normalny.massiv[0].x;
 
        b = normalny.massiv[general].x;
 
        return normalny;
 
    }
 
    };
 
  
    trees love (double a)                                   //
+
        sf r = prepare(x);
    {
+
         F tmp(r.glength,r.gfirstx,r.glastx);
         trees privet;
+
 
         for (int i = 0; i < k; i++ )
+
         for (int i = 0; i <= (r.e1 - r.i1); i++)
             if ((massiv[i].x < a)&& (a < massiv[i+1].x))
+
        {
 +
            tmp.a[i].x = a[i + r.i1].x;
 +
            int ii = x.pfind(tmp.a[i].x);
 +
             if (ii < 0)
 +
                tmp.a[i].y = pow(x.a[-ii - 1].y, a[i + r.i1].y);
 +
            else
 +
                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);
 +
        }
 +
        for (int i = (r.e1 - r.i1 + 1); i <= (r.e2 - r.i2 + (r.e1 - r.i1) + 1) ; i++)
 +
        {
 +
            int ii = pfind(x.a[i - (r.e1 - r.i1 + 1) + r.i2].x);
 +
            if (ii >= 0)
 
             {
 
             {
                 privet.n = i;
+
                 tmp.a[i - kk].x = x.a[i - (r.e1 - r.i1 + 1) + r.i2].x;
                 privet.pol = true;
+
                 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);
                return privet;
 
 
             }
 
             }
 
             else
 
             else
                if (massiv[i].x == a)
+
            {
                {
+
                 kk++;
                    privet.n = i;
+
                glength --;
                    privet.pol = false;
+
                 tmp.length --;
                    return privet;
+
            }
                 }
 
                else
 
                if (massiv[i+1].x == a)
 
                {
 
                    privet.n = i+1;
 
                    privet.pol = false;
 
                    return privet;
 
                 }
 
    }
 
 
 
 
 
    approx approximate ()                                  //функция аппроксимации
 
    {
 
        approx hey;
 
        stars mattafix (double a, double b, double step, int k, int length);
 
        double sigmaX = 0;
 
        double sigmaY = 0;
 
        double sigmaXY = 0;
 
        double sigmaXsqrt = 0;
 
        for (int i = 0; i < length; i++)
 
        {
 
          sigmaX += a + step * i;
 
          sigmaY += b + i * 5;
 
          sigmaXY += (a + step * i)*(b + i * 5);
 
          sigmaXsqrt += (a + step * i)*(a + step * i);
 
 
         }
 
         }
        hey.koefficientA = ((k * (sigmaXY) - (sigmaX*sigmaY))/(k*sigmaXsqrt - (sigmaX * sigmaX)));
 
        hey.koefficientB = ((sigmaY - hey.koefficientA*sigmaX)/k);
 
        return hey;
 
  
 +
        for (int i = 0; i < glength; i++)
 +
            for (int j = 0; j < glength - 1; j++)
 +
            if (tmp.a[j].x > tmp.a[j + 1].x)
 +
            {
 +
                fun t = tmp.a[j];
 +
                tmp.a[j] = tmp.a[j + 1];
 +
                tmp.a[j + 1] = t;
 +
            }
  
 +
        return tmp;
 
     }
 
     }
 
};
 
};
Строка 1721: Строка 1730:
 
int main()
 
int main()
 
{
 
{
     int tyu;
+
  /*
     stars function3;
+
    F f1(5,-2,1.5);
     int firstnumber1;
+
    F f2(30,-10,0.5);
     int firstnumber2;
+
    F f3, f4;
     int lastnumber1;
+
    f1.FOut();
     int lastnumber2;
+
    f2.FOut();
     int step1;
+
    f3 = f1 + f2;
     int step2;
+
    f3.FOut();
     while (true)
+
     f4 = f1 * f2;
 +
     f4.FOut();
 +
     cout << " ________" << endl;
 +
*/
 +
     char vc, s[255], ce;
 +
     ifstream infile;
 +
     int n;
 +
     fun *a;
 +
     F f5,f6,f7,f8,f9;
 +
 
 +
     while(true)
 
     {
 
     {
 
+
    start :
         cout << "Input 0 - vvedite parametry pervoy funkcii"<< endl;
+
        system("cls");
         cout << "Input 1 - vvedite parametry vtoroy funkcii"<< endl;
+
        cout << "1 - Vvesti 1uu func"            << endl;
         cout << "Input 2 - slozhenie"<< endl;
+
        cout << "2 - Vvesti 2uu func"            << endl;
         cout << "Input 3 - umnozhenie"<< endl;
+
         cout << "3 - Sloshit'"                   << endl;
         cout << "Input 4 - delenie"<< endl;
+
         cout << "4 - Umnozhit'"                 << endl;
         cout << "Input 5 - vychitanie"<< endl;
+
         cout << "5 - Vozvesti v stepen'"         << endl;
         cout << "Input 6 - aproximate"<< endl;
+
         cout << "6 - Aproximirovat'"             << endl;
         cin >> tyu ;
+
         cout << "7 - Zapics' v file func"       << endl;
 
+
         cout << "8 - Zapics' v file aprok fun"   << endl;
         switch (tyu)
+
         cout << "0 - Vihod"                     << endl;
 +
         cin >> vc;
 +
         switch (vc)
 
         {
 
         {
             case 0:
+
             case '0':
             {   cout << "Vvedite pervy x" << endl;
+
                return 0 ;
                 cin >> firstnumber1;
+
             case '1':
                 cout << "Vvedite posledniy x" << endl;
+
                {
                cin >> lastnumber1;
+
                system("cls");
                 cout << "Vvedite shag" << endl;
+
                strcpy(s,"");
                 cin >> step1;
+
                delete []a;
                 break;
+
                a = NULL;
            }
+
                cout << "Vvedite imya fila" << endl;
             case 1:
+
                 cin >> s;
            {
+
                 strcat(s, ".txt");
                 cout << "Vvedite pervy x" << endl;
+
                infile.open(s);
                 cin >> firstnumber2;
+
                infile >> n;
                 cout << "Vvedite posledniy x" << endl;
+
                a = new fun [n];
                cin >> lastnumber2;
+
                for(int i = 0; i < n; i ++)
                 cout << "Vvedite shag" << endl;
+
                    infile >> a[i].x >> a[i].y;
                 cin >> step2;
+
                f5.ad(a,n);
                 break;
+
                f5.FOut();
            }
+
                infile.close();
             case 2:
+
                 cout << "Nazhmite \"b\" chotibi viti" << endl;
            {
+
                 cin >> ce;
                 stars function1 (firstnumber1, lastnumber1, step1);
+
                 while (true)
                 function1.out();
+
                if (ce == 'b')
                 function1.outinfile ();
+
                    goto start;
 
+
                }
                 stars function2 (firstnumber2, lastnumber2, step2);
+
             case '2':
                 function2.out();
+
                {
                 function2.outinfile ();
+
                system("cls");
 
+
                strcpy(s,"");
                 function3 = function1 + function2;
+
                delete []a;
                 function3.out();
+
                a = NULL;
                 function3.outinfile ();
+
                 cout << "Vvedite imya fila" << endl;
                 break;
+
                 cin >> s;
            }
+
                 strcat(s, ".txt");
            case 3:
+
                infile.open(s);
            {
+
                infile >> n;
                 stars function1 (firstnumber1, lastnumber1, step1);
+
                a = new fun[n];
                 function1.out();
+
                for(int i = 0; i < n; i ++)
                 function1.outinfile ();
+
                    infile >> a[i].x >> a[i].y;
 
+
                f6.ad(a,n);
                 stars function2 (firstnumber2, lastnumber2, step2);
+
                f6.FOut();
                 function2.out();
+
                infile.close();
                 function2.outinfile ();
+
                 cout << "Nazhmite \"b\" chotibi viti" << endl;
 
+
                 cin >> ce;
                 function3 = function1 * function2;
+
                 while (true)
                 function3.out();
+
                if (ce == 'b')
                 function3.outinfile ();
+
                    goto start;
                 break;
+
                }
            }
+
             case '3':
             case 4:
+
                 system("cls");
             {
+
                 f5.FOut();
                 stars function1 (firstnumber1, lastnumber1, step1);
+
                 f6.FOut();
                 function1.out();
+
                f7 = f5 + f6;
                function1.outinfile ();
+
                 f7.FOut();
 
+
                 cout << "Nazhmite \"b\" chotibi viti" << endl;
                 stars function2 (firstnumber2, lastnumber2, step2);
+
                cin >> ce;
                function2.out();
+
                while (true)
                 function2.outinfile ();
+
                 if (ce == 'b')
 
+
                    goto start;
                 function3 = function1 / function2;
+
            case '4':
                 function3.out();
+
                 system("cls");
                 function3.outinfile ();
+
                 f5.FOut();
                break;
+
                 f6.FOut();
 +
                 f7 = f5 * f6;
 +
                f7.FOut();
 +
                cout << "Nazhmite \"b\" chotibi viti" << endl;
 +
                 cin >> ce;
 +
                 while (true)
 +
                 if (ce == 'b')
 +
                    goto start;
 +
            case '5':
 +
                 system("cls");
 +
                 f5.FOut();
 +
                 f6.FOut();
 +
                f7 = f5 ^ f6;
 +
                 f7 = f5 ^ f6;
 +
                 f7.FOut();
 +
                 cout << "Nazhmite \"b\" chotibi viti" << endl;
 +
                cin >> ce;
 +
                while (true)
 +
                 if (ce == 'b')
 +
                    goto start;
 +
             case '6':
 +
             {
 +
                 system("cls");
 +
                 ap tmp = aproks(f7.geta(), f7.getlength());
 +
                 f8.addpar(tmp.k, tmp.b, f7.getlength(), f7.geta());
 +
                 f8.FOut();
 +
                cout << "Nazhmite \"b\" chotibi viti" << endl;
 +
                 cin >> ce;
 +
                 while (true)
 +
                 if (ce == 'b')
 +
                    goto start;
 
             }
 
             }
             case 5:
+
             case '7':
 
             {
 
             {
 +
                system("cls");
 +
                strcpy(s,"");
 +
                cout << "Vvedite imya fila" << endl;
 +
                cin >> s;
 +
                strcat(s, ".txt");
 +
                ofstream outfile(s);
 +
                outfile << "x          y" << endl;
 +
                for (int i = 0; i < f7.getlength(); i ++)
 +
                    outfile << f7.getelx(i) << "          " << f7.getely(i) << endl;
  
                 stars function1 (firstnumber1, lastnumber1, step1);
+
                 cout << "done" << endl;
                 function1.out();
+
                cout << "Nazhmite \"b\" chotibi viti" << endl;
                 function1.outinfile ();
+
                cin >> ce;
 
+
                 while (true)
                 stars function2 (firstnumber2, lastnumber2, step2);
+
                 if (ce == 'b')
                 function2.out();
+
                    goto start;
                 function2.outinfile ();
+
            }
 
+
            case '8':
                 function3 = function1 - function2;
+
                 system("cls");
                 function3.out();
+
                 strcpy(s,"");
                 function3.outinfile ();
+
                 cout << "Vvedite imya fila" << endl;
                 break;
+
                 cin >> s;
            }
+
                 strcat(s, ".txt");
            case 6:
+
                 ofstream outfile(s);
                 {
+
                 outfile << "x          y" << endl;
                    approx you;
+
                 for (int i = 0; i < f8.getlength(); i ++)
                    function3.approximate();
+
                     outfile << f8.getelx(i) << "           " << f8.getely(i) << endl;
                     outfile.open ("meow", ios :: app);
+
                cout << "done" << endl;
                    outfile << "Y = "<< you.koefficientA <<"* x + "<<you.koefficientB << endl;
+
                cout << "Nazhmite \"b\" chotibi viti" << endl;
                    outfile << endl;
+
                cin >> ce;
                    outfile.close();
+
                while (true)
 
+
                 if (ce == 'b')
 
+
                    goto start;
                 }
+
         }
            }
+
     }
         }
+
    return 0;
     };
+
}
 
+
</syntaxhighlight>
 
+
</div>
</syntaxhighlight>
+
 
</div>
+
'''[[Лобанов Илья]]'''
 
 
  
 +
'''Описание программы''':
 +
Программа позволяет складывать , вычитать , делить,умножать 2 функции,заданные на одном интервале.При считывании с файла сначала указывается отрезок, потом величина шага, а потом дискретные значения.
  
 +
Скачать можно [[http://tm.spbstu.ru/File:func.rar тут]]
  
  
Строка 2038: Строка 2100:
 
</div>
 
</div>
  
 +
'''[[Сергей Ляжков]]'''
 +
'''Описание программы''':программа позволяет проводить следующие действия с функциями: сложение, вычитание, умножение, те же действия с числами, проводить аппроксимацию и интерполяцию
 +
Скачать можно [[http://tm.spbstu.ru/File:Функции.zip тут]]
  
 +
<br>'''[[Нарядчиков Александр]]'''<br>
 +
'''Инструкция:''' Пользователю достаточно просто запустить программу.<br>
 +
'''Описание программы:''' В окне рисуются графики с разным шагом, количеством точек, начальными и конечными координатами, по клавише 'G' происходит их кубическая интерполяция, также рисуется график их суммы. По клавише 'S' можно сохранить полученный график в текстовый документ в виде координат его точек. По клавише 'L' можно загрузить график из текстового документа, и он появится в окне программы. Также происходит линейная аппроксимация графика суммы, и график аппроксимации рисуется на экран.<br>
 +
'''Описание алгоритма:''' Вся графика написана с помощью библиотек OpenGL и GLUT. Кубическая интерполяция написана с помощью кривых Безье(интерполяция по четырем точкам - кубическая кривая). При сложение двух графиков происходит их интерполяция, для приведения их к общему шагу. Линейная аппроксимация написана с помощью метода наименьших квадратов.<br>
 +
<div class="mw-collapsible mw-collapsed" style="width:100%" >
 +
"'''T05GRAPH.CPP'''"
 +
<syntaxhighlight lang="cpp" line start="1" enclose="div">
 +
/* FILENAME: T05GRAPH.CPP
 +
* LAST UPDATE: 17.01.2016
 +
*/
  
 +
#include "GRAPH.H"
  
'''[[Козловская Анна]]'''
+
/* Глобальные переменные */
 +
// Глобальная переменная, хранящая время в секундах с момента старта программы
 +
double SyncTime;
 +
// Глобальные переменные для отслеживания нажатия клавиш
 +
bool IsGraph, IsSave, IsLoad, IsLoaded;
  
'''Описание программы''': программа позволяет сложить, умножить, возвести одну в степень другой две таблично заданные функции, а также линейно аппроксимировать результат. Чтение и вывод происходит через файл.
+
/* Timer function */
 +
// Подсчет времени
 +
void Timer( void )
 +
{
 +
long t;
 +
static long StartTime = -1;
  
'''Пояснения к алгоритму''': Программа создаёт и хранит значения двух функций с одинаковом шагом и заданных на одинаковом интервале. Методы позволяют сложить эти две функции,интерполировать одну из них по заданному шагу или апроксимировать методом наименьших квадратов. Данные берутся из файла. При считывании с файла сначала указывается отрезок, потом величина, а потом дискретные значения.
+
t = clock();
 +
if (StartTime == -1)
 +
StartTime = t;
 +
SyncTime = (double)(t - StartTime) / CLOCKS_PER_SEC;
 +
} /* End of 'Timer' function */
  
 +
/* Display function */
 +
// Стандартная функция, вызываемая при перерисовке окна
 +
void Display( void )
 +
{
 +
graph G1(-15, 15, 0.1), G2(2, 10, 0.4), G3, G4;
  
Скачать можно  [http://tm.spbstu.ru/File:project1.rar тут].
+
// Запуск времени
 +
Timer();
  
 +
// Установка цвета закраски фона в белый
 +
glClearColor(1, 1, 1, 1);
 +
// Очищаем цветовой буфер для создания нового изображения
 +
glClear(GL_COLOR_BUFFER_BIT);
  
 +
glLoadIdentity();
 +
glScaled(0.1 / (1366 / 768.0), 0.1, 0.1);
  
 +
// Отрисовка осей X и Y
 +
glBegin(GL_LINE_STRIP);
  
'''[[Сюрис Александр]]'''
+
glColor3d(0, 0, 1);
Задаются две функции с разными шагами и начальными и конечными значениями.  Аппроксимирует одну функцию по шагу другой и складывает/умножает/вычитает/делит их
+
glVertex2d(0, -1000);
 +
glVertex2d(0, 1000);
  
Скачать можно  [http://mech.spbstu.ru/File:%D0%A4%D1%83%D0%BD%D0%BA%D1%86%D0%B8%D1%8F(%D0%A1%D1%8E%D1%80%D0%B8%D1%81%D0%90%D0%BB%D0%B5%D0%BA%D1%81%D0%B0%D0%BD%D0%B4%D1%80).zip тут].
+
glColor3d(1, 0, 0);
 +
glVertex2d(-1000, 0);
 +
glVertex2d(1000, 0);
  
<div class="mw-collapsible-content">
+
glEnd();
<syntaxhighlight lang="cpp" line start="1" enclose="div">
 
  
#include <iostream>
+
/* Отрисовка графиков */
#include <vector>
+
// Отрисовка первого графика и его интерполяция по клавише "G"
#include<math.h>
+
G1.Draw(sin);
 +
if (IsGraph == 1)
 +
G1.Interpolation_Draw(1.0 / 32);
  
using namespace std;
+
// Отрисовка второго графика и его интерполяция по клавише "G"
class f{
+
G2.Draw(log);
    private:
+
if (IsGraph == 1)
    double st, en, d; //начало, конец, дельта
+
G2.Interpolation_Draw(1.0 / 32);
    vector<double> v;//вектор, содержащий y
 
    public:
 
    f(double _st, double _en, double _d, vector<double> _v){
 
        st=_st;
 
        en=_en;
 
        d=_d;
 
        for(int i=0;i<_v.size();i++) //копируем массив, который вводим в консоль
 
            v.push_back(_v[i]);
 
        //return *this;
 
    }
 
    f(){};
 
    f aprox(double _st, double _en, double _d){ //метод интерполяции, поиск коэфф a и b для y=ax+b
 
        double sum_x=0, sum_y=0, sum_2x=0,sum_xy=0,a,b;
 
        for(int i=0; i<=(en-st)/d; i++)
 
            sum_x=sum_x+st+i*d;
 
        for(int i=0; i<=(en-st)/d; i++)
 
            sum_y=sum_y+v[i];
 
        for(int i=0; i<=(en-st)/d; i++)
 
            sum_2x=sum_2x+pow(st+i*d,2);
 
        for (int i=0; i<=(en-st)/d; i++)
 
            sum_xy=sum_xy+v[i]*(st+i*d);
 
        a=(((en-st)/d+1)*sum_xy-sum_x*sum_y)/(((en-st)/d+1)*sum_2x-sum_x*sum_x);
 
        b=(sum_y-a*sum_x)/(((en-st)/d+1));
 
  
        vector<double> v1;//вектор, содержащий проинтерполированную функцию
+
// Отрисовка графика суммы для первого и второго графиков
            for(int i=0; i<=(en-st)/d; i++)
+
G3 = G2 + G1;
                v1.push_back(a*(st+i*d)+b);//добавление значений проинтерполированной ф-ции с шагом другой функции
+
glColor3d(0, 1, 0);
        return f(_st,_en,_d,v1);
+
G3.Draw();
 +
// Аппроксимация графика суммы
 +
G3.Approximation();
  
    }
+
// Сохранение графика по клавише "S"
 +
if (IsSave == 1)
 +
{
 +
G3.SaveArray();
 +
IsSave == 0;
 +
}
 +
 +
// Загрузка графика по клавише "L"
 +
if (IsLoad == 1)
 +
{
 +
delete[] G4.mas;
 +
delete[] G4.Color;
 +
G4.LoadArray("graph.txt");
 +
IsLoad == 0;
 +
IsLoaded = 1;
 +
}
 +
 +
// Отрисовка загруженного графика
 +
if (IsLoaded == 1)
 +
{
 +
glColor3d(1, 0, 0);
 +
G4.Draw();
 +
IsLoaded = 0;
 +
}
  
    f operator +(f x){//оператор сложения
+
// Чистка памяти
        double _en,_st,_d;
+
delete[] G1.mas;
        _en=min(en,x.en); //поиск области пересечения
+
delete[] G1.Color;
        _st=max(st,x.st);
+
delete[] G2.mas;
        if (_en>_st){//проверяем, пересекаются ли функции
+
delete[] G2.Color;
            vector<double> _v;
+
delete[] G3.mas;
            f y;
+
delete[] G3.Color;
            if(x.st<st){ //сравниваем начала двух отрезков, для того, чтобы выбрать, какую функцию апроксимировать
+
delete[] G4.mas;
                vector<double> _v;
+
delete[] G4.Color;
                y=x.aprox(_st, _en, d);
 
                for (int i=0; i<=(_en-_st)/d; i++)
 
                    _v.push_back(y.v[i]+v[i]); //вектор с суммой функций
 
                return f(_st,_en,d,_v);
 
            }
 
            else{
 
                vector<double> _v;
 
                y=this->aprox(_st, _en, x.d); //this-> функция, в которой мы работаем
 
              for (int i=0; i<=(_en-_st)/x.d; i++)
 
                    _v.push_back(y.v[i]+x.v[i]);
 
                return f(_st,_en,x.d,_v);
 
            }
 
        }
 
    }
 
  
    f prot(){ //поиск противоположной функции
+
glFinish();
        for (int i=0; i<=(en-st)/d; i++)
+
// Копируем вторичный буфер в окно
            v[i]=(-1)*v[i];
+
glutSwapBuffers();
        return *this;
+
// Вызываем функцию обновления кадра
    }
+
glutPostRedisplay();
 +
} /* End of 'Display' function */
  
    f operator - (f x){ //разность функций
+
/* Keyboard function */
        return(*this + x.prot());
+
// Стандартная функция, вызываемая при нажатие клавиш на клавиатуре
    }
+
void Keyboard( unsigned char Key, int X, int Y )
 
+
{
f operator *(f x){//оператор умножения
+
// Выход из программы
        double _en,_st,_d;
+
if (Key == 27)
        _en=min(en,x.en); //поиск области пересечения
+
exit(0);
        _st=max(st,x.st);
+
// Отрисовка интерполированных графиков
        if (_en>_st){//проверяем, пересекаются ли функции
+
else if ((Key == 'G') || (Key == 'g'))
            vector<double> _v;
+
IsGraph = !IsGraph;
            f y;
+
// Сохранение графика суммы в файл
            if(x.st<st){ //сравниваем начала двух отрезков, для того, чтобы выбрать, какую функцию апроксимировать
+
else if ((Key == 'S') || (Key == 's'))
                vector<double> _v;
+
IsSave = !IsSave;
                y=x.aprox(_st, _en, d);
+
// Загрузка графика из файла
                for (int i=0; i<=(_en-_st)/d; i++)
+
else if ((Key == 'L') || (Key == 'l'))
                    _v.push_back(y.v[i]*v[i]); //вектор с суммой функций
+
IsLoad = !IsLoad;
                return f(_st,_en,d,_v);
+
// Открытие программы в полном экране
            }
+
else if ((Key == 'F') || (Key == 'f'))
            else{
+
glutFullScreen();
                vector<double> _v;
+
} /* End of 'Keyboard' function */
                y=this->aprox(_st, _en, x.d); //this-> функция, в которой мы работаем
 
              for (int i=0; i<=(_en-_st)/x.d; i++)
 
                    _v.push_back(y.v[i]*x.v[i]);
 
                return f(_st,_en,x.d,_v);
 
            }
 
        }
 
    }
 
  
f obr(){
+
/* Main function */
  for (int i=0; i<=(en-st)/d; i++)
+
int main( int argc, char *argv[] )
            v[i]=1/v[i];
+
{
        return *this;
+
// Инициализации OpenGL и GLUT
}
+
glutInit(&argc, argv);
 +
glutInitDisplayMode(GLUT_RGB | GLUT_DOUBLE);
  
f operator /(f x){
+
// Задача размеров и позиции окна
return(*this*x.obr());
+
glutInitWindowPosition(0, 0);
}
+
glutInitWindowSize(500, 500);
 +
// Создание окна
 +
glutCreateWindow("T05GRAPH");
  
    void vivod(){ //вывод
+
// Установка функций 'обратного вызова'
    for(int i=0; i<v.size(); i++)
+
glutDisplayFunc(Display);
        cout<<v[i]<<" ";
+
glutKeyboardFunc(Keyboard);
  
    }
+
// Запускаем основной цикл построения
};
+
glutMainLoop();
int main(){
+
return 0;
    setlocale(LC_ALL, "Russian");
+
} /* End of 'main' function */
    double a,b,a1,b1,d,d1,t;
 
    int o;
 
    cout << "Введите начала и конец отрезка и дельту: ";
 
    cin>>a>>b>>d;
 
    int amount=(b-a)/d+1,amount2;
 
    vector<double>x;
 
    cout << "Введите " << amount << " значений функции на данном интервале:";
 
    for (int i=0; i<amount; i++)
 
    {
 
        cin>>t;
 
        x.push_back(t);
 
    }
 
  
    cout << "Проделаем ровно то же самое для 2 функции ";
+
/* END OF 'T05GRAPH.CPP' FILE */
    cout << "Введите начала и конец отрезка и дельту: ";
+
</syntaxhighlight>
    cin >> a1 >> b1 >> d1;
+
"'''GRAPH.CPP'''"
 
+
<syntaxhighlight lang="cpp" line start="1" enclose="div">
    amount2=(b1-a1)/d1+1;
+
/* FILENAME: GRAPH.CPP
    vector<double>y;
+
* LAST UPDATE: 17.01.2016
    cout << "Введите " << amount2 << " значений функции на данном интервале:";
+
*/
    for (int i=0; i<amount2; i++)
 
    {
 
        cin>>t;
 
        y.push_back(t);
 
    }
 
    f g(a,b,d,x);
 
    f h(a1,b1,d1,y);
 
  
    cout<<"Выберете дейстивя с функциями: +, -, *, \ " << endl;
+
#include "GRAPH.H"
    cout<<"Введите число, соответсвующее порядковому номеру операции(1-4) - ";
 
    cin>>o;
 
    if(o==1){              //по невыясненным причинам одновременно написанные слева идущие if -ы не работают,
 
        cout<<"Сумма:";    //но если заккоментить их и менять знак + в скобке на другие, то все работает
 
        (g+h).vivod();
 
  
    }
+
/* Load Array of points function */
 +
// Загрузка графика из файла по точкам
 +
void graph::LoadArray( char *FileName )
 +
{
 +
// Создание указателя на тип FILE
 +
FILE *F;
  
    if(o==2){
+
// Создание файла и открытие его в режиме чтения
        cout<<"Разность:"
+
fopen_s(&F, FileName, "rt");
        (g-h).vivod();
 
  
    }
+
// Количество точек
 
+
fscanf(F, "%d", &N);
    if(o==3){
+
// Шаг функции
        cout<<"Произведение:"
+
fscanf(F, "%lf", &Step);
        (g*h).vivod();
+
// Начальная координата по X
 +
fscanf(F, "%lf", &MinX);
 +
// Конечная координата по X
 +
fscanf(F, "%lf", &MaxX);
 +
 +
// Выделение памяти под массив точек
 +
mas = new vec[N];
  
 +
// Заполнение массива точек из файла
 +
for (int i = 0; i < N; ++i)
 +
{
 +
// Заполнение по X
 +
fscanf(F, "%lf", &mas[i].X);
 +
// Заполнение по Y
 +
fscanf(F, "%lf", &mas[i].Y);
 +
}
  
    }
+
// Закрытие файла
 +
fclose(F);
 +
} /* End of 'LoadArray' function */
  
    if(o==3){
+
/* Fill mas function */
        cout<<"Отношение:"
+
// Заполнение массива координат точек с цветом
        (g/h).vivod();
+
void graph::Fill( double(*f)(double) )
    }
+
{
 +
// Выделение памяти под массив точек
 +
mas = new vec[N];
 +
// Выделение памяти под массив цветов
 +
Color = new vec[N];
  
 +
// Заполнение массивов
 +
for (int i = 0; i < N; i++)
 +
{
 +
mas[i] = vec(MinX + i * Step, f(MinX + i * Step));
 +
Color[i] = vec::Rnd();
 +
}
 +
} /* End of 'Fill' function */
  
}
+
/* Draw graph function */
 
+
// Рисование заполненного графика на экран
</syntaxhighlight>
+
void graph::Draw( void )
</div>
+
{
 +
  // Задача размер точки
 +
glPointSize(1);
 +
// Рисование
 +
glBegin(GL_POINTS);
 +
for (int i = 0; i < N; i++)
 +
glVertex2d(mas[i].X, mas[i].Y);
 +
glEnd();
 +
} /* End of 'Draw' function */
  
 +
/* Draw graph function */
 +
// Рисование не заполненного еще графика на экран
 +
void graph::Draw( double(*f)(double) )
 +
{
 +
// Заполнение массива
 +
graph::Fill(f);
  
 +
// Задача цвета и размера точки
 +
glColor3d(0, 0, 0);
 +
glPointSize(1);
 +
// Рисование
 +
glBegin(GL_POINTS);
 +
for (int i = 0; i < N; i++)
 +
glVertex2d(mas[i].X, mas[i].Y);
 +
glEnd();
 +
} /* End of 'Draw' function */
  
 +
/* Interpolation draw graph function */
 +
// Рисование интерполированного графика на экран
 +
void graph::Interpolation_Draw( double i_step )
 +
{
 +
// Коэффициент Катмулл-Рома
 +
double alpha = 1.0 / 6;
 +
 +
// Кубическая интерполяция кривыми Безье
 +
for (int i = 0; i < N - 1; i++)
 +
{
 +
// Создание 4 точек для интерполяции по ним
 +
vec P0 = mas[i], P1, P2, P3 = mas[i + 1];
 +
vec Color0 = mas[i], Color1, Color2, Color3 = mas[i + 1];
  
<div class="mw-collapsible mw-collapsed" style="width:100%" >
+
// Значения для первого и последнего отрезков
 
+
if (i == 0)
 
+
{
 +
P1 = (mas[1] - mas[0]) * alpha + mas[0];
 +
Color1 = (mas[1] - mas[0]) * alpha + mas[0];
 +
}
 +
else
 +
{
 +
P1 = (mas[i + 1] - mas[i - 1]) * alpha + mas[i];
 +
Color1 = (mas[i + 1] - mas[i - 1]) * alpha + mas[i];
 +
}
 +
if (i == N - 2)
 +
{
 +
P2 = -(mas[N - 1] - mas[N - 2]) * alpha + mas[N - 1];
 +
Color2 = -(mas[N - 1] - mas[N - 2]) * alpha + mas[N - 1];
 +
}
 +
else
 +
{
 +
P2 = -(mas[i + 2] - mas[i]) * alpha + mas[i + 1];
 +
Color2 = -(mas[i + 2] - mas[i]) * alpha + mas[i + 1];
 +
}
  
 +
glLineWidth(2);
 +
glBegin(GL_LINE_STRIP);
 +
for (double t = 0; t <= 1; t += i_step)
 +
{
 +
vec p, color;
  
 +
// Вычисление точки интерполированного графика по 4 точкам
 +
p = P0 * (1 - t) * (1 - t) * (1 - t) + P1 * 3 * (1 - t) * (1 - t) * t + P2 * 3 * (1 - t) * t * t + P3 * t * t * t;
 +
color = Color0 * (1 - t) * (1 - t) * (1 - t) + Color1 * 3 * (1 - t) * (1 - t) * t + Color2 * 3 * (1 - t) * t * t + Color3 * t * t * t;
  
'''[[Уманский Александр]]'''
+
// Рисование
 +
glColor3d(color.X / 10, 0, color.Y);
 +
glVertex2d(p.X, p.Y);
 +
}
 +
glEnd();
 +
}
 +
} /* End of 'Interpolation_Draw' function */
  
'''Инструкция к программе''': пользователь вводит начало и конец отрезка и шаг для функций, после чего создается две функции. Затем функции суммируются, после чего пользователь вводит значение нового шага, суммированная функция интерполируется по новому шагу, после этого по МНК(методу наименьших квадратов) функция апроксимируется.
+
/* Interpolation graph function */
 +
// Интерполяция графика
 +
graph graph::Interpolation( double i_step )
 +
{
 +
graph G_New;
 +
// Коэффициент Катмулл-Рома
 +
double alpha = 1.0 / 6;
  
 +
// Заполнение параметров для нового графика
 +
G_New.MinX = MinX;
 +
G_New.MaxX = MaxX;
 +
G_New.Step = Step * i_step;
 +
G_New.N = (int)((G_New.MaxX - G_New.MinX) / G_New.Step);
 +
G_New.mas = new vec[G_New.N];
 +
 +
// Кубическая интерполяция кривыми Безье
 +
for (int i = 0; i < N - 1; i++)
 +
{
 +
// Создание 4 точек для интерполяции по ним
 +
vec P0 = mas[i], P1, P2, P3 = mas[i + 1];
 +
 +
// Значения для первого и последнего отрезков
 +
if (i == 0)
 +
P1 = (mas[1] - mas[0]) * alpha + mas[0];
 +
else
 +
P1 = (mas[i + 1] - mas[i - 1]) * alpha + mas[i];
 +
if (i == N - 2)
 +
P2 = -(mas[N - 1] - mas[N - 2]) * alpha + mas[N - 1];
 +
else
 +
P2 = -(mas[i + 2] - mas[i]) * alpha + mas[i + 1];
 +
 +
for (double t = 0; t <= 1; t += i_step)
 +
{
 +
vec p;
  
 +
// Вычисление точки интерполированного графика по 4 точкам
 +
G_New.mas[(int)((t + i) / i_step)] = P0 * (1 - t) * (1 - t) * (1 - t) + P1 * 3 * (1 - t) * (1 - t) * t + P2 * 3 * (1 - t) * t * t + P3 * t * t * t;
 +
}
 +
}
  
Скачать программу можно по [http://mech.spbstu.ru/File:Untitled1.rar ссылке]
+
return G_New;
<div class="mw-collapsible mw-collapsed" style="width:100%" >
+
} /* End of 'Interpolation' function */
Метод наименьших квадратов
 
задача состоит в том, чтобы минимизировать выражение:
 
1: http://mech.spbstu.ru/images/b/b0/003.png
 
Доказано, что минимум достигается при:
 
2: http://mech.spbstu.ru/images/2/20/005.png
 
записываем пункт 2 в нашу программу, находим коэффициенты и находим значение линейной функции y=ax+b, по интерполированным значениям x.
 
  
 +
/* Sum of 2 graphics function */
 +
// Сложение двух графиков
 +
graph graph::operator+( graph &G )
 +
{
 +
graph G_New, G1, G2;
 +
int i, j;
  
<div class="mw-collapsible-content">
+
// Заполнение параметров графика суммы
<syntaxhighlight lang="cpp" line start="1" enclose="div">
+
G_New.MinX = (MinX >= G.MinX) ? MinX : G.MinX;
 
+
G_New.MaxX = (MaxX <= G.MaxX) ? MaxX : G.MaxX;
#include <iostream>
+
G_New.Step = Step * G.Step;
#include <math.h>
+
G_New.N = (int)((G_New.MaxX - G_New.MinX) / G_New.Step);
#include <iomanip>
+
G_New.mas = new vec[G_New.N];
#include<stdlib.h>
 
using namespace std;
 
  
class func
+
// Интерполяция слагаемых графиков, для приведение к общему шагу
{
+
G1 = Interpolation(G.Step);
private:
+
G2 = G.Interpolation(Step);
    double a/*начало*/,b/*конец*/,c/*шаг*/,k/**/,m/**/,rr/**/;
 
    int d/*переменная для изменения типа, кол-во элементов для начальных элементов*/,tt/*переменная для изиенения типа, кол-ва элементов для счёта суммы*/;
 
    double *F/*массив для значений У*/, *X/*Массив для значений Х*/, *R/*массив для значений У после интерполяции*/, *Q;
 
public:
 
  
    func (double a1, double b1, double c1):a(a1),b(b1),c(c1)//создаём конструктор для функции
+
// Поиск общего начала и конца графиков
    {
+
for (i = 0; i < G1.N; i++)
        double p = (b-a)/c;
+
if (fabs(G1.mas[i].X - G_New.MinX) <= Threshold)
        d = (int)p;
+
break;
        if (b > (d*c+a)) d += 2; //в зависимости от случая прибавляем либо 2 либо 1, чтобы не произошло переполнения массива
 
        else d += 1;
 
  
        F = new double [d];//создание динамического массива для У
+
for (j = 0; j < G2.N; j++)
        X = new double [d];// создание динамического массива для Х
+
if (fabs(G2.mas[j].X - G_New.MinX) <= Threshold)
        X[0]=a;//первый элемент
+
break;
        X[d-1]=b;//последний элемент, для того чтобы последний элемент был в конце промежутка, чтобы его не потерять
 
        for(int i = 1; i < d-1; i++) X[i]=a+c*i; //присваивание значений всех Х
 
 
 
    }
 
    void first ()//функция для первой функции
 
    {
 
        double y;//в зависимости от случая прибавляем либо 2 либо 1, чтобы не произошло переполнения массива
 
        F[0]=pow(2,a);//объявление значения У для начала промежутка
 
        F[d-1]=pow(2,b);//объявление значения У для конца промежутка
 
        for(int i = 1; i < d-1; ++i)
 
        {
 
            y = pow(2,((c*i)+a));//высчитываем значения У внутри промежутка
 
            F[i] = y;//присваиваем массиву значения по У
 
        }
 
  
        cout << " " << endl;//пробел и конец строки
+
// Заполнение графика суммы
    }
+
for (int k = 0; k < G_New.N; k++)
 +
{
 +
G_New.mas[k].X = G_New.MinX + k * G_New.Step;
 +
G_New.mas[k].Y = G1.mas[i + k].Y + G2.mas[j + k].Y;
 +
}
  
    void second ()//функция для второй функции
+
return G_New;
    {
+
} /* End of 'Sum' function */
        if(a==0 || b==0) return;
 
        F[0]=1*a*a; //присваивание значения функции в начале промежутка
 
        F[d-1]=1*b*b;//присваивание значения функции в конце промежутка
 
  
        for(int k = 1; k <d-1; ++k)
+
/* Save Array of points function */
        {
+
// Сохранение графика в файл по точкам
            double n = c*k+a;
+
void graph::SaveArray( void )
            if (n != 0)//условие неделимости на ноль
+
{
            {
+
// Создание указателя на тип FILE
                F[k] = 1*n*n;
+
FILE *F;
            }
 
        }
 
  
    }
+
// Создание файла и открытие его в режиме записи
 +
fopen_s(&F, "graph.txt", "wt");
  
    void operator +(func Q)//перегрузка оператора +
+
/* Запись в файл данных */
    {
+
// Количество точек
        sum(Q);
+
fprintf(F, "%d\n", N);
    }
+
// Шаг функции
 +
fprintf(F, "%lf\n", Step);
 +
// Начальная координата по X
 +
fprintf(F, "%lf\n", MinX);
 +
// Конечная координата по X
 +
fprintf(F, "%lf\n", MaxX);
  
    void sum (func Q)//функция суммирования функций на интерполированном шаге
+
// Координаты всех точек
    {  double m, p = (b-a)/c;
+
for (int i = 0; i < N; ++i)
    int i;
+
  fprintf(F, "%lf %lf ", mas[i].X, mas[i].Y);
        R=new double[d+2];
 
          if (b > (d*c+a)) d += 2; //в зависимости от случая прибавляем либо 2 либо 1, чтобы не произошло переполнения массива
 
        else d += 1;
 
    m=a;
 
cerr<<"\n";
 
  
        for(i = 0; i <d-1; ++i)//цикл суммирования функций и вывода значений суммы, функций и иксов
+
// Закрытие файла
        {
+
fclose(F);
 +
} /* End of 'SaveArray' function */
  
            cerr <<"YFirst: "<< F[i] << "  ";
+
/* Approximation of function function */
            cerr << "YSecond: "<< Q.F[i] << "  ";
+
// Аппроксимация графика
            R[i] = F[i] + Q.F[i];
+
void graph::Approximation( void )
            cerr << "Ysum: "<< R[i] << "  ";
+
{
            cerr << "X:" << m << '\n';
+
double k, b, s1 = 0, s2 = 0, s3 = 0, s4 = 0;
  
            m=m+c;
+
// Линейная аппроксимация
        }
+
for (int i = 0; i < N; i++)
  for(i = 0; i <d-1; ++i)
+
{
        {Q.F[i]=R[i];
+
if (fabs(mas[i].X) < MAX && fabs(mas[i].Y) < MAX)
}
+
{
        cerr << " " << endl;
+
s1 += mas[i].X * mas[i].Y;
    }
+
s2 += mas[i].X;
 +
s3 += mas[i].X * mas[i].X;
 +
s4 += mas[i].Y;
 +
}
 +
}
  
double interp( double pnt/*новый шаг*/, func Q)//функция для интерполяции функции
+
k = (N * s1 - s2 * s4) / (double(N) * s3 - s2 * s2);
    {double p,h,i,w,*X,aApr,bApr,X2sm,XYsm,Xsm/*хранит сумму интерполированных иксов*/,Ysm/*хранит сумму интерполированных игреков*/;
+
b = (s4 - k * s2) / double(N);
    int q,k,l,o;
 
    p=(b-a)/pnt+1;
 
    q=int(p);
 
    R=new double [q];
 
    X=new double [q];
 
  
    l=0;
+
// Задача цвета и ширины линии
    k=0;
+
glColor3d(1, 0.5, 0);
 +
glLineWidth(1);
 +
// Рисование
 +
glBegin(GL_LINE_STRIP);
 +
glVertex2d(MinX, MinX * k + b);
 +
glVertex2d(MaxX, MaxX * k + b);
 +
glEnd();
 +
} /* End of 'Approximation' function */
  
    for(h=a/*начало функции*/; h<=b/*конец функции*/; h=h+c/*старый шаг*/) //шагает по нормальному шагу
+
/* End of 'GRAPH.CPP' file */
    {
+
</syntaxhighlight>
        for(i=a-1; i<=b; i=i+pnt/*новый шаг*/)
+
"'''GRAPH.H'''"
          if((i>h)&&(i<=(h+c)))//проверяет лежит ли новый шаг между точками старого
+
<syntaxhighlight lang="cpp" line start="1" enclose="div">
            {  R[k]=(Q.F[l]-Q.F[l-1])*(i-h)/c+Q.F[l-1];//формула интерполяции
+
/* FILENAME: GRAPH.H
                cout<<"\n"<<"Yinter: "<<R[k]<<" "<<"X: "<<i-1;//вывод интерполированных значений и иксов
+
* LAST UPDATE: 17.01.2016
                X[k]=i-1;
+
*/
                k++;
 
            }
 
        l++;
 
    }
 
    cout<<"\n";
 
    cout<<"\n";
 
    cout<<"\n";
 
    //обнуление значений сумм для МНК
 
    Xsm=0;
 
    Ysm=0;
 
    XYsm=0;
 
    X2sm=0;
 
  
    for(o=0;o<=k;o++)//цикл подготавливает суммы для МНК
+
#ifndef _GRAPH_H_
        {Xsm+=X[o];
+
#define _GRAPH_H_
        Ysm+=R[o];
 
        XYsm+=X[o]*R[o];
 
        X2sm+=X[o]*X[o];
 
        }
 
  
aApr=(k*XYsm-Xsm*Ysm)/(k*X2sm-Xsm*Xsm);//находим коэфициенты по МНК
+
#define _CRT_SECURE_NO_WARNINGS
bApr=(Ysm-a*Xsm)/k;
 
cout<<"\n"<<"aAprox"<<a<<"  "<<"bAprox"<<b<<"\n";//выводим их
 
for(o=0;o<k;o++)
 
        {c=aApr*X[o]+bApr;//считаем значение Y при данных коэфициентах
 
        cout<<"YAprox: "<<c<<" "<<"X:"<<X[o]<<"\n" ;
 
        }
 
  
 +
#include <iostream>
 +
#include <stdio.h>
 +
#include <stdlib.h>
 +
#include <math.h>
 +
#include <time.h>
 +
#include <GL\glut.h>
  
    return 0;}
+
#define MAX 100
};
 
  
int main(){
+
using namespace std;
    double x, xn, s1,pnt;
 
    cout << "Input the beginning of the function: " << endl;
 
    cin >> x;
 
    cout << "Input the ending of the function: " << endl;
 
    cin >> xn;
 
    cout << "Input step for the function: " << endl;
 
    cin >> s1;
 
    func H(x,xn,s1);
 
    H.first();
 
    func G(x,xn,s1);
 
    G.second();
 
    H+G;
 
    cout<<"\n" << "Input new step for the function: " << endl;
 
    cin >> pnt;
 
    H.interp(pnt,G);
 
  
return 0;}
+
/* Useful constants */
</syntaxhighlight>
+
const double Threshold = 1e-10;
</div>
+
const double Infinity = 1e+10;
  
 +
/* Vector representation type */
 +
class vec
 +
{
 +
public:
 +
double X, Y;
  
<div class="mw-collapsible mw-collapsed" style="width:100%" >
+
/* Default constructor */
'''[[Рубинова Раиса]]'''
+
vec( void )
 +
{
 +
}
  
'''Описание программы''': программа, позволяющая складывать, вычитать, умножать и делить две функции, заданные на одном интервале, интерполирующая первую функцию по второй и аппроксимирующая результат арифметической операции с заданными пользователем функции.
+
/* Class constructor */
 +
vec( double A ) : X(A), Y(A)
 +
{
 +
}
  
'''Инструкция к программе''':
+
/* Class constructor */
1. Пользователь вводит параметры первой функции
+
vec( double A, double B ) : X(A), Y(B)
2. Пользователь вводит параметры второй функции (при этом шаг второй функции меньше шага первой)
+
{
3. Происходит интерполяция первой функции по второй
+
}
4. Пользователь выбирает арифметическую операцию
 
5. При желании пользователь может выполнить аппроксимацию полученного результата
 
  
 +
static double R0( void )
 +
{
 +
return rand() / (double)RAND_MAX;
 +
} /* End of 'R0' function */
  
Скачать можно [http://tm.spbstu.ru/File:Funcc.rar тут].
+
static vec Rnd( void )
 +
{
 +
return vec(R0(), R0());
 +
} /* End of 'Rnd' function */
  
 +
/* The functions of operations on vectors */
  
<div class="mw-collapsible-content">
+
/* Vector = vector function */
<syntaxhighlight lang="cpp" line start="1" enclose="div">
+
vec operator=( vec &B )
#ifndef FUNC_H
+
{
#define FUNC_H
+
X = B.X;
 +
Y = B.Y;
  
 +
return B;
 +
} /* end of 'operator+' function */
  
class Func
+
/* Vector add vector function */
{
+
vec operator+( const vec &B ) const
    public:
+
{
        Func(double a1, double b1, double c1);
+
return vec(X + B.X, Y + B.Y);
        virtual ~Func();
+
} /* end of 'operator+' function */
        void DefFunc ();    // функция, определяющая количество элементов j на промежутке от a до b, с шагом c
+
 
        void PluFunc (Func D); // функция, складывающая значения двух функций линейно (то есть значения первой функции при определенной переменной x складывается со значением второй функции при том же значении переменной)
+
/* Vector sub vector function */
        void operator +(Func D); // перегрузка оператора '+'
+
vec operator-( const vec &B ) const
        void MinFunc (Func D);  // функция, линейно вычитающая значения второй функции из значений первой функции
+
{
        void operator -(Func D); // перегрузка оператора '-'
+
return vec(X - B.X, Y - B.Y);
        void UmnFunc (Func D);  // функция, линейно переумножающая значения функций
+
} /* end of 'operator-' function */
        void operator *(Func D);  // перегрузка оператора '*'
 
        void DelFunc (Func D);  // функция, линейно делящая значения первой функци на значения второй функции
 
        void operator /(Func D);  // перегрузка оператора '/'
 
        void In (Func D);  // функция, интерполирующая первую функцию по второй
 
        void App (); // функция, аппроксимирующая полученную в результате сложения/вычитания/деления/умножения двух функций функцию
 
        void Viv ();  // Функция вывода на экран значений
 
    protected:
 
    private:
 
        double a,b,c;
 
        int j,z;
 
        double *A,*B;
 
};
 
  
#endif // FUNC_H
+
vec operator-( void ) const
 +
{
 +
return vec(-X, -Y);
 +
} /* end of 'operator-' function */
  
 +
/* Vector mul number function */
 +
vec operator*( const double N ) const
 +
{
 +
return vec(X * N, Y * N);
 +
} /* end of 'operator*' function */
  
 +
/* Vector div number function */
 +
vec operator/( const double N ) const
 +
{
 +
return vec(X / N, Y / N);
 +
} /* end of 'operator/' function */
  
#include "Func.h"
+
/* Vector dot vector function */
#include <fstream>
+
double operator&( const vec &B ) const
#include <iostream>
+
{
#include <math.h>
+
return double(X * B.X + Y * B.Y);
 +
} /* end of 'operator&' function */
  
Func::Func(double a1, double b1, double c1):a(a1),b(b1),c(c1)  // конструктор для класса Func, создающий объект данного класса, определенный тремя значениями, введенными пользователем
+
vec & operator+=( const vec &B )
{
+
{
    double d=(b-a)/c;   // расчет количества элементов, определяющих функцию
+
X += B.X;
    j=floor(d);   // созданной целочисленной переменной присваивается значение, равное целой части числа, рассчитанного выше, с округлением в меньшую сторону
+
Y += B.Y;
    A = new double [j+1];  // создание массива
 
}
 
  
Func::~Func()  // деструктор для класса Func
+
return *this;
{
+
} /* end of 'operator+=' function */
    //dtor
 
}
 
  
void Func::Viv ()   // Функция вывода на экран значений
+
vec & operator-=( const vec &B )
{
+
{
    std::cout << "x ";
+
X -= B.X;
    for (int z=0; z<=j; ++z)
+
Y -= B.Y;
    {
 
        std::cout << z+1 << " ";
 
    }
 
}
 
  
void Func::DefFunc ()  // функция, определяющая количество элементов j на промежутке от a до b, с шагом c
+
return *this;
{
+
} /* end of 'operator-=' function */
    double x;   // создание переменной, используемой для расчета значений функции
 
    for(int i=0; i<=j; ++i) // создание цикла, рассчитывающего j элементов
 
    {
 
        x =i*c+a;  // задание значения перемнной x, определенной выше
 
        A[i]=x*x;  // задание значения самой функции (при этом в данной ситуации нам неважно, как именно задается функция, ее значения могут быть определены любым способом, от этого алгоритм не меняется)
 
        std::cerr << A[i] << " ";  // вывод на экран значения функции
 
    }
 
}
 
  
void Func::PluFunc (Func D)   // функция, складывающая значения двух функций линейно (то есть значения первой функции при определенной переменной x складывается со значением второй функции при том же значении переменной)
+
vec & operator*=( const double N )
{
+
{
    std::ofstream out("zap.txt");   // открытие файла "zap.txt", находящегося в той же папке, что и программа, для работы
+
X *= N;
    for(int i=0; i<=D.j; ++i)  // создание цикла, повторяющегося (D.j+1) раз
+
Y *= N;
    {
+
 
        B[i]=B[i]+D.A[i];   // сложение значений двух функций для одного и того же значения переменной
+
return *this;
    }
+
} /* end of 'operator*=' function */
    for (int i=0; i<=D.j; ++i) // создание цикла, рассчитанного на то же количество раз, что и предыдущий
+
 
    {
+
vec & operator/=( const double N )
        out << B[i] << '\n';    // запись значений, полученных в предыдущем цикле, в файл
+
{
    }
+
X /= N;
    out.close();    // закрытие файла после записи в него значений
+
Y /= N;
    D.Viv();
+
 
    std::cout << std::endl << "y ";
+
return *this;
    for (int i=0; i<=D.j; ++i)  // аналогичный предыдущему цикл, выводящий значения на экран
+
} /* end of 'operator/=' function */
    {
+
 
        std::cout << B[i] << " ";
+
double operator!( void ) const
    }
+
{
}
+
return double(X * X + Y * Y);
void Func::operator +(Func D)  // перегрузка оператора '+'
+
} /* end of 'operator!' function */
{
+
 
    PluFunc(D);                         // с помощью данного куска программы мы позволяем записать функцию в несколько ином виде: теперь запись f1+f2 будет работать аналогично записи f1.PluFunc(f2)
+
/* Access vector components by index function */
}
+
double operator[]( const int i ) const
void Func::MinFunc (Func D)    // функция, линейно вычитающая значения второй функции из значений первой функции
+
{
 +
switch (i)
 +
{
 +
case 0:
 +
return double(X);
 +
case 1:
 +
return double(Y);
 +
}
 +
} /* end of 'operator[]' function */
 +
 
 +
/* Normalizing vector function */
 +
vec & Normalize( void )
 +
{
 +
double len = !*this;
 +
 
 +
if (len != 1 && len != 0)
 +
*this /= sqrt(len);
 +
return *this;
 +
} /* end of 'Normalize' function */
 +
}; /* end of 'vec' class */
 +
 
 +
/* Graph class */
 +
class graph
 
{
 
{
    std::ofstream out("zap.txt");   // открытие файла "zap.txt", находящегося в той же папке, что и программа, для работы
+
public:
    for(int i=0; i<=D.j; ++i)  // создание цикла, повторяющегося (D.j+1) раз
+
double MinX, MaxX, Step; // Начальная координата по X; Конечная координата по X; Шаг функции
    {
+
int N; // Количество точек
        B[i]=B[i]-D.A[i];   // вычитание значений второй функций из значений первой для одного и того же значения переменной
+
vec *mas, *Color; // Массивы точек и цветов
    }
+
 
    for (int i=0; i<=D.j; ++i)  // создание цикла, рассчитанного на то же количество раз, что и предыдущий
+
/* Default constructor */
    {
+
graph( void )
        out << B[i] << '\n';    // запись значений, полученных в предыдущем цикле, в файл
+
{
    }
+
MinX = -10, MaxX = 10, Step = 0.1, N = 200;
    out.close();    // закрытие файла после записи в него значений
+
}
    D.Viv();
+
 
    std::cout << std::endl << "y ";
+
/* Class constructor */
    for (int i=0; i<=D.j; ++i)  // аналогичный предыдущему цикл, выводящий значения на экран
+
graph( double _MinX, double _MaxX, double _Step ) : MinX(_MinX), MaxX(_MaxX), Step(_Step)
    {
+
{
        std::cout << B[i] << " ";
+
N = (int)((MaxX - MinX) / Step);
    }
+
// Выделение памяти
}
+
mas = new vec[N];
void Func::operator -(Func D)  // перегрузка оператора '-'
+
Color = new vec[N];
{
+
}
    MinFunc(D);     // с помощью данного куска программы мы позволяем записать функцию в несколько ином виде: теперь запись f1-f2 будет работать аналогично записи f1.MinFunc(f2)
+
 
}
+
/* Load Array of points function */
void Func::UmnFunc (Func D)     // функция, линейно переумножающая значения функций
+
void LoadArray( char *FileName );
{
+
 
    std::ofstream out("zap.txt");   // открытие файла "zap.txt", находящегося в той же папке, что и программа, для работы
+
/* Fill mas function */
    for(int i=0; i<=D.j; ++i)  // создание цикла, повторяющегося (D.j+1) раз
+
void Fill( double(*f)(double) );
    {
+
 
        B[i]=B[i]*D.A[i];  // умножение значений первой функций на значенийя второй для одного и того же значения переменной
+
/* Draw graph function */
    }
+
void Draw( double(*f)(double) );
    for (int i=0; i<=D.j; ++i)    // создание цикла, рассчитанного на то же количество раз, что и предыдущий
+
 
    {
+
/* Draw graph function */
        out << B[i] << '\n';    // запись значений, полученных в предыдущем цикле, в файл
+
void Draw( void );
    }
+
 
    out.close();   // закрытие файла после записи в него значений
+
/* Interpolation draw graph function */
    D.Viv();
+
void Interpolation_Draw( double i_step );
    std::cout << std::endl << "y ";
+
 
    for (int i=0; i<=D.j; ++i)  // аналогичный предыдущему цикл, выводящий значения на экран
+
/* Interpolation graph function */
    {
+
graph Interpolation( double i_step );
        std::cout << B[i] << " ";
+
 
    }
+
/* Sum of 2 graphics function */
}
+
graph operator+( graph &G );
void Func::operator *(Func D)   // перегрузка оператора '*'
+
 
{
+
/* Save Array of points function */
    UmnFunc(D);    // с помощью данного куска программы мы позволяем записать функцию в несколько ином виде: теперь запись f1*f2 будет работать аналогично записи f1.UmnFunc(f2)
+
void SaveArray( void );
}
+
 
void Func::DelFunc (Func D)    // функция, линейно делящая значения первой функци на значения второй функции
+
/* Approximation of function function */
{
+
void Approximation( void );
    std::ofstream out("zap.txt");  // открытие файла "zap.txt", находящегося в той же папке, что и программа, для работы
+
}; /* end of 'graph' class */
    for(int i=0; i<=D.j; ++i)    // создание цикла, повторяющегося (D.j+1) раз
+
 
    {
+
#endif /* _GRAPH_H_ */
        B[i]=B[i]/D.A[i];      // деление значений первой функций на значенийя второй для одного и того же значения переменной
+
 
    }
+
/* End of 'GRAPH.H' file */
    for (int i=0; i<=D.j; ++i)      // создание цикла, рассчитанного на то же количество раз, что и предыдущий
+
</syntaxhighlight>
    {
+
</div>
        out << B[i] << '\n';        // запись значений, полученных в предыдущем цикле, в файл
+
[http://tm.spbstu.ru/File:T05GRAPH.7z Скачать архив]
    }
+
<br>
    out.close();    // закрытие файла после записи в него значений
+
 
    D.Viv();
+
<div class="mw-collapsible mw-collapsed" style="width:100%" >
    std::cout << std::endl << "y ";
+
'''[[Рубинова Раиса]]'''
    for (int i=0; i<=D.j; ++i)      // аналогичный предыдущему цикл, выводящий значения на экран
+
 
    {
+
'''Описание программы''': программа, позволяющая складывать, вычитать, умножать и делить две функции, заданные на одном интервале, интерполирующая первую функцию по второй и аппроксимирующая результат арифметической операции с заданными пользователем функции.
        std::cout << B[i] << " ";
+
 
    }
+
'''Инструкция к программе''':
}
+
1. Пользователь вводит параметры первой функции
void Func::operator /(Func D)  // перегрузка оператора '/'
+
2. Пользователь вводит параметры второй функции (при этом шаг второй функции меньше шага первой)
 +
3. Происходит интерполяция первой функции по второй
 +
4. Пользователь выбирает арифметическую операцию
 +
5. При желании пользователь может выполнить аппроксимацию полученного результата
 +
 
 +
 
 +
Скачать можно [http://tm.spbstu.ru/File:Funcc.rar тут].
 +
 
 +
 
 +
<div class="mw-collapsible-content">
 +
<syntaxhighlight lang="cpp" line start="1" enclose="div">
 +
#ifndef FUNC_H
 +
#define FUNC_H
 +
 
 +
 
 +
class Func
 
{
 
{
     DelFunc(D);     // с помощью данного куска программы мы позволяем записать функцию в несколько ином виде: теперь запись f1/f2 будет работать аналогично записи f1.DelFunc(f2)
+
     public:
}
+
        Func(double a1, double b1, double c1);
void Func::In (Func D)     // функция, интерполирующая первую функцию по второй
+
        virtual ~Func();
 +
        void DefFunc ();    // функция, определяющая количество элементов j на промежутке от a до b, с шагом c
 +
        void PluFunc (Func D);  // функция, складывающая значения двух функций линейно (то есть значения первой функции при определенной переменной x складывается со значением второй функции при том же значении переменной)
 +
        void operator +(Func D); // перегрузка оператора '+'
 +
        void MinFunc (Func D);  // функция, линейно вычитающая значения второй функции из значений первой функции
 +
        void operator -(Func D); // перегрузка оператора '-'
 +
        void UmnFunc (Func D); // функция, линейно переумножающая значения функций
 +
        void operator *(Func D);  // перегрузка оператора '*'
 +
        void DelFunc (Func D);  // функция, линейно делящая значения первой функци на значения второй функции
 +
        void operator /(Func D);  // перегрузка оператора '/'
 +
        void In (Func D)// функция, интерполирующая первую функцию по второй
 +
        void App (); // функция, аппроксимирующая полученную в результате сложения/вычитания/деления/умножения двух функций функцию
 +
        void Viv ();  // Функция вывода на экран значений
 +
    protected:
 +
    private:
 +
        double a,b,c;
 +
        int j,z;
 +
        double *A,*B;
 +
};
 +
 
 +
#endif // FUNC_H
 +
 
 +
 
 +
 
 +
#include "Func.h"
 +
#include <fstream>
 +
#include <iostream>
 +
#include <math.h>
 +
 
 +
Func::Func(double a1, double b1, double c1):a(a1),b(b1),c(c1)  // конструктор для класса Func, создающий объект данного класса, определенный тремя значениями, введенными пользователем
 +
{
 +
    double d=(b-a)/c;  // расчет количества элементов, определяющих функцию
 +
    j=floor(d);    // созданной целочисленной переменной присваивается значение, равное целой части числа, рассчитанного выше, с округлением в меньшую сторону
 +
    A = new double [j+1];  // создание массива
 +
}
 +
 
 +
Func::~Func()  // деструктор для класса Func
 
{
 
{
    double l=c/D.c;     // создаем переменную, которой присваиваем значение, обозначающее, во сколько раз один шаг больше другого
+
     //dtor
    c=D.c;      // приводим больший шаг к меньшему значению
+
}
    z=D.j+1;    // ранее созданной переменной присваиваем значение, равное количеству элементов плюс один
+
 
    int p=l;    // создаем целочисленную переменную, равную переменной l
+
void Func::Viv ()  // Функция вывода на экран значений
    B = new double [D.j+2];    // создание массива с количеством элементов D.j+2
+
{
     D.Viv(); std::cout << std::endl << "y ";
+
     std::cout << "x ";
    B[0]=A[0]; std::cerr << B[0] << " ";    // присваиваем первому элементу нового массива значение первого элемента старого массива и выводим его на экран
+
     for (int z=0; z<=j; ++z)
    int k=0;    // создаем вспомогательную целочисленную переменную
 
     for (int i=0; i<=j; i+=p)   // создаем цикл, рассчитанный на j повторов через p
 
 
     {
 
     {
         for (int m=1; m<p; ++m)    // создание цикла, выссчитывавшего промежуточное значение
+
         std::cout << z+1 << " ";
        {B[i+m]=((A[k]+A[k+1])/p)*(l-m); std::cerr << B[i+m] << " ";}  // присваиваем (i+m)-ому элементу значение, выссчитанного по формуле через заданные изначально значения и вывод егона экран
 
        B[i+p]=A[k+1];      // присваивание значению (i+p)-ого элемента нового массива значения (k+1)-ого элемента старого массива
 
        std::cerr << B[i+p] << " ";     // вывод высчитанного выше значения на экран
 
        k=k+1; // увеличение k на единицу
 
 
     }
 
     }
 
}
 
}
void Func::App ()  // функция, аппроксимирующая полученную в результате сложения/вычитания/деления/умножения двух функций функцию
+
 
 +
void Func::DefFunc ()  // функция, определяющая количество элементов j на промежутке от a до b, с шагом c
 
{
 
{
     double d=0,e=0,f=0,g=0;    // создание переменных
+
     double x;   // создание переменной, используемой для расчета значений функции
    double k=0,l=0;     // создание переменных
+
     for(int i=0; i<=j; ++i) // создание цикла, рассчитывающего j элементов
    for (int i=0; i<z; ++i)    // цикл, который высчитывает сумму произведений зависимой и независимой переменных
 
        {d=i*B[i]+d;}
 
    for (int i=0; i<z; ++i)    // цикл, который высчитывает сумму всех значений функции
 
        {e=B[i]+e;}
 
     for (int i=0; i<z; ++i)    // цикл, высчитывающий сумму всех аргументов функции
 
        {f=i+f;}
 
    for (int i=0; i<z; ++i)     // цикл, высчитывающий сумму квадратов всех аргументов функции
 
        {g=i*i+g;}
 
    k=(z*d-f*e)/(z*g-f*f);      // расчет углового коэффициента прямой
 
    l=(e-k*f)/z;        // расчет свободного коэффициента прямой
 
    std::cout << "y=" << k << "x+" << l;    // вывод уравнения полученной прямой на экран
 
    std::ofstream out("ap.txt");        // запись полученного уравнения в файл
 
 
     {
 
     {
         out << "y=" << k << "x+" << l;
+
         x =i*c+a;  // задание значения перемнной x, определенной выше
 +
        A[i]=x*x;  // задание значения самой функции (при этом в данной ситуации нам неважно, как именно задается функция, ее значения могут быть определены любым способом, от этого алгоритм не меняется)
 +
        std::cerr << A[i] << " ";   // вывод на экран значения функции
 
     }
 
     }
    out.close();
 
 
}
 
}
  
 
+
void Func::PluFunc (Func D)  // функция, складывающая значения двух функций линейно (то есть значения первой функции при определенной переменной x складывается со значением второй функции при том же значении переменной)
 
+
{
#include <iostream>
+
    std::ofstream out("zap.txt");  // открытие файла "zap.txt", находящегося в той же папке, что и программа, для работы
#include <fstream>
+
    for(int i=0; i<=D.j; ++i)  // создание цикла, повторяющегося (D.j+1) раз
#include "Func.h"
+
    {
 
+
        B[i]=B[i]+D.A[i];  // сложение значений двух функций для одного и того же значения переменной
using namespace std;
+
    }
double m,n,o, m1, n1, o1;
+
    for (int i=0; i<=D.j; ++i) // создание цикла, рассчитанного на то же количество раз, что и предыдущий
int a;
+
    {
char b;
+
        out << B[i] << '\n';    // запись значений, полученных в предыдущем цикле, в файл
 
+
    }
int main()
+
    out.close();    // закрытие файла после записи в него значений
 +
    D.Viv();
 +
    std::cout << std::endl << "y ";
 +
    for (int i=0; i<=D.j; ++i)  // аналогичный предыдущему цикл, выводящий значения на экран
 +
    {
 +
        std::cout << B[i] << " ";
 +
    }
 +
}
 +
void Func::operator +(Func D)  // перегрузка оператора '+'
 +
{
 +
    PluFunc(D);                         // с помощью данного куска программы мы позволяем записать функцию в несколько ином виде: теперь запись f1+f2 будет работать аналогично записи f1.PluFunc(f2)
 +
}
 +
void Func::MinFunc (Func D)   // функция, линейно вычитающая значения второй функции из значений первой функции
 
{
 
{
     cout << "Enter the beginning, the end and the step of a function." << endl; // ввод опорных значений первой функции: начало, конец, шаг;
+
     std::ofstream out("zap.txt");   // открытие файла "zap.txt", находящегося в той же папке, что и программа, для работы
    cin >> m >> n >> o; // считывание значений
+
     for(int i=0; i<=D.j; ++i)   // создание цикла, повторяющегося (D.j+1) раз
    cout << "Enter the beginning, the end and the step of another function." << endl; // ввод опорных значений второй функции: начало, конец, шаг;
+
     {
    cin >> m1 >> n1 >> o1; // считывание значений
+
        B[i]=B[i]-D.A[i];   // вычитание значений второй функций из значений первой для одного и того же значения переменной
    Func F(m,n,o); // создание объекта класса Func, определяющий первую функцию
+
     }
     cout << "The first function is" << endl; F.Viv(); cout << endl << "y ";
+
     for (int i=0; i<=D.j; ++i)  // создание цикла, рассчитанного на то же количество раз, что и предыдущий
    F.DefFunc(); // определение первой функции через создание массива с ее значениями
+
     {
    cout << endl;
+
        out << B[i] << '\n';   // запись значений, полученных в предыдущем цикле, в файл
    Func F1(m1,n1,o1); // создание объекта класса Func, определяющий вторую функцию
+
     }
    cout << "The second function is" << endl; F1.Viv(); cout << endl << "y ";
+
     out.close();   // закрытие файла после записи в него значений
    F1.DefFunc(); // определение второй функции через создание массива с ее значениями
+
     D.Viv();
     cout << endl;
+
     std::cout << std::endl << "y ";
    cout << "As two functions have different steps, we made the interpolation of the first function." << endl;
+
     for (int i=0; i<=D.j; ++i) // аналогичный предыдущему цикл, выводящий значения на экран
    F.In(F1); // линейная интерполяция первой функции по второй
+
     {
     cout << endl;
+
        std::cout << B[i] << " ";
     cout << "What do you want to do with these functions?" << '\n' << "Enter 1 to sum them;" << '\n' << "Enter 2 to subtract the second from the first;" << '\n' << "Enter 3 to multiply them;" << '\n' << "Enter 4 to divide first by second" << endl;
+
     }
    cin >> a;
 
    if (a==1)
 
    {cout << "Function 1 + function 2 =" << '\n'; F+F1;}  // сложение двух функций с одинаковым шагом и интервалом
 
     else if (a==2)
 
    {cout << "Function 1 - function 2 =" << '\n'; F-F1;}  // вычитание двух функций с одинаковым шагом и интервалом
 
     else if (a==3)
 
    {cout << "Function 1 * function 2 =" << '\n'; F*F1;}   // умножение двух функций с одинаковым шагом и интервалом
 
     else if (a==4)
 
    {cout << "Function 1 / function 2 =" << '\n'; F/F1;}  // деление двух функций с одинаковым шагом и интервалом
 
     cout << endl;
 
     cout << "Enter 5 to do the approximation of the result function" << endl;  // пользователь сам выбирает, выполнять ли аппроксимацию;
 
    cout << "Otherwise enter 6 to quit" << endl;
 
    cin >> a;
 
     if (a==5)
 
     {cout << "Appromaximation:" << endl;
 
     F.App();}   // аппроксимация
 
    return 0;
 
 
}
 
}
 
+
void Func::operator -(Func D)  // перегрузка оператора '-'
</syntaxhighlight>
+
{
</div>
+
    MinFunc(D);    // с помощью данного куска программы мы позволяем записать функцию в несколько ином виде: теперь запись f1-f2 будет работать аналогично записи f1.MinFunc(f2)
 
+
}
<div class="mw-collapsible mw-collapsed" style="width:100%" >
+
void Func::UmnFunc (Func D)    // функция, линейно переумножающая значения функций
'''[[Савельева Ольга]]'''
 
 
'''Краткое описание алгоритма :''' Программа создаёт и хранит значения двух функций с одинаковом шагом и заданных на одинаковом интервале. Методы позволяют сложить эти две функции,интерполировать одну из них по заданному шагу или апроксимировать методом наименьших квадратов. Данные берутся из файла. При считывании с файла сначала указывается отрезок, потом величина, а потом дискретные значения.
 
<div class="mw-collapsible-content">
 
<syntaxhighlight lang="cpp" line start="1" enclose="div">
 
#include <stdio.h>
 
#include <stdlib.h>
 
//Бибилотека необходимая для возможности включения русского языка в консоли
 
#include <locale.h>
 
 
 
class fun
 
 
{
 
{
/*
+
    std::ofstream out("zap.txt");    // открытие файла "zap.txt", находящегося в той же папке, что и программа, для работы
fx - массив с дискретными значениями функции
+
    for(int i=0; i<=D.j; ++i)  // создание цикла, повторяющегося (D.j+1) раз
a - начало отрезка определения функции
+
    {
b - конец отрезка определения функции
+
        B[i]=B[i]*D.A[i];   // умножение значений первой функций на значенийя второй для одного и того же значения переменной
dx - шаг
+
    }
*/
+
    for (int i=0; i<=D.j; ++i)     // создание цикла, рассчитанного на то же количество раз, что и предыдущий
double *fx, a, b, dx;
+
    {
//Чтобы очусть ошибки округления в вещественных числах при сравнениях используется константа eps.
+
        out << B[i] << '\n';   // запись значений, полученных в предыдущем цикле, в файл
//К примеру два вещественных числа x и y сравниваются не так x>=y, а так x-y>=-eps.
+
    }
const double eps = 1e-10; //1e-10 это тоже самое что 0.0000000001
+
    out.close();   // закрытие файла после записи в него значений
 
+
    D.Viv();
public:
+
    std::cout << std::endl << "y ";
//Коструктор по умолчанию
+
    for (int i=0; i<=D.j; ++i)   // аналогичный предыдущему цикл, выводящий значения на экран
fun();
+
    {
//Конструктор копирования
+
        std::cout << B[i] << " ";
fun(fun &tmp);
+
    }
//Деструктор
+
}
~fun();
+
void Func::operator *(Func D)   // перегрузка оператора '*'
 
 
//Перегруженные операторы. Ключевое слово const в конце означает, что объект от которого вызвается метод не изменяется
 
const fun operator+(const fun& right) const;
 
const fun operator-(const fun& right) const;
 
const fun operator*(const fun& right) const;
 
const fun operator/(const fun& right) const;
 
const fun& operator=(const fun& right);
 
 
 
//Метод считывания из файла
 
void readFile(const char *path);
 
//Метод вывода в файл
 
void writeFile(const char *path);
 
 
 
//Метод изменения шага
 
void changeDx(double newDx);
 
//Метод вычисления значения в заданной точке
 
double getX(double x1);
 
};
 
 
 
//В конструкторе по умолчанию все просто.
 
fun::fun()
 
 
{
 
{
a = b = dx = 0;
+
    UmnFunc(D);     // с помощью данного куска программы мы позволяем записать функцию в несколько ином виде: теперь запись f1*f2 будет работать аналогично записи f1.UmnFunc(f2)
fx = NULL;
 
 
}
 
}
 
+
void Func::DelFunc (Func D)   // функция, линейно делящая значения первой функци на значения второй функции
//Конструктор копирования
 
fun::fun(fun &tmp)
 
 
{
 
{
int i, n;
+
    std::ofstream out("zap.txt");   // открытие файла "zap.txt", находящегося в той же папке, что и программа, для работы
//Копирование свойств объекта tmp в текущий объект
+
    for(int i=0; i<=D.j; ++i)    // создание цикла, повторяющегося (D.j+1) раз
a = tmp.a;
+
    {
b = tmp.b;
+
        B[i]=B[i]/D.A[i];       // деление значений первой функций на значенийя второй для одного и того же значения переменной
dx = tmp.dx;
+
    }
//Вычисление количества дискретных значений
+
    for (int i=0; i<=D.j; ++i)      // создание цикла, рассчитанного на то же количество раз, что и предыдущий
n = (b - a) / dx + 1;
+
    {
//Выделение необходимой памяти для хранения дискретных значений
+
        out << B[i] << '\n';        // запись значений, полученных в предыдущем цикле, в файл
fx = new double[n];
+
    }
//Копирование дискретных значений объекта tmp в текущий объект
+
    out.close();   // закрытие файла после записи в него значений
for (i = 0; i<n; ++i)
+
    D.Viv();
fx[i] = tmp.fx[i];
+
    std::cout << std::endl << "y ";
 +
    for (int i=0; i<=D.j; ++i)     // аналогичный предыдущему цикл, выводящий значения на экран
 +
    {
 +
        std::cout << B[i] << " ";
 +
    }
 
}
 
}
 
+
void Func::operator /(Func D)   // перегрузка оператора '/'
//Деструктор
 
fun::~fun()
 
 
{
 
{
//Освобождение памяти выделенной для массива дискретных значений
+
    DelFunc(D);    // с помощью данного куска программы мы позволяем записать функцию в несколько ином виде: теперь запись f1/f2 будет работать аналогично записи f1.DelFunc(f2)
if (fx != NULL) delete[] fx;
 
 
}
 
}
//Оператор сложения.
+
void Func::In (Func D)     // функция, интерполирующая первую функцию по второй
const fun fun::operator+(const fun& right) const
 
 
{
 
{
//Создание результирующего объекта
+
    double l=c/D.c;    // создаем переменную, которой присваиваем значение, обозначающее, во сколько раз один шаг больше другого
fun result;
+
    c=D.c;     // приводим больший шаг к меньшему значению
int i, n;
+
    z=D.j+1;   // ранее созданной переменной присваиваем значение, равное количеству элементов плюс один
//Копирование свойств в результирующий объект
+
    int p=l;   // создаем целочисленную переменную, равную переменной l
result.dx = dx;
+
    B = new double [D.j+2];     // создание массива с количеством элементов D.j+2
result.a = a;
+
    D.Viv(); std::cout << std::endl << "y ";
result.b = b;
+
    B[0]=A[0]; std::cerr << B[0] << " ";   // присваиваем первому элементу нового массива значение первого элемента старого массива и выводим его на экран
//Вычисление количества дискретных значений
+
    int k=0;    // создаем вспомогательную целочисленную переменную
n = (b - a) / dx + 1;
+
    for (int i=0; i<=j; i+=p)  // создаем цикл, рассчитанный на j повторов через p
//Выделение необходимой памяти для хранения дискретных значений
+
    {
result.fx = new double[n];
+
        for (int m=1; m<p; ++m)     // создание цикла, выссчитывавшего промежуточное значение
//Вычисление дискретных значений результирующего объекта
+
        {B[i+m]=((A[k]+A[k+1])/p)*(l-m); std::cerr << B[i+m] << " ";}  // присваиваем (i+m)-ому элементу значение, выссчитанного по формуле через заданные изначально значения и вывод егона экран
for (i = 0; i<n; ++i)
+
        B[i+p]=A[k+1];     // присваивание значению (i+p)-ого элемента нового массива значения (k+1)-ого элемента старого массива
result.fx[i] = fx[i] + right.fx[i];
+
        std::cerr << B[i+p] << " ";    // вывод высчитанного выше значения на экран
 
+
        k=k+1; // увеличение k на единицу
//Возвращение результата
+
    }
return result;
 
 
}
 
}
 
+
void Func::App ()   // функция, аппроксимирующая полученную в результате сложения/вычитания/деления/умножения двух функций функцию
//Этот оператор аналогичен оператору сложение
 
const fun fun::operator-(const fun& right) const
 
 
{
 
{
fun result;
+
    double d=0,e=0,f=0,g=0;    // создание переменных
int i, n;
+
    double k=0,l=0;     // создание переменных
result.dx = dx;
+
    for (int i=0; i<z; ++i)    // цикл, который высчитывает сумму произведений зависимой и независимой переменных
result.a = a;
+
        {d=i*B[i]+d;}
result.b = b;
+
    for (int i=0; i<z; ++i)    // цикл, который высчитывает сумму всех значений функции
n = (b - a) / dx + 1;
+
        {e=B[i]+e;}
result.fx = new double[n];
+
    for (int i=0; i<z; ++i)     // цикл, высчитывающий сумму всех аргументов функции
for (i = 0; i<n; ++i)
+
        {f=i+f;}
result.fx[i] = fx[i] - right.fx[i];
+
    for (int i=0; i<z; ++i)     // цикл, высчитывающий сумму квадратов всех аргументов функции
 +
        {g=i*i+g;}
 +
    k=(z*d-f*e)/(z*g-f*f);      // расчет углового коэффициента прямой
 +
    l=(e-k*f)/z;        // расчет свободного коэффициента прямой
 +
    std::cout << "y=" << k << "x+" << l;    // вывод уравнения полученной прямой на экран
 +
    std::ofstream out("ap.txt");        // запись полученного уравнения в файл
 +
    {
 +
        out << "y=" << k << "x+" << l;
 +
    }
 +
    out.close();
 +
}
 +
 
  
return result;
 
}
 
  
//Этот оператор аналогичен оператору сложение
+
#include <iostream>
const fun fun::operator*(const fun& right) const
+
#include <fstream>
{
+
#include "Func.h"
fun result;
 
int i, n;
 
result.dx = dx;
 
result.a = a;
 
result.b = b;
 
n = (b - a) / dx + 1;
 
result.fx = new double[n];
 
for (i = 0; i<n; ++i)
 
result.fx[i] = fx[i] * right.fx[i];
 
  
return result;
+
using namespace std;
}
+
double m,n,o, m1, n1, o1;
 +
int a;
 +
char b;
  
//Этот оператор аналогичен оператору сложение
+
int main()
const fun fun::operator/(const fun& right) const
 
 
{
 
{
fun result;
+
    cout << "Enter the beginning, the end and the step of a function." << endl; // ввод опорных значений первой функции: начало, конец, шаг;
int i, n;
+
    cin >> m >> n >> o; // считывание значений
result.dx = dx;
+
    cout << "Enter the beginning, the end and the step of another function." << endl; // ввод опорных значений второй функции: начало, конец, шаг;
result.a = a;
+
    cin >> m1 >> n1 >> o1; // считывание значений
result.b = b;
+
    Func F(m,n,o); // создание объекта класса Func, определяющий первую функцию
n = (b - a) / dx + 1;
+
    cout << "The first function is" << endl; F.Viv(); cout << endl << "y ";
result.fx = new double[n];
+
    F.DefFunc(); // определение первой функции через создание массива с ее значениями
for (i = 0; i<n; ++i)
+
    cout << endl;
result.fx[i] = fx[i] / right.fx[i];
+
    Func F1(m1,n1,o1); // создание объекта класса Func, определяющий вторую функцию
 
+
    cout << "The second function is" << endl; F1.Viv(); cout << endl << "y ";
return result;
+
    F1.DefFunc(); // определение второй функции через создание массива с ее значениями
 +
    cout << endl;
 +
    cout << "As two functions have different steps, we made the interpolation of the first function." << endl;
 +
    F.In(F1); // линейная интерполяция первой функции по второй
 +
    cout << endl;
 +
    cout << "What do you want to do with these functions?" << '\n' << "Enter 1 to sum them;" << '\n' << "Enter 2 to subtract the second from the first;" << '\n' << "Enter 3 to multiply them;" << '\n' << "Enter 4 to divide first by second" << endl;
 +
    cin >> a;
 +
    if (a==1)
 +
    {cout << "Function 1 + function 2 =" << '\n'; F+F1;}  // сложение двух функций с одинаковым шагом и интервалом
 +
    else if (a==2)
 +
    {cout << "Function 1 - function 2 =" << '\n'; F-F1;}  // вычитание двух функций с одинаковым шагом и интервалом
 +
    else if (a==3)
 +
    {cout << "Function 1 * function 2 =" << '\n'; F*F1;}  // умножение двух функций с одинаковым шагом и интервалом
 +
    else if (a==4)
 +
    {cout << "Function 1 / function 2 =" << '\n'; F/F1;}  // деление двух функций с одинаковым шагом и интервалом
 +
    cout << endl;
 +
    cout << "Enter 5 to do the approximation of the result function" << endl;  // пользователь сам выбирает, выполнять ли аппроксимацию;
 +
    cout << "Otherwise enter 6 to quit" << endl;
 +
    cin >> a;
 +
    if (a==5)
 +
    {cout << "Appromaximation:" << endl;
 +
    F.App();}  // аппроксимация
 +
    return 0;
 
}
 
}
  
//Оператор присваивания
+
</syntaxhighlight>
const fun& fun::operator=(const fun& right)
+
</div>
 +
 
 +
<div class="mw-collapsible mw-collapsed" style="width:100%" >
 +
'''[[Савельева Ольга]]'''
 +
 +
'''Краткое описание алгоритма :''' Программа создаёт и хранит значения двух функций с одинаковом шагом и заданных на одинаковом интервале. Методы позволяют сложить эти две функции,интерполировать одну из них по заданному шагу или апроксимировать методом наименьших квадратов. Данные берутся из файла. При считывании с файла сначала указывается отрезок, потом величина, а потом дискретные значения.
 +
<div class="mw-collapsible-content">
 +
<syntaxhighlight lang="cpp" line start="1" enclose="div">
 +
#include <stdio.h>
 +
#include <stdlib.h>
 +
//Бибилотека необходимая для возможности включения русского языка в консоли
 +
#include <locale.h>
 +
 
 +
class fun
 
{
 
{
//Проверка на самоприсваивание
+
/*
if (this == &right)
+
fx - массив с дискретными значениями функции
//Возвращение в качестве результата текущий объект
+
a - начало отрезка определения функции
return *this;
+
b - конец отрезка определения функции
 +
dx - шаг
 +
*/
 +
double *fx, a, b, dx;
 +
//Чтобы очусть ошибки округления в вещественных числах при сравнениях используется константа eps.
 +
//К примеру два вещественных числа x и y сравниваются не так x>=y, а так x-y>=-eps.
 +
const double eps = 1e-10; //1e-10 это тоже самое что 0.0000000001
  
 +
public:
 +
//Коструктор по умолчанию
 +
fun();
 +
//Конструктор копирования
 +
fun(fun &tmp);
 +
//Деструктор
 +
~fun();
  
int i, n;
+
//Перегруженные операторы. Ключевое слово const в конце означает, что объект от которого вызвается метод не изменяется
//Присваивание свойств объекта right текущему объекту
+
const fun operator+(const fun& right) const;
a = right.a;
+
const fun operator-(const fun& right) const;
b = right.b;
+
const fun operator*(const fun& right) const;
dx = right.dx;
+
const fun operator/(const fun& right) const;
//Вычисление количества дискретных значений
+
const fun& operator=(const fun& right);
n = (b - a) / dx + 1;
+
 
//Если в текущем объекте есть какие-то дискретные значения, то их нужно удалить. То есть удалить память выделенную под них
+
//Метод считывания из файла
if (fx != NULL) delete[] fx;
+
void readFile(const char *path);
//Выделение необходимой памяти для хранения дискретных значений
+
//Метод вывода в файл
fx = new double[n];
+
void writeFile(const char *path);
  
//Копирование дискретных значений объекта right в текущий объект
+
//Метод изменения шага
for (i = 0; i<n; ++i)
+
void changeDx(double newDx);
fx[i] = right.fx[i];
+
//Метод вычисления значения в заданной точке
 +
double getX(double x1);
 +
};
  
//Возвращение в качестве результата текущий объект
+
//В конструкторе по умолчанию все просто.
return *this;
+
fun::fun()
 +
{
 +
a = b = dx = 0;
 +
fx = NULL;
 
}
 
}
  
/*
+
//Конструктор копирования
Метод считывания из файла
+
fun::fun(fun &tmp)
path - путь к файлу из которого считывать
 
*/
 
 
 
void fun::readFile(const char *path)
 
 
{
 
{
//Открытие файла для считывания
 
FILE *in = fopen(path, "r");
 
 
int i, n;
 
int i, n;
//Считывание границ отрезка и шага из файла
+
//Копирование свойств объекта tmp в текущий объект
fscanf(in, "%lf%lf%lf", &a, &b, &dx);
+
a = tmp.a;
 +
b = tmp.b;
 +
dx = tmp.dx;
 
//Вычисление количества дискретных значений
 
//Вычисление количества дискретных значений
 
n = (b - a) / dx + 1;
 
n = (b - a) / dx + 1;
//Если в текущем объекте есть какие-то дискретные значения, то их нужно удалить. То есть удалить память выделенную под них
 
if (fx != NULL) delete[] fx;
 
 
//Выделение необходимой памяти для хранения дискретных значений
 
//Выделение необходимой памяти для хранения дискретных значений
 
fx = new double[n];
 
fx = new double[n];
//Считывание дискретных значений из файла
+
//Копирование дискретных значений объекта tmp в текущий объект
for (i = 0; i<n; ++i) fscanf(in, "%lf", &fx[i]);
+
for (i = 0; i<n; ++i)
//Закрытие файла
+
fx[i] = tmp.fx[i];
fclose(in);
 
 
}
 
}
  
/*
+
//Деструктор
Метод вывода в файл
+
fun::~fun()
path - путь к файлу в который нужно вывести
+
{
*/
+
//Освобождение памяти выделенной для массива дискретных значений
 
+
if (fx != NULL) delete[] fx;
void fun::writeFile(const char *path)
+
}
 +
//Оператор сложения.
 +
const fun fun::operator+(const fun& right) const
 
{
 
{
//Открытие файла для вывода
+
//Создание результирующего объекта
FILE *out = fopen(path, "w");
+
fun result;
 
int i, n;
 
int i, n;
double x = a;
+
//Копирование свойств в результирующий объект
 +
result.dx = dx;
 +
result.a = a;
 +
result.b = b;
 
//Вычисление количества дискретных значений
 
//Вычисление количества дискретных значений
 
n = (b - a) / dx + 1;
 
n = (b - a) / dx + 1;
//Вывод информации о отрезке и шаге в файл
+
//Выделение необходимой памяти для хранения дискретных значений
fprintf(out, "[%.5lf, %.5lf] dx=%.5lf\n", a, b, dx);
+
result.fx = new double[n];
//Последовательный вывод пары (точка, значение в точке) в файл
+
//Вычисление дискретных значений результирующего объекта
for (i = 0; i<n; ++i, x += dx)
+
for (i = 0; i<n; ++i)
fprintf(out, "x=%.5lf f(x)=%.5lf\n", x, fx[i]);
+
result.fx[i] = fx[i] + right.fx[i];
//Закрытие файла
+
 
fclose(out);
+
//Возвращение результата
 +
return result;
 
}
 
}
  
/*
+
//Этот оператор аналогичен оператору сложение
Метод изменения величины шага
+
const fun fun::operator-(const fun& right) const
*/
 
void fun::changeDx(double newDx)
 
 
{
 
{
int i, j, n, newN;
+
fun result;
double *newFx, x, newX, x1, y1, x2, y2, K, B;
+
int i, n;
//Вычисление количества старых дискретных значений
+
result.dx = dx;
 +
result.a = a;
 +
result.b = b;
 
n = (b - a) / dx + 1;
 
n = (b - a) / dx + 1;
//Вычисление количества новых дискретных значений
+
result.fx = new double[n];
newN = (b - a) / newDx + 1;
+
for (i = 0; i<n; ++i)
//Выделение памяти под новые дискретные значения
+
result.fx[i] = fx[i] - right.fx[i];
newFx = new double[newN];
+
 
//Определение первой точки в которой вычисляется новое дискретное значение
+
return result;
newX = a;
+
}
//Переменная которая бежит по старым дискретным значениям
+
 
i = 0;
+
//Этот оператор аналогичен оператору сложение
//Определение первой точки в которой вычисляется старое дискретное значение
+
const fun fun::operator*(const fun& right) const
x = a;
+
{
//Цикл для формирования новых дискретных значений
+
fun result;
for (j = 0; j<newN; ++j, newX += newDx)
+
int i, n;
{
+
result.dx = dx;
//В цикле находим отрезок где лежит точка в которой нужно вычислить новое дискретное значение
+
result.a = a;
for (; i<n - 1; ++i, x += dx)
+
result.b = b;
//Если без eps, то сравнения такие: x<=newX<=x+dx
+
n = (b - a) / dx + 1;
if ((newX - x>-eps) && ((x+dx) - newX>-eps))
+
result.fx = new double[n];
{
+
for (i = 0; i<n; ++i)
//Линейная интерполяция
+
result.fx[i] = fx[i] * right.fx[i];
x1 = x;
+
 
x2 = x + dx;
+
return result;
y1 = fx[i];
 
y2 = fx[i + 1];
 
K = (y2 - y1) / (x2 - x1);
 
B = (y2*x1 - y1*x2) / (x1 - x2);
 
//Вычисления значения в точке с помощью линейной интерполяции
 
newFx[j] = newX*K + B;
 
//Выход из цикла по i
 
break;
 
}
 
}
 
//Смена величины шага на новый
 
dx = newDx;
 
//Удаление старых дискретных значений
 
delete[] fx;
 
//Присвоение текущему объекту новых дискретных значений
 
fx = newFx;
 
 
}
 
}
  
/*
+
//Этот оператор аналогичен оператору сложение
Метод вычисляет значение в точке xAns с помощью линейной интерполяции.
+
const fun fun::operator/(const fun& right) const
*/
 
double fun::getX(double xAns)
 
 
{
 
{
 +
fun result;
 
int i, n;
 
int i, n;
double x, x1, y1, x2, y2, K, B;
+
result.dx = dx;
x = a;
+
result.a = a;
//Вычисление количества дискретных значений
+
result.b = b;
 
n = (b - a) / dx + 1;
 
n = (b - a) / dx + 1;
//Ищем отрезок в котором лежит точка xAns
+
result.fx = new double[n];
for (i = 0; i<n - 1; ++i, x += dx)
+
for (i = 0; i<n; ++i)
{
+
result.fx[i] = fx[i] / right.fx[i];
//Если без eps, то сравнения такие: x<=newX<=x+dx
+
 
if (((x+dx) - xAns>-eps) && (xAns - x>-eps))
+
return result;
{
 
//Линейная интерполяция
 
x1 = x;
 
x2 = x + dx;
 
y1 = fx[i];
 
y2 = fx[i + 1];
 
K = (y2 - y1) / (x2 - x1);
 
B = (y2*x1 - y1*x2) / (x1 - x2);
 
//Вычисления значения функции в заданной точке с помощью линейной интерполяции
 
return K*xAns + B;
 
}
 
}
 
 
}
 
}
  
int main()
+
//Оператор присваивания
 +
const fun& fun::operator=(const fun& right)
 
{
 
{
//Включение поддержки русского языка в консоли
+
//Проверка на самоприсваивание
setlocale(LC_ALL, "Russian");
+
if (this == &right)
//Объявление трех переменных типа fun
+
//Возвращение в качестве результата текущий объект
fun a, b, c;
+
return *this;
//Считывания первых дискретных значений из файла inputA.txt
+
 
a.readFile("inputA.txt");
 
//Считывания вторых дискретных значений из файла inputB.txt
 
b.readFile("inputB.txt");
 
  
//Первая функция
+
int i, n;
a.writeFile("outputA.txt");
+
//Присваивание свойств объекта right текущему объекту
//Вторая функция
+
a = right.a;
b.writeFile("outputB.txt");
+
b = right.b;
 +
dx = right.dx;
 +
//Вычисление количества дискретных значений
 +
n = (b - a) / dx + 1;
 +
//Если в текущем объекте есть какие-то дискретные значения, то их нужно удалить. То есть удалить память выделенную под них
 +
if (fx != NULL) delete[] fx;
 +
//Выделение необходимой памяти для хранения дискретных значений
 +
fx = new double[n];
  
c = a + b;
+
//Копирование дискретных значений объекта right в текущий объект
//Результат сложения двух функций
+
for (i = 0; i<n; ++i)
c.writeFile("outputAaddB.txt");
+
fx[i] = right.fx[i];
  
 +
//Возвращение в качестве результата текущий объект
 +
return *this;
 +
}
  
c = a - b;
+
/*
//Результат вычитания второй функции из первой
+
Метод считывания из файла
c.writeFile("outputAsubB.txt");
+
path - путь к файлу из которого считывать
 +
*/
  
c = a*b;
+
void fun::readFile(const char *path)
//Результат умножения двух функций
+
{
c.writeFile("outputAmultiB.txt");
+
//Открытие файла для считывания
 
+
FILE *in = fopen(path, "r");
c = a / b;
+
int i, n;
//Результат деления первой функции на вторую
+
//Считывание границ отрезка и шага из файла
c.writeFile("outputAdivB.txt");
+
fscanf(in, "%lf%lf%lf", &a, &b, &dx);
 
+
//Вычисление количества дискретных значений
//У первой функции изменили шаг на 0.5
+
n = (b - a) / dx + 1;
a.changeDx(0.5);
+
//Если в текущем объекте есть какие-то дискретные значения, то их нужно удалить. То есть удалить память выделенную под них
//Вывели её дискретные значения
+
if (fx != NULL) delete[] fx;
a.writeFile("outputChangeDx.txt");
+
//Выделение необходимой памяти для хранения дискретных значений
 
+
fx = new double[n];
//Функция, которая аппроксимирует её кусочно линейная.
+
//Считывание дискретных значений из файла
//Для примера нашли значение аппроксимируещей функции в точке не совпадающей с дискретными значениями.
+
for (i = 0; i<n; ++i) fscanf(in, "%lf", &fx[i]);
printf("Значение в точке 1.8 первой функции %.5lf\n", a.getX(1.8));
+