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

Материал из Department of Theoretical and Applied Mechanics
Перейти к: навигация, поиск
 
Строка 133: Строка 133:
 
</div>
 
</div>
  
 +
<div>
 +
 +
'''[[Бальцер Анастасия]]'''
 +
 +
'''Описание программы''' : программа записывает в четыре файла результаты вычисления:
 +
 +
Координаты, рассчитанные по формуле, при движении без сопротивления воздуха;
 +
Координаты, полученные методом Верле при линейной зависимости силы сопротивлении воздуха от скорости;
 +
Координаты, полученные из точного решения, при линейной зависимости силы сопротивлении воздуха от скорости;
 +
Координаты, полученные методом Верле при квадратичной зависимости силы сопротивлении воздуха от скорости.
 +
 +
Посмотреть программу можно [http://tm.spbstu.ru/File:falling.zip здесь]
 +
 +
</div>
  
 
<div class="mw-collapsible mw-collapsed" style="width:100%" >
 
<div class="mw-collapsible mw-collapsed" style="width:100%" >
Строка 286: Строка 300:
 
</div>
 
</div>
  
 +
<div class="mw-collapsible mw-collapsed" style="width:100%" >
 +
'''[[Васильева Анастасия]]'''
  
<div class="mw-collapsible mw-collapsed" style="width:100%" >
+
'''Описание программы''': пользователь вводит начальную скорость полета, угол падения и шаг, с которым будут рассчитаны точки.
'''[[Лебедев Станислав]]'''  
 
  
'''Описание программы''': программа записывает в четыре файла результаты вычисления:
+
Программа записывает в один файл результаты вычисления:
 
# Координаты, рассчитанные по формуле, при движении без сопротивления воздуха;  
 
# Координаты, рассчитанные по формуле, при движении без сопротивления воздуха;  
# Координаты, полученные методом Верле при линейной зависимости силы сопротивлении воздуха от скорости;
+
# Координаты, полученные при численном интегрировании - метод Эйлера;
 +
# Координаты, полученные методом Верле при квадратичной зависимости силы сопротивлении воздуха от скорости.
 
# Координаты, полученные из точного решения, при линейной зависимости силы сопротивлении воздуха от скорости;
 
# Координаты, полученные из точного решения, при линейной зависимости силы сопротивлении воздуха от скорости;
# Координаты, полученные методом Верле при квадратичной зависимости силы сопротивлении воздуха от скорости.
 
  
Скачать можно  [http://tm.spbstu.ru/Файл:Шарик.rar тут].
+
Скачать можно  [http://tm.spbstu.ru/Файл:fly.zip тут].
 +
 
  
 
<div class="mw-collapsible-content">
 
<div class="mw-collapsible-content">
 
[[File:1.png]]
 
  
  
 
'''Визуализированный результат работы программы'''
 
'''Визуализированный результат работы программы'''
[[File:graph.png]]
+
[[File:graphick.png]]
  
# o1 - координаты, рассчитанные по формуле, при движении без сопротивления воздуха;
+
Для тела с массой 0.5 кг,сопротивлением воздуха 0.1, угол бросания 30°, начальная скорость 30 м/с, ускорение свободного падения 9.8 м/c^2, шаг 0.001;
# o2 - координаты, полученные методом Верле при линейной зависимости силы сопротивлении воздуха от скорости;
 
# o3 - координаты, полученные из точного решения, при линейной зависимости силы сопротивлении воздуха от скорости;
 
# o4 - координаты, полученные методом Верле при квадратичной зависимости силы сопротивлении воздуха от скорости.
 
  
 +
# "output.txt" using 1 : 2 - координаты, рассчитанные по формуле, при движении без сопротивления воздуха;
 +
# "output.txt" using 3 : 4 - координаты, полученные из точного решения, при линейной зависимости силы сопротивлении воздуха от скорости (численное интегрирование - метод Эйлера);
 +
# "output.txt" using 5 : 6 - координаты, полученные методом Верле при квадратичной зависимости силы сопротивлении воздуха от скорости;
 +
# "output.txt" using 7 : 8 - координаты, полученные методом Верле при линейной зависимости силы сопротивлении воздуха от скорости.
  
Для тела с массой 10,сопротивлением воздуха 1, угол бросания 30°, начальная скорость 30 м/с, ускорение свободного падения 9.8 м/c^2;
 
  
''Примечание: графики o1 и o2 намеренно посчитаны с малой точностью, чтобы графики не сливались.''
+
<syntaxhighlight lang="cpp" line start="1" enclose="div">
  
Файл "'''main.cpp'''"
 
<syntaxhighlight lang="cpp" line start="1" enclose="div">
 
 
#include <iostream>
 
#include <iostream>
 +
#include <fstream>
 +
#include <iomanip>
 +
#include <time.h>
 +
#include <conio.h>
 +
#include <stdlib.h>
 
#include <math.h>
 
#include <math.h>
#include "Vector.h"
 
 
#include <cstring>
 
#include <cstring>
#include <cmath>
 
#include <malloc.h>
 
#include <fstream>
 
 
 
using namespace std;
 
using namespace std;
  
int n = 100;
+
class pad ///создаем класс
ofstream outfile;
 
 
 
class Ball                                          //класс бросаемого тела
 
 
{
 
{
    private:
+
private: ///в закрытом доступе
        double angle,m,k;                           //угол броска,масса,коэффицент сопротивления воздуха
+
    double *X, *Y, *E, *G, *Z, *S, *V, *U; ///координаты по х и у; *E, *G : численное интегрирование метод Эйлера, *Z, *S- метод верле, *V, *U- точный метод
        Vector3D r,v,a;                             //радиус-вектор,вектор скорости,ускорения
+
    double a, g , pi;///ускорение, коэфф свободного падения, значение числа пи
     public:
+
    int Size; ///размер массива- сколько точек считать в первом способе
 +
     double v, shag, b, vx, vy;///скорость, шаг по времени, угол в градусах скорость по х, скорость по у
  
        //задание начальных параметров через угол,начальное положение,скорость и ускорение,с которым движется тело. Без сопротивления воздуха
+
    void SetX() ///создаем функцию для вычисления значенй по х для простого падения и по эйлеру
         Ball(double _angle, Vector3D _r, Vector3D _v, Vector3D _a)
+
    {
 +
        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 (для нуля мы задали), чтобы считать координаты
 
         {
 
         {
             angle = _angle;
+
             t += shag; ///каждый раз прибавляем по времени шаг
             r    = _r;
+
             X[i] = v * cos(a) * t; ///координаты по х для простого падения
             v     = _v;
+
             E[i] = E[i-1] + v * cos(a) * shag; ///х из интегрирования по эйлеру
            a     = _a;
 
 
         }
 
         }
 +
    }
  
        //задание начальных параметров через угол,начальное положение,скорость и ускорение,с которым движется тело. Без сопротивления воздуха
+
    void SetY()///создаем функцию для вычисления значенй по у для простого падения и по эйлеру
         Ball(double _angle, double _m, double _k, Vector3D _r, Vector3D _v, Vector3D _a)
+
    {
 +
        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 (для нуля мы задали), чтобы считать координаты
 
         {
 
         {
             angle = _angle;
+
             t += shag; ///каждый раз прибавляем по времени шаг
             r    = _r;
+
             Y[i] = v * sin (a) *t - (g * t * t) * 0.5; ///координаты по у для простого падения
            v     = _v;
+
             Vy -= g * shag; ///значение скорости по у для метода эйлера
            a     = _a;
+
             G[i] = G[i-1] + Vy  * shag;///у из интегрирования по эйлеру
             m    = _m;
 
             k    = _k;
 
 
         }
 
         }
 +
    }
  
         //точная формула зависимости координаты от времени
+
    void SetVerle() ///функция для метода верле
         Vector3D positionReal(double t)
+
    {
 +
        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++) ///задаем цикл
 
         {
 
         {
             double c1 = m/k,c2 = fabs(a.y)*c1, c3 = exp(-t/c1), c4 = c2*t;
+
             S[i+2] = 2.0 * S[i+1] - S[i] - (k / m) * v * vx * shag * shag;///значения по х для верле
             return MakeVector(v.x*c1*(1 - c3), c1*(v.y + c2)*(1 - c3) - c4 , 0 );
+
            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() ///функция для точного метода верле
        void writePosToScreen()
+
    {
        {
+
        double k = 0.1, m = 0.5;///коэфф сопротивления водуха, масса тела
            cout << r.x << "  " << r.y << "  " << r.z << endl;
+
        g = 9.8; /// коэфф свободного падения
         }
+
        uint32_t Size2 = 1000000.0; ///размер массива
 
+
        float t = 0; ///время
         //вывод положения в файл
+
         V = new double [Size2]; ///создаем массив для значений по х для точного метода верле
         void writePosToFile(char s[])
+
        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++)
 
         {
 
         {
             outfile.open(s,ios :: app);
+
             t += shag; ///увеличиваем время на шаг
             outfile << r.x << "          " << r.y << endl;
+
             V[i] = vx * (m / k) * (1.0 - exp(((-k) / m) * t)); ///значения по х для точного верле
             outfile.close();
+
             U[i] = (m / k) * (vy +  g * (m / k)) * (1.0 -  (exp(((-k) / m) * t))) - g * t * (m / k);///значения по х для точного верле
 
         }
 
         }
 +
    }
  
         //вывод произвольного вектора на экран
+
public: ///в открытом
         void WVTS(Vector3D v)
+
    pad()
         {
+
    {
            cout.width(15);
+
         X = 0; ///зануляем значения
            cout << v.x;
+
         Y = 0;
            cout.width(15);
+
        Size = 0;
            cout << v.y;
+
        v = 0;
            cout.width(15);
+
        shag = 0;
            cout << v.z << endl;
+
        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() ///функция записи в файл
         void WVTF(Vector3D v,char s[])
+
    {
         {
+
         ofstream fout("output.txt"); ///открываем файл уже созданный в папке с программой
            outfile.open(s,ios :: app);
+
         fout << "X:    " << "    Y:    " << "    E:  " << "  G:  " << "  S:  " << "  Z:  "<< "  V:  "<< "    U:    "<<"\n" ; ///выводим стоку с разными названиями массивов, соотв. координатам по х и у различных методов
            outfile << v.x << "           " << v.y << endl;
+
        for (int i = 0; i < Size; i++) ///цикл
            outfile.close();
+
        fout << X[i] << "    " << Y[i] << "    " << E[i] << "    "  << G[i] << "  " << S[i] << "  " << Z[i] << "  " << V[i] <<"   "<< U[i] <<"\n"; ///забивает сами значения массивов
        }
+
        fout.close();///закрываем файл
 +
    };
 +
};
  
        //"пересчет" координаты по Верле(Линейная зависмость)
+
int main()/// основная функция
        void changeR(Vector3D r1, double dt)
+
{
        {
+
    double shag, b, v; ///шаг, угол в градусах, скорость начальная
            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 );
+
    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>
  
        //"пересчет" координаты по Верле(Квадратичная зависимость)
+
'''[[Гильманов Илья]]'''
        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);
+
#  Полет тела при линейной зависимости силы сопротивления воздуха от скорости, при котором координаты тела рассчитываются методом Верле;
        }
+
#  Полет тела при квадратичной зависимости силы сопротивлении воздуха от скорости, при котором координаты тела рассчитываются методом Верле;
 +
 
 +
Скачать можно [[http://mech.spbstu.ru/File:Движение_тела_в_среде.rar тут]]
 +
 
 +
<div class="mw-collapsible mw-collapsed" style="width:100%" >
 +
'''[[Демченко Артём]]'''
  
        //возращает координату тела
+
'''Описание программы''': программа записывает в четыре файла результаты вычисления:
        Vector3D getR()
+
# Координаты, рассчитанные по формуле, при движении без сопротивления воздуха;
        {
+
# Координаты, полученные методом Верле при линейной зависимости силы сопротивлении воздуха от скорости;
            return r;
+
# Координаты, полученные из точного решения, при линейной зависимости силы сопротивлении воздуха от скорости;
        }
+
# Координаты, полученные методом Верле при квадратичной зависимости силы сопротивлении воздуха от скорости.
  
        //рассчет времени полета
+
''' Инструкция ''':
        double TimeOfFly()
+
Пользователь вводит начальные данные ( массу, скорость, угол броска, шаг по времени и сопротивление воздуха). Выбираем режим работы программы, после этого в папке с программой создается файл, который требуется открыть программой gnuplot для просмотра графика, построенного на полученных координатах.
        {
 
            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);
 
        }
 
  
};
+
<div class="mw-collapsible-content">
 +
 
  
int main()
 
{
 
    //задание начальных параметров
 
    Vector3D g = {0,-9.8,0};
 
    double a,dt = 0;
 
    char s[20];
 
  
//    cin >> dt;
+
'''Визуализированный результат работы программы'''
  
    dt = 0.1;
+
[[:File:Throws.png]]
    a = (M_PI * 30)/180;
 
    Ball b1(a, MakeVector(0,0,0),MakeVector(30,a),g);
 
  
    double tof = b1.TimeOfFly()+1;  //единичка прибавлена,чтобы график красивым был
+
<syntaxhighlight lang="cpp" line start="1" enclose="div">
  
    //Без сопротивления возлуха
+
#include <iostream>
    strcpy(s,"");
+
#include <math.h>
    strcat(s, "o1.txt");
+
#include <iomanip>
    outfile.open(s, ios :: trunc);
+
#include <fstream>
    outfile.close();
+
#include <conio.h>
    for (double i = 0; i <= tof; i += dt)
+
#include <stdio.h>
    {
 
        b1.WVTS(b1.position(i));
 
        b1.WVTF(b1.position(i), s);
 
    }
 
  
  
    //Верле(Линейная зависимость)
+
using namespace std;
    dt = 0.1;
 
    a = (M_PI * 30)/180;
 
    Ball b2(a,10 , 1, MakeVector(0,0,0),MakeVector(30,a),g);
 
  
    strcpy(s,"");
+
double g = 9.8, Pi = 3.1415; // Задаем две глобальные переменные ускорения свободного падения и числа Pi
    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;
 
    }
 
  
    //Точное решение (Линейная зависимость)
+
int WoutR(double alpha, double dt, double t, double Yo, double Vo) // Функция, записывающая в файл Throws Without Resistance.txt координаты тела, которое движется без сопротивления
     dt = 0.1;
+
{
    a = (M_PI * 30)/180;
+
     FILE *Coord;
    Ball b3(a,10 , 1, MakeVector(0,0,0),MakeVector(30,a),g);
+
  Coord = fopen ("Throws Without Resistance.txt", "w");
 +
    double X = 0, Y = 0; // Координаты начала
  
    strcpy(s,"");
+
    while ( Y >= Yo) // Yo используем для того, чтобы цикл прекратился тогда, когда тело упадет
    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);
 
    }
 
  
 +
      X =  Vo*t*cos(alpha);
 +
      Y =  Vo*t*sin(alpha) - (g*t*t)*0.5;
 +
      t+= dt;
 +
    if (Y > Yo )
 +
        fprintf(Coord, "%.3lf \t %.3lf\n", X, Y);
 +
    else
 +
        fprintf(Coord, "%.3lf \t %.3lf\n", X, 0.000); // Используем такой else для того, чтобы не получить отрицательную координату
 +
    }
  
    //Верле (Квадратичная зависимость)
 
    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>
 
  
Файл "'''Vector.h'''"
+
int ExactForm(double alpha, double dt, double t, double Yo, double Vo, double R, double m) // Функция, записывающая в файл ExactForm.txt координаты тела, рассчитывающиеся по формлуе точного решения
<syntaxhighlight lang="cpp" line start="1" enclose="div">
+
{                                                                                          // для линейной зависимости
#ifndef VECTOR_H_INCLUDED
+
    FILE *Coord;
#define VECTOR_H_INCLUDED
+
  Coord = fopen ("ExactForm.txt", "w");
 +
    double X, Y = 0, Vx, Vy;
  
struct Vector3D
+
    while ( Y >= Yo) // Использование Yo аналогично использованию в прошлом пункте.
{
+
    {
  double x,y,z;
 
};
 
  
Vector3D VmV(Vector3D v1,Vector3D v2)               //векторное вычитание
+
      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*m)/R;
    Vector3D v = {v1.x - v2.x,v1.y - v2.y,v1.z - v2.z };
+
      Vx = Vo*cos(alpha);
    return v;
+
      Vy = Vo*sin(alpha);
};
+
      t+= dt;
Vector3D VpV(Vector3D v1,Vector3D v2)               //векторное сложение
+
    if (Y > Yo )
{
+
        fprintf(Coord, "%.3lf \t %.3lf\n", X, Y);
    Vector3D v = {v1.x + v2.x,v1.y + v2.y,v1.z + v2.z };
+
    else
    return v;
+
        fprintf(Coord, "%.3lf \t %.3lf\n", X, 0.000); // используется аналогично прошлому пункту
 +
      }
 
}
 
}
  
double VV(Vector3D v1,Vector3D v2)               //скалярное умножение
+
int VerleSq (double alpha, double dt, double t, double Yo, double Xo, double Vo, double R, double m) // Функция, записывающая в файл VerleSq.txt оординаты тела, рассчитывающиеся по формлуе Верле
{
+
{                                                                                                   // для Квадратичной зависимости сопротивления от скорости
  return (v1.x*v2.x + v1.y*v2.y + v1.z*v2.z);
+
    FILE *Coord;
}
+
  Coord = fopen ("VerleSq.txt", "w");
  
Vector3D VxV(Vector3D v1,Vector3D v2)               //векторное умножение
+
    double X, Xnext, Xprev, Y, Ynext, Yprev, Vx, Vy, V, Yop, Xop; // X, Y - текущие координаты; Xnext, Ynext - координаты следующего шага; Xprev, Yprev - координаты предыдущего шага.
{
+
                                                                  // Xop, Yop - вспомогательные координаты для (-1)-го шага
  Vector3D v = {v1.y*v2.z - v1.z*v2.y, v1.z*v2.x - v1.x*v2.z,v1.x*v2.y - v1.y*v2.x};
+
 
  return v;
+
    Yop = Yo - Vo*sin(alpha)*dt; // Сторки 62-79 используются для просчитывания (-1)-го шага, так как в точке 0;0 у нас нету предыдущего шага
}
+
    Xop = Xo - Vo*cos(alpha)*dt;
 +
    X = Xo;
 +
    Y = Yo;
 +
    Xnext = 2.0*X - Xop - (R/m)*Vo*Vo*cos(alpha)*(dt*dt);
 +
    Vx = (1.0/(2.0*dt))*(Xnext - Xop);
 +
    Ynext = 2.0*Y - Yop - (g +(R/m)*Vo*Vo*sin((alpha)))*(dt*dt);
 +
    Vy =  (1.0/(2.0*dt))*(Ynext - Yop);
 +
    V = sqrt((Vo*cos(alpha)*Vo*cos(alpha)) + (Vo*sin(alpha)*Vo*sin(alpha)));
  
bool Kol(Vector3D v1,Vector3D v2)
+
    fprintf(Coord, "%.3lf \t %.3lf\n", X, Y); // Записываем первую координату в файл
{
 
  return ((v1.x/v2.x == v1.y/v2.y)&&(v1.z/v2.z == v1.y/v2.y))? true:false;
 
}
 
  
Vector3D VS(Vector3D v1, double s)
+
    Xprev = X; // Меняем координаты местами. Так (n-1)-ый шаг становится n-ым шагом, n-ый шаг становится (n+1)-ым шагом. Далее аналогично
{
+
    X = Xnext;
     Vector3D v = {v1.x*s, v1.y*s, v1.z*s};
+
     Yprev = Y;
     return v;
+
     Y = Ynext;
}
 
  
double Length(Vector3D v1)
 
{
 
    return sqrt(VV(v1,v1));
 
}
 
  
Vector3D MakeVector(double x,double y,double z)
+
    while (Y >= Yo) // После выполнения строк 62-79 получаем все необходимые данные для выполнения алгоритма.
{
+
    {
     Vector3D v = {x,y,z};
+
     Xnext = 2.0*X - Xprev - (R/m)*V*Vx*(dt*dt);
     return v;
+
    Vx = (1.0/(2.0*dt))*(Xnext - Xprev);
}
+
    Ynext = 2.0*Y - Yprev - (g +(R/m)*V*Vy)*(dt*dt);
 +
    Vy =  (1.0/(2.0*dt))*(Ynext - Yprev);
 +
    V = sqrt((Vx*cos(alpha)*Vx*cos(alpha)) + (Vy*sin(alpha) - g*dt)*(Vy*sin(alpha) - g*dt));
 +
    if (Ynext > Yo )
 +
        fprintf(Coord, "%.3lf \t %.3lf\n", Xnext, Ynext);
 +
     else
 +
 
 +
      fprintf(Coord, "%.3lf \t %.3lf\n", X, 0.000);
  
Vector3D MakeVector(double length,double angle)
+
    Xprev = X;
{
+
    X = Xnext;
     Vector3D v = {length * cos(angle), length * sin(angle),0};
+
     Yprev = Y;
     return v;
+
     Y = Ynext;
}
+
    }
  
double Proection(Vector3D base, Vector3D dir)
 
{
 
    return (VV(base,dir)/Length(base));
 
 
}
 
}
#endif // VECTOR_H_INCLUDED
+
int VerleL (double alpha, double dt, double t, double Yo, double Xo, double Vo, double R, double m) // Функция, записывающая в файл VerleL.txt оординаты тела, рассчитывающиеся по формлуе Верле
</syntaxhighlight>
+
{                                                                                                  // для линейной зависимости сопротивления от скорости
</div>
+
    FILE *Coord;
 +
  Coord = fopen ("VerleL.txt", "w");
  
 +
    double X, Xnext, Xprev, Y, Ynext, Yprev, Vx, Vy, V,Yop, Xop; // Комментарии аналогичны переменным и формулам в VtrleSq
  
 +
    Yop = Yo - Vo*sin(alpha)*dt;
 +
    Xop = Xo - Vo*cos(alpha)*dt;
 +
    X = Xo;
 +
    Y = Yo;
 +
    Xnext = 2.0*X - Xop - (R/m)*Vo*Vo*cos(alpha)*(dt*dt);
 +
    Vx = (1.0/(2.0*dt))*(Xnext - Xop);
 +
    Ynext = 2.0*Y - Yop - (g +(R/m)*Vo*Vo*sin((alpha)))*(dt*dt);
 +
    Vy =  (1.0/(2.0*dt))*(Ynext - Yop);
 +
    V = sqrt((Vo*cos(alpha)*Vo*cos(alpha)) + (Vo*sin(alpha)*Vo*sin(alpha)));
  
<div class="mw-collapsible mw-collapsed" style="width:100%" >
+
    fprintf(Coord, "%.3lf \t %.3lf\n", X, Y);
'''[[Васильева Анастасия]]'''
 
  
'''Описание программы''': пользователь вводит начальную скорость полета, угол падения и шаг, с которым будут рассчитаны точки.
+
    Xprev = X;
 
+
    X = Xnext;
Программа записывает в один файл результаты вычисления:
+
    Yprev = Y;
# Координаты, рассчитанные по формуле, при движении без сопротивления воздуха;  
+
    Y = Ynext;
# Координаты, полученные при численном интегрировании - метод Эйлера;
 
# Координаты, полученные методом Верле при квадратичной зависимости силы сопротивлении воздуха от скорости.
 
# Координаты, полученные из точного решения, при линейной зависимости силы сопротивлении воздуха от скорости;
 
  
Скачать можно  [http://tm.spbstu.ru/Файл:fly.zip тут].
 
  
 +
    while (Y >= Yo)
 +
    {
 +
    Xnext = 2.0*X - Xprev - (R/m)*Vx*(dt*dt);
 +
    Vx = (1.0/(2.0*dt))*(Xnext - Xprev);
 +
    Ynext = 2.0*Y - Yprev - (g +(R/m)*Vy)*(dt*dt);
 +
    Vy =  (1.0/(2.0*dt))*(Ynext - Yprev);
 +
  if (Ynext > Yo )
 +
        fprintf(Coord, "%.3lf \t %.3lf\n", Xnext, Ynext);
 +
    else
 +
      fprintf(Coord, "%.3lf \t %.3lf\n", Xnext, 0.000);
  
<div class="mw-collapsible-content">
+
    Xprev = X;
 +
    X = Xnext;
 +
    Yprev = Y;
 +
    Y = Ynext;
 +
    }
  
 +
}
  
'''Визуализированный результат работы программы'''
+
int main()
[[File:graphick.png]]
+
{
 +
  double alpha, Vo, dt, R, m , t = 0, Yo = 0, Xo = 0; // Объявляем переменные: alpha - угол броска; Vo - начальная скорость; dt - шаг по времени; R- коэф. сопротивления; m- масса тела;
 +
                                                      // t = 0 - начало отсчета времени с 0; Yo = 0, Xo = 0 - координаты начала
 +
  int i = 0; // переменная для оператора switch
  
Для тела с массой 0.5 кг,сопротивлением воздуха 0.1, угол бросания 30°, начальная скорость 30 м, ускорение свободного падения 9.8 м/c^2, шаг 0.001;
+
  cout << "Enter start speed:\n";
 +
  cin >> Vo; // Вводим с клавиатуры начальную скорость
 +
  cout << "Enter angle in grades ( from 0 to 180 ):\n";
 +
  cin >> alpha; // Вводим с клавиатуры угол броска в градусах
 +
  alpha = alpha*Pi / 180; // переводим угол броска из градусов в радианы
 +
  cout << "Enter mass:\n";
 +
  cin >> m; // Вводим с клавиатуры массу
 +
  cout << "Enter precision:\n";
 +
  cin >> dt; // Вводим с клавиатуры шаг по времени
 +
  cout << "Enter resistance:\n";
 +
  cin >> R; // Вводим сопротивление воздуха
 +
  cout << "Press 1 to draw graph without resistance\n\n"
 +
          "Press 2 to draw graph in Exact form\n\n"
 +
          "Press 3 to draw graph in VerleSq form\n\n"
 +
          "Press 4 to draw graph in VerleL form\n\n"
 +
          "Press 5 to draw all graphs at the same time\n\n"
 +
          "Press 0 to quit\n\n";
 +
  cin >> i;
 +
  cout << "\nPress any button\n";
  
# "output.txt" using 1 : 2 - координаты, рассчитанные по формуле, при движении без сопротивления воздуха;
 
# "output.txt" using 3 : 4 - координаты, полученные из точного решения, при линейной зависимости силы сопротивлении воздуха от скорости (численное интегрирование - метод Эйлера);
 
# "output.txt" using 5 : 6 - координаты, полученные методом Верле при квадратичной зависимости силы сопротивлении воздуха от скорости;
 
# "output.txt" using 7 : 8 - координаты, полученные методом Верле при линейной зависимости силы сопротивлении воздуха от скорости.
 
  
 +
    FILE *Gnu;
 +
    Gnu = fopen ("Throws.gp", "w"); // Создаем файл формата gp, который будем открывать программой gnuplot для того, чтобы построить наш график/ки по точкам
 +
 +
switch ( i )
 +
{
 +
case 1:
 +
    {
 +
    WoutR(alpha,dt,t,Yo,Vo);
 +
    fprintf(Gnu, "plot \"Throws Without Resistance.txt\" using 1:2 w l");
 +
    break;
 +
    }
 +
case 2:
 +
    {
 +
    ExactForm(alpha,dt,t,Yo,Vo,R,m);
 +
    fprintf(Gnu, "plot \"ExactForm.txt\" using 1:2 w l");
 +
    break;
 +
    }
 +
case 3:
 +
    {
 +
    VerleSq(alpha,dt,t,Yo,Xo,Vo,R, m);
 +
    fprintf(Gnu, "plot \"VerleSq.txt\" using 1:2 w l");
 +
    break;
 +
    }
 +
case 4:
 +
    {
 +
    VerleL(alpha,dt,t,Yo,Xo,Vo,R, m);
 +
    fprintf(Gnu, "plot \"VerleL.txt\" using 1:2 w l");
 +
    break;
 +
    }
 +
case 5:
 +
    {
 +
  WoutR(alpha,dt,t,Yo,Vo);
 +
  ExactForm(alpha,dt,t,Yo,Vo,R,m);
 +
  VerleSq(alpha,dt,t,Yo,Xo,Vo,R, m);
 +
  VerleL(alpha,dt,t,Yo,Xo,Vo,R, m);
 +
  fprintf(Gnu, "plot \"Throws Without Resistance.txt\" using 1:2 w l, \"ExactForm.txt\" using 1:2 w l, \"VerleSq.txt\" using 1:2 w l, \"VerleL.txt\" using 1:2 w l"); // записываем в Throws.gp названия четырех файлов
 +
  break;
 +
    }                                                  // с координатами таким образом, чтобы программа gnuplot смогла их увидеть и прочесть
 +
case 0:
 +
    break;
 +
default:
 +
    break;
 +
}
 +
    return 0;
 +
}
 +
 +
</syntaxhighlight>
 +
</div>
  
<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; ///время
+
Начальная скорость: 40 м/с, угол бросания: 45 градусов, коэффициент сопротивления воздуха: 0.023, шаг по времени : 0.1 секунды.
        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()///создаем функцию для вычисления значенй по у для простого падения и по эйлеру
+
Скачать программу можно [http://tm.spbstu.ru/File:main.zip здесь]
    {
 
        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() ///функция для метода верле
+
<div class="mw-collapsible-content">
    {
+
'''Визуализированный результат работы программы'''[[File:graph.png]]
        double k = 0.1, m = 0.5; ///коэфф сопротивления водуха, масса тела
+
 
        g = 9.8; /// коэфф свободного падения
+
[[:File:graph.png]]
        uint32_t Size1 = 1000000.0; ///размер массива
+
 
        S = new double [Size1]; ///создаем массив для значений по х для метода верле
+
<syntaxhighlight lang="cpp" line start="1" enclose="div">
        Z = new double [Size1]; ///создаем массив для значений по у для метода верле
+
#include <iostream>
        vx = v * cos(a); ///формулы для вычисления скорости по оси х
+
#include <math.h>
        vy = v * sin(a); ///формулы для вычисления скорости по оси у
+
#include <iomanip>
        S[1] = 0; ///значение х метод верле
+
#include <fstream>
        S[0] = -vx * shag; ///значение в нуле
+
#include <conio.h>
        Z[1] = 0; ///значение у метод верле
+
 
        Z[0] = -vy * shag; ///значение в нуле
+
 
        for (int i = 0; i < Size1-2; i++) ///задаем цикл
+
using namespace std;
        {
+
 
            S[i+2] = 2.0 * S[i+1] - S[i] - (k / m) * v * vx * shag * shag;///значения по х для верле
+
ofstream outfile;
            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;///значения по х для верле
+
double perevod (double angle) //перевод из градусов в радианы
            vy = 0.5 * ( 1.0 / shag )* ( Z[i+2] - Z[i]);///считаем значения скорости по оси х
+
{
            v = sqrt (vx * vx + vy * vy); ///модуль общей скорости
+
    return (angle * M_PI / 180 );
        }
+
}
     }
+
 
    void SetVerleLast() ///функция для точного метода верле
+
 
 +
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)
 
     {
 
     {
         double k = 0.1, m = 0.5;///коэфф сопротивления водуха, масса тела
+
         X = Xo + Vo * cos(alpha) * t;
        g = 9.8; /// коэфф свободного падения
+
         Vx = Vo * cos(alpha);
        uint32_t Size2 = 1000000.0; ///размер массива
+
         Y = Yo + Vo * sin(alpha) * t  - 0.5 * g * t * t;
        float t = 0; ///время
+
        Vy = Vo * sin(alpha) - g * t;
        V = new double [Size2]; ///создаем массив для значений по х для точного метода верле
+
         t += dt;
        U = new double [Size2]; ///создаем массив для значений по у для точного метода верле
+
 
        vx = v * cos(a); ///формулы для вычисления скорости по оси х
+
        outfile << X << ' ' << Y << endl;
         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);///значения по х для точного верле
 
         }
 
 
     }
 
     }
 +
    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);
  
public: ///в открытом
+
    outfile.open("2.txt");
     pad()
+
 
 +
     while (Y >= Yo)
 
     {
 
     {
         X = 0; ///зануляем значения
+
         Xnext = 2.0 * X - Xprev - (R / m) * V * Vx * (dt * dt);
        Y = 0;
+
         Vx = ( Xnext - Xprev )/ (2.0 * dt);
         Size = 0;
+
         Ynext = 2.0 * Y - Yprev - (g + (R / m) * V * Vy) * (dt * dt);
         v = 0;
+
         Vy = (Ynext - Yprev)/ (2.0 * dt);
        shag = 0;
+
         V = sqrt(Vy*Vy + Vx*Vx );
        b = 0;
+
         outfile << X << ' ' << Y << endl;
    }
+
 
    pad(double _v, double _shag, double _b) ///конструктор с параметрами
+
         Xprev = X;
    {
+
         X = Xnext;
        pi = M_PI; ///значение числа пи
+
         Yprev = Y;
        g = 9.8; ///коэфф свободного падения
+
         Y = Ynext;
        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();
 
 
     }
 
     }
 +
    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");
  
     void FilePrint() ///функция записи в файл
+
     while (Y >= Yo)
 
     {
 
     {
         ofstream fout("output.txt"); ///открываем файл уже созданный в папке с программой
+
         Xnext = 2.0 * X - Xprev - (R / m) * Vx * (dt * dt);
         fout << "X:    " << "    Y:    " << "    E:  " << "  G:  " << "  S:  " << "  Z:  "<< "  V:  "<< "    U:    "<<"\n" ; ///выводим стоку с разными названиями массивов, соотв. координатам по х и у различных методов
+
         Vx = ( Xnext - Xprev )/ (2.0 * dt);
         for (int i = 0; i < Size; i++) ///цикл
+
         Ynext = 2.0 * Y - Yprev - (g + (R / m) * Vy) * (dt * dt);
         fout << X[i] << "    " << Y[i] << "    " << E[i] << "    " << G[i] << "  " << S[i] << "  " << Z[i] << "  " << V[i] <<"    "<< U[i] <<"\n"; ///забивает сами значения массивов
+
         Vy = (Ynext - Yprev)/ (2.0 * dt);
        fout.close();///закрываем файл
+
        V = sqrt(Vy*Vy + Vx*Vx );
    };
+
        outfile << X << ' ' << Y << endl;
};
 
 
 
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>
 
  
 +
        Xprev = X;
 +
        X = Xnext;
 +
        Yprev = Y;
 +
        Y = Ynext;
 +
    }
 +
    outfile.close();
  
 +
    //точное решения для линейной зависимости
 +
    Y = Yo;
 +
    X = Xo;
 +
    t = 0;
  
'''[[Иванова Яна]]'''
+
    outfile.open("4.txt");
  
'''Описание программы''': в программе выполняются четыре метода подсчета координат тела, брошенного под углом к горизонту. Координаты записываются в файл, строятся четыре графика, иллюстрирующие поведение тела при полете. Код написан для определенных начальных условий (для примера), если Вы хотите выполнить расчет для другой конфигурации, внесите изменения в начальные данные программы в самом коде.
+
    while (Y >= Yo)
Начальная скорость: 40 м/с, угол бросания: 45 градусов, коэффициент сопротивления воздуха: 0.023, шаг по времени : 0.1 секунды.
+
    {
 +
        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();
  
Скачать программу можно [http://tm.spbstu.ru/File:main.zip здесь]
+
    return 0;
  
<div class="mw-collapsible-content">
+
}
'''Визуализированный результат работы программы'''[[File:graph.png]]
 
  
[[:File:graph.png]]
+
</syntaxhighlight>
 +
</div>
  
<syntaxhighlight lang="cpp" line start="1" enclose="div">
+
<div>
#include <iostream>
 
#include <math.h>
 
#include <iomanip>
 
#include <fstream>
 
#include <conio.h>
 
  
 +
'''[[Капитанюк Светлана]]'''
  
using namespace std;
+
'''Описание программы''' : программа записывает в четыре файла результаты вычисления:
  
ofstream outfile;
+
Координаты, рассчитанные по формуле, при движении без сопротивления воздуха;
 +
Координаты, полученные методом Верле при линейной зависимости силы сопротивлении воздуха от скорости;
 +
Координаты, полученные из точного решения, при линейной зависимости силы сопротивлении воздуха от скорости;
 +
Координаты, полученные методом Верле при квадратичной зависимости силы сопротивлении воздуха от скорости.
  
double perevod (double angle) //перевод из градусов в радианы
+
Скачивать [http://tm.spbstu.ru/File:Point_03.zip тут]
{
 
    return (angle * M_PI / 180 );
 
}
 
  
 +
</div>
  
int main()
+
<div>
{
+
'''[[Киселёв Лев]]'''
    //объявление переменных и задание начальных значений
 
    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);
+
'''Описание программы''': программа рассчитывает координаты точки при следующих случаях
 +
#  Полет тела без сопротивления воздуха;
 +
#  Полет тела при линейной зависимости силы сопротивления воздуха от скорости, при котором координаты тела рассчитываются точным методом;
 +
#  Полет тела при линейной зависимости силы сопротивления воздуха от скорости, при котором координаты тела рассчитываются методом Верле;
 +
#  Полет тела при квадратичной зависимости силы сопротивлении воздуха от скорости, при котором координаты тела рассчитываются методом Верле;
  
    //точное решение для случая движения без сопротивления воздуха
+
Скачать можно [[http://mech.spbstu.ru/File:3zadanie.rar тут]]
    Y = Yo;
+
</div>
    X = Xo;
 
  
    outfile.open("1.txt");
+
<div class="mw-collapsible mw-collapsed" style="width:100%" >
 +
'''[[Лебедев Станислав]]'''
  
    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;
+
Скачать можно  [http://tm.spbstu.ru/Файл:Шарик.rar тут].
    }
 
    outfile.close();
 
  
    //начальные условия для квадратичной зависимости (метод Верле)
+
<div class="mw-collapsible-content">
    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");
+
[[File:1.png]]
  
    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;
+
[[File:graph.png]]
        Yprev = Y;
 
        Y = Ynext;
 
    }
 
    outfile.close();
 
  
    //начальные условия для линейной зависимости (метод Верле)
+
# o1 - координаты, рассчитанные по формуле, при движении без сопротивления воздуха;  
    Yprev = Yo - Vo*sin(alpha)*dt;
+
# o2 - координаты, полученные методом Верле при линейной зависимости силы сопротивлении воздуха от скорости;
    Xprev = Xo - Vo*cos(alpha)*dt;
+
# o3 - координаты, полученные из точного решения, при линейной зависимости силы сопротивлении воздуха от скорости;
    X = Xo;
+
# o4 - координаты, полученные методом Верле при квадратичной зависимости силы сопротивлении воздуха от скорости.
    Y = Yo;
 
    V = Vo;
 
    Vx = Vo * cos(alpha);
 
    Vy = Vo * sin(alpha);
 
  
    outfile.open("3.txt");
 
  
    while (Y >= Yo)
+
Для тела с массой 10,сопротивлением воздуха 1, угол бросания 30°, начальная скорость 30 м/с, ускорение свободного падения 9.8 м/c^2;
    {
 
        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;
+
''Примечание: графики o1 и o2 намеренно посчитаны с малой точностью, чтобы графики не сливались.''
        X = Xnext;
 
        Yprev = Y;
 
        Y = Ynext;
 
    }
 
    outfile.close();
 
  
    //точное решения для линейной зависимости
+
Файл "'''main.cpp'''"
    Y = Yo;
+
<syntaxhighlight lang="cpp" line start="1" enclose="div">
    X = Xo;
+
#include <iostream>
    t = 0;
+
#include <math.h>
 +
#include "Vector.h"
 +
#include <cstring>
 +
#include <cmath>
 +
#include <malloc.h>
 +
#include <fstream>
  
    outfile.open("4.txt");
+
using namespace std;
  
    while (Y >= Yo)
+
int n = 100;
    {
+
ofstream outfile;
        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;
+
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;
 +
        }
  
</syntaxhighlight>
+
        //задание начальных параметров через угол,начальное положение,скорость и ускорение,с которым движется тело. Без сопротивления воздуха
</div>
+
        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 );
 +
        }
  
<div class="mw-collapsible mw-collapsed" style="width:100%" >
+
        //вывод положения на экран
'''[[Уманский Александр]]'''
+
        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();
 +
        }
  
<div class="mw-collapsible-content">
+
        //вывод произвольного вектора на экран
 +
        void WVTS(Vector3D v)
 +
        {
 +
            cout.width(15);
 +
            cout << v.x;
 +
            cout.width(15);
 +
            cout << v.y;
 +
            cout.width(15);
 +
            cout << v.z << endl;
 +
        }
  
[[File:Methods.rar|Скачать архив]]
+
        //вывод произвольного вектора в файл
 +
        void WVTF(Vector3D v,char s[])
 +
        {
 +
            outfile.open(s,ios :: app);
 +
            outfile << v.x << "          " << v.y << endl;
 +
            outfile.close();
 +
        }
  
[[File:1.png]]
+
        //"пересчет" координаты по Верле(Линейная зависмость)
 
+
        void changeR(Vector3D r1, double dt)
<syntaxhighlight lang="cpp" line start="1" enclose="div">
+
        {
 
+
            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 );
</syntaxhighlight>
+
        }
</div>
 
  
 +
        //"пересчет" координаты по Верле(Квадратичная зависимость)
 +
        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));
 +
        }
  
<div class="mw-collapsible mw-collapsed" style="width:100%" >
+
        //рассчет предыдущегт к 0ому элементу
'''[[Лосева Татьяна ]]'''
+
        Vector3D MR1(double dt)
 +
        {
 +
            return MakeVector(r.x - v.x * dt,r.y - v.y * dt,0);
 +
        }
  
'''Описание:''' Пользователя попросят ввести начальную скорость,угол бросания,массу тела и коэф.сопротивления воздуха,тогда программа запишет в 4 разных файла результаты следующих вычислений:
+
        //возращает координату тела
# Координаты, рассчитанные по формуле, при движении без сопротивления воздуха;
+
        Vector3D getR()
# Координаты, полученные методом Верле при линейной зависимости силы сопротивлении воздуха от скорости;
+
        {
# Координаты, полученные методом Верле при квадратичной зависимости силы сопротивлении воздуха от скорости.
+
            return r;
# Координаты, полученные из точного решения, при линейной зависимости силы сопротивлении воздуха от скорости;
+
        }
  
<div class="mw-collapsible-content">
+
        //рассчет времени полета
 +
        double TimeOfFly()
 +
        {
 +
            return (2*Length(v)*sin(angle)/Length(a));
 +
        }
  
''Графики полученные при скорости =10 m/c;угле = 30 градусам;массе=10 кг;коэф.сопротивления=1;''
+
        //рассчет координаты по точной формуле. без сопротивления воздуха.
 +
        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);
 +
        }
  
[[File:загружено (1).png]][[:File:загружено (1).png]]
+
};
  
<syntaxhighlight lang="cpp" line start="1" enclose="div">
+
int main()
#include<iostream>
+
{
using namespace std;
+
    //задание начальных параметров
#define N 1
+
    Vector3D g = {0,-9.8,0};
#define PI 3.14159265
+
    double a,dt = 0;
#include <fstream>
+
    char s[20];
#include<cmath>
+
 
double g=9.8;
+
//    cin >> dt;
double step=0.01;
 
#include<math.h>
 
  
void Func(double v,double r)//1.Координаты, рассчитанные по формуле, при движении без сопротивления воздуха;
+
    dt = 0.1;
 +
    a = (M_PI * 30)/180;
 +
    Ball b1(a, MakeVector(0,0,0),MakeVector(30,a),g);
  
{
+
    double tof = b1.TimeOfFly()+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)
+
    //Без сопротивления возлуха
{
+
    strcpy(s,"");
y=v*t*sin(r*PI/ 180)-g*t*t/2;//координата y
+
    strcat(s, "o1.txt");
x=v*t*cos(r*PI / 180);//координата х
+
    outfile.open(s, ios :: trunc);
 
+
    outfile.close();
fout<<x<<"   ";//запись в файл х
+
    for (double i = 0; i <= tof; i += dt)
cout<<"X="<<x<<endl;//вывод на экран
+
    {
    fout<<y<<"    ";//запись в файл
+
        b1.WVTS(b1.position(i));
cout<<"Y="<<y<<endl<<endl;//вывод на экран
+
        b1.WVTF(b1.position(i), s);
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
+
    dt = 0.1;
 +
    a = (M_PI * 30)/180;
 +
    Ball b2(a,10 , 1, MakeVector(0,0,0),MakeVector(30,a),g);
  
  xn_1=x0-vx*step;//X(n-1) для первого случая n=0
+
    strcpy(s,"");
  yn_1=y0-vy*step;//Y(n-1) для первого случая n=0
+
    strcat(s, "o2.txt");
  ofstream fout;//открытие файла
+
    outfile.open(s,ios :: trunc);
fout.open("C:\\Users\\Light\\Desktop\\2.txt");//путь записи в файл
+
    outfile.close();
cout<<"Verle1"<<endl<<endl;
+
    Vector3D r1 = b2.MR1(dt),rp;
for(double t=0.02;t<N;t=t+step)
+
    for (double i = 0; i <= 20; i += dt)
{
+
    {
x=2*x0-xn_1-(n*vx*step*step)/m;//считаем Хn+1
+
        rp = b2.getR();
vx=(x-xn_1)/(2*step);
+
        b2.writePosToFile(s);
         xn_1=x0;//для следущего шага Xn-1=Xn
+
         b2.writePosToScreen();
         x0=x;//для следущего шага Xn=Xn+1
+
         b2.changeR(r1,dt);
+
        b2.changeV(r1,dt);
y=2*y0-yn_1-(g+(n*vy)/m)*step*step;//Yn+1
+
        r1.x = rp.x;
vy=(y-yn_1)/(2*0.01);//скорость
+
        r1.y = rp.y;
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;  
 
 
  
}
+
    //Точное решение (Линейная зависимость)
}
+
    dt = 0.1;
 +
    a = (M_PI * 30)/180;
 +
    Ball b3(a,10 , 1, MakeVector(0,0,0),MakeVector(30,a),g);
  
void Verle2( double n,double m ,double v0,double r)//3.Координаты, полученные методом Верле при квадратичной зависимости силы сопротивлении воздуха от скорости.
+
    strcpy(s,"");
 
+
    strcat(s, "o3.txt");
{
+
    outfile.open(s, ios :: trunc);
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);
+
    outfile.close();
 +
    for (double i = 0; i <= 20; i += dt)
 +
    {
 +
        b3.WVTS(b3.positionReal(i));
 +
        b3.WVTF(b3.positionReal(i), s);
 +
    }
  
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
+
    dt = 0.1;
  ofstream fout;//открытие файла
+
    a = (M_PI * 30)/180;
  fout.open("C:\\Users\\Light\\Desktop\\3.txt");//путь записи
+
    Ball b4(a,10 , 1, MakeVector(0,0,0),MakeVector(30,a),g);
cout<<"Verle2"<<endl<<endl;
 
for(double t=0.02;t<N;t=t+step)
 
{
 
  
  v=sqrt(vx*vx+vy*vy);//скорость V
+
    strcpy(s,"");
 
+
    strcat(s, "o4.txt");
x=2*x0-xn_1-(n*v*vx*step*step)/m;//Xn+1
+
    outfile.open(s, ios :: trunc);
vx=(x-xn_1)/(2*step);//скорость Vx
+
    outfile.close();
        xn_1=x0;//для следущего шага Xn-1=Xn
+
    r1 = b4.MR1(dt);
x0=x;//для следущего шага Xn=Xn+1
+
    for (double i = 0; i <= 20; i += dt)
+
    {
y=2*y0-yn_1-(g+(n*vy*v)/m)*step*step;//Yn+1
+
        rp = b4.getR();
vy=(y-yn_1)/(2*0.01);//скорость Vy
+
        b4.writePosToFile(s);
yn_1=y0;//для следущего шага Yn-1=Yn
+
        b4.writePosToScreen();
y0=y;//для следущего шага Yn=Yn+1
+
        b4.changeRSQ(r1,dt);
cout<<"X="<<x<<endl;
+
        b4.changeV(r1,dt);
cout<<"Y="<<y<<endl<<endl;
+
        r1.x = rp.x;
fout<<x<<" ";
+
        r1.y = rp.y;
fout<<y<<"  ";
+
    }
fout<<endl;  
+
 
}
+
    return 0;
 
 
}
 
}
 +
</syntaxhighlight>
 +
 +
Файл "'''Vector.h'''"
 +
<syntaxhighlight lang="cpp" line start="1" enclose="div">
 +
#ifndef VECTOR_H_INCLUDED
 +
#define VECTOR_H_INCLUDED
  
void method4(double n,double m ,double v0,double r)//Координаты, полученные из точного решения, при линейной зависимости силы сопротивлении воздуха от скорости;
+
struct Vector3D
 
{
 
{
double x,y,x0=0,y0=0;//x0,y0 начальные значения;
+
  double x,y,z;
 +
};
  
double vx=v0*cos(r*PI / 180);//рассчитваем Vx
+
Vector3D VmV(Vector3D v1,Vector3D v2)               //векторное вычитание
  double vy=v0*sin(r*PI/ 180)-g*step;//рассчитваем Vy
+
{
 
+
    Vector3D v = {v1.x - v2.x,v1.y - v2.y,v1.z - v2.z };
  ofstream fout;//открытие файла
+
    return v;
  fout.open("C:\\Users\\Light\\Desktop\\4.txt");
+
};
cout<<"4"<<endl<<endl;
+
Vector3D VpV(Vector3D v1,Vector3D v2)               //векторное сложение
for(double t=0.01;t<N;t=t+step)
+
{
{
+
    Vector3D v = {v1.x + v2.x,v1.y + v2.y,v1.z + v2.z };
x=x0+m*vx*(1-(exp((-1*n)*t/m)))/n;//координата х
+
    return v;
+
}
y = y0+(m/n)*((vy + g * m / n)*(1 - exp(-1 * n * t / m))) - g * t*m/n;//координата у
 
  
//вывод в файл  и на экран
+
double VV(Vector3D v1,Vector3D v2)              //скалярное умножение
    cout<<"X="<<x<<endl;
+
{
cout<<"Y="<<y<<endl<<endl;
+
  return (v1.x*v2.x + v1.y*v2.y + v1.z*v2.z);
fout<<x<<" ";
+
}
fout<<y<<" ";
 
fout<<endl;
 
  
}
+
Vector3D VxV(Vector3D v1,Vector3D v2)              //векторное умножение
 +
{
 +
  Vector3D v = {v1.y*v2.z - v1.z*v2.y, v1.z*v2.x - v1.x*v2.z,v1.x*v2.y - v1.y*v2.x};
 +
  return v;
 
}
 
}
 
 
int main(void)
 
{
 
  
double v0,r,m,n;//v0-начальная скорость,r-угол в градусах,m-масса;n-коэф.сопротивления ветра
+
bool Kol(Vector3D v1,Vector3D v2)
 +
{
 +
  return ((v1.x/v2.x == v1.y/v2.y)&&(v1.z/v2.z == v1.y/v2.y))? true:false;
 +
}
  
cout<<"Enter  start speed:"<<endl;
+
Vector3D VS(Vector3D v1, double s)
cin>>v0;
+
{
cout<<"Enter angle less than 90 deg:"<<endl;
+
    Vector3D v = {v1.x*s, v1.y*s, v1.z*s};
cin>>r;
+
    return v;
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);
 
  
 +
double Length(Vector3D v1)
 +
{
 +
    return sqrt(VV(v1,v1));
 +
}
  
 
+
Vector3D MakeVector(double x,double y,double z)
int k;
+
{
cin>>k;
+
    Vector3D v = {x,y,z};
return 0;
+
    return v;
 
}
 
}
  
</syntaxhighlight>
+
Vector3D MakeVector(double length,double angle)
 +
{
 +
    Vector3D v = {length * cos(angle), length * sin(angle),0};
 +
    return v;
 +
}
 +
 
 +
double Proection(Vector3D base, Vector3D dir)
 +
{
 +
    return (VV(base,dir)/Length(base));
 +
}
 +
#endif // VECTOR_H_INCLUDED
 +
</syntaxhighlight>
 
</div>
 
</div>
  
Скачать можно  [http://tm.spbstu.ru/Файл:Verle.rar  тут].
 
  
<div class="mw-collapsible mw-collapsed" style="width:100%" >
+
<div>
'''[[Степанянц Степан]]'''  
+
'''[[Лобанов Илья]]'''
  
'''Описание программы''': программа записывает в четыре файла результаты вычисления:
+
'''Описание программы''' : программа записывает в четыре файла результаты вычисления:
# Координаты, рассчитанные по формуле, при движении без сопротивления воздуха;
 
# Координаты, полученные методом Верле при линейной зависимости силы сопротивлении воздуха от скорости;
 
# Координаты, полученные из точного решения, при линейной зависимости силы сопротивлении воздуха от скорости;
 
# Координаты, полученные методом Верле при квадратичной зависимости силы сопротивлении воздуха от скорости.
 
  
Скачать можно  [http://tm.spbstu.ru/%D0%A4%D0%B0%D0%B9%D0%BB:Mainpr.rar тут].
+
Координаты, рассчитанные по формуле, при движении без сопротивления воздуха;
 +
Координаты, полученные методом Верле при линейной зависимости силы сопротивлении воздуха от скорости;
 +
Координаты, полученные из точного решения, при линейной зависимости силы сопротивлении воздуха от скорости;
 +
Координаты, полученные методом Верле при квадратичной зависимости силы сопротивлении воздуха от скорости.
  
<div class="mw-collapsible-content">
 
[[File:graph239.png]]
 
  
Для тела с массой 1,сопротивлением воздуха 0.05, угол бросания 30°, начальная скорость 40 м/с, ускорение свободного падения 9.8 м/c^2;
+
'''Краткая инструкция''':
  
 +
В окне консоли пользователю предлагается вывести следующие значения: начальную скорость , угол и шаг.
 +
После этого полученные в результате работы программы данные выводятся в файл.
  
 +
Скачивать [[http://tm.spbstu.ru/File:Air.rar тут]]
 +
[[http://tm.spbstu.ru/File:phys.rar тут]]
 +
 +
</div>
 +
 +
<div class="mw-collapsible mw-collapsed" style="width:100%" >
 +
'''[[Лосева Татьяна ]]'''
 +
 +
'''Описание:''' Пользователя попросят ввести начальную скорость,угол бросания,массу тела  и коэф.сопротивления воздуха,тогда программа запишет в 4 разных файла результаты следующих вычислений:
 +
# Координаты, рассчитанные по формуле, при движении без сопротивления воздуха;
 +
# Координаты, полученные методом Верле при линейной зависимости силы сопротивлении воздуха от скорости;
 +
# Координаты, полученные методом Верле при квадратичной зависимости силы сопротивлении воздуха от скорости.
 +
# Координаты, полученные из точного решения, при линейной зависимости силы сопротивлении воздуха от скорости;
 +
 +
<div class="mw-collapsible-content">
 +
 +
''Графики полученные при скорости =10 m/c;угле = 30 градусам;массе=10 кг;коэф.сопротивления=1;''
 +
 +
[[File:загружено (1).png]][[:File:загружено (1).png]]
  
Файл "'''main.cpp'''"
 
 
<syntaxhighlight lang="cpp" line start="1" enclose="div">
 
<syntaxhighlight lang="cpp" line start="1" enclose="div">
#include <iostream>
+
#include<iostream>
#include <locale.h>
+
using namespace std;
#include <math.h>
+
#define N 1
 +
#define PI 3.14159265
 
#include <fstream>
 
#include <fstream>
#include<iomanip>
+
#include<cmath>
#include <cmath>
+
double g=9.8;
using namespace std;
+
double step=0.01;
main ()
+
#include<math.h>
 +
 
 +
void Func(double v,double r)//1.Координаты, рассчитанные по формуле, при движении без сопротивления воздуха;
 +
 
 
{
 
{
    ofstream F;                                                                    //a1-угол в градусах,dt-шаг,r-сопротивление воздуха
+
double x,y;
int u0=50;
+
double x,y,t,a,a1=30,dt=0.1,y0=0,x0=0,g=9.8,r=0.05,m=1,ux,uy,ypr,xpr,ysl,xsl,u,yt; //ux,uy - проэкции скорости на оси х и у.
+
ofstream fout;//открытие файла
a=a1*M_PI/180; //Градусы в радианы
+
  fout.open("C:\\Users\\Light\\Desktop\\1.txt");//указываем путь записи
t=0;
+
cout<<"method1"<<endl;
+
 
                                        //Движение без сопротивления воздуха
+
  for(double t=0.01;t<N;t=t+0.01)
F.open("C:\\1.txt",ios::out);
+
{
while(y>=0)
+
y=v*t*sin(r*PI/ 180)-g*t*t/2;//координата y
{
+
x=v*t*cos(r*PI / 180);//координата х
    x=x0+u0*cos(M_PI/6)*t;
+
 
    y=y0+u0*sin(M_PI/6)*t - 0.5 * g * t * t; //Расчитываем координаты в каждой точке через шаг
+
fout<<x<<"  ";//запись в файл х
  F<<x<<" "<<y<<endl;
+
cout<<"X="<<x<<endl;//вывод на экран
  t=t+dt;
+
    fout<<y<<"   ";//запись в файл
+
cout<<"Y="<<y<<endl<<endl;//вывод на экран
 +
fout<<endl;
 +
  }
 
}
 
}
+
 
F.close();
+
void Verle1( double n,double m ,double v0,double r)//Координаты, полученные методом Верле при линейной зависимости силы сопротивлении воздуха от скорости;
                                        //Точное решение для линейной зависимости
+
 
F.open("C:\\2.txt",ios::out);
+
{
y=y0;
+
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);
x=x0;
+
 
t=0;                                                                           //Расчитываем координаты в каждой точке через шаг
+
double vx=v0*cos(r*PI / 180);//рассчитваем Vn для первого случая n=0 для x
while(y>=0)
+
  double vy=v0*sin(r*PI/ 180)-g*step;//рассчитваем Vn для первого случая n=0 для y
{
+
 
        ux = u0 * cos(a);
+
   xn_1=x0-vx*step;//X(n-1) для первого случая n=0
        uy = u0 * sin(a);
+
  yn_1=y0-vy*step;//Y(n-1) для первого случая n=0
        x = x0+ (m * ux / r)* (1 - exp(-1 * r * t / m));                     //подстановка формул
+
  ofstream fout;//открытие файла
        y = y0+(m/r)*((uy + g * m / r)*(1 - exp(-1 * r * t / m)) - g * t);
+
fout.open("C:\\Users\\Light\\Desktop\\2.txt");//путь записи в файл
        t = t + dt;
+
cout<<"Verle1"<<endl<<endl;
+
for(double t=0.02;t<N;t=t+step)
      F << x << ' ' << y << endl;
+
{
+
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
   F.close();
+
                                                        //метод Верле 1
+
y=2*y0-yn_1-(g+(n*vy)/m)*step*step;//Yn+1
ypr = y0 - u0*sin(a)*dt;
+
vy=(y-yn_1)/(2*0.01);//скорость
yt=ypr;
+
yn_1=y0;//для следущего шага Yn-1=Yn
    xpr = x0 - u0*cos(a)*dt;
+
y0=y;//для следущего шага Yn=Yn+1
    x = x0;                          //Начальные условия
+
    cout<<"X="<<x<<endl;
    y = y0;
+
cout<<"Y="<<y<<endl<<endl;
    u = u0;
+
    fout<<x<<" ";
    ux = u0 * cos(a);
+
fout<<y<<"  ";
    uy = u0 * sin(a);                      
+
fout<<endl;  
F.open("C:\\3.txt",ios::out);
+
+
 
    while (y >= y0)
+
}
    {
+
}
        xsl = 2 * x - xpr - (r / m) * u * ux * (dt * dt);
+
 
        ux = ( xsl - xpr )/ (2 * dt);
+
void Verle2( double n,double m ,double v0,double r)//3.Координаты, полученные методом Верле при квадратичной зависимости силы сопротивлении воздуха от скорости.
         ysl = 2 * y - ypr - (g + (r / m) * u * uy) * (dt * dt);       //xsl,ysl - координаты на шаге вперед. xpr,ypr- назад
+
 
        uy = (ysl - ypr)/ (2 * dt);
+
{
        u = sqrt(uy*uy + ux*ux );
+
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);
        F << x << ' ' << y << endl;
+
 
+
double vx=v0*cos(r*PI / 180);//рассчитваем Vn для первого случая n=0 для x
        xpr = x;
+
  double vy=v0*sin(r*PI/ 180)-g*step;//рассчитваем Vn для первого случая n=0 для y
        x = xsl;
+
 
        ypr = y;
+
  xn_1=x0-vx*step;//X(n-1) для первого случая n=0
        y = ysl;
+
  yn_1=y0-vy*step;//Y(n-1) для первого случая n=0
    }
+
  ofstream fout;//открытие файла
    F.close();
+
  fout.open("C:\\Users\\Light\\Desktop\\3.txt");//путь записи
                                                      //Метод Верле 2
+
cout<<"Verle2"<<endl<<endl;
    ypr = y0 - u0*sin(a)*dt;
+
for(double t=0.02;t<N;t=t+step)
yt=ypr;
+
{
    xpr = x0 - u0*cos(a)*dt;
+
 
    x = x0;                                                                           //xsl,ysl - координаты на шаге вперед. xpr,ypr- назад
+
  v=sqrt(vx*vx+vy*vy);//скорость V
    y = y0;
+
 
    u = u0;
+
x=2*x0-xn_1-(n*v*vx*step*step)/m;//Xn+1
    ux = u0 * cos(a);                           
+
vx=(x-xn_1)/(2*step);//скорость Vx
    uy = u0 * sin(a);
+
         xn_1=x0;//для следущего шага Xn-1=Xn
F.open("C:\\4.txt",ios::out);
+
x0=x;//для следущего шага Xn=Xn+1
+
    while (y >= y0)
+
y=2*y0-yn_1-(g+(n*vy*v)/m)*step*step;//Yn+1
    {
+
vy=(y-yn_1)/(2*0.01);//скорость Vy
        xsl = 2 * x - xpr - (r / m) * ux * (dt * dt);
+
yn_1=y0;//для следущего шага Yn-1=Yn
        ux = ( xsl - xpr )/ (2 * dt);
+
y0=y;//для следущего шага Yn=Yn+1
         ysl = 2 * y - ypr - (g + (r / m) * uy) * (dt * dt);
+
cout<<"X="<<x<<endl;
        uy = (ysl - ypr)/ (2 * dt);
+
cout<<"Y="<<y<<endl<<endl;
        u = sqrt(uy*uy + ux*ux );
+
fout<<x<<" ";
        F << x << ' ' << y << endl;
+
fout<<y<<"  ";
+
fout<<endl;  
        xpr = x;
+
}
        x = xsl;
+
        ypr = y;
 
        y = ysl;
 
    }
 
    F.close();
 
 
 
return 0;
 
 
 
 
}
 
}
  
</syntaxhighlight>
+
void method4(double n,double m ,double v0,double r)//Координаты, полученные из точного решения, при линейной зависимости силы сопротивлении воздуха от скорости;
</div>
+
{
 +
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)
 +
{
  
<div class="mw-collapsible mw-collapsed" style="width:100%" >
+
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);
  
'''Описание программы''':
 
Программа записывает в текстовый файл результаты вычисления координат по x и y с шагом в 0.1 секунду(возможно изменить) четырьмя различными способами:
 
#Координаты, рассчитанные по формуле, при движении без сопротивления воздуха
 
#Координаты, полученные из точного решения, при линейной зависимости силы сопротивлении          воздуха от скорости
 
#Координаты, полученные методом Верле при линейной зависимости силы сопротивлении воздуха от скорости
 
#Координаты, полученные методом Верле при квадратичной зависимости силы сопротивлении воздуха от скорости
 
Скачать можно  [http://mech.spbstu.ru/File:%D0%9F%D0%BE%D0%BB%D0%B5%D1%82_%D1%82%D0%B5%D0%BB%D0%B0(%D0%90%D0%BB%D0%B5%D0%BA%D1%81%D0%B0%D0%BD%D0%B4%D1%80%D0%A1%D1%8E%D1%80%D0%B8%D1%81).zip тут].
 
<div class="mw-collapsible-content">
 
[[File:Снимок.PNG]]
 
Для тела с массой 1,сопротивлением воздуха 0.05, угол бросания 45°, начальная скорость 30 м/с, ускорение свободного падения 9.8 м/c^2;
 
Файл "'''main.cpp'''"
 
<syntaxhighlight lang="cpp" line start="1" enclose="div">
 
#include <iostream>
 
#include <fstream>
 
#include <math.h>
 
#include <cmath>
 
using namespace std;
 
int o;
 
double v,a,m,k;
 
ofstream fout("file.txt");//создаем объект, сяванный с файлом file.txt
 
  
  
 +
int k;
 +
cin>>k;
 +
return 0;
 +
}
  
int rez_1(double v, double a)
+
</syntaxhighlight>
{
+
</div>
    fout<<"---------------Первый режим-------------------------"<<endl;
 
    fout<<" T=0 x=0 y=0";
 
    fout<<endl;
 
    double x=0,y=0,t=0.1, V0x, V0y, g=9.8,t1, T=0.1, Ty;
 
    V0x=v*cos(a/180*M_PI);//рассчет проекций начальных скоростей на оси x и y с переводом угла в радианы
 
    V0y=v*sin(a/180*M_PI);
 
    Ty=2*V0y/g;//время полета
 
    while (y>0 || x==0)//условие: пока тело не упадет на землю(те y=0, при этом не учитывая начало полета
 
    {
 
        x=x+V0x*t;              //ф-лы для рассчета x и y в данный момент времени
 
        y=y+V0y*t-g*pow(t,2)/2;
 
  
        if (y<0) //если y<0
+
Скачать можно  [http://tm.spbstu.ru/Файл:Verle.rar  тут].
            {
 
                t1=Ty-T; //рассчитываем время,которое осталось лететь телу до земли
 
                x=x+V0x*t1;//используя это время находим координату по х
 
                fout<<" T="<<Ty<<" x="<<x<<" y=0"<<endl;//ввод в текстовый файл
 
                break;
 
            }
 
            else
 
                {
 
                    V0y=V0y-g*t;// иначе находим новую скорость по y (по x не меняется)
 
                    fout<<" T="<<T<<" x="<<x<<" y="<<y<<endl;
 
                    T=T+t;//увел время на шаг
 
                }
 
    }
 
  
 +
<div>
  
}
+
'''[[Ляжков Сергей]]'''
  
 +
'''Описание программы''': Программа рассчитывает координаты полета тела по х и у. Как и в программе шахмат и интерполяции, здесь представлено меню выбора функций. Вы вводите начальные координаты, начальную скорость и угол полета(например, мяча или снаряда)(Нет смысла вводить величину скорости света, так как парабола вряд ли получится).
 +
Затем Вы выбираете в меню "вариант" сопротивления воздуха, после чего вводите массу тела и коэффициент сопротивления среды(без сопротивления воздуха этим можно пренебречь). Программа выводит массив точек и сохраняет их в текстовый файл. Эти точки - координаты полета до тех пор, пока значения y не станет ОТРИЦАТЕЛЬНЫМИ...
 +
Это мой первый проект по моделированию, спасибо за предоставленную возможность попрактиковаться.
 +
Скачать можно [[http://mech.spbstu.ru/File:Полет.zip тут]]
 +
</div>
  
int rez_2(double v, double a, double k, double m)
+
<br>'''[[Нарядчиков Александр]]'''<br>
{
+
'''Инструкция:''' Пользователю достаточно просто запустить программу.<br>
    fout<<"---------------Второй режим работы-------------------------"<<endl;
+
'''Описание программы:''' В комнате скачут 4 мячика, первый двигается без сопротивления воздуха, второй двигается с квадратичной зависимостью сопротивления воздуха от скорости (Метод Верле), третий двигается с линейной зависимостью сопротивления воздуха от скорости (точное решение), четвертый двигается с линейной зависимостью сопротивления воздуха от скорости (Метод Верле).<br>
    fout<<" T=0 x=0 y=0";
+
'''Описание алгоритма:''' Программа реализована с помощью системы анимации(class anim), используя библиотеки OpenGl и GLUT. Изменения координат мячей проходят в режиме реального времени в векторной форме.<br>
    fout<<endl;
+
<div class="mw-collapsible mw-collapsed" style="width:100%" >
    double t=0.1, Vx=v*cos(a/180*M_PI), Vy=v*sin(a/180*M_PI),y,x,T=0.1,g=9.8;
+
"'''T06BALL.CPP'''"
    x=(m*Vx/k)*(1-exp(-1*k*T/m));            //ф-лы для рассчета x и y в данный момент времени
+
<syntaxhighlight lang="cpp" line start="1" enclose="div">
    y =(m/k)*((Vy+g*m/k)*(1-exp(-1*k*T/m))-g*T);  //точное решение при лин завсисимости
+
/* FILENAME: T06BALL.CPP
    while (y>0)
+
* LAST UPDATE: 17.01.2016
    {
+
*/
        x=(m*Vx/k)*(1-exp(-1*k*T/m));
 
        y =(m/k)*((Vy+g*m/k)*(1-exp(-1*k*T/m))-g*T);
 
        fout<<" T="<<T<<" x="<<x<<" y="<<y<<endl;
 
        T=T+t;
 
    }
 
  
 +
#include "ANIM.H"
 +
#include "SAMPLE.H"
  
}
+
/* Main function */
 
+
void main( void )
 
 
 
 
int rez_3(double v, double a, double k, double m)
 
 
{
 
{
  fout<<"---------------Третий режим работы-------------------------"<<endl;
+
// Получение единственного экземпляра класса анимации
    fout<<" T=0 x=0 y=0";
+
sagl::anim &My = sagl::anim::Get();
    fout<<endl;
+
 
    double t=0.1, Vxn=v*cos(a/180*M_PI), Vyn=v*sin(a/180*M_PI),
+
// Шар, летящий без сопротивлением воздуха
    x3=0,x2=0,x1=x2-Vxn*t,  y3=0,
+
        for (int i = 0; i < 1; i++)
    y2=0, y1=y2-Vyn*t, g=9.8, t1, T=0.1;//шаг, скорость по х в момент времени T, -\\- по y в момент времени Т
+
                My << new ball(Pi / 6, 10 + i);
    //координата по х в в момент времени T, -\\- в n-1 шаг, -\\- в n шаге, аналогично для y,
 
  
 +
// Шар, летящий с сопротивлением воздуха
 +
// Координаты получены методом Верле при квадратичной зависимости силы сопротивлении воздуха от скорости
 +
for (int i = 0; i < 1; i++)
 +
My << new ball_air(Pi / 6, 10 + i, 10, 0.01);
  
    x3=2*x2-x1-k/m*Vxn*pow(t,2);  //координаты в момент времени T
+
// Шар, летящий с сопротивлением воздуха
    y3=2*y2-y1-(g-+k/m*Vyn)*pow(t,2);
+
// Координаты получены из точного решения при линейной зависимости силы сопротивлении воздуха от скорости
    Vxn=(x3-x1)/(2.0*t); //скорость в момент времени T
+
for (int i = 0; i < 1; i++)
    Vyn=(y3-y1)/(2.0*t);
+
My << new ball_air_2(Pi / 6, 10 + i, 10, 0.01);
    x1=x2;// приравнивание к координате на n-1 шаге значение координаты в n шаге
 
    y1=y2;
 
    x2=x3;//-//- к координате в n шаге значение в момент времени T
 
    y2=y3;
 
    while (y2>0)
 
    {
 
        x3=2*x2-x1-k/m*Vxn*pow(t,2);
 
        y3=2*y2-y1-(g+k/m*Vyn)*pow(t,2);
 
        Vxn=(x3-x1)/(2.0*t);
 
        Vyn=(y3-y1)/(2.0*t);
 
        fout<<" T="<<T<<" x="<<x2<<" y="<<y2<<endl;
 
  
        if (y3<0)
+
// Шар, летящий с сопротивлением воздуха
        {
+
// Координаты получены методом Верле при линейной зависимости силы сопротивлении воздуха от скорости
            t1=sqrt(abs((-y1+2*y2)/(g+k/m*Vyn)));
+
for (int i = 0; i < 1; i++)
            x3=2*x2-x1-k/m*Vxn*pow((t+t1),2);
+
My << new ball_air_3(Pi / 6, 10 + i, 10, 0.01);
            fout<<" T="<<T+t1<<" x="<<x3<<" y="<<0<<endl;
+
 
        }
+
// Запуск главного цикла
 +
  My.Run();
 +
} // End of 'main' function
  
        T=T+t;
+
// END OF 'T43ANIM.CPP' FILE
        x1=x2;
+
</syntaxhighlight>
        y1=y2;
+
"'''ANIM.CPP'''"
        x2=x3;
+
<syntaxhighlight lang="cpp" line start="1" enclose="div">
        y2=y3;
+
/* FILENAME: ANIM.CPP
 +
* LAST UPDATE: 17.01.2016
 +
*/
  
    }
+
#include <stdio.h>
 +
#include <stdlib.h>
 +
#include <time.h>
  
}
+
#include "ANIM.H"
  
 +
// Единственный экземпляр класса
 +
sagl::anim sagl::anim::Instance;
  
int rez_4(double v, double a, double k, double m)
+
/* Reshape function */
 +
// Стандартная функция, вызываемая при изменении размеров окна
 +
void sagl::anim::Reshape( int W, int H )
 
{
 
{
   fout<<"---------------Четвертый режим работы-------------------------"<<endl;
+
   // Установка области просмотра - все окно
    fout<<" T=0 x=0 y=0";
+
glViewport(0, 0, W, H);
    fout<<endl;
+
  Instance.WinW = W;
    double t=0.1, Vxn=v*cos(a/180*M_PI), Vyn=v*sin(a/180*M_PI),
+
  Instance.WinH = H;
    x3=0,x1=0, x2=x1+Vxn*t, y3=0, y1=0,
+
  double ratio_x = 1, ratio_y = 1;
    y2=y1+Vyn*t, g=9.8, t1, T=0.1, V=v;//шаг, скорость по х в момент времени T, -\\- по y в момент времени Т
+
  if (W > H)
    //координата по х в в момент времени T, -\\- в n-1 шаг, -\\- в n шаге, аналогично для y,
+
    ratio_x = (double)W / H;
 +
  else
 +
    ratio_y = (double)H / W;
 +
  double Size = 1, Near = 1, Far = 500;
 +
  // Установка системы координат "камеры"
 +
glMatrixMode(GL_PROJECTION);
 +
  glLoadIdentity();
 +
  glFrustum(-Size * ratio_x, Size * ratio_x,
 +
            -Size * ratio_y, Size * ratio_y,
 +
            Near, Far);
 +
// Установка "мировой" СК в состояние без преобразований
 +
  glMatrixMode(GL_MODELVIEW);
 +
} // End of 'Reshape' function
  
 +
/* Timer function */
 +
// Подсчет времени
 +
void sagl::anim::Timer( void )
 +
{
 +
  long Time = clock();
 +
 
 +
  if (IsPause)
 +
    DeltaTime = 0, PauseTime += Time - OldTime;
 +
  else
 +
    DeltaTime = (Time - OldTime) / (double)CLOCKS_PER_SEC;
 +
  OldTime = Time;
  
    x3=2.0*x2-x1-(k/m)*V*Vxn*pow(t,2);
+
  SyncTime = (Time - PauseTime - StartTime) / (double)CLOCKS_PER_SEC;
    y3=2.0*y2-y1-(g+(k/m)*V*Vyn)*pow(t,2);
+
} /* End of 'Timer' function */
    Vxn=(x3-x1)/(2.0*t);
 
    Vyn=(y3-y1)/(2.0*t);
 
    V=sqrt(pow(Vxn,2)+pow(Vyn,2.0));
 
    x1=x2;
 
    y1=y2;
 
    x2=x3;
 
    y2=y3;
 
    while (y2>0)
 
    {
 
        x3=2.0*x2-x1-(k/m)*Vxn*V*pow(t,2);
 
        y3=2.0*y2-y1-(g+(k/m)*Vyn*V)*pow(t,2);
 
        Vxn=(x3-x1)/(2.0*t);
 
        Vyn=(y3-y1)/(2.0*t);
 
        V=sqrt(pow(Vxn,2)+pow(Vyn,2));
 
        fout<<" T="<<T<<" x="<<x2<<" y="<<y2<<endl;
 
  
        if (y3<0)
+
/* Display function */
        {
+
// Стандартная функция, вызываемая при перерисовке окна
            t1=sqrt(abs((-y1+2.0*y2)/(g+(k/m)*Vyn*V)));
+
void sagl::anim::Display( void )
            x3=2.0*x2-x1-(k/m)*Vxn*V*pow((t+t1),2);
+
{
            fout<<" T="<<T+t1<<" x="<<x3<<" y="<<0<<endl;
+
// Запуск времени
        }
+
Instance.Timer();
 +
// Очищаем цветовой буфер для создания нового изображения
 +
  glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
  
 +
  glLoadIdentity();
 +
  // Позиционирование СК
 +
gluLookAt(-40, 0, 0, 0, 0, 0, 0, 1, 0);
  
        T=T+t;
+
// Отрисовка объектов
        x1=x2;
+
  Instance.Render();
        y1=y2;
 
        x2=x3;
 
        y2=y3;
 
  
    }
+
  glFinish();
 +
// Копируем вторичный буфер в окно
 +
glutSwapBuffers();
 +
// Вызываем функцию обновления кадра
 +
glutPostRedisplay();
 +
} // End of 'Display' function
  
}
+
/* Keyboard function */
 +
// Стандартная функция, вызываемая при нажатие клавиш на клавиатуре
 +
void sagl::anim::Keyboard( unsigned char Key, int X, int Y )
 +
{
 +
// Выход из программы
 +
if (Key == 27)
 +
    exit(0);
 +
// Открытие программы в полном экране
 +
else if (Key == 'f')
 +
    glutFullScreen();
 +
  // Пауза
 +
else if (Key == 'p' || Key == 'P')
 +
    Instance.IsPause = !Instance.IsPause;
 +
} // End of 'Keyboard' function
  
 
+
sagl::anim::anim( void ) : IsPause(false), SyncTime(0), DeltaTime(0),
int main()
+
  StartTime(clock()), OldTime(StartTime), PauseTime(0), StockSize(0)
 
{
 
{
 +
// Инициализации OpenGL и GLUT
 +
glutInitDisplayMode(GLUT_RGB | GLUT_DOUBLE | GLUT_DEPTH);
 +
 
 +
// Задача размеров и позиции окна
 +
glutInitWindowPosition(0, 0);
 +
  glutInitWindowSize(700, 700);
 +
// Создание окна
 +
glutCreateWindow("T06BALL");
  
setlocale(LC_ALL, "rus");
+
// Установка функций 'обратного вызова'
cout<<"Введите скорость тела и угол"<<endl;
+
  glutDisplayFunc(Display);
cin>>v>>a;
+
  glutKeyboardFunc(Keyboard);
 
+
  glutReshapeFunc(Reshape);
while (1>0){
 
cout<<"Выберите режим работы программы:"<<endl;
 
cout<<"1 - Координаты, рассчитанные по формуле, при движении без сопротивления воздуха"<<endl;
 
cout<<"2 - Координаты, полученные из точного решения, при линейной зависимости силы сопротивлении воздуха от скорости"<<endl;
 
cout<<"3- Координаты, полученные методом Верле при линейной зависимости силы сопротивлении воздуха от скорости"<<endl;
 
cout<<"4 - Координаты, полученные методом Верле при квадратичной зависимости силы сопротивлении воздуха от скорости"<<endl;
 
cout<<"5 - Выйти";
 
cin>>o;
 
  
if (o==1)
+
// Установка цвета закраски фона
    rez_1(v,a);
+
  glClearColor(0.3, 0.5, 0.7, 1);
if (o==2)
+
  // Включение буфера глубины
    {
+
glEnable(GL_DEPTH_TEST);
    cout<<"Введите массу тела и коэф сопротивления воздуха:"<<endl;
+
  // Включение режима вычисления цвета согласно освещенности от источников света
    cin>>m>>k;
+
glEnable(GL_LIGHTING);
    rez_2(v,a,k,m);
+
// Включение источника света
    }
+
   glEnable(GL_LIGHT0);
 
+
// Включение упрощенного режима освещенности для простого способа описания свойств поверхности
if (o==3)
+
  glEnable(GL_COLOR_MATERIAL);
    {
+
// Приведение нормалей к единичной длине
    cout<<"Введите массу тела и коэф сопротивления воздуха:"<<endl;
+
   glEnable(GL_NORMALIZE);
    cin>>m>>k;
+
}
    rez_3(v,a,k,m);
 
    }
 
   if (o==4)
 
    {
 
    cout<<"Введите массу тела и коэф сопротивления воздуха:"<<endl;
 
    cin>>m>>k;
 
    rez_4(v,a,k,m);
 
    }
 
   if (o==5)
 
        break;
 
  
            }
+
// Деструктор
 +
sagl::anim::~anim( void )
 +
{
 +
  // Чистка памяти
 +
for (int i = 0; i < StockSize; i++)
 +
    delete Stock[i];
 
}
 
}
  
 +
/* Render function */
 +
// Отрисовка объектов
 +
void sagl::anim::Render( void )
 +
{
 +
for (int i = 0; i < StockSize; i++)
 +
Stock[i]->Render(*this);
 +
} // End of 'Render' function
  
</syntaxhighlight>
+
/* Run function */
</div>
+
// Запуск главного цикла
 +
void sagl::anim::Run( void )
 +
{
 +
// Запуск основного цикла построения
 +
glutMainLoop();
 +
} // End of 'Run' function
  
 +
// END OF 'ANIM.CPP' FILE
 +
</syntaxhighlight>
 +
"'''ANIM.H'''"
 +
<syntaxhighlight lang="cpp" line start="1" enclose="div">
 +
/* FILENAME: ANIM.H
 +
* LAST UPDATE: 17.01.2016
 +
*/
  
<div class="mw-collapsible mw-collapsed" style="width:100%" >
+
#ifndef __ANIM_H_
'''[[Тимошенко Валентина]]'''
+
#define __ANIM_H_
  
'''Описание программы''': при запуске пользователь вводит шаг функции, угол, под которым бросают тело, массу тела, сопротивление воздуха и скорость.  
+
#include <stdio.h>
Программа записывает в четыре файла результаты вычисления:
+
#include <stdlib.h>
#Координаты, рассчитанные по формуле для движения без сопротивления воздуха;
+
#include <time.h>
#Координаты, рассчитанные по формуле для движения с учетом сопротивления воздуха;
 
#Координаты, полученные методом Верле при квадратичной зависимости силы сопротивления воздуха от скорости.
 
#Координаты, полученные методом Верле при линейной зависимости силы сопротивления воздуха от скорости;
 
  
Скачать можно  [http://tm.spbstu.ru/Файл:motion.zip тут.]
+
#include <GL\glut.h>
  
<div class="mw-collapsible-content">
+
#include "VEC.H"
  
'''Визуализированный результат работы программы'''
+
// Константы
[[File:Grafics.png]]
+
#define Pi 3.14159265358979323846
 +
#define E 2.71828182845904523536
  
Графики приведены для движения тела массой 1, со скоростью 50, под углом 45 градусов. Сопротивление воздуха принято равным 0.0001, шаг 0,1.
+
// Собственное пространство имен 'sagl'
 
+
namespace sagl
<syntaxhighlight lang="cpp" line start="1" enclose="div">
 
 
 
#include <iostream> ///программа, подсчитывающая и записывающая в файл координаты движения тела для двух вариантов метода Верле
 
#include <fstream> /// и для движений с учётом сопротивления и без его учёта
 
#include <math.h>
 
#include<stdlib.h>
 
using namespace std;
 
 
 
int main()
 
 
{
 
{
    double a, step, Pi, g, Vo, m, r;
+
  // Объявления класса анимации наперед
    ///а - угол, под которым движется тело, step - шаг функции, Vo - начальная скорость тела, m - масса тела, r - величина сопротивления
+
class anim;
 
+
 
    double x, y, x_0, y_0, x0, y0, Vx, Vy;
+
// Функции получения случайных чисел
    ///переменные для движения точки без учёта сопротивления и с его учётом
+
inline double r0( void )
    ///х - изменяющаяся пошагово координата тела по оси Ох, у - изменяющаяся пошагово координата тела по оси Оу,
+
  {
    ///х0 - начальная координата тела по оси Ох, у0 - начальная координата тела по оси Оу
+
     return rand() / (double)RAND_MAX;
    ///Vx - скорость тела по оси Ох, Vу - скорость тела по оси Оу
+
  }
     ///x_0 - изменяющаяся пошагово координата тела по оси Ох с учётом сопротивления, у_0 - изменяющаяся пошагово координата тела по оси Оу с учётом сопротивления
+
  inline double r1( void )
 
+
  {
    double Vy0, Vx0, x1, x2, x3, y1, y2, y3, Vxn, Vyn, Vn;
+
     return 2.0 * rand() / RAND_MAX - 1;
    ///переменные для 1го варианта метода Верле
+
  }
    ///х1 - координата тела по оси Ох на (n-1) шаге, х2 - координата тела по оси Ох на (n) шаге, х3 - координата тела по оси Ох на (n+1) шаге
+
 
     ///у1 - координата тела по оси Оу на (n-1) шаге, у2 - координата тела по оси Оу на (n) шаге, у3 - координата тела по оси Оу на (n+1) шаге
+
// Класс объектов
    ///Vx0 - начальная скорость тела по оси Ох, Vy0 - начальная скорость тела по оси Оу
+
class object
     ///Vxn - скорость тела в данный момент времени по оси Ох, Vyn - скорость тела в данный момент времени по оси Оу
+
  {
 
+
  public:
    double Vxn2, Vyn2, x_1, x_2, x_3, y_1, y_2, y_3;
+
     // Вектора перемещения и скоростей
     ///переменные для 2го варианта метода Верле
+
vec P, V, AbsV;
    ///х_1 - координата тела по оси Ох на (n-1) шаге, х_2 - координата тела по оси Ох на (n) шаге, х_3 - координата тела по оси Ох на (n+1) шаге
+
      
    ///у_1 - координата тела по оси Оу на (n-1) шаге, у_2 - координата тела по оси Оу на (n) шаге, у_3 - координата тела по оси Оу на (n+1) шаге
+
// Конструктор
    ///Vxn2 - скорость тела в данный момент времени по оси Ох, Vyn2 - скорость тела в данный момент времени по оси Оу
+
object( void ) : P(vec::Rnd1()), V(vec::Rnd()), AbsV(V)
 
 
    g=10; ///значение ускорения свободного падения
 
    Pi=3.14159265; /// значение числа П, используем для перевода радиан в градусы
 
 
 
    do ///цикл, запрашивающий ввод пользователем значения шага функции
 
 
     {
 
     {
        cout << "Input the step, it must be less than 1" << endl; ///ввод с клавиатуры шага(то же самое, что дельта t), шаг должен быть маленьким (меньше 1)
 
        cin >> step;  ///вывод величины шага на экран
 
 
     }
 
     }
    while (step>=1); ///выход из цикла не будет обеспечен, пока пользователь не введет число, меньшее 1
+
 
+
// Отрисовка объектов
     cout << '\n' << "Input the corner in degrees,the corner is in the range from 0 to 90 degrees" << endl; ///ввод с клавиатуры угла в радианах (угол от 0 до 90 градусов)
+
virtual void Render( anim &Ani )
     cin >> a; ///вывод значение угла на экран
+
    {
    a=(Pi*a)/180.0;
+
     } // End of 'Render' function
     cout << '\n' << "Input the weight" << endl; ///ввод с клавиатуры значения массы
+
  }; // end of 'object' class
     cin >> m; ///вывод величины массы на экран
+
 
 +
// Класс анимации
 +
class anim
 +
  {
 +
  private:
 +
     // Функции 'обратного вызова'
 +
static void Display( void );
 +
     static void Keyboard( unsigned char Key, int X, int Y );
 +
     static void Reshape( int W, int H );
  
     do ///цикл, запрашивающий ввод пользователем значения сопротивления воздуха
+
     // Единственный экземпляр класса
     {
+
static anim Instance;
        cout << '\n' << "Input the value of the resistance, it must be less than 1" << endl; ///ввод с клавиатуры величины сопротивления
+
      
        cin >> r; ///вывод значения сопротивления на экран
+
    // Конструктор
    }
+
anim( void );
    while (r>=1); ///выход из цикла не будет обеспечен, пока пользователь не введет число, меньшее 1
 
  
     cout << '\n' << "Input the speed" << endl; ///ввод с клавиатуры значения начальной скорости
+
// Максимальное количество объектов
     cin >> Vo; ///вывод значения скорости на экран
+
    static const int Max = 100;
 
+
     // 'Контейнер' объектов
     ///для движения без учёта сопротивления
+
object *Stock[Max];
     x0=0; ///обнуление переменных
+
    // Размер 'контейнера' объектов
     y0=0;
+
int StockSize;
     x=0;
+
   
     y=0;
+
// Переменные, хранящие время в секундах
 +
     long StartTime, OldTime, PauseTime;
 +
   
 +
// Отрисовка объектов
 +
void Render( void );
 +
 +
// Подсчет времени
 +
void Timer( void );
 +
  public:
 +
     // Добавление объектов в 'контейнер'
 +
anim & operator<<( object *Obj )
 +
     {
 +
      if (StockSize < Max )
 +
        Stock[StockSize++] = Obj;
 +
      else
 +
        delete Obj;
 +
     
 +
return *this;
 +
     }
 +
      
 +
// Ширина и высота окна
 +
     int WinW, WinH;
  
    ///для движения с учётом сопротивления
+
// Переменные, хранящие время в секундах
    x_0=0; ///обнуление переменных
+
     double SyncTime, DeltaTime;
     y_0=0;
 
  
     ///для 1го варианта метода Верле
+
     // Переменная, отвечающая за паузу
 +
bool IsPause;
  
     Vx0=Vo*cos(a); ///расчет проекции начальной скорости по оси Ох
+
     // Деструктор
    Vy0=Vo*sin(a); ///расчет проекции начальной скорости по оси Оу
+
~anim( void );
 +
   
 +
// Запуск главного цикла
 +
void Run( void );
 +
   
 +
    // Метод, возвращающий переменную - единственный экземпляр данного типа
 +
static anim & Get( void )
 +
    {
 +
      return Instance;
 +
    }
 +
  }; // end of 'anim' class
 +
} // end of 'sagl' namespace
  
    x2=0; ///обнуление переменных
+
#endif /*__ANIM_H_ */
    y2=0;
 
    x3=0;
 
    y3=0;
 
  
    y1=y2-Vy0*step; ///расчет начального значения координаты по оси Оу
+
// END OF 'ANIM.H' FILE
    x1=x2-Vx0*step; ///расчет начального значения координаты по оси Ох
+
</syntaxhighlight>
 +
"'''VEC.H'''"
 +
<syntaxhighlight lang="cpp" line start="1" enclose="div">
 +
/* FILENAME: VEC.H
 +
* LAST UPDATE: 17.01.2016
 +
*/
  
    ///для 2го варианта метода Верле
+
#ifndef __VEC_H_
 +
#define __VEC_H_
  
    x_2=0; ///обнуление переменных
+
#include <stdlib.h>
    y_2=0;
+
#include <math.h>
    x_3=0;
 
    y_3=0;
 
  
    Vxn2=Vo*cos(a); ///расчет скорости тела на начальный момент времени по оси Ох
+
// Собственное пространство имен 'sagl'
     Vyn2=Vo*sin(a); ///расчет скорости тела на начальный момент времени по оси Оу
+
namespace sagl
 
+
{
     y_1=y_2-Vo*sin(a)*step; ///расчет начального значения координаты на (п-1) шаге по оси Оу
+
  // Класс векторов
    x_1=-Vo*cos(a)*step;    ///расчет начального значения координаты на (п-1) шаге по оси Ох
+
class vec
 
+
  {
    ofstream out("For method without resistance.txt");
+
  public:
    ///запись в файл значений координат по осям Ох и Оу для движения без сопротивления
+
     // Координаты вектора
 
+
double X, Y, Z;
    for (int i=0; y>=0; ++i) ///цикл для подсчета координат при движении тела без учёта сопротивления
+
      
 +
// Конструктор
 +
vec( void ) : X(0), Y(0), Z(0)
 
     {
 
     {
        x=Vo*step*i*cos(a); ///расчет координаты тела по оси х
 
        y=Vo*sin(a)*i*step-(g*i*step*i*step)*0.5; ///расчет координаты тела по оси y
 
 
        out << x << "    " << y <<'\n';  ///вывод всех значений координат по оси х и по оси у при движении тела без учёта сопротивления
 
 
     }
 
     }
     out.close();
+
      
 
+
// Конструктор
    ofstream out1 ("For method with resistance.txt");
+
vec( double A, double B, double C ) : X(A), Y(B), Z(C)
    ///запись в файл значений координат по осям Ох и Оу для движения с учётом сопротивления
 
 
 
    for (int i=0; y_0>=0; ++i) ///цикл для подсчета координат при движении тела с учётом сопротивления
 
 
     {
 
     {
        Vx=Vo*cos(a); ///расчет скорости тела по оси Ох
 
        Vy=Vo*sin(a); ///расчет скорости тела по оси Оу
 
        x_0=x0+(m/r)*Vx*(1.0 - exp((-r*i*step)/m)); ///расчет координаты тела по оси х
 
        y_0=y0+(m/r)*(Vy+g*(m/r))*(1.0 - exp((-r*i*step)/m))-g*i*step*(m/r); ///расчет координаты тела по оси y
 
 
        out1 << x_0 << "    " << y_0 <<'\n';  ///вывод всех значений координат по оси х и по оси у при движении c учётом сопротивления
 
 
     }
 
     }
     out1.close();
+
      
 
+
// Функции получения случайных чисел
    ofstream out2 ("For method Verle 1.txt");
+
static double R0( void )
     ///запись в файл значений координат по осям Ох и Оу для 1го варианта метода Верле
+
    {
 
+
      return rand() / (double)RAND_MAX;
    for (int i=0; y3>=0; ++i) ///цикл для подсчета координат и скорости по времени для 1го варианта метода Верле
+
     }
 +
   
 +
static double R1( void )
 
     {
 
     {
        x3=2*x2-x1-(r/m)*Vn*Vxn*step*step; ///расчет координаты в данный момент времени по оси Ох
+
      return 2 * rand() / (double)RAND_MAX - 1;
        y3=2*y2-y1-(g+(r/m)*Vn*Vyn)*step*step; ///расчет координаты в данный момент времени по оси Оу
 
        Vxn=(x3-x1)/(2.0*step); ///расчет скорости в данный момент времени по оси Оу
 
        Vyn=(y3-y1)/(2.0*step); /// расчет скорости в данный момент времени по оси Ох
 
        Vn=sqrt(Vxn*Vxn+Vyn*Vyn); ///расчет скорости тела по модулю
 
 
 
        x1=x2; ///присваивание значению координаты х1 на (n-1) шаге значение координаты х2 на n шаге
 
        x2=x3; ///присваивание значению координаты х2 на (n) шаге значение координаты х3 на (n+1) шаге
 
        y1=y2; ///присваивание значению координаты у1 на (n-1) шаге значение координаты у2 на n шаге
 
        y2=y3; ///присваивание значению координаты у2 на (n) шаге значение координаты у3 на (n+1) шаге
 
 
 
        out2 << x3 << "  " << y3 <<'\n'; ///вывод всех значений координат по оси Ох и по оси Оу на экран для 1го варианта метода Верле
 
 
     }
 
     }
     out2.close();
+
      
 
+
// Функции получения случайных векторов
    ofstream out3 ("For method Verle 2.txt");
+
static vec Rnd( void )
     ///запись в файл значений координат по осям Ох и Оу для 2го варианта метода Верле
+
    {
 
+
      return vec(R0(), R0(), R0());
    for (int i=0; y_3>=0; ++i) ///цикл для подсчета координат и скорости по времени для 2го варианта метода Верле
+
     }
 +
   
 +
static vec Rnd1( void )
 
     {
 
     {
        x_3=2*x_2-x_1-(r/m)*Vxn2*step*step; ///расчет координаты в данный момент времени по оси Ох
+
      return vec(R1(), R1(), R1());
        y_3=2*y_2-y_1-(g+(r/m)*Vyn2)*step*step; ///расчет координаты в данный момент времени по оси Оу
 
        Vxn2=(x_3-x_1)/(2.0*step); ///расчет скорости в данный момент времени по оси Оу
 
        Vyn2=(y_3-y_1)/(2.0*step); ///расчет скорости в данный момент времени по оси Ох
 
 
 
        x_1=x_2; ///присваивание значению координаты х_1 на (n-1) шаге значение координаты х_2 на n шаге
 
        x_2=x_3; ///присваивание значению координаты х_2 на (n) шаге значение координаты х_3 на (n+1) шаге
 
        y_1=y_2; ///присваивание значению координаты у_1 на (n-1) шаге значение координаты у_2 на n шаге
 
        y_2=y_3; ///присваивание значению координаты у_2 на (n-1) шаге значение координаты у_3 на (n+1) шаге
 
 
 
        out3 << x_3 << "  " << y_3 <<'\n'; ///вывод на экран всех значений координат по оси Ох и по оси Оу для 2го варианта метода Верле
 
 
 
 
     }
 
     }
     out3.close();
+
 
+
vec operator+( vec V )
     cout << '\n' << "All results are saved in files." << endl; ///вывод на экран сообщения о записи в файл всех результатов
+
{
    cout << '\n' << "The program is finished." << endl; ///вывод на экран сообщения о завершении работы программы
+
return vec(X + V.X, Y + V.Y, Z + V.Z);
    return 0;
+
}
}
+
</syntaxhighlight>
+
vec operator*( double t )
</div>
+
     {
 
+
      return vec(X * t, Y * t, Z * t);
<div class="mw-collapsible mw-collapsed" style="width:100%" >
+
    }
'''[[Савельева Ольга]]'''  
+
      
 +
vec & operator+=( const vec &V )
 +
    {
 +
      X += V.X;
 +
      Y += V.Y;
 +
      Z += V.Z;
 +
     
 +
return *this;
 +
    }
 +
 +
// Длина вектора
 +
double operator!(void) const
 +
{
 +
return sqrt(X * X + Y * Y + Z * Z);
 +
} /* end of 'operator!' function */
 +
  }; // end of 'vec' class
 +
} // end of 'sagl' namespace
  
'''Описание:''' Пользователя попросят ввести начальную скорость, угол бросания, тогда программа запишет в файл результаты следующих вычислений:
+
#endif /*__VEC_H_ */
# Координаты, рассчитанные по формуле, при движении без сопротивления воздуха;
 
# Координаты, полученные методом Верле при линейной зависимости силы сопротивлении воздуха от скорости;
 
# Координаты, полученные методом Верле при квадратичной зависимости силы сопротивлении воздуха от скорости.
 
# Координаты, полученные из точного решения, при линейной зависимости силы сопротивлении воздуха от скорости;
 
 
 
<div class="mw-collapsible-content">
 
  
 +
// END OF 'VEC.H' FILE
 +
</syntaxhighlight>
 +
"'''SAMPLE.H'''"
 
<syntaxhighlight lang="cpp" line start="1" enclose="div">
 
<syntaxhighlight lang="cpp" line start="1" enclose="div">
#include <stdio.h>
+
/* FILENAME: SAMPLE.H
#include <stdlib.h>
+
* LAST UPDATE: 17.01.2016
#include <cmath>
+
*/
  
using namespace std;
+
#ifndef __SAMPLE_H_
 +
#define __SAMPLE_H_
  
FILE *output;
+
#include <math.h>
  
double e = 0.0000001; //точность
+
#include "ANIM.H"
double g = 9.8; //ускорение свободного падения
 
double dt = 0.00001;  //шаг по времени
 
double windageLinearCoefficient = 0.1;
 
double windageSquareCoefficient = 0.00001;
 
  
struct Vector  //вектор
+
// Шар, летящий без сопротивлением воздуха
 +
class ball : public sagl::object
 
{
 
{
    double x, y;
+
private:
    Vector():x(0), y(0)
+
  double angle, v; // угол вектора скорости к горизонту; модуль скорости
    {}
+
public:
    Vector(double x, double y):x(x), y(y)
+
  // Конструктор
    {}
+
ball( void ) : angle(Pi / 3), v(1)
    const Vector operator+(const Vector &v) const
+
  {
    {
+
P = sagl::vec(sagl::r0() + 5, 5, 0);
        return Vector(this -> x + v.x, this -> y + v.y);
+
V.X = 0;
    }
+
V.Y = sin(angle) * v;
    const Vector operator-(const Vector &v) const
+
V.Z = cos(angle) * v;
    {
+
  }
        return Vector(this -> x - v.x, this -> y - v.y);
+
    }
+
// Конструктор
    const Vector operator*(const double k) const
+
ball( double angle1, double v1 ) : angle(angle1), v(v1)
    {
+
{
        return Vector(this -> x * k, this -> y * k);
+
P = sagl::vec(sagl::r0() + 5, 5, 0);
    }
+
V.X = 0;
    const Vector operator*(const int k) const
+
V.Y = sin(angle) * v;
    {
+
V.Z = cos(angle) * v;
        return Vector(this -> x * k, this -> y * k);
+
}
    }
+
 
    const Vector operator/(const double k) const
+
// Отрисовка объекта
    {
+
void Render( sagl::anim &Ani )
        return Vector(this -> x / k, this -> y / k);
+
  {
    }
+
// Вектор ускорения свободного падения
};
+
sagl::vec g = sagl::vec(0, -9.8, 0);
 +
// Размер комнаты
 +
double Size = 120;
  
const Vector operator*(const double a, const Vector &v)
+
// Изменение вектора скорости
{
+
V += g * Ani.DeltaTime;
    return Vector(v.x * a, v.y * a);
+
// Изменение вектора перемещения
}
+
P += V * Ani.DeltaTime;
  
const Vector operator*(const int k, const Vector &v)
+
// Ограничения - стенки
{
+
if (P.X > Size / 4)
    return Vector(v.x * k, v.y * k);
+
V.X = -fabs(V.X);
}
+
if (P.X < -Size / 4)
 +
V.X = fabs(V.X);
  
double abs(const Vector &v)
+
if (P.Y > Size / 4)
{
+
V.Y = -fabs(V.Y);
    return sqrt(v.x * v.x + v.y * v.y);
+
if (P.Y < -Size / 4)
}
+
      V.Y = fabs(V.Y);
  
void printCoordinate(const char *description, const Vector &v) //выводит координаты в более читаемом виде
+
if (P.Z > Size / 4)
{
+
V.Z = -fabs(V.Z);
     fputs(description, output);
+
if (P.Z < -Size / 4)
    fputs(": ", output);
+
V.Z = fabs(V.Z);
    fprintf(output, "%lf", v.x);
+
     fputs(", ", output);
+
     // Запоминание состояния изменения текущей СК
    fprintf(output, "%lf\n", v.y);
+
glPushMatrix();
}
+
 +
// Рисование стенок
 +
glutWireCube(Size / 2);
 +
// Задача перемещения мяча
 +
glTranslated(P.X, P.Y, P.Z);
 +
     // Цвет мяча
 +
glColor3d(0, 1, 0);
 +
// Рисование мяча
 +
glutSolidSphere(0.5, 30, 30);
 +
   
 +
// Восстановление последнего запоминания состояния изменения текущей СК
 +
glPopMatrix();
 +
  }
 +
}; // end of 'ball' class
  
Vector getCoordinatesWithoutWindage(double velocity, double angle, double time = -1)
+
// Шар, летящий с сопротивлением воздуха
 +
// Координаты получены методом Верле при квадратичной зависимости силы сопротивлении воздуха от скорости
 +
class ball_air : public sagl::object
 
{
 
{
    double fallTime = 2 * velocity * sin(angle) / g; //расчет времени падения
+
private:
    if((time < 0) or (time > fallTime))
+
double angle, v, m, n;
        time = fallTime;
+
public:
    double x = velocity * cos(angle) * time;   // x = vx*t;
+
// Конструктор
    double y = velocity * sin(angle) * time - g * time * time / 2;  // y = vy*t-(g*t^2)/2;
+
ball_air( void ) : angle(Pi / 3), v(1), m(1), n(0.1)
    return Vector(x, y);
+
{
}
+
P = sagl::vec(sagl::r0() + 5, 5, 0);
 +
V.X = 0;
 +
V.Y = sin(angle) * v;
 +
V.Z = cos(angle) * v;
 +
}
 +
 +
// Конструктор
 +
ball_air( double angle1, double v1, double m1, double n1 ) : angle(angle1), v(v1), m(m1), n(n1)
 +
{
 +
P = sagl::vec(sagl::r0() + 5, 5, 0);
 +
V.X = 0;
 +
V.Y = sin(angle) * v;
 +
V.Z = cos(angle) * v;
 +
}
 +
 +
// Отрисовка объекта
 +
void Render( sagl::anim &Ani )
 +
{
 +
// Вектор ускорения свободного падения и вектор полного ускорения
 +
sagl::vec g = sagl::vec(0, -9.8, 0), a;
 +
// Размер комнаты
 +
double Size = 120;
 +
 
 +
// Изменение вектора ускорения
 +
a = sagl::vec(0, g.Y - n / m * !V * V.Y, -n / m * !V * V.Z);
 +
 
 +
// Изменение вектора скорости
 +
V += a * Ani.DeltaTime;
 +
// Изменение вектора перемещения
 +
P += V * Ani.DeltaTime;
  
Vector getCoordinatesVerletLinear(double velocity, double angle, double time = -1)
+
// Ограничения - стенки
{
+
if (P.X > Size / 4)
    double nowTime = dt;
+
V.X = -fabs(V.X);
    Vector rsb(0, 0);
+
if (P.X < -Size / 4)
    if((time >= 0) and (dt / 2 - time > 0)) //если время расчета дается слишком малого промежутка
+
V.X = fabs(V.X);
        return rsb; //вернитесь в начальную точку
 
    Vector v(velocity * cos(angle), velocity * sin(angle)); //проекции начальной скорости
 
    Vector r = v * dt;    //вторая точка
 
    Vector a = -windageLinearCoefficient * v; //ускорение в начальной точке
 
    a.y -= g;
 
    v = v + a * dt; //скорость во второй точке
 
    a = -windageLinearCoefficient * v; //ускорение во второй точке
 
    a.y -= g;
 
    while((r.y > 0) or ((time > 0) and (nowTime <= time)))  //пока точка выше 0 или не достигла заданного времени
 
    {
 
        Vector rn = 2 * r - rsb + a * dt * dt;  // r(t+dt) = 2*r(t)-r(t-dt)+a(t)*dt^2;
 
        v = (rn - rsb) / (2 * dt); // v(t) = (r(t+dt)-r(t-dt))/(2*dt);
 
        rsb = r;    //обновление r(t-dt) and r(t)
 
        r = rn;
 
        a = -windageLinearCoefficient * v;  //обновление a(t)
 
        a.y -= g;
 
        nowTime += dt;  //обновленное время
 
    }
 
    return r;
 
}
 
  
Vector calculateForTime(Vector &v, double time)
+
if (P.Y > Size / 4)
{
+
V.Y = -fabs(V.Y);
    Vector r;
+
if (P.Y < -Size / 4)
    // x = vx/k*(1-e^(-k*t));
+
V.Y = fabs(V.Y);
    r.x = v.x / windageLinearCoefficient * (1 - exp(-windageLinearCoefficient * time));
 
    // y = ((vy+g/k)*(1-e^(-k*t))-g*t)/k;
 
    r.y = ((v.y + g / windageLinearCoefficient) * (1 - exp(-windageLinearCoefficient * time)) - g * time) / windageLinearCoefficient;
 
    return r;
 
}
 
  
Vector getCoordinatesAccurateLinear(double velocity, double angle, double time = -1)
+
if (P.Z > Size / 4)
 +
V.Z = -fabs(V.Z);
 +
if (P.Z < -Size / 4)
 +
V.Z = fabs(V.Z);
 +
 +
// Запоминание состояния изменения текущей СК
 +
glPushMatrix();
 +
 +
// Рисование стенок
 +
glutWireCube(Size / 2);
 +
// Задача перемещения мяча
 +
glTranslated(P.X, P.Y, P.Z);
 +
// Цвет мяча
 +
glColor3d(1, 0, 0);
 +
// Рисование мяча
 +
glutSolidSphere(0.5, 30, 30);
 +
 +
// Восстановление последнего запоминания состояния изменения текущей СК
 +
glPopMatrix();
 +
}
 +
}; // end of 'ball_air' class
 +
 
 +
// Шар, летящий с сопротивлением воздуха
 +
// Координаты получены из точного решения при линейной зависимости силы сопротивлении воздуха от скорости
 +
class ball_air_2 : public sagl::object
 
{
 
{
    if(windageLinearCoefficient < e)  //если коэффициент слишком близок к нулю
+
private:
        return getCoordinatesWithoutWindage(velocity, angle, time);   //вычисляй будто это 0
+
double angle, v, m, n;
    Vector r;
+
public:
    Vector v(velocity * cos(angle), velocity * sin(angle)); //проекции начальной скорости
+
// Конструктор
    if(time >= 0)   //время данное
+
ball_air_2( void ) : angle(Pi / 3), v(1), m(1), n(0.1)
    {
+
{
        r = calculateForTime(v, time);
+
P = sagl::vec(sagl::r0() + 5, 5, 0);
        if(r.y >= 0)   //если объект в воздухе или только приземлился
+
V.X = 0;
            return r;   //затем верните координаты объекта
+
V.Y = sin(angle) * v;
        else    //еще
+
V.Z = cos(angle) * v;
            return getCoordinatesAccurateLinear(velocity, angle);   //верните координаты приземления
+
}
    }
+
    else
+
// Конструктор
    {
+
ball_air_2( double angle1, double v1, double m1, double n1 ) : angle(angle1), v(v1), m(m1), n(n1)
        double timer, timel, timem;
+
{
        timer = v.y / g;
+
P = sagl::vec(sagl::r0() + 5, 5, 0);
        timel = 0;
+
V.X = 0;
        while(calculateForTime(v, timer).y > 0) //смотрим на некоторые значения времени, которые больше времени посадки
+
V.Y = sin(angle) * v;
            timer *= 1.5;
+
V.Z = cos(angle) * v;
        timem = timel + (timer - timel) / 2;
+
}
        r = calculateForTime(v, timem);
+
        while(abs(r.y) > e)    //бинарный поиск времени посадки
+
// Отрисовка объекта
        {
+
void Render( sagl::anim &Ani )
            if(r.y > 0)
+
{
                timel = timem;
+
// Вектор ускорения свободного падения и вектор полного ускорения
            else
+
sagl::vec g = sagl::vec(0, -9.8, 0), a;
                timer = timem;
+
// Размер комнаты
            timem = timel + (timer - timel) / 2;
+
double Size = 120;
            r = calculateForTime(v, timem);
+
 
        }
+
// Изменение вектора скорости
        return r;
+
V.Z = V.Z * exp(-n / m * Ani.DeltaTime);
    }
+
V.Y = (V.Y - g.Y * m / n) * exp(-n / m * Ani.DeltaTime) + g.Y * m / n;
}
+
// Изменение вектора перемещения
 +
P += V * Ani.DeltaTime;
  
Vector getCoordinatesVerletSquare(double velocity, double angle, double time = -1)
+
// Ограничения - стенки
{
+
if (P.X > Size / 4)
    double nowTime = dt;
+
V.X = -fabs(V.X);
    Vector rsb(0, 0);
+
if (P.X < -Size / 4)
    if((dt / 2 - time > 0)and(time >= 0))  //если время слишком малое для рсчета
+
V.X = fabs(V.X);
        return rsb; //вернитесь в начальную точку
+
 
    Vector v(velocity * cos(angle), velocity * sin(angle)); //проекции начальной скорости
+
if (P.Y > Size / 4)
    Vector r = v * dt;  //вторая точка
+
V.Y = -fabs(V.Y);
    Vector a = -abs(v) * v * windageSquareCoefficient; //ускорение в начальной точке
+
if (P.Y < -Size / 4)
    a.y -= g;
+
V.Y = fabs(V.Y);
    v = v + a * dt; //скорость во второй точке
 
    a = -abs(v) * v * windageSquareCoefficient; //ускорение во второй точке
 
    a.y -= g;
 
    while((r.y > 0) or ((time > 0) and (nowTime <= time)))  //когда точка выше нулевой отметки и не достигает заданного времени
 
    {
 
        Vector rn = 2 * r - rsb + a * dt * dt;  // r(t+dt) = 2*r(t)-r(t-dt)+a(t)*dt^2;
 
        v = (rn - rsb) / (2 * dt);  // v(t) = (r(t+dt)-r(t-dt))/(2*dt);
 
        rsb = r;    //updating r(t-dt) and r(t)
 
        r = rn;
 
        a = -abs(v) * v * windageSquareCoefficient; //новое a(t)
 
        a.y -= g;
 
        nowTime += dt;  //новое a(t)
 
    }
 
    return r;
 
}
 
  
void err(const char *s) //печатает сообщение об ошибке и завершает работу
+
if (P.Z > Size / 4)
{
+
V.Z = -fabs(V.Z);
    fputs(s, output);
+
if (P.Z < -Size / 4)
    exit(1);
+
V.Z = fabs(V.Z);
}
 
  
int main(int argc, const char *argv[])
+
// Запоминание состояния изменения текущей СК
{
+
glPushMatrix();
    double velocity, angle;
 
    bool needRead = true;
 
    if(argc==3) //если даны 2 аргумента
 
    {
 
        velocity = atof(argv[1]);  //истолкование его как скорости и угла
 
        angle = atof(argv[2]);
 
        needRead = false;
 
    }
 
    if(needRead)
 
    {
 
        puts("Enter initial velocity (m/s)");
 
        scanf("%lf", &velocity);
 
    }
 
    if(velocity < 0)    //проверка, если скорость меньше 0
 
        err("Initial velocity must be above 0");
 
    if(needRead)
 
    {
 
        puts("Enter initial angle (0-180 degrees)");
 
        scanf("%lf", &angle);
 
    }
 
    if((angle < 0) or (angle > 180))    //проверка, что угол в нужном интервале
 
        err("Initial angle must be from 0 to 180");
 
    angle = angle / 180 * M_PI; // a = a/180*pi; преобразование угла из градусов в радианы
 
    output = fopen("Coordinates.txt", "w"); //открытие результативного файла
 
    //вычисление и печать 4 значений
 
    printCoordinate("Without windage", getCoordinatesWithoutWindage(velocity, angle));
 
    printCoordinate("Verlet, linear dependence", getCoordinatesVerletLinear(velocity, angle));
 
    printCoordinate("Accurate, linear dependence", getCoordinatesAccurateLinear(velocity, angle));
 
    printCoordinate("Verlet, square dependence", getCoordinatesVerletSquare(velocity, angle));
 
    fclose(output); //закрытие файла
 
    return 0;
 
}
 
</syntaxhighlight>
 
</div>
 
Скачать можно [http://tm.spbstu.ru/%D0%A4%D0%B0%D0%B9%D0%BB:%D0%9A%D0%BE%D0%BE%D1%80%D0%B4%D0%B8%D0%BD%D0%B0%D1%82%D1%8B.zip здесь]
 
  
 +
// Рисование стенок
 +
glutWireCube(Size / 2);
 +
// Задача перемещения мяча
 +
glTranslated(P.X, P.Y, P.Z);
 +
// Цвет мяча
 +
glColor3d(0, 1, 1);
 +
// Рисование мяча
 +
glutSolidSphere(0.5, 30, 30);
 +
 +
// Восстановление последнего запоминания состояния изменения текущей СК
 +
glPopMatrix();
 +
}
 +
}; // end of 'ball_air_2' class
  
 +
// Шар, летящий с сопротивлением воздуха
 +
// Координаты получены методом Верле при линейной зависимости силы сопротивлении воздуха от скорости
 +
class ball_air_3 : public sagl::object
 +
{
 +
private:
 +
double angle, v, m, n;
 +
public:
 +
// Конструктор
 +
ball_air_3( void ) : angle(Pi / 3), v(1), m(1), n(0.1)
 +
{
 +
P = sagl::vec(sagl::r0() + 5, 5, 0);
 +
V.X = 0;
 +
V.Y = sin(angle) * v;
 +
V.Z = cos(angle) * v;
 +
}
 +
 +
// Конструктор
 +
ball_air_3( double angle1, double v1, double m1, double n1 ) : angle(angle1), v(v1), m(m1), n(n1)
 +
{
 +
P = sagl::vec(sagl::r0() + 5, 5, 0);
 +
V.X = 0;
 +
V.Y = sin(angle) * v;
 +
V.Z = cos(angle) * v;
 +
}
 +
 +
// Отрисовка объекта
 +
void Render( sagl::anim &Ani )
 +
{
 +
// Вектор ускорения свободного падения и вектор полного ускорения
 +
sagl::vec g = sagl::vec(0, -9.8, 0), a;
 +
// Размер комнаты
 +
double Size = 120;
  
<div class="mw-collapsible mw-collapsed" style="width:100%" >
+
// Изменение вектора ускорения
 
+
a = sagl::vec(0, g.Y - n / m * V.Y, -n / m * V.Z);
 
 
'''[[Сенников Иван]]'''
 
 
 
'''Суть программы:'''Программа позволяет отслеживать траекторию движения тела, брошенного под углом к горизонту, в каждом из четырех случаев/методов.
 
 
 
'''Идея:''' Программа состоит из четырех методов: 1) движение тела без учета сопротивления воздуха; 2) движение тела с учетом сопротивления воздуха по первому методу Верле; 3) движение тела с учетом сопротивления воздуха по точному методу; 4) движение тела с учетом сопротивления воздуха по второму методу Верле.
 
 
 
'''Инструкция:''' Результаты программы будут записаны в соответствующий файл (подробности смотри в самой программе). Пользователю будет предоставлена возможность ввести начальную скорость и угол, под которым и бросают тело.
 
 
 
Ссылка для скачиваний: [http://tm.spbstu.ru/Файл:Throws_v2.0.zip здесь].
 
 
 
 
 
'''[[Рубинова Раиса]]'''
 
 
 
'''Описание программы''': программа состоит из четырех независимых друг от друга частей:
 
#  Полет тела без сопротивления воздуха;
 
#  Полет тела при линейной зависимости силы сопротивления воздуха от скорости, при котором координаты тела рассчитываются точным методом;
 
#  Полет тела при линейной зависимости силы сопротивления воздуха от скорости, при котором координаты тела рассчитываются методом Верле;
 
#  Полет тела при квадратичной зависимости силы сопротивлении воздуха от скорости, при котором координаты тела рассчитываются методом Верле;
 
  
Скачать можно [http://tm.spbstu.ru/File:Полет.rar тут].
+
// Изменение вектора скорости
 +
V += a * Ani.DeltaTime;
 +
// Изменение вектора перемещения
 +
P += V * Ani.DeltaTime;
  
<div class="mw-collapsible-content">
+
// Ограничения - стенки
 +
if (P.X > Size / 4)
 +
V.X = -fabs(V.X);
 +
if (P.X < -Size / 4)
 +
V.X = fabs(V.X);
  
[[File:Обычный.png]]
+
if (P.Y > Size / 4)
[[File:Точный.png]]
+
V.Y = -fabs(V.Y);
[[File:Верле2.png]]
+
if (P.Y < -Size / 4)
[[File:Верле1.png]]
+
V.Y = fabs(V.Y);
  
<syntaxhighlight lang="cpp" line start="1" enclose="div">
+
if (P.Z > Size / 4)
// Первый случай
+
V.Z = -fabs(V.Z);
 +
if (P.Z < -Size / 4)
 +
V.Z = fabs(V.Z);
  
#include <iostream>
+
// Запоминание состояния изменения текущей СК
#include <math.h>
+
glPushMatrix();
#include <cstdlib>
 
#include <fstream>
 
  
/// Программа, анализирующая полет тела;
+
// Рисование стенок
 
+
glutWireCube(Size / 2);
using namespace std;
+
// Задача перемещения мяча
double a,s,H,p1,p2,X,f;   /// Создание переменных, необходимых для работы:
+
glTranslated(P.X, P.Y, P.Z);
                                                                                /// a - угол к горизонту, под которым летит тело, вводится пользователем;
+
// Цвет мяча
                                                                                /// s - начальная скорость, с которой тело начинает лететь, вводится пользователем;
+
glColor3d(1, 0.5, 0);
                                                                                /// H - координата тела по оси Oy;
+
// Рисование мяча
                                                                                /// p1, p2 - промежуточные переменные, предназначенные для расчетов;
+
glutSolidSphere(0.5, 30, 30);
                                                                                /// X - координата тела по оси Oy;
+
                                                                                /// f - шаг по времени;
+
// Восстановление последнего запоминания состояния изменения текущей СК
 +
glPopMatrix();
 +
}
 +
}; // end of 'ball_air_3' class
 +
 
 +
#endif /*__SAMPLE_H_ */
 +
 
 +
// END OF 'SAMPLE.H' FILE
 +
</syntaxhighlight>
 +
</div>
 +
[http://tm.spbstu.ru/File:T06BALL.7z Скачать архив]
 +
<br>
 +
 
 +
'''[[Рубинова Раиса]]'''
  
int main()
+
'''Описание программы''': программа состоит из четырех независимых друг от друга частей:
{
+
#  Полет тела без сопротивления воздуха;  
    cout << "Enter speed and angle and step of time" << endl;  /// Обращение к пользователю, где требуется ввести скорость тела, угол к горизонту и шаг по времени;
+
#  Полет тела при линейной зависимости силы сопротивления воздуха от скорости, при котором координаты тела рассчитываются точным методом;
    cin >> s >> a >> f;    /// Считывание данных, введенных пользователем, в переменные;
+
#  Полет тела при линейной зависимости силы сопротивления воздуха от скорости, при котором координаты тела рассчитываются методом Верле;
    double t=s*sin(a*3.14159/180.0)/9.8;        /// Создание новой переменной t, хранящей значение времени полета тела вверх (вычисленное через уравнение скорости по оси Oy);
+
#  Полет тела при квадратичной зависимости силы сопротивлении воздуха от скорости, при котором координаты тела рассчитываются методом Верле;
    for (double i=f; i<(2*t+f); i+=f)      /// Для вычисления координат тела в n-ом количестве точек мы создаем цикл, который повторяется то количество раз, сколько раз шаг по времени, введенным пользователем, вмещается во время полета всего тела;
+
 
    {
+
Скачать можно [http://tm.spbstu.ru/File:Полет.rar тут].
        p1=s*sin(a*3.14159/180)*i;      /// Вычисление первой компоненты координаты тела по оси Oy, представляемй как произведение скорости по этой оси на время (выражено из уравнения равноускоренного прямолинейного движения);
+
 
        p2=4.9*i*i;        /// Вычисление второй компоненты координаты тела по оси Oy, представляемой как произведение квадрата времени на половину укорения свободного падения (выражено из уравнения РУПД);
+
<div class="mw-collapsible-content">
        H=double(p1)-p2;    /// Вычисление координаты тела по оси Oy;
+
 
        X=s*cos(a*3.14159/180)*i;      /// Вычисление координаты тела по оси Ox как произведение скорости по оси Ox на время (выражено из уравнения равномерного движения);
+
[[File:Обычный.png]]
        cerr << X << " ";      /// Вывод на экран значения по оси Ox
+
[[File:Точный.png]]
        cerr << H << endl;      /// и по оси Oy;
+
[[File:Верле2.png]]
    }
+
[[File:Верле1.png]]
    ofstream out("zap.txt");        /// Так как результаты анализа не только выводятся на экран, но и записываются в файл, мы создаем переменную, соответствующую файлу "Res.txt", находящемуся в папке с программой, и открываем файл для записи;
 
    for (double i=0; i<(2*t+f); i+=f)        /// Для вычисления координат тела в n-ом количестве точек мы создаем цикл, который повторяется то количество раз, сколько раз шаг по времени, введенным пользователем, вмещается во время полета всего тела;
 
    {
 
        p1=s*sin(a*3.14159/180)*i;      /// Вычисление первой компоненты координаты тела по оси Oy, представляемй как произведение скорости по этой оси на время (выражено из уравнения равноускоренного прямолинейного движения);
 
        p2=4.9*i*i;            /// Вычисление второй компоненты координаты тела по оси Oy, представляемой как произведение квадрата времени на половину укорения свободного падения (выражено из уравнения РУПД);
 
        H=double(p1)-p2;        /// Вычисление координаты тела по оси Oy;
 
        X=s*cos(a*3.14159/180)*i;      /// Вычисление координаты тела по оси Ox как произведение скорости по оси Ox на время (выражено из уравнения равномерного движения);
 
        out << X << " ";        /// Запись в файл значения по оси Ox
 
        out << H << endl;      /// и по оси Oy;
 
    }
 
    out.close();        /// Закрываем файл, с которым работали в течение программы;
 
    return 0;          /// По умолчанию возвращаем функции int main значение 0, тем самым завершая программу;
 
}
 
  
// Второй случай  
+
<syntaxhighlight lang="cpp" line start="1" enclose="div">
 +
// Первый случай
  
 
#include <iostream>
 
#include <iostream>
Строка 1967: Строка 2150:
 
#include <fstream>
 
#include <fstream>
  
/// Программа, позволяющая описать полет точки при помощи точного метода;
+
/// Программа, анализирующая полет тела;
  
 
using namespace std;
 
using namespace std;
double v,a,st,m;    /// Создание переменных, необходимых для работы:
+
double a,s,H,p1,p2,X,f;    /// Создание переменных, необходимых для работы:
                        /// v - модуль скорости, который задает сам пользователь;
+
                                                                                /// a - угол к горизонту, под которым летит тело, вводится пользователем;
                        /// a - угол относительно горизонта, под которым летит тело, задается пользователем;
+
                                                                                /// s - начальная скорость, с которой тело начинает лететь, вводится пользователем;
                        /// st - шаг по времени, через который расчитываются координаты точек, задается пользователем;
+
                                                                                /// H - координата тела по оси Oy;
                        /// m - масса тела, задается пользователем;
+
                                                                                /// p1, p2 - промежуточные переменные, предназначенные для расчетов;
double *V,*X, *Y, *U;  /// Создание массивов, хранящих значения типа double, в которых хранятся значения:
+
                                                                                /// X - координата тела по оси Oy;
                        /// V - массив, хранящий значения скорости по оси Ox;
+
                                                                                /// f - шаг по времени;
                        /// X - массив, хранящий координаты точки по оси Ox;
 
                        /// Y - массив, хранящий значения скорости по оси Oy;
 
                        /// U - массив, хранящий координаты точки по оси Oy;
 
  
 
int main()
 
int main()
 
{
 
{
     cout << "Enter speed and angle and step of time and weight" << endl;       /// Обращение к пользователю, где требуется ввести скорость тела, угол к горизонту, шаг по времени и массу тела;
+
     cout << "Enter speed and angle and step of time" << endl;   /// Обращение к пользователю, где требуется ввести скорость тела, угол к горизонту и шаг по времени;
     cin >> v >> a >> st >> m;           /// Считывание данных, введенных пользователей в переменные;
+
     cin >> s >> a >> f;     /// Считывание данных, введенных пользователем, в переменные;
     double t=(v/9.8)*sin(3.14159*a/180.0);         /// Создание новой переменной t, хранящей значение времени всего полета тела, вычисленного, как два времени взлета (через уравнение скорости по оси Oy);
+
     double t=s*sin(a*3.14159/180.0)/9.8;       /// Создание новой переменной t, хранящей значение времени полета тела вверх (вычисленное через уравнение скорости по оси Oy);
     int n=2*t/st;      /// Создание новой целочисленной переменной, которая равна времени полета тела (преобразование типов для переменной t) деленного на шаг, которая будет использоваться при создании массивов для размера;
+
     for (double i=f; i<(2*t+f); i+=f)       /// Для вычисления координат тела в n-ом количестве точек мы создаем цикл, который повторяется то количество раз, сколько раз шаг по времени, введенным пользователем, вмещается во время полета всего тела;
    //int p=1/st;
 
    V = new double [n+2];      /// Создание динамического массива V, предназначенного для хранения значений скорости по оси Ox, размером (n+2) (n показывает, сколько раз шаг по времени помещается во все время, то есть, сколько точек мы будем рассматривать, анализируя полет точки);
 
    X = new double [n+2];      /// Создание динамического массива X, предназначенного для хранения координаты тела по оси Ox и имеющего схожие характеристики с массивом V;
 
    Y = new double [n+2];      /// Создание динамического массива X, предназначенного для хранения координаты тела по оси Oy и имеющего схожие характеристики с массивом V;
 
    U = new double [n+2];      /// Создание динамического массива U, предназначенного для хранения значений скорости тела по оси Oy и имеющего схожие характеристики с массивом V;
 
    V[0]=v*cos(3.14159*a/180.0);        /// Вычисление значения скорости по оси Ox в начальный момент времени, как состовляющая модуля скорости, заданного пользователем;
 
    X[0]=0;        /// Задание координаты точки по оси Ox в начальный момент времени. Мы рассматриваем движение тела под углом к горизонту из начала координат, поэтому x=0;
 
    U[0]=v*sin(3.14159*a/180.0);       /// Вычисление значения скорости по оси Oy в начальный момент времени, как компонента модуля скорости, заданного пользователем, по вертикальной оси;
 
    Y[0]=0;        /// Задание координаты точки по оси Oy в начальный момент времени. Мы рассматриваем движение тела под углом к горизонту из начала координат, поэтому y=0;
 
    ofstream out("Res.txt");        /// Так как результаты анализа не только выводятся на экран, но и записываются в файл, мы создаем переменную, соответствующую файлу "Res.txt", находящемуся в папке с программой, и открываем файл для записи;
 
    for (int i=1; i<n; ++i)         /// Для вычисления координат тела в пространстве в зависимости от времени мы создаем цикл, который позволяет, использая общую формулу нахождкения координат и компонент скорости, вычислять эти значения
 
                                    /// Цикл повторяется (n-1) раз, так как значения в начальный момент времени были найдены отдельно от цикла, и повторяется столько раз, сколько точек траектории мы рассматриваем;
 
 
     {
 
     {
         Y[i]=(m/0.001)*(U[0]+9.8*(m/0.001))*(1-exp(((0-0.001)/m)*i*st))-9.8*(m/0.001)*i*st;        /// Вычисление координаты тела в момент времени (i*st) по оси Oy по формуле, выведенной через дифференциальное уравнение точки для вертикальной оси и находящей координату как функцию от времени и координаты тела в предыдущей рассматриваемой нами точке;
+
         p1=s*sin(a*3.14159/180)*i;      /// Вычисление первой компоненты координаты тела по оси Oy, представляемй как произведение скорости по этой оси на время (выражено из уравнения равноускоренного прямолинейного движения);
         X[i]=V[0]*(m/0.001)*(1-exp(((0-0.001)/m)*i*st));         /// Аналогично вычисляем координаты тела в момент времени (i*st) по оси Ox как функцию от времени и координате в предыдущей рассматриваемой точке;
+
        p2=4.9*i*i;        /// Вычисление второй компоненты координаты тела по оси Oy, представляемой как произведение квадрата времени на половину укорения свободного падения (выражено из уравнения РУПД);
                                                                  /// В приведенных выше формулах зачение 0.001 - это коэффициент сопротивления воздуха;
+
        H=double(p1)-p2;    /// Вычисление координаты тела по оси Oy;
                                                                  /// Движение по горизонтальной оси рассматривается как равномерное прямолинейное движение;
+
         X=s*cos(a*3.14159/180)*i;       /// Вычисление координаты тела по оси Ox как произведение скорости по оси Ox на время (выражено из уравнения равномерного движения);
                                                                  /// Движение по вертикальной оси рассматривается как равноускоренное прямолинейное движение;
+
        cerr << X << " ";      /// Вывод на экран значения по оси Ox
         cerr << X[i] << " " << Y[i] << endl;       /// Выведение рассчитанных значений на экран в виде строки, где первым идет координата по оси Ox, вторым - по оси Oy;
+
        cerr << H << endl;      /// и по оси Oy;
         out << X[i] << " " << Y[i] << endl;         /// Запись рассчитанных значений в файл "Res.txt" в виде строки, где первым идет координата по оси Ox, вторым - по оси Oy;
+
    }
                                                    /// Таким образом, в результате работы программы мы получаем два столбика значений для координат по обеим осям, которые как записаны в файл, так и выведены на экран;
+
    ofstream out("zap.txt");        /// Так как результаты анализа не только выводятся на экран, но и записываются в файл, мы создаем переменную, соответствующую файлу "Res.txt", находящемуся в папке с программой, и открываем файл для записи;
 +
    for (double i=0; i<(2*t+f); i+=f)        /// Для вычисления координат тела в n-ом количестве точек мы создаем цикл, который повторяется то количество раз, сколько раз шаг по времени, введенным пользователем, вмещается во время полета всего тела;
 +
    {
 +
        p1=s*sin(a*3.14159/180)*i;      /// Вычисление первой компоненты координаты тела по оси Oy, представляемй как произведение скорости по этой оси на время (выражено из уравнения равноускоренного прямолинейного движения);
 +
        p2=4.9*i*i;            /// Вычисление второй компоненты координаты тела по оси Oy, представляемой как произведение квадрата времени на половину укорения свободного падения (выражено из уравнения РУПД);
 +
        H=double(p1)-p2;        /// Вычисление координаты тела по оси Oy;
 +
         X=s*cos(a*3.14159/180)*i;       /// Вычисление координаты тела по оси Ox как произведение скорости по оси Ox на время (выражено из уравнения равномерного движения);
 +
         out << X << " ";       /// Запись в файл значения по оси Ox
 +
        out << H << endl;       /// и по оси Oy;
 
     }
 
     }
 
     out.close();        /// Закрываем файл, с которым работали в течение программы;
 
     out.close();        /// Закрываем файл, с которым работали в течение программы;
 
     return 0;          /// По умолчанию возвращаем функции int main значение 0, тем самым завершая программу;
 
     return 0;          /// По умолчанию возвращаем функции int main значение 0, тем самым завершая программу;
 
 
 
}
 
}
  
// Третий случай
+
// Второй случай  
  
 
#include <iostream>
 
#include <iostream>
Строка 2022: Строка 2196:
 
#include <fstream>
 
#include <fstream>
  
/// Программа, анализирующая полет тела при помощи модифицированного метода Верле;
+
/// Программа, позволяющая описать полет точки при помощи точного метода;
  
 
using namespace std;
 
using namespace std;
double v,a,st,m,x,y;    /// Создание переменных, необходимых для работы;
+
double v,a,st,m;    /// Создание переменных, необходимых для работы:
 
                         /// v - модуль скорости, который задает сам пользователь;
 
                         /// v - модуль скорости, который задает сам пользователь;
 
                         /// a - угол относительно горизонта, под которым летит тело, задается пользователем;
 
                         /// a - угол относительно горизонта, под которым летит тело, задается пользователем;
 
                         /// st - шаг по времени, через который расчитываются координаты точек, задается пользователем;
 
                         /// st - шаг по времени, через который расчитываются координаты точек, задается пользователем;
 
                         /// m - масса тела, задается пользователем;
 
                         /// m - масса тела, задается пользователем;
                        /// x - координата тела по оси Ox в мнимый момент времени t=-1;
 
                        /// y - координата тела по оси Oy в мнимый момент времени t=-1;
 
 
double *V,*X, *Y, *U;  /// Создание массивов, хранящих значения типа double, в которых хранятся значения:
 
double *V,*X, *Y, *U;  /// Создание массивов, хранящих значения типа double, в которых хранятся значения:
 
                         /// V - массив, хранящий значения скорости по оси Ox;
 
                         /// V - массив, хранящий значения скорости по оси Ox;
Строка 2040: Строка 2212:
 
int main()
 
int main()
 
{
 
{
     cout << "Enter speed and angle and step of time and weight" << endl;   /// Обращение к пользователю, где требуется ввести скорость тела, угол к горизонту, шаг по времени и массу тела;
+
     cout << "Enter speed and angle and step of time and weight" << endl;       /// Обращение к пользователю, где требуется ввести скорость тела, угол к горизонту, шаг по времени и массу тела;
     cin >> v >> a >> st >> m;       /// Считывание данных, введенных пользователей в переменные;
+
     cin >> v >> a >> st >> m;           /// Считывание данных, введенных пользователей в переменные;
     double t=(v/9.8)*sin(3.14159*a/180.0);     /// Создание новой переменной t, хранящей значение времени всего полета тела, вычисленного, как два времени взлета (через уравнение скорости по оси Oy);
+
     double t=(v/9.8)*sin(3.14159*a/180.0);         /// Создание новой переменной t, хранящей значение времени всего полета тела, вычисленного, как два времени взлета (через уравнение скорости по оси Oy);
     int n=2*t/st;   /// Создание новой целочисленной переменной, которая равна времени полета тела (преобразование типов для переменной t) деленного на шаг, которая будет использоваться при создании массивов для размера;
+
     int n=2*t/st;       /// Создание новой целочисленной переменной, которая равна времени полета тела (преобразование типов для переменной t) деленного на шаг, которая будет использоваться при создании массивов для размера;
 
     //int p=1/st;
 
     //int p=1/st;
 
     V = new double [n+2];      /// Создание динамического массива V, предназначенного для хранения значений скорости по оси Ox, размером (n+2) (n показывает, сколько раз шаг по времени помещается во все время, то есть, сколько точек мы будем рассматривать, анализируя полет точки);
 
     V = new double [n+2];      /// Создание динамического массива V, предназначенного для хранения значений скорости по оси Ox, размером (n+2) (n показывает, сколько раз шаг по времени помещается во все время, то есть, сколько точек мы будем рассматривать, анализируя полет точки);
Строка 2049: Строка 2221:
 
     Y = new double [n+2];      /// Создание динамического массива X, предназначенного для хранения координаты тела по оси Oy и имеющего схожие характеристики с массивом V;
 
     Y = new double [n+2];      /// Создание динамического массива X, предназначенного для хранения координаты тела по оси Oy и имеющего схожие характеристики с массивом V;
 
     U = new double [n+2];      /// Создание динамического массива U, предназначенного для хранения значений скорости тела по оси Oy и имеющего схожие характеристики с массивом V;
 
     U = new double [n+2];      /// Создание динамического массива U, предназначенного для хранения значений скорости тела по оси Oy и имеющего схожие характеристики с массивом V;
     V[0]=v*cos(3.14159*a/180.0);   /// Вычисление значения скорости по оси Ox в начальный момент времени, как состовляющая модуля скорости, заданного пользователем;
+
     V[0]=v*cos(3.14159*a/180.0);       /// Вычисление значения скорости по оси Ox в начальный момент времени, как состовляющая модуля скорости, заданного пользователем;
     X[0]=0;     /// Задание координаты точки по оси Ox в начальный момент времени. Мы рассматриваем движение тела под углом к горизонту из начала координат, поэтому x=0;
+
     X[0]=0;         /// Задание координаты точки по оси Ox в начальный момент времени. Мы рассматриваем движение тела под углом к горизонту из начала координат, поэтому x=0;
    x=X[0]-V[0]*st;    /// Суть данного метода заключается в том, что мы находим значение параметров тела по предыдущим двум состояниям, поэтому нам нужно вычислить мнимые координаты тела в -1 момент времени. Это расчет коордлинаты по оси Ox;
+
     U[0]=v*sin(3.14159*a/180.0);       /// Вычисление значения скорости по оси Oy в начальный момент времени, как компонента модуля скорости, заданного пользователем, по вертикальной оси;
    X[1]=2*X[0]-x-(0.01/m)*V[0]*st*st;  /// Вычисление координаты тела по оси Ox в момент времени t=1;
+
     Y[0]=0;         /// Задание координаты точки по оси Oy в начальный момент времени. Мы рассматриваем движение тела под углом к горизонту из начала координат, поэтому y=0;
     U[0]=v*sin(3.14159*a/180.0);   /// Вычисление значения скорости по оси Oy в начальный момент времени, как компонента модуля скорости, заданного пользователем, по вертикальной оси;
 
     Y[0]=0;     /// Задание координаты точки по оси Oy в начальный момент времени. Мы рассматриваем движение тела под углом к горизонту из начала координат, поэтому y=0;
 
    y=Y[0]-U[0]*st;    /// Суть данного метода заключается в том, что мы находим значение параметров тела по предыдущим двум состояниям, поэтому нам нужно вычислить мнимые координаты тела в -1 момент времени. Это расчет коордлинаты по оси Oу;
 
    Y[1]=2*Y[0]-y-(0.01/m)*U[0]*st*st;      /// Вычисление координаты тела по оси Oу в момент времени t=1;
 
    cerr << X[1] << " " << Y[1] << endl;    /// Вывод на экран значений координат по обеим осям в момент времени t=1;
 
 
     ofstream out("Res.txt");        /// Так как результаты анализа не только выводятся на экран, но и записываются в файл, мы создаем переменную, соответствующую файлу "Res.txt", находящемуся в папке с программой, и открываем файл для записи;
 
     ofstream out("Res.txt");        /// Так как результаты анализа не только выводятся на экран, но и записываются в файл, мы создаем переменную, соответствующую файлу "Res.txt", находящемуся в папке с программой, и открываем файл для записи;
    out << X[1] << " " << Y[1] << endl;    /// Записываем в файл полученные значения координат тела в момент времени t=1;
+
     for (int i=1; i<n; ++i)         /// Для вычисления координат тела в пространстве в зависимости от времени мы создаем цикл, который позволяет, использая общую формулу нахождкения координат и компонент скорости, вычислять эти значения
    int k=1;        /// Создаем целочисленную переменную k=1 для работы в цикле;
+
                                    /// Цикл повторяется (n-1) раз, так как значения в начальный момент времени были найдены отдельно от цикла, и повторяется столько раз, сколько точек траектории мы рассматриваем;
    //cerr<<"N "<<n<<"\n";
 
     for (int i=0; i<n; ++i)     /// Для вычисления координат тела в пространстве в зависимости от времени мы создаем цикл, который позволяет, использая общую формулу нахождкения координат и компонент скорости, вычислять эти значения
 
                                /// Цикл повторяется (n-1) раз, так как значения в начальный момент времени были найдены отдельно от цикла, и повторяется столько раз, сколько точек траектории мы рассматриваем;
 
 
     {
 
     {
         X[k+1]=2.0*X[k]-X[k-1]-(0.001/m)*V[k]*st*st;   /// Нахождение координаты тела по оси Ox в момент времени t, основываясь на известных параметрах за моменты времени t-1 и t-2;
+
         Y[i]=(m/0.001)*(U[0]+9.8*(m/0.001))*(1-exp(((0-0.001)/m)*i*st))-9.8*(m/0.001)*i*st;         /// Вычисление координаты тела в момент времени (i*st) по оси Oy по формуле, выведенной через дифференциальное уравнение точки для вертикальной оси и находящей координату как функцию от времени и координаты тела в предыдущей рассматриваемой нами точке;
        V[k]=(X[k+1]-X[k-1])/(2*st);        /// Нахождение значения скорости тела по оси Ox в момент времени t-1, основываясь на рассчитанных выше координатах тела по оси Ox длямоментов времени t и t-2;
+
         X[i]=V[0]*(m/0.001)*(1-exp(((0-0.001)/m)*i*st));         /// Аналогично вычисляем координаты тела в момент времени (i*st) по оси Ox как функцию от времени и координате в предыдущей рассматриваемой точке;
         Y[k+1]=2.0*Y[k]-Y[k-1]-(9.8+(0.001/m)*U[k])*st*st;     /// Нахождение координаты тела по оси Oy в момент времени t, основываясь на известных параметрах за моменты времени t-1 и t-2;
+
                                                                  /// В приведенных выше формулах зачение 0.001 - это коэффициент сопротивления воздуха;
        U[k]=(Y[k+1]-Y[k-1])/(2*st);       /// Нахождение значения скорости тела по оси Oy в момент времени t-1, основываясь на рассчитанных выше координатах тела по оси Ox длямоментов времени t и t-2;
+
                                                                  /// Движение по горизонтальной оси рассматривается как равномерное прямолинейное движение;
        //cerr <<i<<" "<<k<<" "<<
+
                                                                  /// Движение по вертикальной оси рассматривается как равноускоренное прямолинейное движение;
         cerr << X[k+1] << " " << Y[k+1] << endl;   /// Выведение рассчитанных значений на экран в виде строки, где первым идет координата по оси Ox, вторым - по оси Oy;
+
         cerr << X[i] << " " << Y[i] << endl;       /// Выведение рассчитанных значений на экран в виде строки, где первым идет координата по оси Ox, вторым - по оси Oy;
         out << X[k+1] << " " << Y[k+1] << endl;     /// Запись рассчитанных значений в файл "Res.txt" в виде строки, где первым идет координата по оси Ox, вторым - по оси Oy;
+
         out << X[i] << " " << Y[i] << endl;         /// Запись рассчитанных значений в файл "Res.txt" в виде строки, где первым идет координата по оси Ox, вторым - по оси Oy;
        k=k+1;      /// Увеличиваем число k на единицу, чтобы в следующем шаге цикла рассчитать значения для следующего момента времени;
+
                                                    /// Таким образом, в результате работы программы мы получаем два столбика значений для координат по обеим осям, которые как записаны в файл, так и выведены на экран;
                    /// Таким образом, в результате работы программы мы получаем два столбика значений для координат по обеим осям, которые как записаны в файл, так и выведены на экран;
 
 
     }
 
     }
     out.close();   /// Закрываем файл, с которым работали в течение программы;
+
     out.close();       /// Закрываем файл, с которым работали в течение программы;
     return 0;       /// По умолчанию возвращаем функции int main значение 0, тем самым завершая программу;
+
     return 0;           /// По умолчанию возвращаем функции int main значение 0, тем самым завершая программу;
 +
 
 +
 
 
}
 
}
  
// Четвертый случай
+
// Третий случай
  
 
#include <iostream>
 
#include <iostream>
Строка 2086: Строка 2251:
 
#include <fstream>
 
#include <fstream>
  
/// Программа, анализирующая полет тела при помощи метода Верле;
+
/// Программа, анализирующая полет тела при помощи модифицированного метода Верле;
  
 
using namespace std;
 
using namespace std;
double v,a,st,m,x,y;       /// Создание переменных, необходимых для работы:
+
double v,a,st,m,x,y;   /// Создание переменных, необходимых для работы;
                            /// v - модуль скорости, который задает сам пользователь;
+
                        /// v - модуль скорости, который задает сам пользователь;
                            /// a - угол относительно горизонта, под которым летит тело, задается пользователем;
+
                        /// a - угол относительно горизонта, под которым летит тело, задается пользователем;
                            /// st - шаг по времени, через который расчитываются координаты точек, задается пользователем;
+
                        /// st - шаг по времени, через который расчитываются координаты точек, задается пользователем;
                            /// m - масса тела, задается пользователем;
+
                        /// m - масса тела, задается пользователем;
                            /// x - координата тела по оси Ox в мнимый момент времени t=-1;
+
                        /// x - координата тела по оси Ox в мнимый момент времени t=-1;
                            /// y - координата тела по оси Oy в мнимый момент времени t=-1;
+
                        /// y - координата тела по оси Oy в мнимый момент времени t=-1;
double *V,*X, *Y, *U;       /// Создание массивов, хранящих значения типа double, в которых хранятся значения:
+
double *V,*X, *Y, *U;   /// Создание массивов, хранящих значения типа double, в которых хранятся значения:
                            /// V - массив, хранящий значения скорости по оси Ox;
+
                        /// V - массив, хранящий значения скорости по оси Ox;
                            /// X - массив, хранящий координаты точки по оси Ox;
+
                        /// X - массив, хранящий координаты точки по оси Ox;
                            /// Y - массив, хранящий значения скорости по оси Oy;
+
                        /// Y - массив, хранящий значения скорости по оси Oy;
                            /// U - массив, хранящий координаты точки по оси Oy;
+
                        /// U - массив, хранящий координаты точки по оси Oy;
  
 
int main()
 
int main()
 
{
 
{
     cout << "Enter speed and angle and step of time and weight" << endl;       /// Обращение к пользователю, где требуется ввести скорость тела, угол к горизонту, шаг по времени и массу тела;
+
     cout << "Enter speed and angle and step of time and weight" << endl;   /// Обращение к пользователю, где требуется ввести скорость тела, угол к горизонту, шаг по времени и массу тела;
     cin >> v >> a >> st >> m;      /// Считывание данных, введенных пользователем, в переменные;
+
     cin >> v >> a >> st >> m;      /// Считывание данных, введенных пользователей в переменные;
 
     double t=(v/9.8)*sin(3.14159*a/180.0);      /// Создание новой переменной t, хранящей значение времени всего полета тела, вычисленного, как два времени взлета (через уравнение скорости по оси Oy);
 
     double t=(v/9.8)*sin(3.14159*a/180.0);      /// Создание новой переменной t, хранящей значение времени всего полета тела, вычисленного, как два времени взлета (через уравнение скорости по оси Oy);
     int n=2*t/st;           /// Создание новой целочисленной переменной, которая равна времени полета тела (преобразование типов для переменной t) деленного на шаг, которая будет использоваться при создании массивов для размера;
+
     int n=2*t/st;   /// Создание новой целочисленной переменной, которая равна времени полета тела (преобразование типов для переменной t) деленного на шаг, которая будет использоваться при создании массивов для размера;
 
     //int p=1/st;
 
     //int p=1/st;
     V = new double [n+2];   /// Создание динамического массива V, предназначенного для хранения значений скорости по оси Ox, размером (n+2) (n показывает, сколько раз шаг по времени помещается во все время, то есть, сколько точек мы будем рассматривать, анализируя полет точки);
+
     V = new double [n+2];       /// Создание динамического массива V, предназначенного для хранения значений скорости по оси Ox, размером (n+2) (n показывает, сколько раз шаг по времени помещается во все время, то есть, сколько точек мы будем рассматривать, анализируя полет точки);
     X = new double [n+2];   /// Создание динамического массива X, предназначенного для хранения координаты тела по оси Ox и имеющего схожие характеристики с массивом V;
+
     X = new double [n+2];       /// Создание динамического массива X, предназначенного для хранения координаты тела по оси Ox и имеющего схожие характеристики с массивом V;
     Y = new double [n+2];   /// Создание динамического массива X, предназначенного для хранения координаты тела по оси Oy и имеющего схожие характеристики с массивом V;
+
     Y = new double [n+2];       /// Создание динамического массива X, предназначенного для хранения координаты тела по оси Oy и имеющего схожие характеристики с массивом V;
     U = new double [n+2];   /// Создание динамического массива U, предназначенного для хранения значений скорости тела по оси Oy и имеющего схожие характеристики с массивом V;
+
     U = new double [n+2];       /// Создание динамического массива U, предназначенного для хранения значений скорости тела по оси Oy и имеющего схожие характеристики с массивом V;
     V[0]=v*cos(3.14159*a/180.0);       /// Вычисление значения скорости по оси Ox в начальный момент времени, как состовляющая модуля скорости, заданного пользователем;
+
     V[0]=v*cos(3.14159*a/180.0);   /// Вычисление значения скорости по оси Ox в начальный момент времени, как состовляющая модуля скорости, заданного пользователем;
     X[0]=0;                 /// Задание координаты точки по оси Ox в начальный момент времени. Мы рассматриваем движение тела под углом к горизонту из начала координат, поэтому x=0;
+
     X[0]=0;     /// Задание координаты точки по оси Ox в начальный момент времени. Мы рассматриваем движение тела под углом к горизонту из начала координат, поэтому x=0;
     x=X[0]-V[0]*st;         /// Суть данного метода заключается в том, что мы находим значение параметров тела по предыдущим двум состояниям, поэтому нам нужно вычислить мнимые координаты тела в -1 момент времени. Это расчет коордлинаты по оси Ox;
+
     x=X[0]-V[0]*st;     /// Суть данного метода заключается в том, что мы находим значение параметров тела по предыдущим двум состояниям, поэтому нам нужно вычислить мнимые координаты тела в -1 момент времени. Это расчет коордлинаты по оси Ox;
     X[1]=2*X[0]-x-(0.01/m)*V[0]*V[0]/cos(3.14159*a/180.0)*st*st;   /// Вычисление координаты тела по оси Ox в момент времени t=1;
+
     X[1]=2*X[0]-x-(0.01/m)*V[0]*st*st; /// Вычисление координаты тела по оси Ox в момент времени t=1;
 
     U[0]=v*sin(3.14159*a/180.0);    /// Вычисление значения скорости по оси Oy в начальный момент времени, как компонента модуля скорости, заданного пользователем, по вертикальной оси;
 
     U[0]=v*sin(3.14159*a/180.0);    /// Вычисление значения скорости по оси Oy в начальный момент времени, как компонента модуля скорости, заданного пользователем, по вертикальной оси;
     Y[0]=0;                 /// Задание координаты точки по оси Oy в начальный момент времени. Мы рассматриваем движение тела под углом к горизонту из начала координат, поэтому y=0;
+
     Y[0]=0;     /// Задание координаты точки по оси Oy в начальный момент времени. Мы рассматриваем движение тела под углом к горизонту из начала координат, поэтому y=0;
     y=Y[0]-U[0]*st;         /// Суть данного метода заключается в том, что мы находим значение параметров тела по предыдущим двум состояниям, поэтому нам нужно вычислить мнимые координаты тела в -1 момент времени. Это расчет коордлинаты по оси Oу;
+
     y=Y[0]-U[0]*st;     /// Суть данного метода заключается в том, что мы находим значение параметров тела по предыдущим двум состояниям, поэтому нам нужно вычислить мнимые координаты тела в -1 момент времени. Это расчет коордлинаты по оси Oу;
     Y[1]=2*Y[0]-y-(0.01/m)*U[0]*U[0]/sin(3.14159*a/180.0)*st*st;   /// Вычисление координаты тела по оси Oу в момент времени t=1;
+
     Y[1]=2*Y[0]-y-(0.01/m)*U[0]*st*st;     /// Вычисление координаты тела по оси Oу в момент времени t=1;
 
     cerr << X[1] << " " << Y[1] << endl;    /// Вывод на экран значений координат по обеим осям в момент времени t=1;
 
     cerr << X[1] << " " << Y[1] << endl;    /// Вывод на экран значений координат по обеим осям в момент времени t=1;
 
     ofstream out("Res.txt");        /// Так как результаты анализа не только выводятся на экран, но и записываются в файл, мы создаем переменную, соответствующую файлу "Res.txt", находящемуся в папке с программой, и открываем файл для записи;
 
     ofstream out("Res.txt");        /// Так как результаты анализа не только выводятся на экран, но и записываются в файл, мы создаем переменную, соответствующую файлу "Res.txt", находящемуся в папке с программой, и открываем файл для записи;
     out << X[1] << " " << Y[1] << endl;         /// Записываем в файл полученные значения координат тела в момент времени t=1;
+
     out << X[1] << " " << Y[1] << endl;     /// Записываем в файл полученные значения координат тела в момент времени t=1;
     int k=1;           /// Создаем целочисленную переменную k=1 для работы в цикле;
+
     int k=1;       /// Создаем целочисленную переменную k=1 для работы в цикле;
 
     //cerr<<"N "<<n<<"\n";
 
     //cerr<<"N "<<n<<"\n";
     for (int i=0; i<n; ++i)         /// Для вычисления координат тела в пространстве в зависимости от времени мы создаем цикл, который позволяет, использая общую формулу нахождкения координат и компонент скорости, вычислять эти значения
+
     for (int i=0; i<n; ++i)     /// Для вычисления координат тела в пространстве в зависимости от времени мы создаем цикл, который позволяет, использая общую формулу нахождкения координат и компонент скорости, вычислять эти значения
                                    /// Цикл повторяется (n-1) раз, так как значения в начальный момент времени были найдены отдельно от цикла, и повторяется столько раз, сколько точек траектории мы рассматриваем;
+
                                /// Цикл повторяется (n-1) раз, так как значения в начальный момент времени были найдены отдельно от цикла, и повторяется столько раз, сколько точек траектории мы рассматриваем;
 
     {
 
     {
         X[k+1]=2.0*X[k]-X[k-1]-(0.001/m)*V[k]*V[k]*st*st;       /// Нахождение координаты тела по оси Ox в момент времени t, основываясь на известных параметрах за моменты времени t-1 и t-2;
+
         X[k+1]=2.0*X[k]-X[k-1]-(0.001/m)*V[k]*st*st;   /// Нахождение координаты тела по оси Ox в момент времени t, основываясь на известных параметрах за моменты времени t-1 и t-2;
 
         V[k]=(X[k+1]-X[k-1])/(2*st);        /// Нахождение значения скорости тела по оси Ox в момент времени t-1, основываясь на рассчитанных выше координатах тела по оси Ox длямоментов времени t и t-2;
 
         V[k]=(X[k+1]-X[k-1])/(2*st);        /// Нахождение значения скорости тела по оси Ox в момент времени t-1, основываясь на рассчитанных выше координатах тела по оси Ox длямоментов времени t и t-2;
         Y[k+1]=2.0*Y[k]-Y[k-1]-(9.8+(0.001/m)*U[k]*U[k])*st*st;     /// Нахождение координаты тела по оси Oy в момент времени t, основываясь на известных параметрах за моменты времени t-1 и t-2;
+
         Y[k+1]=2.0*Y[k]-Y[k-1]-(9.8+(0.001/m)*U[k])*st*st;     /// Нахождение координаты тела по оси Oy в момент времени t, основываясь на известных параметрах за моменты времени t-1 и t-2;
         U[k]=(Y[k+1]-Y[k-1])/(2*st);   /// Нахождение значения скорости тела по оси Oy в момент времени t-1, основываясь на рассчитанных выше координатах тела по оси Ox длямоментов времени t и t-2;
+
         U[k]=(Y[k+1]-Y[k-1])/(2*st);       /// Нахождение значения скорости тела по оси Oy в момент времени t-1, основываясь на рассчитанных выше координатах тела по оси Ox длямоментов времени t и t-2;
 
         //cerr <<i<<" "<<k<<" "<<
 
         //cerr <<i<<" "<<k<<" "<<
 
         cerr << X[k+1] << " " << Y[k+1] << endl;    /// Выведение рассчитанных значений на экран в виде строки, где первым идет координата по оси Ox, вторым - по оси Oy;
 
         cerr << X[k+1] << " " << Y[k+1] << endl;    /// Выведение рассчитанных значений на экран в виде строки, где первым идет координата по оси Ox, вторым - по оси Oy;
 
         out << X[k+1] << " " << Y[k+1] << endl;    /// Запись рассчитанных значений в файл "Res.txt" в виде строки, где первым идет координата по оси Ox, вторым - по оси Oy;
 
         out << X[k+1] << " " << Y[k+1] << endl;    /// Запись рассчитанных значений в файл "Res.txt" в виде строки, где первым идет координата по оси Ox, вторым - по оси Oy;
 
         k=k+1;      /// Увеличиваем число k на единицу, чтобы в следующем шаге цикла рассчитать значения для следующего момента времени;
 
         k=k+1;      /// Увеличиваем число k на единицу, чтобы в следующем шаге цикла рассчитать значения для следующего момента времени;
                                                    /// Таким образом, в результате работы программы мы получаем два столбика значений для координат по обеим осям, которые как записаны в файл, так и выведены на экран;
+
                    /// Таким образом, в результате работы программы мы получаем два столбика значений для координат по обеим осям, которые как записаны в файл, так и выведены на экран;
 
     }
 
     }
 
     out.close();    /// Закрываем файл, с которым работали в течение программы;
 
     out.close();    /// Закрываем файл, с которым работали в течение программы;
Строка 2143: Строка 2308:
 
}
 
}
  
</syntaxhighlight>
+
// Четвертый случай
</div>
 
  
 +
#include <iostream>
 +
#include <math.h>
 +
#include <cstdlib>
 +
#include <fstream>
  
'''[[Козловская Анна]]'''
+
/// Программа, анализирующая полет тела при помощи метода Верле;
  
 +
using namespace std;
 +
double v,a,st,m,x,y;        /// Создание переменных, необходимых для работы:
 +
                            /// v - модуль скорости, который задает сам пользователь;
 +
                            /// a - угол относительно горизонта, под которым летит тело, задается пользователем;
 +
                            /// st - шаг по времени, через который расчитываются координаты точек, задается пользователем;
 +
                            /// m - масса тела, задается пользователем;
 +
                            /// x - координата тела по оси Ox в мнимый момент времени t=-1;
 +
                            /// y - координата тела по оси Oy в мнимый момент времени t=-1;
 +
double *V,*X, *Y, *U;      /// Создание массивов, хранящих значения типа double, в которых хранятся значения:
 +
                            /// V - массив, хранящий значения скорости по оси Ox;
 +
                            /// X - массив, хранящий координаты точки по оси Ox;
 +
                            /// Y - массив, хранящий значения скорости по оси Oy;
 +
                            /// U - массив, хранящий координаты точки по оси Oy;
  
'''Описание программы''': программа записывает в четыре файла результаты вычисления:
+
int main()
# Координаты, рассчитанные по формуле, при движении без сопротивления воздуха;  
+
{
# Координаты, полученные методом Верле при линейной зависимости силы сопротивлении воздуха от скорости;
+
    cout << "Enter speed and angle and step of time and weight" << endl;        /// Обращение к пользователю, где требуется ввести скорость тела, угол к горизонту, шаг по времени и массу тела;
# Координаты, полученные из точного решения, при линейной зависимости силы сопротивлении воздуха от скорости;
+
    cin >> v >> a >> st >> m;      /// Считывание данных, введенных пользователем, в переменные;
# Координаты, полученные методом Верле при квадратичной зависимости силы сопротивлении воздуха от скорости.
+
    double t=(v/9.8)*sin(3.14159*a/180.0);      /// Создание новой переменной t, хранящей значение времени всего полета тела, вычисленного, как два времени взлета (через уравнение скорости по оси Oy);
 
+
    int n=2*t/st;          /// Создание новой целочисленной переменной, которая равна времени полета тела (преобразование типов для переменной t) деленного на шаг, которая будет использоваться при создании массивов для размера;
Скачать можно  [http://tm.spbstu.ru/File:project2.rar тут].
+
    //int p=1/st;
 
+
    V = new double [n+2];  /// Создание динамического массива V, предназначенного для хранения значений скорости по оси Ox, размером (n+2) (n показывает, сколько раз шаг по времени помещается во все время, то есть, сколько точек мы будем рассматривать, анализируя полет точки);
<br>'''[[Нарядчиков Александр]]'''<br>
+
    X = new double [n+2];  /// Создание динамического массива X, предназначенного для хранения координаты тела по оси Ox и имеющего схожие характеристики с массивом V;
'''Инструкция:''' Пользователю достаточно просто запустить программу.<br>
+
    Y = new double [n+2];  /// Создание динамического массива X, предназначенного для хранения координаты тела по оси Oy и имеющего схожие характеристики с массивом V;
'''Описание программы:''' В комнате скачут 4 мячика, первый двигается без сопротивления воздуха, второй двигается с квадратичной зависимостью сопротивления воздуха от скорости (Метод Верле), третий двигается с линейной зависимостью сопротивления воздуха от скорости (точное решение), четвертый двигается с линейной зависимостью сопротивления воздуха от скорости (Метод Верле).<br>
+
    U = new double [n+2];  /// Создание динамического массива U, предназначенного для хранения значений скорости тела по оси Oy и имеющего схожие характеристики с массивом V;
'''Описание алгоритма:''' Программа реализована с помощью системы анимации(class anim), используя библиотеки OpenGl и GLUT. Изменения координат мячей проходят в режиме реального времени в векторной форме.<br>
+
    V[0]=v*cos(3.14159*a/180.0);        /// Вычисление значения скорости по оси Ox в начальный момент времени, как состовляющая модуля скорости, заданного пользователем;
<div class="mw-collapsible mw-collapsed" style="width:100%" >
+
    X[0]=0;                /// Задание координаты точки по оси Ox в начальный момент времени. Мы рассматриваем движение тела под углом к горизонту из начала координат, поэтому x=0;
"'''T06BALL.CPP'''"
+
    x=X[0]-V[0]*st;        /// Суть данного метода заключается в том, что мы находим значение параметров тела по предыдущим двум состояниям, поэтому нам нужно вычислить мнимые координаты тела в -1 момент времени. Это расчет коордлинаты по оси Ox;
<syntaxhighlight lang="cpp" line start="1" enclose="div">
+
    X[1]=2*X[0]-x-(0.01/m)*V[0]*V[0]/cos(3.14159*a/180.0)*st*st;    /// Вычисление координаты тела по оси Ox в момент времени t=1;
/* FILENAME: T06BALL.CPP
+
    U[0]=v*sin(3.14159*a/180.0);    /// Вычисление значения скорости по оси Oy в начальный момент времени, как компонента модуля скорости, заданного пользователем, по вертикальной оси;
* LAST UPDATE: 17.01.2016
+
    Y[0]=0;                /// Задание координаты точки по оси Oy в начальный момент времени. Мы рассматриваем движение тела под углом к горизонту из начала координат, поэтому y=0;
*/
+
    y=Y[0]-U[0]*st;        /// Суть данного метода заключается в том, что мы находим значение параметров тела по предыдущим двум состояниям, поэтому нам нужно вычислить мнимые координаты тела в -1 момент времени. Это расчет коордлинаты по оси Oу;
 
+
    Y[1]=2*Y[0]-y-(0.01/m)*U[0]*U[0]/sin(3.14159*a/180.0)*st*st;    /// Вычисление координаты тела по оси Oу в момент времени t=1;
#include "ANIM.H"
+
    cerr << X[1] << " " << Y[1] << endl;    /// Вывод на экран значений координат по обеим осям в момент времени t=1;
#include "SAMPLE.H"
+
    ofstream out("Res.txt");        /// Так как результаты анализа не только выводятся на экран, но и записываются в файл, мы создаем переменную, соответствующую файлу "Res.txt", находящемуся в папке с программой, и открываем файл для записи;
 
+
    out << X[1] << " " << Y[1] << endl;        /// Записываем в файл полученные значения координат тела в момент времени t=1;
/* Main function */
+
    int k=1;            /// Создаем целочисленную переменную k=1 для работы в цикле;
void main( void )
+
    //cerr<<"N "<<n<<"\n";
{
+
    for (int i=0; i<n; ++i)        /// Для вычисления координат тела в пространстве в зависимости от времени мы создаем цикл, который позволяет, использая общую формулу нахождкения координат и компонент скорости, вычислять эти значения
// Получение единственного экземпляра класса анимации
+
                                    /// Цикл повторяется (n-1) раз, так как значения в начальный момент времени были найдены отдельно от цикла, и повторяется столько раз, сколько точек траектории мы рассматриваем;
sagl::anim &My = sagl::anim::Get();
+
    {
 
+
        X[k+1]=2.0*X[k]-X[k-1]-(0.001/m)*V[k]*V[k]*st*st;      /// Нахождение координаты тела по оси Ox в момент времени t, основываясь на известных параметрах за моменты времени t-1 и t-2;
// Шар, летящий без сопротивлением воздуха
+
        V[k]=(X[k+1]-X[k-1])/(2*st);        /// Нахождение значения скорости тела по оси Ox в момент времени t-1, основываясь на рассчитанных выше координатах тела по оси Ox длямоментов времени t и t-2;
         for (int i = 0; i < 1; i++)
+
        Y[k+1]=2.0*Y[k]-Y[k-1]-(9.8+(0.001/m)*U[k]*U[k])*st*st;     /// Нахождение координаты тела по оси Oy в момент времени t, основываясь на известных параметрах за моменты времени t-1 и t-2;
                My << new ball(Pi / 6, 10 + i);
+
         U[k]=(Y[k+1]-Y[k-1])/(2*st);    /// Нахождение значения скорости тела по оси Oy в момент времени t-1, основываясь на рассчитанных выше координатах тела по оси Ox длямоментов времени t и t-2;
 +
        //cerr <<i<<" "<<k<<" "<<
 +
        cerr << X[k+1] << " " << Y[k+1] << endl;   /// Выведение рассчитанных значений на экран в виде строки, где первым идет координата по оси Ox, вторым - по оси Oy;
 +
        out << X[k+1] << " " << Y[k+1] << endl;    /// Запись рассчитанных значений в файл "Res.txt" в виде строки, где первым идет координата по оси Ox, вторым - по оси Oy;
 +
        k=k+1;      /// Увеличиваем число k на единицу, чтобы в следующем шаге цикла рассчитать значения для следующего момента времени;
 +
                                                    /// Таким образом, в результате работы программы мы получаем два столбика значений для координат по обеим осям, которые как записаны в файл, так и выведены на экран;
 +
    }
 +
    out.close();   /// Закрываем файл, с которым работали в течение программы;
 +
    return 0;      /// По умолчанию возвращаем функции int main значение 0, тем самым завершая программу;
 +
}
  
// Шар, летящий с сопротивлением воздуха
+
</syntaxhighlight>
// Координаты получены методом Верле при квадратичной зависимости силы сопротивлении воздуха от скорости
+
</div>
for (int i = 0; i < 1; i++)
 
My << new ball_air(Pi / 6, 10 + i, 10, 0.01);
 
  
// Шар, летящий с сопротивлением воздуха
+
<div class="mw-collapsible mw-collapsed" style="width:100%" >
// Координаты получены из точного решения при линейной зависимости силы сопротивлении воздуха от скорости
+
'''[[Савельева Ольга]]'''
for (int i = 0; i < 1; i++)
 
My << new ball_air_2(Pi / 6, 10 + i, 10, 0.01);
 
  
// Шар, летящий с сопротивлением воздуха
+
'''Описание:''' Пользователя попросят ввести начальную скорость, угол бросания, тогда программа запишет в файл результаты следующих вычислений:
// Координаты получены методом Верле при линейной зависимости силы сопротивлении воздуха от скорости
+
# Координаты, рассчитанные по формуле, при движении без сопротивления воздуха;
for (int i = 0; i < 1; i++)
+
# Координаты, полученные методом Верле при линейной зависимости силы сопротивлении воздуха от скорости;
My << new ball_air_3(Pi / 6, 10 + i, 10, 0.01);
+
# Координаты, полученные методом Верле при квадратичной зависимости силы сопротивлении воздуха от скорости.
 +
# Координаты, полученные из точного решения, при линейной зависимости силы сопротивлении воздуха от скорости;
  
// Запуск главного цикла
+
<div class="mw-collapsible-content">
  My.Run();
 
} // End of 'main' function
 
  
// END OF 'T43ANIM.CPP' FILE
 
</syntaxhighlight>
 
"'''ANIM.CPP'''"
 
 
<syntaxhighlight lang="cpp" line start="1" enclose="div">
 
<syntaxhighlight lang="cpp" line start="1" enclose="div">
/* FILENAME: ANIM.CPP
 
* LAST UPDATE: 17.01.2016
 
*/
 
 
 
#include <stdio.h>
 
#include <stdio.h>
 
#include <stdlib.h>
 
#include <stdlib.h>
#include <time.h>
+
#include <cmath>
  
#include "ANIM.H"
+
using namespace std;
  
// Единственный экземпляр класса
+
FILE *output;
sagl::anim sagl::anim::Instance;
 
  
/* Reshape function */
+
double e = 0.0000001; //точность
// Стандартная функция, вызываемая при изменении размеров окна
+
double g = 9.8; //ускорение свободного падения
void sagl::anim::Reshape( int W, int H )
+
double dt = 0.00001;  //шаг по времени
{
+
double windageLinearCoefficient = 0.1;
  // Установка области просмотра - все окно
+
double windageSquareCoefficient = 0.00001;
glViewport(0, 0, W, H);
 
  Instance.WinW = W;
 
  Instance.WinH = H;
 
  double ratio_x = 1, ratio_y = 1;
 
   if (W > H)
 
    ratio_x = (double)W / H;
 
  else
 
    ratio_y = (double)H / W;
 
  double Size = 1, Near = 1, Far = 500;
 
  // Установка системы координат "камеры"
 
glMatrixMode(GL_PROJECTION);
 
  glLoadIdentity();
 
  glFrustum(-Size * ratio_x, Size * ratio_x,
 
            -Size * ratio_y, Size * ratio_y,
 
            Near, Far);
 
// Установка "мировой" СК в состояние без преобразований
 
  glMatrixMode(GL_MODELVIEW);
 
} // End of 'Reshape' function
 
  
/* Timer function */
+
struct Vector  //вектор
// Подсчет времени
 
void sagl::anim::Timer( void )
 
 
{
 
{
  long Time = clock();
+
    double x, y;
 
+
    Vector():x(0), y(0)
  if (IsPause)
+
    {}
     DeltaTime = 0, PauseTime += Time - OldTime;
+
    Vector(double x, double y):x(x), y(y)
  else
+
    {}
     DeltaTime = (Time - OldTime) / (double)CLOCKS_PER_SEC;  
+
    const Vector operator+(const Vector &v) const
  OldTime = Time;
+
    {
 +
        return Vector(this -> x + v.x, this -> y + v.y);
 +
    }
 +
    const Vector operator-(const Vector &v) const
 +
    {
 +
        return Vector(this -> x - v.x, this -> y - v.y);
 +
    }
 +
    const Vector operator*(const double k) const
 +
     {
 +
        return Vector(this -> x * k, this -> y * k);
 +
    }
 +
    const Vector operator*(const int k) const
 +
     {
 +
        return Vector(this -> x * k, this -> y * k);
 +
    }
 +
    const Vector operator/(const double k) const
 +
    {
 +
        return Vector(this -> x / k, this -> y / k);
 +
    }
 +
};
  
  SyncTime = (Time - PauseTime - StartTime) / (double)CLOCKS_PER_SEC;
+
const Vector operator*(const double a, const Vector &v)
} /* End of 'Timer' function */
+
{
 +
    return Vector(v.x * a, v.y * a);
 +
}
  
/* Display function */
+
const Vector operator*(const int k, const Vector &v)
// Стандартная функция, вызываемая при перерисовке окна
 
void sagl::anim::Display( void )
 
 
{
 
{
// Запуск времени
+
    return Vector(v.x * k, v.y * k);
Instance.Timer();
+
}
// Очищаем цветовой буфер для создания нового изображения
 
  glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
 
  
  glLoadIdentity();
+
double abs(const Vector &v)
  // Позиционирование СК
+
{
gluLookAt(-40, 0, 0, 0, 0, 0, 0, 1, 0);
+
    return sqrt(v.x * v.x + v.y * v.y);
 +
}
  
// Отрисовка объектов
+
void printCoordinate(const char *description, const Vector &v)  //выводит координаты в более читаемом виде
  Instance.Render();
+
{
 +
    fputs(description, output);
 +
    fputs(": ", output);
 +
    fprintf(output, "%lf", v.x);
 +
    fputs(", ", output);
 +
    fprintf(output, "%lf\n", v.y);
 +
}
  
  glFinish();
+
Vector getCoordinatesWithoutWindage(double velocity, double angle, double time = -1)
// Копируем вторичный буфер в окно
 
glutSwapBuffers();
 
// Вызываем функцию обновления кадра
 
glutPostRedisplay();
 
} // End of 'Display' function
 
 
 
/* Keyboard function */
 
// Стандартная функция, вызываемая при нажатие клавиш на клавиатуре
 
void sagl::anim::Keyboard( unsigned char Key, int X, int Y )
 
 
{
 
{
// Выход из программы
+
    double fallTime = 2 * velocity * sin(angle) / g;  //расчет времени падения
if (Key == 27)
+
    if((time < 0) or (time > fallTime))
     exit(0);
+
        time = fallTime;
// Открытие программы в полном экране
+
     double x = velocity * cos(angle) * time;   // x = vx*t;
else if (Key == 'f')
+
     double y = velocity * sin(angle) * time - g * time * time / 2; // y = vy*t-(g*t^2)/2;
     glutFullScreen();
+
     return Vector(x, y);
  // Пауза
+
}
else if (Key == 'p' || Key == 'P')
 
     Instance.IsPause = !Instance.IsPause;
 
} // End of 'Keyboard' function
 
  
sagl::anim::anim( void ) : IsPause(false), SyncTime(0), DeltaTime(0),
+
Vector getCoordinatesVerletLinear(double velocity, double angle, double time = -1)
  StartTime(clock()), OldTime(StartTime), PauseTime(0), StockSize(0)
 
 
{
 
{
// Инициализации OpenGL и GLUT
+
    double nowTime = dt;
glutInitDisplayMode(GLUT_RGB | GLUT_DOUBLE | GLUT_DEPTH);
+
    Vector rsb(0, 0);
 
+
    if((time >= 0) and (dt / 2 - time > 0)) //если время расчета дается слишком малого промежутка
// Задача размеров и позиции окна
+
        return rsb; //вернитесь в начальную точку
glutInitWindowPosition(0, 0);
+
    Vector v(velocity * cos(angle), velocity * sin(angle)); //проекции начальной скорости
  glutInitWindowSize(700, 700);
+
    Vector r = v * dt;   //вторая точка
// Создание окна
+
    Vector a = -windageLinearCoefficient * v; //ускорение в начальной точке
glutCreateWindow("T06BALL");
+
    a.y -= g;
 
+
    v = v + a * dt; //скорость во второй точке
// Установка функций 'обратного вызова'
+
    a = -windageLinearCoefficient * v; //ускорение во второй точке
  glutDisplayFunc(Display);
+
    a.y -= g;
  glutKeyboardFunc(Keyboard);
+
    while((r.y > 0) or ((time > 0) and (nowTime <= time))) //пока точка выше 0 или не достигла заданного времени
  glutReshapeFunc(Reshape);
+
    {
 
+
        Vector rn = 2 * r - rsb + a * dt * dt;  // r(t+dt) = 2*r(t)-r(t-dt)+a(t)*dt^2;
// Установка цвета закраски фона
+
        v = (rn - rsb) / (2 * dt); // v(t) = (r(t+dt)-r(t-dt))/(2*dt);
  glClearColor(0.3, 0.5, 0.7, 1);
+
        rsb = r;    //обновление r(t-dt) and r(t)
  // Включение буфера глубины
+
        r = rn;
glEnable(GL_DEPTH_TEST);
+
        a = -windageLinearCoefficient * v;  //обновление a(t)
  // Включение режима вычисления цвета согласно освещенности от источников света
+
        a.y -= g;
glEnable(GL_LIGHTING);
+
        nowTime += dt;  //обновленное время
// Включение источника света
+
    }
  glEnable(GL_LIGHT0);
+
    return r;
// Включение упрощенного режима освещенности для простого способа описания свойств поверхности
 
  glEnable(GL_COLOR_MATERIAL);
 
// Приведение нормалей к единичной длине
 
  glEnable(GL_NORMALIZE);
 
 
}
 
}
  
// Деструктор
+
Vector calculateForTime(Vector &v, double time)
sagl::anim::~anim( void )
 
 
{
 
{
  // Чистка памяти
+
    Vector r;
for (int i = 0; i < StockSize; i++)
+
    // x = vx/k*(1-e^(-k*t));
     delete Stock[i];
+
    r.x = v.x / windageLinearCoefficient * (1 - exp(-windageLinearCoefficient * time));
 +
    // y = ((vy+g/k)*(1-e^(-k*t))-g*t)/k;
 +
    r.y = ((v.y + g / windageLinearCoefficient) * (1 - exp(-windageLinearCoefficient * time)) - g * time) / windageLinearCoefficient;
 +
     return r;
 
}
 
}
  
/* Render function */
+
Vector getCoordinatesAccurateLinear(double velocity, double angle, double time = -1)
// Отрисовка объектов
 
void sagl::anim::Render( void )
 
 
{
 
{
for (int i = 0; i < StockSize; i++)
+
    if(windageLinearCoefficient < e) //если коэффициент слишком близок к нулю
Stock[i]->Render(*this);
+
        return getCoordinatesWithoutWindage(velocity, angle, time);   //вычисляй будто это 0
} // End of 'Render' function
+
    Vector r;
 
+
    Vector v(velocity * cos(angle), velocity * sin(angle)); //проекции начальной скорости
/* Run function */
+
    if(time >= 0)  //время данное
// Запуск главного цикла
+
    {
void sagl::anim::Run( void )
+
        r = calculateForTime(v, time);
{
+
        if(r.y >= 0)    //если объект в воздухе или только приземлился
// Запуск основного цикла построения
+
            return r;  //затем верните координаты объекта
glutMainLoop();
+
        else    //еще
} // End of 'Run' function
+
            return getCoordinatesAccurateLinear(velocity, angle);   //верните координаты приземления
 
+
    }
// END OF 'ANIM.CPP' FILE
+
    else
</syntaxhighlight>
+
    {
"'''ANIM.H'''"
+
        double timer, timel, timem;
<syntaxhighlight lang="cpp" line start="1" enclose="div">
+
        timer = v.y / g;
/* FILENAME: ANIM.H
+
        timel = 0;
* LAST UPDATE: 17.01.2016
+
        while(calculateForTime(v, timer).y > 0) //смотрим на некоторые значения времени, которые больше времени посадки
*/
+
            timer *= 1.5;
 +
        timem = timel + (timer - timel) / 2;
 +
        r = calculateForTime(v, timem);
 +
        while(abs(r.y) > e)    //бинарный поиск времени посадки
 +
        {
 +
            if(r.y > 0)
 +
                timel = timem;
 +
            else
 +
                timer = timem;
 +
            timem = timel + (timer - timel) / 2;
 +
            r = calculateForTime(v, timem);
 +
        }
 +
        return r;
 +
    }
 +
}
  
#ifndef __ANIM_H_
+
Vector getCoordinatesVerletSquare(double velocity, double angle, double time = -1)
#define __ANIM_H_
+
{
 
+
    double nowTime = dt;
#include <stdio.h>
+
    Vector rsb(0, 0);
#include <stdlib.h>
+
    if((dt / 2 - time > 0)and(time >= 0))  //если время слишком малое для рсчета
#include <time.h>
+
        return rsb; //вернитесь в начальную точку
 +
    Vector v(velocity * cos(angle), velocity * sin(angle)); //проекции начальной скорости
 +
    Vector r = v * dt;  //вторая точка
 +
    Vector a = -abs(v) * v * windageSquareCoefficient;  //ускорение в начальной точке
 +
    a.y -= g;
 +
    v = v + a * dt; //скорость во второй точке
 +
    a = -abs(v) * v * windageSquareCoefficient; //ускорение во второй точке
 +
    a.y -= g;
 +
    while((r.y > 0) or ((time > 0) and (nowTime <= time)))  //когда точка выше нулевой отметки и не достигает заданного времени
 +
    {
 +
        Vector rn = 2 * r - rsb + a * dt * dt;  // r(t+dt) = 2*r(t)-r(t-dt)+a(t)*dt^2;
 +
        v = (rn - rsb) / (2 * dt);  // v(t) = (r(t+dt)-r(t-dt))/(2*dt);
 +
        rsb = r;    //updating r(t-dt) and r(t)
 +
        r = rn;
 +
        a = -abs(v) * v * windageSquareCoefficient; //новое a(t)
 +
        a.y -= g;
 +
        nowTime += dt;  //новое a(t)
 +
    }
 +
    return r;
 +
}
  
#include <GL\glut.h>
+
void err(const char *s) //печатает сообщение об ошибке и завершает работу
 +
{
 +
    fputs(s, output);
 +
    exit(1);
 +
}
  
#include "VEC.H"
+
int main(int argc, const char *argv[])
 
 
// Константы
 
#define Pi 3.14159265358979323846
 
#define E 2.71828182845904523536
 
 
 
// Собственное пространство имен 'sagl'
 
namespace sagl
 
 
{
 
{
  // Объявления класса анимации наперед
+
    double velocity, angle;
class anim;
+
     bool needRead = true;
 
+
     if(argc==3) //если даны 2 аргумента
// Функции получения случайных чисел
 
inline double r0( void )
 
  {
 
     return rand() / (double)RAND_MAX;
 
  }
 
  inline double r1( void )
 
  {
 
     return 2.0 * rand() / RAND_MAX - 1;
 
  }
 
 
 
// Класс объектов
 
class object
 
  {
 
  public:
 
    // Вектора перемещения и скоростей
 
vec P, V, AbsV;
 
   
 
// Конструктор
 
object( void ) : P(vec::Rnd1()), V(vec::Rnd()), AbsV(V)
 
 
     {
 
     {
 +
        velocity = atof(argv[1]);  //истолкование его как скорости и угла
 +
        angle = atof(argv[2]);
 +
        needRead = false;
 
     }
 
     }
+
    if(needRead)
// Отрисовка объектов
 
virtual void Render( anim &Ani )
 
 
     {
 
     {
     } // End of 'Render' function
+
        puts("Enter initial velocity (m/s)");
  }; // end of 'object' class
+
        scanf("%lf", &velocity);
 
+
     }
// Класс анимации
+
    if(velocity < 0)    //проверка, если скорость меньше 0
class anim
+
        err("Initial velocity must be above 0");
  {
+
    if(needRead)
  private:
+
    {
     // Функции 'обратного вызова'
+
        puts("Enter initial angle (0-180 degrees)");
static void Display( void );
+
        scanf("%lf", &angle);
     static void Keyboard( unsigned char Key, int X, int Y );
+
    }
     static void Reshape( int W, int H );
+
    if((angle < 0) or (angle > 180))    //проверка, что угол в нужном интервале
 +
        err("Initial angle must be from 0 to 180");
 +
    angle = angle / 180 * M_PI; // a = a/180*pi; преобразование угла из градусов в радианы
 +
    output = fopen("Coordinates.txt", "w"); //открытие результативного файла
 +
     //вычисление и печать 4 значений
 +
    printCoordinate("Without windage", getCoordinatesWithoutWindage(velocity, angle));
 +
     printCoordinate("Verlet, linear dependence", getCoordinatesVerletLinear(velocity, angle));
 +
     printCoordinate("Accurate, linear dependence", getCoordinatesAccurateLinear(velocity, angle));
 +
    printCoordinate("Verlet, square dependence", getCoordinatesVerletSquare(velocity, angle));
 +
    fclose(output); //закрытие файла
 +
    return 0;
 +
}
 +
</syntaxhighlight>
 +
</div>
 +
Скачать можно [http://tm.spbstu.ru/%D0%A4%D0%B0%D0%B9%D0%BB:%D0%9A%D0%BE%D0%BE%D1%80%D0%B4%D0%B8%D0%BD%D0%B0%D1%82%D1%8B.zip здесь]
 +
 
 +
<div class="mw-collapsible mw-collapsed" style="width:100%" >
  
    // Единственный экземпляр класса
 
static anim Instance;
 
   
 
    // Конструктор
 
anim( void );
 
  
// Максимальное количество объектов
+
'''[[Сенников Иван]]'''  
    static const int Max = 100;
 
    // 'Контейнер' объектов
 
object *Stock[Max];
 
    // Размер 'контейнера' объектов
 
int StockSize;
 
   
 
// Переменные, хранящие время в секундах
 
    long StartTime, OldTime, PauseTime;
 
   
 
// Отрисовка объектов
 
void Render( void );
 
 
// Подсчет времени
 
void Timer( void );
 
  public:
 
    // Добавление объектов в 'контейнер'
 
anim & operator<<( object *Obj )
 
    {
 
      if (StockSize < Max )
 
        Stock[StockSize++] = Obj;
 
      else
 
        delete Obj;
 
     
 
return *this;
 
    }
 
   
 
// Ширина и высота окна
 
    int WinW, WinH;
 
  
// Переменные, хранящие время в секундах
+
'''Суть программы:'''Программа позволяет отслеживать траекторию движения тела, брошенного под углом к горизонту, в каждом из четырех случаев/методов.
    double SyncTime, DeltaTime;
 
  
    // Переменная, отвечающая за паузу
+
'''Идея:''' Программа состоит из четырех методов: 1) движение тела без учета сопротивления воздуха; 2) движение тела с учетом сопротивления воздуха по первому методу Верле; 3) движение тела с учетом сопротивления воздуха по точному методу; 4) движение тела с учетом сопротивления воздуха по второму методу Верле.
bool IsPause;
 
  
    // Деструктор
+
'''Инструкция:''' Результаты программы будут записаны в соответствующий файл (подробности смотри в самой программе). Пользователю будет предоставлена возможность ввести начальную скорость и угол, под которым и бросают тело.
~anim( void );
 
   
 
// Запуск главного цикла
 
void Run( void );
 
   
 
    // Метод, возвращающий переменную - единственный экземпляр данного типа
 
static anim & Get( void )
 
    {
 
      return Instance;
 
    }
 
  }; // end of 'anim' class
 
} // end of 'sagl' namespace
 
  
#endif /*__ANIM_H_ */
+
Ссылка для скачиваний: [http://tm.spbstu.ru/Файл:Throws_v2.0.zip здесь].
  
// END OF 'ANIM.H' FILE
+
</div>
</syntaxhighlight>
 
"'''VEC.H'''"
 
<syntaxhighlight lang="cpp" line start="1" enclose="div">
 
/* FILENAME: VEC.H
 
* LAST UPDATE: 17.01.2016
 
*/
 
  
#ifndef __VEC_H_
+
<div class="mw-collapsible mw-collapsed" style="width:100%" >
#define __VEC_H_
+
'''[[Степанянц Степан]]'''
  
#include <stdlib.h>
+
'''Описание программы''': программа записывает в четыре файла результаты вычисления:
#include <math.h>
+
# Координаты, рассчитанные по формуле, при движении без сопротивления воздуха;
 +
# Координаты, полученные методом Верле при линейной зависимости силы сопротивлении воздуха от скорости;
 +
# Координаты, полученные из точного решения, при линейной зависимости силы сопротивлении воздуха от скорости;
 +
# Координаты, полученные методом Верле при квадратичной зависимости силы сопротивлении воздуха от скорости.
  
// Собственное пространство имен 'sagl'
+
Скачать можно  [http://tm.spbstu.ru/%D0%A4%D0%B0%D0%B9%D0%BB:Mainpr.rar тут].
namespace sagl
+
 
 +
<div class="mw-collapsible-content">
 +
[[File:graph239.png]]
 +
 
 +
Для тела с массой 1,сопротивлением воздуха 0.05, угол бросания 30°, начальная скорость 40 м/с, ускорение свободного падения 9.8 м/c^2;
 +
 
 +
 
 +
 
 +
Файл "'''main.cpp'''"
 +
<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;
 +
main ()
 
{
 
{
  // Класс векторов
+
    ofstream F;                                                                    //a1-угол в градусах,dt-шаг,r-сопротивление воздуха
class vec
+
int u0=50;
  {
+
double x,y,t,a,a1=30,dt=0.1,y0=0,x0=0,g=9.8,r=0.05,m=1,ux,uy,ypr,xpr,ysl,xsl,u,yt; //ux,uy - проэкции скорости на оси х и у.
  public:
+
a=a1*M_PI/180; //Градусы в радианы
    // Координаты вектора
+
t=0;
double X, Y, Z;
+
   
+
                                        //Движение без сопротивления воздуха
// Конструктор
+
F.open("C:\\1.txt",ios::out);
vec( void ) : X(0), Y(0), Z(0)
+
while(y>=0)
    {
+
{
    }
+
    x=x0+u0*cos(M_PI/6)*t;
   
+
    y=y0+u0*sin(M_PI/6)*t - 0.5 * g * t * t;  //Расчитываем координаты в каждой точке через шаг
// Конструктор
+
  F<<x<<" "<<y<<endl;
vec( double A, double B, double C ) : X(A), Y(B), Z(C)
+
  t=t+dt;
    {
+
    }
+
}
   
+
// Функции получения случайных чисел
+
F.close();
static double R0( void )
+
                                        //Точное решение для линейной зависимости
     {
+
F.open("C:\\2.txt",ios::out);
      return rand() / (double)RAND_MAX;
+
y=y0;
     }
+
x=x0;
      
+
t=0;                                                                            //Расчитываем координаты в каждой точке через шаг
static double R1( void )
+
while(y>=0)
     {
+
{
      return 2 * rand() / (double)RAND_MAX - 1;
+
        ux = u0 * cos(a);
    }
+
        uy = u0 * sin(a);
      
+
        x = x0+ (m * ux / r)* (1 - exp(-1 * r * t / m));                      //подстановка формул
// Функции получения случайных векторов
+
        y = y0+(m/r)*((uy + g * m / r)*(1 - exp(-1 * r * t / m)) - g * t);
static vec Rnd( void )
+
        t = t + dt;
 +
 +
      F << x << ' ' << y << endl;
 +
 +
 +
 +
}
 +
  F.close();
 +
                                                        //метод Верле 1
 +
ypr = y0 - u0*sin(a)*dt;
 +
yt=ypr;
 +
     xpr = x0 - u0*cos(a)*dt;
 +
    x = x0;                          //Начальные условия
 +
    y = y0;
 +
     u = u0;
 +
     ux = u0 * cos(a);
 +
     uy = u0 * sin(a);                       
 +
F.open("C:\\3.txt",ios::out);
 +
 +
     while (y >= y0)
 
     {
 
     {
      return vec(R0(), R0(), R0());
+
        xsl = 2 * x - xpr - (r / m) * u * ux * (dt * dt);
    }
+
        ux = ( xsl - xpr )/ (2 * dt);
   
+
        ysl = 2 * y - ypr - (g + (r / m) * u * uy) * (dt * dt);      //xsl,ysl - координаты на шаге вперед. xpr,ypr- назад
static vec Rnd1( void )
+
        uy =  (ysl - ypr)/ (2 * dt);
    {
+
        u = sqrt(uy*uy + ux*ux );
      return vec(R1(), R1(), R1());
+
        F << x << ' ' << y << endl;
 +
 +
        xpr = x;
 +
        x = xsl;
 +
        ypr = y;
 +
        y = ysl;
 
     }
 
     }
+
    F.close();
vec operator+(