Редактирование: Информатика: Движение тела в среде

<div class="mw-collapsible mw-collapsed" style="width:100%" >
'''[[Лебедев Станислав]]''' 
'''Описание программы''': программа записывает в четыре файла результаты вычисления:
# Координаты, рассчитанные по формуле, при движении без сопротивления воздуха; 
# Координаты, полученные методом Верле при линейной зависимости силы сопротивлении воздуха от скорости;
# Координаты, полученные из точного решения, при линейной зависимости силы сопротивлении воздуха от скорости;
# Координаты, полученные методом Верле при квадратичной зависимости силы сопротивлении воздуха от скорости.
<br />
Скачать можно  [http://tm.spbstu.ru/Файл:Движение_тела.rar тут].
<br /><br />

<div class="mw-collapsible-content">


[[File:1.png]]
<br /><br />
'''Визуализированный результат работы программы'''
[[File:graph.png]]

# o1 - координаты, рассчитанные по формуле, при движении без сопротивления воздуха; 
# o2 - координаты, полученные методом Верле при линейной зависимости силы сопротивлении воздуха от скорости;
# o3 - координаты, полученные из точного решения, при линейной зависимости силы сопротивлении воздуха от скорости;
# o4 - координаты, полученные методом Верле при квадратичной зависимости силы сопротивлении воздуха от скорости.
<br />
Для тела с массой 10,сопротивлением воздуха 1, угол бросания 30°, начальная скорость 30 м/с, ускорение свободного падения 9.8 м/c^2;
<br />
''Примечание: графики o1 и o2 намеренно посчитаны с малой точностью, чтобы графики не сливались.''
<syntaxhighlight lang="cpp" line start="1" enclose="div">
#include <iostream>
#include <math.h>
#include "Vector.h"
#include <cstring>
#include <cmath>
#include <malloc.h>
#include <fstream>

#include <iostream>
#include <math.h>
#include "Vector.h"
#include <cstring>
#include <cmath>
#include <malloc.h>
#include <fstream>

using namespace std;

int n = 100;
ofstream outfile;

class Ball                                          //класс бросаемого тела
{
    private:
        double angle,m,k;                           //угол броска,масса,коэффицент сопротивления воздуха
        Vector3D r,v,a;                             //радиус-вектор,вектор скорости,ускорения
    public:

        //задание начальных параметров через угол,начальное положение,скорость и ускорение,с которым движется тело. Без сопротивления воздуха
        Ball(double _angle, Vector3D _r, Vector3D _v, Vector3D _a)
        {
            angle = _angle;
            r     = _r;
            v     = _v;
            a     = _a;
        }

         //задание начальных параметров через угол,начальное положение,скорость и ускорение,с которым движется тело. Без сопротивления воздуха
        Ball(double _angle, double _m, double _k, Vector3D _r, Vector3D _v, Vector3D _a)
        {
            angle = _angle;
            r     = _r;
            v     = _v;
            a     = _a;
            m     = _m;
            k     = _k;
        }

        //точная формула зависимости координаты от времени
        Vector3D positionReal(double t)
        {
            double c1 = m/k,c2 = fabs(a.y)*c1, c3 = exp(-t/c1), c4 = c2*t;
            return MakeVector(v.x*c1*(1 - c3), c1*(v.y + c2)*(1 - c3) - c4 , 0 );
        }

        //вывод положения на экран
        void writePosToScreen()
        {
            cout << r.x << "   " << r.y << "   " << r.z << endl;
        }

        //вывод положения в файл
        void writePosToFile(char s[])
        {
            outfile.open(s,ios :: app);
            outfile << r.x << "           " << r.y << endl;
            outfile.close();
        }

        //вывод произвольного вектора на экран
        void WVTS(Vector3D v)
        {
            cout.width(15);
            cout << v.x;
            cout.width(15);
            cout << v.y;
            cout.width(15);
            cout << v.z << endl;
        }

        //вывод произвольного вектора в файл
        void WVTF(Vector3D v,char s[])
        {
            outfile.open(s,ios :: app);
            outfile << v.x << "           " << v.y << endl;
            outfile.close();
        }

        //"пересчет" координаты по Верле(Линейная зависмость)
        void changeR(Vector3D r1, double dt)
        {
            r = MakeVector(2 * r.x -  r1.x - k/m*v.x*dt*dt,2*r.y - r1.y - (abs(a.y) + k/m*v.y)*dt*dt, 0 );
        }

        //"пересчет" координаты по Верле(Квадратичная зависимость)
        void changeRSQ(Vector3D r1, double dt)
        {
            r = MakeVector(2 * r.x -  r1.x - k/m*Length(v)*v.x*dt*dt,2*r.y - r1.y - (abs(a.y) + k/m*Length(v)*v.y)*dt*dt, 0 );
        }
        //пересчет скорости по Верле
        void changeV(Vector3D r1,double dt)
        {
            v =VS((VmV(r,r1)),1/(2*dt));
        }

        //рассчет предыдущегт к 0ому элементу
        Vector3D MR1(double dt)
        {
            return MakeVector(r.x - v.x * dt,r.y - v.y * dt,0);
        }

        //возращает координату тела
        Vector3D getR()
        {
            return r;
        }

        //рассчет времени полета
        double TimeOfFly()
        {
            return (2*Length(v)*sin(angle)/Length(a));
        }

        //рассчет координаты по точной формуле. без сопротивления воздуха.
        Vector3D position(double t)
        {
            return MakeVector(r.x + v.x*t + a.x*t*t/2,r.y + v.y*t + a.y*t*t/2,r.z + v.z*t + a.z*t*t/2);
        }

};

int main()
{
    //задание начальных параметров
    Vector3D g = {0,-9.8,0};
    double a,dt = 0;
    char s[20];

//    cin >> dt;

    dt = 0.1;
    a = (M_PI * 30)/180;
    Ball b1(a, MakeVector(0,0,0),MakeVector(30,a),g);

    double tof = b1.TimeOfFly()+1;   //единичка прибавлена,чтобы график красивым был

    //Без сопротивления возлуха
    strcpy(s,"");
    strcat(s, "o1.txt");
    outfile.open(s, ios :: trunc);
    outfile.close();
    for (double i = 0; i <= tof; i += dt)
    {
        b1.WVTS(b1.position(i));
        b1.WVTF(b1.position(i), s);
    }


    //Верле(Линейная зависимость)
    dt = 0.1;
    a = (M_PI * 30)/180;
    Ball b2(a,10 , 1, MakeVector(0,0,0),MakeVector(30,a),g);

    strcpy(s,"");
    strcat(s, "o2.txt");
    outfile.open(s,ios :: trunc);
    outfile.close();
    Vector3D r1 = b2.MR1(dt),rp;
    for (double i = 0; i <= 20; i += dt)
    {
        rp = b2.getR();
        b2.writePosToFile(s);
        b2.writePosToScreen();
        b2.changeR(r1,dt);
        b2.changeV(r1,dt);
        r1.x = rp.x;
        r1.y = rp.y;
    }

    //Точное решение (Линейная зависимость)
    dt = 0.1;
    a = (M_PI * 30)/180;
    Ball b3(a,10 , 1, MakeVector(0,0,0),MakeVector(30,a),g);

    strcpy(s,"");
    strcat(s, "o3.txt");
    outfile.open(s, ios :: trunc);
    outfile.close();
    for (double i = 0; i <= 20; i += dt)
    {
        b3.WVTS(b3.positionReal(i));
        b3.WVTF(b3.positionReal(i), s);
    }


    //Верле (Квадратичная зависимость)
    dt = 0.1;
    a = (M_PI * 30)/180;
    Ball b4(a,10 , 1, MakeVector(0,0,0),MakeVector(30,a),g);

    strcpy(s,"");
    strcat(s, "o4.txt");
    outfile.open(s, ios :: trunc);
    outfile.close();
    r1 = b4.MR1(dt);
    for (double i = 0; i <= 20; i += dt)
    {
        rp = b4.getR();
        b4.writePosToFile(s);
        b4.writePosToScreen();
        b4.changeRSQ(r1,dt);
        b4.changeV(r1,dt);
        r1.x = rp.x;
        r1.y = rp.y;
    }

    return 0;
}

</syntaxhighlight>
</div>

<div class="mw-collapsible mw-collapsed" style="width:100%" >
'''[[Белоусова Екатерина]]''' 
<br />
'''Описание программы''': пользователь вводит начальную скорость полета, угол бросания и шаг, с которым будут рассчитаны точки. 
<br />
Программа записывает в один файл результаты вычисления:
# Координаты, рассчитанные по формуле, при движении без сопротивления воздуха; 
# Координаты, полученные из точного решения, при линейной зависимости силы сопротивлении воздуха от скорости;
# Координаты, полученные методом Верле при квадратичной зависимости силы сопротивлении воздуха от скорости.
# Координаты, полученные методом Верле при линейной зависимости силы сопротивлении воздуха от скорости;
<br />
Скачать можно  [http://tm.spbstu.ru/Файл:задача_3.zip тут].
<br /><br />

<div class="mw-collapsible-content">

[[File:формулы.png]]
<br /><br />
'''Визуализированный результат работы программы'''
[[File:graph1.png]]

Для тела с массой 1 кг,сопротивлением воздуха 0.05, угол бросания 30°, начальная скорость 30 м/с, ускорение свободного падения 9.8 м/c^2, шаг 0.01;
<br />
# "Zapis.txt" using 1 : 2 - координаты, рассчитанные по формуле, при движении без сопротивления воздуха; 
# "Zapis.txt" using 3 : 4 - координаты, полученные из точного решения, при линейной зависимости силы сопротивлении воздуха от скорости;
# "Zapis.txt" using 5 : 6 - координаты, полученные методом Верле при квадратичной зависимости силы сопротивлении воздуха от скорости;
# "Zapis.txt" using 7 : 8 - координаты, полученные методом Верле при линейной зависимости силы сопротивлении воздуха от скорости.
<br />

<syntaxhighlight lang="cpp" line start="1" enclose="div">
#include <iostream>
#include <locale.h>
#include <math.h>
#include <fstream>
#include<iomanip>
#include <cmath>

using namespace std;

class fly ///создаем класс полета тела
{

private: ///объявляем тип переменных в привате
    double Vo, Agrad, Brad, time, step, amountdouble; ///Vo-начальная скорость тела; Agrad-угол, под которым летит тело, в градусах;
                                                      ///Brad-угол, под которым летит тело, в радианах; time-время полета тела; step-шаг;
                                                      ///amountdouble-количество точек (типа double)

public: ///объявляем переменные в паблике
    int amount; ///amoun-количество точек (типа int)

fly (double _step, double _Agrad, double _Vo):step(_step),Agrad(_Agrad),Vo(_Vo) ///создаем конструктор функции с объявлением переменных
{

    double g=9.8; ///объявляем тип и значение переменной g(ускорение свободного падения)
    Brad=3.14159*Agrad/180.0; ///переводим значение угла из градусов в радианы

    time=2*Vo*sin(Brad)/g; ///расчитываем время полета тела
    amountdouble=(round(time/step)+1); ///подсчитываем количество точек с заданым шагом
    amount=static_cast<int>(amountdouble); ///преобразуем количество из типа double к типу int

}
void zapis (char Zapis[]) ///создаем функцию записи
{
    double g=9.8, m=1, n=0.05; ///объявляем тип и значения переменных g (ускорение свободного падения), m (масса тела), n(коэффициэнт сопротивления)
    double Xb, Yb; ///объявляем тип переменных для полёта тела без сопротивления ветра Xb(координата тела по Х), Yb(координата тела по У)
    double V=Vo, Vxv=Vo*cos(Brad), Vyv=Vo*sin(Brad), Xo=0, Yo=0, Xv=0, Yv=0, Y_1=Yo-Vo*sin(Brad)*step, X_1=Xo-Vo*cos(Brad)*step, Y=0, X=0;
           ///объявляем тип переменных для метода ВерлеI V (скорость тела по модулю), Vxv (составляющая скорости по Х),
           ///Vyv (составляющая скорости по У), Xo (начальное положение тела на оси Х), Yo (начальное положение тела на оси У),
           ///Xv (координата тела на оси Х), Yv (координата тела на оси У), Y_1 (координата тела на (n-1)ом шаге на оси У),
           ///X_1 (координата тела на (n-1)ом шаге на оси Х), Y (координата тела на n-ом шаге на оси У),
           ///X (координата тела на n-ом шаге на оси Х);
    double Vxv2=Vo*cos(Brad), Vyv2=Vo*sin(Brad), Xo2=0, Yo2=0, Xv2=0, Yv2=0, Y_12=Yo2-Vo*sin(Brad)*step, X_12=Xo-Vo*cos(Brad)*step, Y2=0, X2=0;
           ///объявляем тип переменных для метода ВерлеII V (скорость тела по модулю), Vxv (составляющая скорости по Х),
           ///Vyv (составляющая скорости по У), Xo (начальное положение тела на оси Х), Yo (начальное положение тела на оси У),
           ///Xv (координата тела на оси Х), Yv (координата тела на оси У), Y_1 (координата тела на (n-1)ом шаге на оси У),
           ///X_1 (координата тела на (n-1)ом шаге на оси Х), Y (координата тела на n-ом шаге на оси У),
           ///X (координата тела на n-ом шаге на оси Х);
    double Yt=0, Xt=0, Yot=0, Xot=0, Voxt=Vo*cos(Brad), Voyt=Vo*sin(Brad);

    ofstream outfile("Zapis.txt"); ///запись элементов функции в фаил "Zapis.txt"
    outfile<<setw(20)<<"Xb"<<setw(20)<<"Yb"<<setw(20)<<"Xt"<<setw(20)<<"Yt"<<setw(20)<<"Xv"<<setw(20)<<"Yv"<<setw(20)<<"Xv2"<<setw(20)<<"Yv2"<<" \n"; ///вывод на экран по столбцам
                                                                                  ///X (координата тела на оси Х без ветра),
                                                                                  ///Y (координата тела на оси У без ветра),
                                                                                  ///Xv (координата тела на оси Х с ветром для метода Верле),
                                                                                  ///Yv (координата тела на оси У с ветром для метода Верле)
                                                                                  ///setw() размер столбиков

    for (int l=0; Yb>=0; ++l) ///создаем цикл от 0 до тех пор пока У больше нуля
    {
        outfile<<setw(20)<<Xb<<setw(20)<<Yb<<setw(20)<<Xt<<setw(20)<<Yt<<setw(20)<<Xv<<setw(20)<<Yv<<setw(20)<<Xv2<<setw(20)<<Yv2<<" \n";
            ///вывод на экран по столбцам Xv, Yv;

        ///полёт без ветра
        Xb=Vo*cos(Brad)*l*step;
        Yb=Vo*sin(Brad)*l*step-(9.8*l*step*l*step*0.5);

        ///точный метод
        Xt=Xot+(m/n)*Voxt*(1.0 - exp((-n*l*step)/m));
        Yt=Yot+(m/n)*(Voyt+g*(m/n))*(1.0 - exp((-n*l*step)/m))-g*l*step*(m/n);

        ///метод Верле I
        Xv=2*X-X_1-(n/m)*V*Vxv*step*step; ///расчитываем координату Х в момент времени t для метода Верле
        Yv=2*Y-Y_1-(g+(n/m)*V*Vyv)*step*step; ///расчитываем координату У в момент времени t для метода Верле
        Vxv=(Xv-X_1)/(2.0*step); ///расчитываем скорость тела по оси Х в момент времени t для метода Верле
        Vyv=(Yv-Y_1)/(2.0*step); ///расчитываем скорость тела по оси У в момент времени t для метода Верле
        V=sqrt(Vxv*Vxv+Vyv*Vyv); ///рассчитываем скорость тела по модулю
        X_1=X; ///присваиваем значению координаты Х на (n-1)ом шаге значение координаты Х на n-ом шаге
        X=Xv;  ///присваиваем значению координаты Х на n-ом шаге значение координаты Х
        Y_1=Y; ///присваиваем значению координаты У на (n-1)ом шаге значение координаты У на n-ом шаге
        Y=Yv;  ///присваиваем значению координаты У на n-ом шаге значение координаты У

        ///метод Верле II
        Xv2=2*X2-X_12-(n/m)*Vxv2*step*step; ///расчитываем координату Х в момент времени t для метода Верле
        Yv2=2*Y2-Y_12-(g+(n/m)*Vyv2)*step*step; ///расчитываем координату У в момент времени t для метода Верле
        Vxv2=(Xv2-X_12)/(2.0*step); ///расчитываем скорость тела по оси Х в момент времени t для метода Верле
        Vyv2=(Yv2-Y_12)/(2.0*step); ///расчитываем скорость тела по оси У в момент времени t для метода Верле
        X_12=X2; ///присваиваем значению координаты Х на (n-1)ом шаге значение координаты Х на n-ом шаге
        X2=Xv2;  ///присваиваем значению координаты Х на n-ом шаге значение координаты Х
        Y_12=Y2; ///присваиваем значению координаты У на (n-1)ом шаге значение координаты У на n-ом шаге
        Y2=Yv2;  ///присваиваем значению координаты У на n-ом шаге значение координаты У

    }

    outfile.close();

}

};

int main()
{

    setlocale(LC_ALL,"RUS"); ///функция, позволяющая с++ распознавать русский язык

    double Vo, Agrad, Brad, time, step; ///объявляем тип переменных Vo (начальная скорость тела), Agrad (угол, под которым летит тело, в градусах);
                                        ///Brad (угол, под которым летит тело, в радианах); time (время полета тела); step (шаг)
    cout<<"Задайте начальную скорость тела в м/с: Vo="; ///на экран выводится сообщение с просьюой задать начальную скорость тела
    cin>>Vo; ///пользователь вводит начальную скорость тела
    cout<<'\n'<<"Задайте в градусах угол, под которым брошено тело (угол должен принимать значения от 0 до 90): a=";
                                                        ///на экран выводится сообщение с просьбой задать угол, под которым летит тело, в градусах
    cin>>Agrad; ///пользователь вводит угол, под которым летит тело
    cout<<'\n'<<"Задайте шаг (шаг должен быть очень маленьким): шаг="; ///на экран выводится сообщение с просьбой ввести шаг
    cin>>step; ///пользователь вводит шаг

    fly X(step,Agrad,Vo); ///объявление коструктора, создание функции Х, зависящей от step,Agrad,Vo
    X.zapis("координаты.txt"); ///запись элементов функции в файл

    return 0; ///конец программы

}


</syntaxhighlight>
</div>


<div class="mw-collapsible mw-collapsed" style="width:100%" >
'''[[Васильева Анастасия]]''' 
<br />
'''Описание программы''': пользователь вводит начальную скорость полета, угол бросания и шаг, с которым будут рассчитаны точки. 
<br />
Программа записывает в один файл результаты вычисления:
# Координаты, рассчитанные по формуле, при движении без сопротивления воздуха; 
# Координаты, полученные при численном интегрировании - метод Эйлера;
# Координаты, полученные методом Верле при квадратичной зависимости силы сопротивлении воздуха от скорости.
# Координаты, полученные из точного решения, при линейной зависимости силы сопротивлении воздуха от скорости;
<br />
Скачать можно  [http://tm.spbstu.ru/Файл:fly.zip тут].
<br /><br />

<div class="mw-collapsible-content">

<br /><br />
'''Визуализированный результат работы программы'''
[[File:graphick.png]]

Для тела с массой 0.5 кг,сопротивлением воздуха 0.1, угол бросания 30°, начальная скорость 30 м/с, ускорение свободного падения 9.8 м/c^2, шаг 0.001;
<br />
# "output.txt" using 1 : 2 - координаты, рассчитанные по формуле, при движении без сопротивления воздуха; 
# "output.txt" using 3 : 4 - координаты, полученные из точного решения, при линейной зависимости силы сопротивлении воздуха от скорости (численное интегрирование - метод Эйлера);
# "output.txt" using 5 : 6 - координаты, полученные методом Верле при квадратичной зависимости силы сопротивлении воздуха от скорости;
# "output.txt" using 7 : 8 - координаты, полученные методом Верле при линейной зависимости силы сопротивлении воздуха от скорости.
<br />

<syntaxhighlight lang="cpp" line start="1" enclose="div">

#include <iostream>
#include <fstream>
#include <iomanip>
#include <time.h>
#include <conio.h>
#include <stdlib.h>
#include <math.h>
#include <cstring>
using namespace std;

class pad ///создаем класс
{
private: ///в закрытом доступе
    double *X, *Y, *E, *G, *Z, *S, *V, *U; ///координаты по х и у; *E, *G : численное интегрирование метод Эйлера, *Z, *S- метод верле, *V, *U- точный метод
    double a, g , pi;///ускорение, коэфф свободного падения, значение числа пи
    int Size; ///размер массива- сколько точек считать в первом способе
    double v, shag, b, vx, vy;///скорость, шаг по времени, угол в градусах скорость по х, скорость по у

    void SetX() ///создаем функцию для вычисления значенй по х для простого падения и по эйлеру
    {
        g = 9.8;///коэфф свободного падения
        float t = 0; ///время
        X = new double [Size];///создаем массив для координат по х для простого падения
        E = new double [Size];///создаем массив для координат по х для интегрирования по эйлеру
        X[0] = 0; ///задаем значение по х в нуле
        E[0] = 0 ; ///задаем значение по х в нуле по эйлеру
        for (int i = 1; i < Size; i++) ///задаем цикл от 1 (для нуля мы задали), чтобы считать координаты
        {
            t += shag; ///каждый раз прибавляем по времени шаг
            X[i] = v * cos(a) * t; ///координаты по х для простого падения
            E[i] = E[i-1] + v * cos(a) * shag; ///х из интегрирования по эйлеру
        }
    }

    void SetY()///создаем функцию для вычисления значенй по у для простого падения и по эйлеру
    {
        g = 9.8; ///коэфф свободного падения
        double Vy; /// переменная для значение скорости по у для метода эйлера
        float t = 0; ///время
        Y = new double [Size];///создаем массив для координат по у для простого падения
        G = new double [Size];///создаем массив для координат по х для интегрирования по эйлеру
        Vy = v * sin (a);/// значение скорости по у для метода эйлера
        Y[0] = 0;///задаем значение по у в нуле
        G[0] = 0;///задаем значение по у в нуле по эйлеру
        for (int i = 1; i < Size; i++)///задаем цикл от 1 (для нуля мы задали), чтобы считать координаты
        {
            t += shag; ///каждый раз прибавляем по времени шаг
            Y[i] = v * sin (a) *t - (g * t * t) * 0.5; ///координаты по у для простого падения
            Vy -= g * shag; ///значение скорости по у для метода эйлера
            G[i] = G[i-1] + Vy  * shag;///у из интегрирования по эйлеру
        }
    }

    void SetVerle() ///функция для метода верле
    {
        double k = 0.1, m = 0.5; ///коэфф сопротивления водуха, масса тела
        g = 9.8; /// коэфф свободного падения
        uint32_t Size1 = 1000000.0; ///размер массива
        S = new double [Size1]; ///создаем массив для значений по х для метода верле
        Z = new double [Size1]; ///создаем массив для значений по у для метода верле
        vx = v * cos(a); ///формулы для вычисления скорости по оси х
        vy = v * sin(a); ///формулы для вычисления скорости по оси у
        S[1] = 0; ///значение х метод верле
        S[0] = -vx * shag; ///значение в нуле
        Z[1] = 0; ///значение у метод верле
        Z[0] = -vy * shag; ///значение в нуле
        for (int i = 0; i < Size1-2; i++) ///задаем цикл
        {
            S[i+2] = 2.0 * S[i+1] - S[i] - (k / m) * v * vx * shag * shag;///значения по х для верле
            vx = 0.5 * ( 1.0 / shag )* ( S[i+2] - S[i]);///считаем значения скорости по оси х
            Z[i+2] = 2.0 * Z[i+1] - Z[i] - ( g + (k / m) * v * vy ) * shag * shag;///значения по х для верле
            vy = 0.5 * ( 1.0 / shag )* ( Z[i+2] - Z[i]);///считаем значения скорости по оси х
            v = sqrt (vx * vx + vy * vy); ///модуль общей скорости
        }
    }
    void SetVerleLast() ///функция для точного метода верле
    {
        double k = 0.1, m = 0.5;///коэфф сопротивления водуха, масса тела
        g = 9.8; /// коэфф свободного падения
        uint32_t Size2 = 1000000.0; ///размер массива
        float t = 0; ///время
        V = new double [Size2]; ///создаем массив для значений по х для точного метода верле
        U = new double [Size2]; ///создаем массив для значений по у для точного метода верле
        vx = v * cos(a); ///формулы для вычисления скорости по оси х
        vy = v * sin(a); ///формулы для вычисления скорости по оси у
        ///double e = 2.7 ;///значение экспоненты
        V[0] = 0; ///значение х точный метод верле
        U[0] = 0; ///значение у точный метод верле
        for (int i = 1; i < Size2; i++)
        {
            t += shag; ///увеличиваем время на шаг
            V[i] = vx * (m / k) * (1.0 - exp(((-k) / m) * t)); ///значения по х для точного верле
            U[i] = (m / k) * (vy +  g * (m / k)) * (1.0 -  (exp(((-k) / m) * t))) - g * t * (m / k);///значения по х для точного верле
        }
    }

public: ///в открытом
    pad()
    {
        X = 0; ///зануляем значения
        Y = 0;
        Size = 0;
        v = 0;
        shag = 0;
        b = 0;
    }
    pad(double _v, double _shag, double _b) ///конструктор с параметрами
    {
        pi = M_PI; ///значение числа пи
        g = 9.8; ///коэфф свободного падения
        v = _v;/// присваиваем значения переменных значению параметров в конструкторе
        shag = _shag;
        b = _b;
        a = (pi * b) / 180.0 ; ///вычисляем значение угла в радианах
        double t = (2.0 * v * sin(a)) / g; /// считаем значение времени
        Size = abs( t / shag )+1;///ищем значение размера массива
        SetX(); ///вызываем функции зависящие от параметров конструктора
        SetY();
        SetVerle();
        SetVerleLast();
    }

    void FilePrint() ///функция записи в файл
    {
        ofstream fout("output.txt"); ///открываем файл уже созданный в папке с программой
        fout << "X:    " << "    Y:    " << "    E:   " << "   G:  " << "   S:  " << "   Z:  "<< "   V:   "<< "    U:    "<<"\n" ; ///выводим стоку с разными названиями массивов, соотв. координатам по х и у различных методов
        for (int i = 0; i < Size; i++) ///цикл
        fout << X[i] << "     " << Y[i] << "     " << E[i] << "    "  << G[i] << "   " << S[i] << "   " << Z[i] << "   " << V[i] <<"    "<< U[i] <<"\n"; ///забивает сами значения массивов
        fout.close();///закрываем файл
    };
};

int main()/// основная функция
{
    double shag, b, v; ///шаг, угол в градусах, скорость начальная
    cout << "vvedite v "; ///просим пользователя ввести значение скорости начальной
    cin >> v; ///считываем начальную скорость
    cout << "vvedite ygol ";///просим пользователя ввести угол в градусах
    cin >> b;/// считываем угол
    cout << "vvedite shag ";///просим пользователя ввести шаг по времени
    cin >> shag; ///считываем значение шага
    pad F1(v, shag, b); ///объявление коструктора, создание функции F1 с переменными v, shag, b
    F1.FilePrint(); ///вызываем функцию для записи файла
}
</syntaxhighlight>
</div>


<div class="mw-collapsible mw-collapsed" style="width:100%" >
'''[[Андреева Полина]]''' 

'''Краткое описание алгоритма''': в классе находятся координаты по формулам и записываются в файл.

''' Инструкция ''': 
Пользователь должен ввести начальную скорость, угол и шаг, с которым будут рассчитываться координаты. В файл координаты записываются в таком порядке: 1, 2 столбики - Координаты, рассчитанные по формуле, при движении без сопротивления воздуха; 3, 4 - Координаты, полученные методом Верле при линейной зависимости силы сопротивлении воздуха от скорости; 5,6 - Координаты, полученные из точного решения, при линейной зависимости силы сопротивлении воздуха от скорости; 7,8 - Координаты, полученные из точного решения, при линейной зависимости силы сопротивлении воздуха от скорости. 

Скачать можно  [http://tm.spbstu.ru/File:ТраекторияАнПол.rar тут].

<div class="mw-collapsible-content">
<syntaxhighlight lang="cpp" line start="1" enclose="div">

</syntaxhighlight>
</div>

<br/>

<div class="mw-collapsible mw-collapsed" style="width:100%" >
'''[[Иванова Яна]]'''
<br/>
'''Описание программы''': в программе выполняются четыре метода подсчета координат тела, брошенного под углом к горизонту. Координаты записываются в файл, строятся четыре графика, иллюстрирующие поведение тела при полете. Код написан для определенных начальных условий (для примера), если Вы хотите выполнить расчет для другой конфигурации, внесите изменения в начальные данные программы в самом коде.
Начальная скорость: 40 м/с, угол бросания: 45 градусов, коэффициент сопротивления воздуха: 0.023, шаг по времени : 0.1 секунды.
<br/>
Скачать программу можно [http://tm.spbstu.ru/File:main.zip здесь]
<br/>
<div class="mw-collapsible-content">
'''Визуализированный результат работы программы'''[[File:graph.png]]
<br/>
 [[:File:graph.png]]
<br />
<syntaxhighlight lang="cpp" line start="1" enclose="div">
#include <iostream>
#include <math.h>
#include <iomanip>
#include <fstream>
#include <conio.h>


using namespace std;

ofstream outfile;

double perevod (double angle) //перевод из градусов в радианы
{
    return (angle * M_PI / 180 );
}


int main()
{
    //объявление переменных и задание начальных значений
    double X, Xnext, Xprev, Y, Ynext, Yprev, Vx, Vy, V,
    m = 1 , dt = 0.1 , g = 9.8,t = 0,
    ugol = 45, alpha, R = 0.023, Xo = 0, Yo = 0, Vo = 40;

    alpha = perevod (ugol);

    //точное решение для случая движения без сопротивления воздуха
    Y = Yo;
    X = Xo;

    outfile.open("1.txt");

    while (Y >= Yo)
    {
        X = Xo + Vo * cos(alpha) * t;
        Vx = Vo * cos(alpha);
        Y = Yo + Vo * sin(alpha) * t  - 0.5 * g * t * t;
        Vy = Vo * sin(alpha) - g * t;
        t += dt;

        outfile << X << ' ' << Y << endl;
    }
    outfile.close();

    //начальные условия для квадратичной зависимости (метод Верле)
    Yprev = Yo - Vo*sin(alpha)*dt;
    Xprev = Xo - Vo*cos(alpha)*dt;
    X = Xo;
    Y = Yo;
    V = Vo;
    Vx = Vo * cos(alpha);
    Vy = Vo * sin(alpha);

    outfile.open("2.txt");

    while (Y >= Yo)
    {
        Xnext = 2.0 * X - Xprev - (R / m) * V * Vx * (dt * dt);
        Vx = ( Xnext - Xprev )/ (2.0 * dt);
        Ynext = 2.0 * Y - Yprev - (g + (R / m) * V * Vy) * (dt * dt);
        Vy =  (Ynext - Yprev)/ (2.0 * dt);
        V = sqrt(Vy*Vy + Vx*Vx );
        outfile << X << ' ' << Y << endl;

        Xprev = X;
        X = Xnext;
        Yprev = Y;
        Y = Ynext;
    }
    outfile.close();

    //начальные условия для линейной зависимости (метод Верле)
    Yprev = Yo - Vo*sin(alpha)*dt;
    Xprev = Xo - Vo*cos(alpha)*dt;
    X = Xo;
    Y = Yo;
    V = Vo;
    Vx = Vo * cos(alpha);
    Vy = Vo * sin(alpha);

    outfile.open("3.txt");

    while (Y >= Yo)
    {
        Xnext = 2.0 * X - Xprev - (R / m) * Vx * (dt * dt);
        Vx = ( Xnext - Xprev )/ (2.0 * dt);
        Ynext = 2.0 * Y - Yprev - (g + (R / m) * Vy) * (dt * dt);
        Vy =  (Ynext - Yprev)/ (2.0 * dt);
        V = sqrt(Vy*Vy + Vx*Vx );
        outfile << X << ' ' << Y << endl;

        Xprev = X;
        X = Xnext;
        Yprev = Y;
        Y = Ynext;
    }
    outfile.close();

    //точное решения для линейной зависимости
    Y = Yo;
    X = Xo;
    t = 0;

    outfile.open("4.txt");

    while (Y >= Yo)
    {
        Vx = Vo * cos(alpha);
        Vy = Vo * sin(alpha);
        X = (m * Vx / R)* (1 - exp(-1 * R * t / m));
        Y = (m/R)*((Vy + g * m / R)*(1 - exp(-1 * R * t / m)) - g * t);
        t += dt;
        outfile << X << ' ' << Y << endl;
    }
    outfile.close();

    return 0;

}

</syntaxhighlight>
</div>


<div class="mw-collapsible mw-collapsed" style="width:100%" >
'''[[Уманский Александр]]''' 


<br />
'''Описание программы''': программа записывает в четыре файла результаты вычисления:
# Координаты, рассчитанные по формуле, при движении без сопротивления воздуха; 
# Координаты, полученные методом Верле при линейной зависимости силы сопротивлении воздуха от скорости;
# Координаты, полученные из точного решения, при линейной зависимости силы сопротивлении воздуха от скорости;
# Координаты, полученные методом Верле при квадратичной зависимости силы сопротивлении воздуха от скорости.

<br />

[[File:Methods.rar|Скачать архив]]

[[File:1.png]]

<div class="mw-collapsible-content">
<syntaxhighlight lang="cpp" line start="1" enclose="div">

</syntaxhighlight>
</div>

'''[[Лосева Татьяна ]]''' 
'''Описание:''' Пользователя попросят ввести начальную скорость,угол бросания,массу тела  и коэф.сопротивления воздуха,тогда программа запишет в 4 разных файла результаты следующих вычислений:
# Координаты, рассчитанные по формуле, при движении без сопротивления воздуха; 
# Координаты, полученные методом Верле при линейной зависимости силы сопротивлении воздуха от скорости;
# Координаты, полученные методом Верле при квадратичной зависимости силы сопротивлении воздуха от скорости.
# Координаты, полученные из точного решения, при линейной зависимости силы сопротивлении воздуха от скорости;

''Графики полученные при скорости =10 m/c;угле = 30 градусам;массе=10 кг;коэф.сопротивления=1;''

[[File:загружено (1).png]][[:File:загружено (1).png]]

<syntaxhighlight lang="cpp" line start="1" enclose="div">
#include<iostream>
using namespace std;
#define N 1
#define PI 3.14159265
#include <fstream>
#include<cmath>
double g=9.8;
double step=0.01;
#include<math.h>

void Func(double v,double r)//1.Координаты, рассчитанные по формуле, при движении без сопротивления воздуха;

{
	double x,y;
	
	ofstream fout;//открытие файла
		   fout.open("C:\\Users\\Light\\Desktop\\1.txt");//указываем путь записи
	cout<<"method1"<<endl;

	   for(double t=0.01;t<N;t=t+0.01)
		{
			y=v*t*sin(r*PI/ 180)-g*t*t/2;//координата y
			x=v*t*cos(r*PI / 180);//координата х
			  
				fout<<x<<"   ";//запись в файл х
				cout<<"X="<<x<<endl;//вывод на экран
			    fout<<y<<"    ";//запись в файл 
				cout<<"Y="<<y<<endl<<endl;//вывод на экран
				fout<<endl;
		   }
}
		   
void Verle1( double n,double m ,double v0,double r)//Координаты, полученные методом Верле при линейной зависимости силы сопротивлении воздуха от скорости;

{ 
	double x,y,x0=0,y0=0,xn_1,yn_1;//x0,y0=Xn,Yn начальные значения;xn_1=X(n-1);yn_1=Y(n-1);

	double vx=v0*cos(r*PI / 180);//рассчитваем Vn для первого случая n=0 для x
   double vy=v0*sin(r*PI/ 180)-g*step;//рассчитваем Vn для первого случая n=0 для y

   xn_1=x0-vx*step;//X(n-1) для первого случая n=0
   yn_1=y0-vy*step;//Y(n-1) для первого случая n=0
   ofstream fout;//открытие файла
 fout.open("C:\\Users\\Light\\Desktop\\2.txt");//путь записи в файл
	cout<<"Verle1"<<endl<<endl;
	for(double t=0.02;t<N;t=t+step)
	{
		x=2*x0-xn_1-(n*vx*step*step)/m;//считаем Хn+1
		vx=(x-xn_1)/(2*step);
        xn_1=x0;//для следущего шага Xn-1=Xn
        x0=x;//для следущего шага Xn=Xn+1
		
		y=2*y0-yn_1-(g+(n*vy)/m)*step*step;//Yn+1
		vy=(y-yn_1)/(2*0.01);//скорость 
		yn_1=y0;//для следущего шага Yn-1=Yn
		y0=y;//для следущего шага Yn=Yn+1
     	cout<<"X="<<x<<endl;
		cout<<"Y="<<y<<endl<<endl;
    	fout<<x<<" ";
		fout<<y<<"  ";
		fout<<endl; 
		

	}
}

	void Verle2( double n,double m ,double v0,double r)//3.Координаты, полученные методом Верле при квадратичной зависимости силы сопротивлении воздуха от скорости.

{ 
	double x,y,x0=0,y0=0,xn_1,yn_1,v;//x0,y0=Xn,Yn начальные значения;xn_1=X(n-1);yn_1=Y(n-1);

	double vx=v0*cos(r*PI / 180);//рассчитваем Vn для первого случая n=0 для x
   double vy=v0*sin(r*PI/ 180)-g*step;//рассчитваем Vn для первого случая n=0 для y

   xn_1=x0-vx*step;//X(n-1) для первого случая n=0
   yn_1=y0-vy*step;//Y(n-1) для первого случая n=0
   ofstream fout;//открытие файла
  fout.open("C:\\Users\\Light\\Desktop\\3.txt");//путь записи
		cout<<"Verle2"<<endl<<endl;
	for(double t=0.02;t<N;t=t+step)
	{

	   v=sqrt(vx*vx+vy*vy);//скорость V

		x=2*x0-xn_1-(n*v*vx*step*step)/m;//Xn+1
		vx=(x-xn_1)/(2*step);//скорость Vx
        xn_1=x0;//для следущего шага Xn-1=Xn
		x0=x;//для следущего шага Xn=Xn+1
		
		y=2*y0-yn_1-(g+(n*vy*v)/m)*step*step;//Yn+1
		vy=(y-yn_1)/(2*0.01);//скорость Vy
		yn_1=y0;//для следущего шага Yn-1=Yn
		y0=y;//для следущего шага Yn=Yn+1
		cout<<"X="<<x<<endl;
		cout<<"Y="<<y<<endl<<endl;
		fout<<x<<" ";
		fout<<y<<"  ";
		fout<<endl; 
	}
	
}

void method4(double n,double m ,double v0,double r)//Координаты, полученные из точного решения, при линейной зависимости силы сопротивлении воздуха от скорости;
{
	double x,y,x0=0,y0=0;//x0,y0 начальные значения;

 double vx=v0*cos(r*PI / 180);//рассчитваем Vx 
  double vy=v0*sin(r*PI/ 180)-g*step;//рассчитваем Vy
  
   ofstream fout;//открытие файла
  fout.open("C:\\Users\\Light\\Desktop\\4.txt");
	cout<<"4"<<endl<<endl;
	for(double t=0.01;t<N;t=t+step)
	{
		x=x0+m*vx*(1-(exp((-1*n)*t/m)))/n;//координата х
		
		y = y0+(m/n)*((vy + g * m / n)*(1 - exp(-1 * n * t / m))) - g * t*m/n;//координата у

		//вывод в файл  и на экран
     	cout<<"X="<<x<<endl;
		cout<<"Y="<<y<<endl<<endl;
		fout<<x<<" ";
		fout<<y<<" ";
		fout<<endl; 

	}
}
	   
int main(void)
{

	double v0,r,m,n;//v0-начальная скорость,r-угол в градусах,m-масса;n-коэф.сопротивления ветра

	cout<<"Enter  start speed:"<<endl;
	cin>>v0;
	cout<<"Enter angle less than 90 deg:"<<endl;
	cin>>r;
	cout<<"Enter mass:"<<endl;
	cin>>m;
	cout<<"Coefficient of resistance:"<<endl;
	cin>>n;
	
	Func(v0,r);
	Verle1(n,m,v0,r);
	Verle2(n,m,v0,r);
	method4(n,m,v0,r);



	int k;
	cin>>k;
		return 0;
}

</syntaxhighlight>
</div>




Скачать можно  [http://tm.spbstu.ru/Файл:Verle.rar  тут].