main(final)

#include <iostream>
#include <vector>
#include <string>
#include <numeric>
#include <algorithm>
#include <fstream>
#include <map>
#include <iomanip>
#include "missile.h"


bool CheckUnique(std::vector <double> T) {
    std::vector <double> temp = T;
    std::sort(temp.begin(), temp.end());
    auto last = std::unique(temp.begin(), temp.end());
    temp.erase(last, temp.end());

    if (temp.size() == T.size())
        return true;
    else
        return false;
}

std::map <double, double> MakeDiscreteDistribution(std::vector <double> T) {
    std::vector <double> temp = T;
    std::sort(temp.begin(), temp.end());
    auto last = std::unique(temp.begin(), temp.end());
    temp.erase(last, temp.end());

    std::map <double, double> res;

    for (int i = 0; i < temp.size(); ++i) {
        double prob = std::count(T.begin(), T.end(), temp[i]);
        prob /= 100;
        res.insert(std::make_pair(temp[i], prob));
    }
    return res;
}

double ExpectedValue(std::map <double, double> T) {
    std::map <double, double> ::iterator it = T.begin();
    double res = 0;
    for (it; it != T.end(); ++it) {
        res += it->first * it->second;
    }
    return res;
}

//среднее арифметическое (мат ожидание)
double ArithmeticMean(std::vector <double> T) {
    double sum_of_elems = std::accumulate(T.rbegin(), T.rend(), 0.0);
    return sum_of_elems / T.size();
}

//дисперсия
double Variance(std::vector <double> T) {
    std::vector <double> squareT;

    for (int i = 0; i < T.size(); ++i) {
        //std::cout << T[i] << "\t\t" << std::pow(T[i], 2) << std::endl;
        squareT.push_back(std::pow(T[i], 2));
    }


    long double E1 = ArithmeticMean(squareT);
    long double E2 = ArithmeticMean(T);
    E2 = std::pow(E2, 2);

    return E1 - E2;
}

//среднеквадратичное отклонение
double StandartDeviation(std::vector <double> T) {
    return std::sqrt(Variance(T));
}


//коэффициент корреляции
double СorrelationСoefficient(std::vector <double> X, std::vector <double> Y) {
    double avgX = ArithmeticMean(X);
    double avgY = ArithmeticMean(Y);
    double cov = 0.0;
    double devX, devY;
    double sumX = 0.0;
    double sumY = 0.0;

    for (int i = 0; i < X.size(); ++i) {
        devX = X[i] - avgX;
        devY = Y[i] - avgY;
        cov += devX * devY;
        sumX += std::pow(devX, 2);
        sumY += std::pow(devY, 2);
    }
    return cov / std::sqrt(sumX * sumY);
}

int main() {
    std::vector <missile_data> data;
    std::ifstream in("1.txt");
    std::ofstream out("output.txt");

    for (int i = 0; i < 100; ++i) {
        missile_data temp;
        //1
        in >> temp.n >> temp.pr_c >> temp.epr >> temp.pr_r >> temp.kim >> temp.dov >> temp.rbv;
        //2
        in >> temp.time_to_mp >> temp.rel_v >> temp.beta_ast >> temp.time_start_homing;
        //3
        in >> temp.mis_coord_n.x >> temp.mis_coord_n.y >> temp.mis_coord_n.z >> temp.mis_v_proj_n.x >> temp.mis_v_proj_n.y >> temp.mis_v_proj_n.z;
        //4
        in >> temp.yaw_angle >> temp.pitch_angle >> temp.bank_angle >> temp.angle_of_attack >> temp.flow_angle;
        //5
        in >> temp.v_obj >> temp.path_obj >> temp.pitch_obj >> temp.coord_n_obj.x >> temp.coord_n_obj.y >> temp.coord_n_obj.z;
        //6
        in >> temp.proj_mp_miss.x >> temp.proj_mp_miss.y >> temp.proj_mp_miss.z >> temp.rel_v_n >> temp.tau_kin;
        //7
        in >> temp.nc_y >> temp.nc_z >> temp.t_dov >> temp.t_bv >> temp.t_sbv;
        //8
        in >> temp.proj_nsm_miss.x >> temp.proj_nsm_miss.y >> temp.proj_nsm_miss.z >> temp.delta_V01 >> temp.delta_V02 >> temp.beta_y;
        //9
        in >> temp.from_n_to_apa.c11 >> temp.from_n_to_apa.c12 >> temp.from_n_to_apa.c13 >> temp.proj_dov_miss.x >> temp.proj_dov_miss.y >> temp.proj_dov_miss.z;
        //10
        in >> temp.bank >> temp.pitch >> temp.ant_course >> temp.delta_gamma.inf >> temp.delta_gamma.exec >> temp.delta_gamma.sum;
        //11
        in >> temp.from_n_to_apa.c21 >> temp.from_n_to_apa.c22 >> temp.from_n_to_apa.c23 >> temp.from_n_to_apa.c31 >> temp.from_n_to_apa.c32 >> temp.from_n_to_apa.c33;


        std::cout << i + 1 << " : " << temp.mis_coord_n.x << "\n";
        data.push_back(temp);
    }

    for (int i = 0; i < 100; ++i) {
        data[i].h = std::sqrt(std::pow(data[i].proj_mp_miss.x, 2) + std::pow(data[i].proj_mp_miss.y, 2) + std::pow(data[i].proj_mp_miss.z, 2));
        if (1.0 < data[i].h && data[i].h <= 3.0) {
            data[i].i = 2;
        }
        else {
            if (3.0 < data[i].h && data[i].h <= 6.0) {
                data[i].i = 3;
            }
            else {
                if (6.0 < data[i].h && data[i].h <= 9.0) {
                    data[i].i = 4;
                }
                else {
                    if (9.0 < data[i].h && data[i].h <= 12.0) {
                        data[i].i = 5;
                    }
                    else {
                        if (12.0 < data[i].h && data[i].h <= 15.0) {
                            data[i].i = 6;
                        }
                        else
                            data[i].i = 1;
                    }
                }
            }
        }
    }
    int count1 = 0;
    int count2 = 0;
    int count3 = 0;
    int count4 = 0;
    int count5 = 0;
    int count6 = 0;

    for (int i = 0; i < 100; ++i) {
        switch (data[i].i)
        {
        case 1:
            count1++;
            break;
        case 2:
            count2++;
            break;
        case 3:
            count3++;
            break;
        case 4:
            count4++;
            break;
        case 5:
            count5++;
            break;
        case 6:
            count6++;
            break;
        }
    }
    std::cout << "1 : " << count1 << std::endl;
    std::cout << "2 : " << count2 << std::endl;
    std::cout << "3 : " << count3 << std::endl;
    std::cout << "4 : " << count4 << std::endl;
    std::cout << "5 : " << count5 << std::endl;
    std::cout << "6 : " << count6 << std::endl;

    std::vector <double> current_data;
    std::vector <double> first_set;
    std::vector <double> second_set;

    out << std::fixed << std::setprecision(3);



    //1 строка вывода
    for (int i = 0; i < 100; ++i)
        current_data.push_back(data[i].mis_coord_n.x);
    out << ArithmeticMean(current_data) << "\t\t\t\t";
    out << StandartDeviation(current_data) << "\t\t";

    current_data.clear();

    for (int i = 0; i < 100; ++i)
        current_data.push_back(std::sqrt(std::pow(data[i].mis_coord_n.x, 2)
                                        + std::pow(data[i].mis_coord_n.x, 2)
                                        + std::pow(data[i].mis_coord_n.z, 2)));
    out << ArithmeticMean(current_data) << "\t\t";


    out << data[0].kim << std::endl;
    current_data.clear();

    //2 строка вывода
    for (int i = 0; i < 100; ++i)
        current_data.push_back(data[i].mis_coord_n.y);
    out << ArithmeticMean(current_data) << "\t\t\t\t";
    out << StandartDeviation(current_data) << "\t\t";
    current_data.clear();
    for (int i = 0; i < 100; ++i)
        current_data.push_back(std::sqrt(std::pow(data[i].mis_coord_n.x, 2) + std::pow(data[i].mis_coord_n.z, 2)));
    out << ArithmeticMean(current_data) << "\t\t";
    out << data[0].pr_r << std::endl;
    current_data.clear();

    //3 строка вывода
    for (int i = 0; i < 100; ++i)
        current_data.push_back(data[i].mis_coord_n.z);
    out << ArithmeticMean(current_data) << "\t\t\t\t";
    out << StandartDeviation(current_data) << "\t\t";
    current_data.clear();

    for (int i = 0; i < 100; ++i)
        first_set.push_back(data[i].coord_n_obj.y);
    for (int i = 0; i < 100; ++i)
        second_set.push_back(std::sqrt(std::pow(data[i].mis_coord_n.x, 2) + std::pow(data[i].mis_coord_n.z, 2)));
    out << ArithmeticMean(first_set) + 7.85 * std::pow(10, -8) * std::pow(ArithmeticMean(second_set), 2) << "\t\t";
    first_set.clear();
    second_set.clear();

    //конец Нз
    out << data[0].pr_c << std::endl;
    current_data.clear();

    //4 строка вывода
    for (int i = 0; i < 100; ++i)
        current_data.push_back(std::sqrt(std::pow(data[i].mis_v_proj_n.x, 2)
                                        + std::pow(data[i].mis_v_proj_n.y, 2)
                                        + std::pow(data[i].mis_v_proj_n.z, 2)));
    out << ArithmeticMean(current_data) << "\t\t\t\t";
    current_data.clear();

    for (int i = 0; i < 100; ++i)
        current_data.push_back(data[i].v_obj);
    out << ArithmeticMean(current_data) << "\t\t";
    current_data.clear();

    for (int i = 0; i < 100; ++i)
        current_data.push_back(data[i].rel_v);
    out << ArithmeticMean(current_data) << "\t\t";
    current_data.clear();
    out << data[0].epr << std::endl;

    //5 строка вывода
    for (int i = 0; i < 100; ++i)
        current_data.push_back(data[i].proj_nsm_miss.y);
    out << ArithmeticMean(current_data) << "\t\t\t\t";
    out << StandartDeviation(current_data) << std::endl;
    current_data.clear();

    //6 строка вывода
    for (int i = 0; i < 100; ++i)
        current_data.push_back(data[i].proj_nsm_miss.z);
    out << ArithmeticMean(current_data) << "\t\t\t\t\t";
    out << StandartDeviation(current_data) << std::endl;
    current_data.clear();

    //7 строка вывода
    for (int i = 0; i < 100; ++i)
        current_data.push_back(std::sqrt(std::pow(data[i].proj_nsm_miss.x, 2)
                                        + std::pow(data[i].proj_nsm_miss.y, 2)
                                        + std::pow(data[i].proj_nsm_miss.z, 2)));
    out << ArithmeticMean(current_data) << "\t\t\t\t\t";
    out << StandartDeviation(current_data) << "\t\t";
    current_data.clear();

    for (int i = 0; i < 100; ++i)
        current_data.push_back(data[i].time_to_mp - data[i].time_start_homing);
    out << ArithmeticMean(current_data) << "\t\t\t";
    out << StandartDeviation(current_data) << std::endl;
    current_data.clear();

    //8 строка вывода
    for (int i = 0; i < 100; ++i)
        current_data.push_back(data[i].proj_dov_miss.y);
    out << ArithmeticMean(current_data) << "\t\t\t\t\t";
    out << StandartDeviation(current_data) << std::endl;
    current_data.clear();

    //9 строка вывода
    for (int i = 0; i < 100; ++i)
        current_data.push_back(data[i].proj_dov_miss.z);
    out << ArithmeticMean(current_data) << "\t\t\t\t\t";
    out << StandartDeviation(current_data) << std::endl;
    current_data.clear();

    //10 строка вывода
    for (int i = 0; i < 100; ++i)
        current_data.push_back(std::sqrt(std::pow(data[i].proj_dov_miss.x, 2)
                                        + std::pow(data[i].proj_dov_miss.y, 2)
                                        + std::pow(data[i].proj_dov_miss.z, 2)));
    out << ArithmeticMean(current_data) << "\t\t\t\t\t";
    out << StandartDeviation(current_data) << "\t\t";
    current_data.clear();

    for (int i = 0; i < 100; ++i)
        current_data.push_back(data[i].time_to_mp - data[i].t_dov);
    out << ArithmeticMean(current_data) << "\t\t\t";
    out << StandartDeviation(current_data) << std::endl;
    current_data.clear();

    //11 строка вывода
    for (int i = 0; i < 100; ++i)
        current_data.push_back(std::sqrt(std::pow(data[i].proj_mp_miss.x, 2)
                                        + std::pow(data[i].proj_mp_miss.y, 2)
                                        + std::pow(data[i].proj_mp_miss.z, 2)));
    out << ArithmeticMean(current_data) << "\t\t\t\t\t";
    out << StandartDeviation(current_data) << "\t\t";
    current_data.clear();

    for (int i = 0; i < 100; ++i)
        current_data.push_back(data[i].time_to_mp);
    out << ArithmeticMean(current_data) << "\t\t\t";
    out << StandartDeviation(current_data) << std::endl;
    current_data.clear();

    //12 строка вывода
    for (int i = 0; i < 100; ++i)
        first_set.push_back(data[i].proj_mp_miss.y);
    for (int i = 0; i < 100; ++i)
        second_set.push_back(data[i].proj_mp_miss.z);
    out << СorrelationСoefficient(first_set, second_set) << std::endl;
    first_set.clear();
    second_set.clear();

    //13 строка вывода
    for (int i = 0; i < 100; ++i)
        current_data.push_back(data[i].time_to_mp - data[i].t_bv);
    out << ArithmeticMean(current_data) << "\t\t\t\t\t";
    out << StandartDeviation(current_data) << std::endl;
    current_data.clear();

    //14 строка вывода
    for (int i = 0; i < 100; ++i)
        current_data.push_back(data[i].time_to_mp - data[i].t_sbv);
    out << ArithmeticMean(current_data) << "\t\t\t\t\t";
    out << StandartDeviation(current_data) << std::endl;
    current_data.clear();

    //15 строка вывода
    for (int i = 0; i < 100; ++i)
        current_data.push_back(data[i].angle_of_attack);
    out << ArithmeticMean(current_data) << "\t\t\t\t\t";
    out << StandartDeviation(current_data) << std::endl;
    current_data.clear();

    //16 строка вывода
    for (int i = 0; i < 100; ++i)
        current_data.push_back(data[i].delta_V01);
    out << ArithmeticMean(current_data) << "\t\t\t\t\t";
    out << StandartDeviation(current_data) << std::endl;
    current_data.clear();

    //17 строка вывода
    for (int i = 0; i < 100; ++i)
        current_data.push_back(data[i].delta_V02);
    out << ArithmeticMean(current_data) << "\t\t\t\t\t";
    out << StandartDeviation(current_data) << std::endl;
    current_data.clear();

    //18 строка вывода
    out << "<<1.0 < h <= 3.0>>" << "\t\t" << count2 << "\t\t\t";

    //вставить Nбв
    int N_bv = 0;
    for (int i = 0; i < 100; ++i)
        if (data[i].time_to_mp - data[i].t_bv > 0.001 && data[i].t_bv > 5 && data[i].i == 2)
            N_bv++;

    out << N_bv << std::endl;
    N_bv = 0;

    //19 строка вывода
    for (int i = 0; i < 100; ++i)
        if (data[i].i == 2)
            current_data.push_back(data[i].delta_gamma.sum);
    out << ArithmeticMean(current_data) << "\t\t\t\t\t";
    current_data.clear();

    for (int i = 0; i < 100; ++i)
        if (data[i].i == 2)
            current_data.push_back(data[i].delta_gamma.exec);
    out << ArithmeticMean(current_data) << "\t\t";
    current_data.clear();

    for (int i = 0; i < 100; ++i)
        if (data[i].i == 2)
            current_data.push_back(data[i].delta_gamma.inf);
    out << ArithmeticMean(current_data) << std::endl;
    current_data.clear();

    //20 строка вывода
    for (int i = 0; i < 100; ++i)
        if (data[i].i == 2)
            current_data.push_back(data[i].delta_gamma.sum);
    out << StandartDeviation(current_data) << "\t\t\t\t\t";
    current_data.clear();

    for (int i = 0; i < 100; ++i)
        if (data[i].i == 2)
            first_set.push_back(data[i].delta_gamma.exec);
    out << StandartDeviation(first_set) << "\t\t";

    for (int i = 0; i < 100; ++i)
        if (data[i].i == 2)
            second_set.push_back(data[i].delta_gamma.inf);
    out << StandartDeviation(second_set) << "\t\t\t";

    out << СorrelationСoefficient(first_set, second_set) << std::endl;
    first_set.clear();
    second_set.clear();

    //21 строка вывода
    out << "<<3.0 < h <= 6.0>>" << "\t\t" << count3 << "\t\t\t";
    for (int i = 0; i < 100; ++i)
        if (data[i].time_to_mp - data[i].t_bv > 0.001 && data[i].t_bv > 5 && data[i].i == 3)
            N_bv++;

    out << N_bv << std::endl;
    N_bv = 0;

    //22 строка вывода
    for (int i = 0; i < 100; ++i)
        if (data[i].i == 3)
            current_data.push_back(data[i].delta_gamma.sum);
    out << ArithmeticMean(current_data) << "\t\t\t\t\t";
    current_data.clear();

    for (int i = 0; i < 100; ++i)
        if (data[i].i == 3)
            current_data.push_back(data[i].delta_gamma.exec);
    out << ArithmeticMean(current_data) << "\t\t";
    current_data.clear();

    for (int i = 0; i < 100; ++i)
        if (data[i].i == 3)
            current_data.push_back(data[i].delta_gamma.inf);
    out << ArithmeticMean(current_data) << std::endl;
    current_data.clear();

    //23 строка вывода
    for (int i = 0; i < 100; ++i)
        if (data[i].i == 3)
            current_data.push_back(data[i].delta_gamma.sum);
    out << StandartDeviation(current_data) << "\t\t\t\t\t";
    current_data.clear();

    for (int i = 0; i < 100; ++i)
        if (data[i].i == 3)
            first_set.push_back(data[i].delta_gamma.exec);
    out << StandartDeviation(first_set) << "\t\t";

    for (int i = 0; i < 100; ++i)
        if (data[i].i == 3)
            second_set.push_back(data[i].delta_gamma.inf);
    out << StandartDeviation(second_set) << "\t\t\t";

    out << СorrelationСoefficient(first_set, second_set) << std::endl;
    first_set.clear();
    second_set.clear();

    //24 строка вывода
    out << "<<6.0 < h <= 9.0>>" << "\t\t" << count4 << "\t\t\t";
    for (int i = 0; i < 100; ++i)
        if (data[i].time_to_mp - data[i].t_bv > 0.001 && data[i].t_bv > 5 && data[i].i == 4)
            N_bv++;

    out << N_bv << std::endl;
    N_bv = 0;

    //25 строка вывода
    for (int i = 0; i < 100; ++i)
        if (data[i].i == 4)
            current_data.push_back(data[i].delta_gamma.sum);
    out << ArithmeticMean(current_data) << "\t\t\t\t\t";
    current_data.clear();

    for (int i = 0; i < 100; ++i)
        if (data[i].i == 4)
            current_data.push_back(data[i].delta_gamma.exec);
    out << ArithmeticMean(current_data) << "\t\t";
    current_data.clear();

    for (int i = 0; i < 100; ++i)
        if (data[i].i == 4)
            current_data.push_back(data[i].delta_gamma.inf);
    out << ArithmeticMean(current_data) << std::endl;
    current_data.clear();

    //26 строка вывода
    for (int i = 0; i < 100; ++i)
        if (data[i].i == 4)
            current_data.push_back(data[i].delta_gamma.sum);
    out << StandartDeviation(current_data) << "\t\t\t\t\t";
    current_data.clear();

    for (int i = 0; i < 100; ++i)
        if (data[i].i == 4)
            first_set.push_back(data[i].delta_gamma.exec);
    out << StandartDeviation(first_set) << "\t\t";

    for (int i = 0; i < 100; ++i)
        if (data[i].i == 4)
            second_set.push_back(data[i].delta_gamma.inf);
    out << StandartDeviation(second_set) << "\t\t\t";

    out << СorrelationСoefficient(first_set, second_set) << std::endl;
    first_set.clear();
    second_set.clear();

    //27 строка вывода
    out << "<<9.0 < h <= 12.0>>" << "\t\t" << count5 << "\t\t\t";
    for (int i = 0; i < 100; ++i)
        if (data[i].time_to_mp - data[i].t_bv > 0.001 && data[i].t_bv > 5 && data[i].i == 5)
            N_bv++;

    out << N_bv << std::endl;
    N_bv = 0;

    //28 строка вывода
    for (int i = 0; i < 100; ++i)
        if (data[i].i == 5)
            current_data.push_back(data[i].delta_gamma.sum);
    out << ArithmeticMean(current_data) << "\t\t\t\t\t";
    current_data.clear();

    for (int i = 0; i < 100; ++i)
        if (data[i].i == 5)
            current_data.push_back(data[i].delta_gamma.exec);
    out << ArithmeticMean(current_data) << "\t\t";
    current_data.clear();

    for (int i = 0; i < 100; ++i)
        if (data[i].i == 5)
            current_data.push_back(data[i].delta_gamma.inf);
    out << ArithmeticMean(current_data) << std::endl;
    current_data.clear();

    //29 строка вывода
    for (int i = 0; i < 100; ++i)
        if (data[i].i == 5)
            current_data.push_back(data[i].delta_gamma.sum);
    out << StandartDeviation(current_data) << "\t\t\t\t\t";
    current_data.clear();

    for (int i = 0; i < 100; ++i)
        if (data[i].i == 5)
            first_set.push_back(data[i].delta_gamma.exec);
    out << StandartDeviation(first_set) << "\t\t";

    for (int i = 0; i < 100; ++i)
        if (data[i].i == 5)
            second_set.push_back(data[i].delta_gamma.inf);
    out << StandartDeviation(second_set) << "\t\t\t";

    out << СorrelationСoefficient(first_set, second_set) << std::endl;
    first_set.clear();
    second_set.clear();

    //30 строка вывода
    out << "<<12.0 < h <= 15.0>>" << "\t" << count6 << "\t\t\t";
    for (int i = 0; i < 100; ++i)
        if (data[i].time_to_mp - data[i].t_bv > 0.001 && data[i].t_bv > 5 && data[i].i == 6)
            N_bv++;

    out << N_bv << std::endl;
    N_bv = 0;

    //31 строка вывода
    for (int i = 0; i < 100; ++i)
        if (data[i].i == 6)
            current_data.push_back(data[i].delta_gamma.sum);
    out << ArithmeticMean(current_data) << "\t\t\t\t\t";
    current_data.clear();

    for (int i = 0; i < 100; ++i)
        if (data[i].i == 6)
            current_data.push_back(data[i].delta_gamma.exec);
    out << ArithmeticMean(current_data) << "\t\t";
    current_data.clear();

    for (int i = 0; i < 100; ++i)
        if (data[i].i == 6)
            current_data.push_back(data[i].delta_gamma.inf);
    out << ArithmeticMean(current_data) << std::endl;
    current_data.clear();

    //32 строка вывода
    for (int i = 0; i < 100; ++i)
        if (data[i].i == 6)
            current_data.push_back(data[i].delta_gamma.sum);
    out << StandartDeviation(current_data) << "\t\t\t\t\t";
    current_data.clear();

    for (int i = 0; i < 100; ++i)
        if (data[i].i == 6)
            first_set.push_back(data[i].delta_gamma.exec);
    out << StandartDeviation(first_set) << "\t\t";

    for (int i = 0; i < 100; ++i)
        if (data[i].i == 6)
            second_set.push_back(data[i].delta_gamma.inf);
    out << StandartDeviation(second_set) << "\t\t\t";

    out << СorrelationСoefficient(first_set, second_set) << std::endl;
    first_set.clear();
    second_set.clear();

    //33 строка вывода
    out << data.size() << "\t\t\t\t\t\t";
    int counter = 0;
    for (int i = 0; i < data.size(); ++i)
        if (data[i].h > 15.0)
            ++counter;
    out << counter << std::endl;
    //34 строка вывода
    counter = 0;
    for (int i = 0; i < data.size(); ++i)
        if (data[i].dov)
            ++counter;
    out << counter << "\t\t\t\t\t\t";
    counter = 0;

    for (int i = 0; i < data.size(); ++i)
        if (data[i].h < 10.0)
            ++counter;
    out << counter << std::endl;
    //35 строка вывода
    counter = 0;
    for (int i = 0; i < data.size(); ++i)
        if (data[i].rbv)
            ++counter;
    out << counter << "\t\t\t\t\t\t";
    counter = 0;

    for (int i = 0; i < data.size(); ++i)
        if (data[i].h < 1.0)
            ++counter;
    out << counter << std::endl;

    //36 строка вывода
    for (int i = 0; i < 100; ++i)
        if (data[i].time_to_mp - data[i].t_bv > 0.001 && data[i].t_bv > 5)
            N_bv++;

    out << "\t\t\t\t\t\t" << N_bv << std::endl;
    //37 строка вывода
    counter = 0;
    for (int i = 0; i < data.size(); ++i)
        if (data[i].t_sbv >= data[i].t_bv)
            counter++;
    out << "\t\t\t\t\t\t" << counter;

}