Ask Question

Name:
Title:
Your Question:

Answer Question

Name:
Your Answer:
User Submitted Source Code!


Description:
  1
Language: C/C++
Code:
#include "stdafx.h"          
#include <iostream>          
#include <conio.h>          
#include <windows.h>           
#include <string>     
#include <complex>
#include <fstream>
#include <omp.h>
using namespace std;

void FillZamesh(string*** Zamesh, int x, int y, int z, int ci)
{
     //Заполнение исходными данными массив схемы замещения
     Zamesh[ci][0][0] = "N1"; Zamesh[ci][0][1] = "R2"; Zamesh[ci][0][2] = "R1"; Zamesh[ci][0][3] = "E1";
     Zamesh[ci][1][0] = "N1"; Zamesh[ci][1][1] = "R3"; Zamesh[ci][1][2] = "N2";
     Zamesh[ci][2][0] = "N1"; Zamesh[ci][2][1] = "R9"; Zamesh[ci][2][2] = "N5";
     Zamesh[ci][3][0] = "N2"; Zamesh[ci][3][1] = "R3"; Zamesh[ci][3][2] = "N1";
     Zamesh[ci][4][0] = "N2"; Zamesh[ci][4][1] = "R4"; Zamesh[ci][4][2] = "N3";
     Zamesh[ci][5][0] = "N2"; Zamesh[ci][5][1] = "R7"; Zamesh[ci][5][2] = "N4";
     Zamesh[ci][6][0] = "N2"; Zamesh[ci][6][1] = "R10"; Zamesh[ci][6][2] = "N5";
     Zamesh[ci][7][0] = "N3"; Zamesh[ci][7][1] = "R4"; Zamesh[ci][7][2] = "N2";
     Zamesh[ci][8][0] = "N3"; Zamesh[ci][8][1] = "R6"; Zamesh[ci][8][2] = "N4";
     Zamesh[ci][9][0] = "N3"; Zamesh[ci][9][1] = "R5"; Zamesh[ci][9][2] = "E2";
     Zamesh[ci][10][0] = "N4"; Zamesh[ci][10][1] = "R7"; Zamesh[ci][10][2] = "N2";
     Zamesh[ci][11][0] = "N4"; Zamesh[ci][11][1] = "R6"; Zamesh[ci][11][2] = "N3";
     Zamesh[ci][12][0] = "N4"; Zamesh[ci][12][1] = "R8"; Zamesh[ci][12][2] = "E3";
     Zamesh[ci][13][0] = "N5"; Zamesh[ci][13][1] = "R9"; Zamesh[ci][13][2] = "N1";
     Zamesh[ci][14][0] = "N5"; Zamesh[ci][14][1] = "R10"; Zamesh[ci][14][2] = "N2";
     Zamesh[ci][15][0] = "N5"; Zamesh[ci][15][1] = "R11"; Zamesh[ci][15][2] = "R12"; Zamesh[ci][15][3] = "E4";
     Zamesh[ci][16][0] = "N5"; Zamesh[ci][16][1] = "R13"; Zamesh[ci][16][2] = "R14"; Zamesh[ci][16][3] = "R15"; Zamesh[ci][16][4] = "R16"; Zamesh[ci][16][5] = "E5";
     for (int j = 0; j < y; j++){
          for (int k = 0; k < x; k++){
               if (Zamesh[ci][j][k] == "")
                    Zamesh[ci][j][k] = "0";
          }
     }
}

void FillZ(complex< double > *&Z, int &z_sum)
{
     //Заполнение исходными данными массив сопротивлений
     double R1 = 0.0085, X1 = 1.105, R2 = 0.0262, X2 = 1.05, R3 = 0.03, X3 = 0.19, R4 = 0.035, X4 = 1.05, R5 = 0.0097, X5 = 1.165, R6 = 0, X6 = 3.225, R7 = 0.035, X7 = 1.05, R8 = 0.0097, X8 = 1.165, R9 = 0.06, X9 = 0.32, R10 = 0.05, X10 = 0.28, R11 = 0.056, X11 = 1.68, R12 = 0.076, X12 = 3.8, R13 = 0.04, X13 = 0.23, R14 = 0.064, X14 = 1.92, R15 = 0.005, X15 = 0.16, R16 = 0, X16 = 1;
     Z[0] = complex< double >(0, 0);
     Z[1] = complex< double >(R1, X1);
     Z[2] = complex< double >(R2, X2);
     Z[3] = complex< double >(R3, X3);
     Z[4] = complex< double >(R4, X4);
     Z[5] = complex< double >(R5, X5);
     Z[6] = complex< double >(R6, X6);
     Z[7] = complex< double >(R7, X7);
     Z[8] = complex< double >(R8, X8);
     Z[9] = complex< double >(R9, X9);
     Z[10] = complex< double >(R10, X10);
     Z[11] = complex< double >(R11, X11);
     Z[12] = complex< double >(R12, X12);
     Z[13] = complex< double >(R13, X13);
     Z[14] = complex< double >(R14, X14);
     Z[15] = complex< double >(R15, X15);
     Z[16] = complex< double >(R16, X16);
}

void FillE(double **&E, int &source_sum, int &source_parametr)
{
     //Заполнение исходными данными массив источников
     double Ub = 1;
     double Sb = 2000;
     for (int k = 0; k < source_parametr; k++)
          E[0][k] = 0;
     E[1][0] = 300;     E[1][1] = 0.85;     E[1][2] = 0.195;//E1 Pn cosfi xdb
     E[2][0] = 200;     E[2][1] = 0.85; E[2][2] = 0.19;     //E2 Pn cosfi xdb
     E[3][0] = 200;     E[3][1] = 0.85;     E[3][2] = 0.19; //E3 Pn cosfi xdb
     E[4][0] = 90;     E[4][1] = 0.9;     E[4][2] = 0.19; //E4 Pn cosfi xdb
     E[5][0] = 0;     E[5][1] = 0;     E[5][2] = 0;  E[5][3] = 1;     

     for (int j = 1; j < (source_sum ); j++)
          E[j][3] = sqrt((pow(Ub*E[j][1], 2)) + (pow(Ub*sqrt(1 - pow(E[j][1], 2)) + E[j][2], 2)));

     E[5][3] = 1;
}

void ShowArray(string*** arr, int x, int y, int z)
{
     //Функция вывода массива схемы замещения в консоль
     for (int i = 0; i < x; i++)
     {
          cout << "ITERATION " << i + 1 << ": " << endl;
          for (int j = 0; j < y; j++)
          {
               for (int k = 0; k < z; k++)
               {
                    cout << arr[i][j][k] << "\t";
               }
               cout << endl;
          }
          cout << endl;

     }
     cout << endl;
     
}

void ShowArrayZ(complex< double > *&Z, int z_sum)
{
     //Функция вывода массива сопротивлений в консоль
     for (int i = 0; i < (1 + z_sum); i++)
     {
          cout << i << Z[i] << "\t";
     }
}

void ShowArrayE(double **&E, int &source_sum, int &source_parameter)
{
     //Функция вывода массива источников в консоль
     
     for (int j = 1; j < source_sum+1; j++)
     cout << "E" << j << " = " << E[j][3] << "\t";
}

void ShowArrayToFile(string*** arr, int x, int y, int z)
{
     //Функция вывода массива схемы замещения в файл
     ofstream f;
     f.open("ofile.txt");
     for (int i = 0; i < x; i++)
     {
          f << "ITERATION " << i + 1 << ": " << endl;
          for (int j = 0; j < y; j++)
          {
               for (int k = 0; k < z; k++)
               {
                    f << arr[i][j][k] << "\t";
               }
               f << endl;
          }
          f << endl;
          f << endl;
     }
     f << endl;
     f << endl;
     f << endl;
     f.close();
}

void ReCreate(string ***&arr, int &x, int &y, int &z, int &x2, int &y2, int &z2)
{
     //Функция переобъявления динамического массива схемы замещения
     string ***newArray = new string**[x2];
     for (int i = 0; i < x2; i++){
          newArray[i] = new string*[y2];
          for (int j = 0; j < y2; j++)
               newArray[i][j] = new string[z2];
     }

     for (int i = 0; i < x2; i++)
          for (int j = 0; j < y2; j++)
               for (int k = 0; k < z2; k++)
                    newArray[i][j][k] = "0";

     int x3, y3, z3;
     if (x2 > x) x3 = x; else x3 = x2;
     if (y2 > y) y3 = y; else y3 = y2;
     if (z2 > z) z3 = z; else z3 = z2;

     for (int i = 0; i < x3; i++)
          for (int j = 0; j < y3; j++)
               for (int k = 0; k < z3; k++)
                    newArray[i][j][k] = arr[i][j][k];
               
     for (int i = 0; i < x; i++)
     {
          for (int j = 0; j < y; j++)
               delete[] arr[i][j];
          delete[] arr[i];
     }
     delete[] arr;
     arr = newArray;
}

void Summing_in_series(int &rows, int &max_line, int &ci, int &iteration_sum,
     int &source_sum, int &sourсe_parameter, string ***&ZameshRef, int &new_Z, int &new_Z_count,
     int &R_in_row, int &N_in_row, int &z_sum, complex< double > *&Z) {
     //Функция последовательного сложения элементов
     int count_pair = 0;
     new_Z = 0;
     new_Z_count = 0;
     for (int j = 0; j < rows; j++)//подсчёт количества новых сопротивлений в массиве Z
     {
          R_in_row = 0;//количество "R" в строке
          N_in_row = 0;//количество "N" в строке
          for (int k = 0; k < max_line; k++){
               if (ZameshRef[ci - 1][j][k][0] == 'N')
                    N_in_row++;
               if (ZameshRef[ci - 1][j][k][0] == 'R')
                    R_in_row++;
          }
          if ((N_in_row == 1) && (R_in_row > 1))
               new_Z++;
          if ((N_in_row == 2) && (R_in_row > 1))
               count_pair++;
          if (count_pair == 2){
               new_Z++; //учёт 2-х одинаковых взаминых сопротивлений между узлами
               count_pair = 0;
          }
     }

     complex< double > *Z1 = new complex< double >[1 + z_sum + new_Z]; //Обьявление вспомогательного массива сопротивлений
     for (int i = 1; i < (1 + z_sum); i++)
          Z1[i] = Z[i];//Запись старого массива в новый
     for (int j = 0; j < rows; j++)
          for (int k = 0; k < max_line; k++)
               ZameshRef[ci][j][k] = ZameshRef[ci - 1][j][k];//Запись старой иттерации в новую
     for (int j = 0; j < rows; j++)//Расчёт новых сопротивлений в массиве Z
     {
          int R_in_row = 0;//количество "R" в строке
          int N_in_row = 0;//количество "N" в строке
          for (int k = 0; k < max_line; k++){
               if (ZameshRef[ci][j][k][0] == 'N')
                    N_in_row++;
               if (ZameshRef[ci][j][k][0] == 'R')
                    R_in_row++;
          }
          complex< double > R_sum_in_row = (0, 0); //Вспомогательная переменная для подсчёта значения суммы сопртотивлений связи
          if ((N_in_row == 1) && (R_in_row > 1)) //Если в строке один N и R>1
          {
               for (int k = 0; k < max_line; k++)
                    if (ZameshRef[ci][j][k][0] == 'R')
                         R_sum_in_row = R_sum_in_row + Z1[stoi(ZameshRef[ci][j][k].substr(1))];    //Подсчёт суммы сопротивлений
               new_Z_count++;
               Z1[z_sum + new_Z_count] = R_sum_in_row; //Запись в новый массив сопротивления на новое место 
               ZameshRef[ci][j][1] = "R" + to_string(z_sum + new_Z_count);
               ZameshRef[ci][j][2] = ZameshRef[ci][j][R_in_row + 1]; //Подтягиваем E на позицию 3 
               for (int h = 3; h < max_line; h++) ZameshRef[ci][j][h] = "0"; //Зачищаем всё что правее E
          }
          if ((N_in_row == 2) && (R_in_row > 1))//Если в строке два N и R>1
          {
               string node_begin = "0"; //номер узла начала (для первой попавшейся строки)
               string node_end = "0"; //номер узла конца (для первой попавшейся строки)
               string old_R = "0"; //вспомогательная переменная, чтобы запоминать R
               for (int k = 0; k < max_line; k++)
                    if (ZameshRef[ci][j][k][0] == 'R')
                         R_sum_in_row = R_sum_in_row + Z1[stoi(ZameshRef[ci][j][k].substr(1))];    //Подсчёт суммы сопротивлений
               new_Z_count++;
               node_begin = ZameshRef[ci][j][0];
               node_end = ZameshRef[ci][j][R_in_row + 1];
               old_R = ZameshRef[ci][j][1];
               Z1[z_sum + new_Z_count] = R_sum_in_row; //Запись в новый массив сопротивления на новое место 
               ZameshRef[ci][j][1] = "R" + to_string(z_sum + new_Z_count);
               ZameshRef[ci][j][2] = ZameshRef[ci][j][R_in_row + 1]; //Подтягиваем N на позицию 3 
               for (int h = 3; h < max_line; h++) ZameshRef[ci][j][h] = "0"; //Зачищаем всё что правее N
               for (int g = j + 1; g < rows; g++){
                    int R_in_row_2 = 0; // вспомогательная переменная подсчёта R 
                    for (int k = 0; k < max_line; k++)
                         if (ZameshRef[ci][g][k][0] == 'R')
                              R_in_row_2++;
                    if ((R_in_row_2 == R_in_row) && (old_R == ZameshRef[ci][g][R_in_row_2])){
                         if ((ZameshRef[ci][g][0] == node_end) && ((ZameshRef[ci][g][R_in_row + 1] == node_begin))){
                              ZameshRef[ci][g][1] = "R" + to_string(z_sum + new_Z_count);
                              ZameshRef[ci][g][2] = ZameshRef[ci][g][R_in_row + 1]; //Подтягиваем N на позицию 3 
                              for (int h = 3; h < max_line; h++) ZameshRef[ci][g][h] = "0"; //Зачищаем всё что правее N
                         }
                    }
               }
          }
     }
     delete[] Z;//Удаление старого массива Z для переобъявления
     z_sum = z_sum + new_Z;
     Z = Z1;//Переобъявление Z
}

void Check_Summing_in_series(string ***&Zamesh, int &rows, int &max_line, int &ci, bool &check_of_necessity) {
     //Функция проверки необходимости выполнения последовательного сложения элементов
     int count_check_R = 0;
     for (int j = 0; j < rows; j++)
     {
          count_check_R = 0;
          for (int k = 0; k < max_line; k++){
               if (Zamesh[ci][j][k][0] == 'R')
                    count_check_R++; //подсчёт сопротивлений в связи
          }
          if (count_check_R>1)
               check_of_necessity = 1;//необходимость проводить сложение
     }
}

void Summing_in_parall(int &rows, int &max_line, int &ci, int &iteration_sum,
     int &source_sum, int &sourсe_parameter, string ***&ZameshRef,
     int &R_in_row, int &N_in_row, int &z_sum, complex< double > *&Z) {
     //Функция параллельного сложения элементов
     for (int j = 0; j < rows; j++)
          for (int k = 0; k < max_line; k++)
               ZameshRef[ci][j][k] = ZameshRef[ci - 1][j][k];//Запись старой иттерации в новую

     for (int j = 0; j < rows - 1; j++)
     {
          if (ZameshRef[ci][j][0][0] == 'N' && ZameshRef[ci][j][2][0] == 'N')
          {
               int count_parall_line = 1;
               complex< double > R_parall = 0;
               complex< double > one = 1;
               string n1 = ZameshRef[ci][j][0];
               string n2 = ZameshRef[ci][j][2];
               for (int g = j + 1; g < rows; g++)
                    if (ZameshRef[ci][g][0] == n1 && ZameshRef[ci][g][2] == n2)
                         count_parall_line++;

               if (count_parall_line > 1){
                    for (int g = 0; g < rows; g++){
                         if (ZameshRef[ci][g][0] == n1 && ZameshRef[ci][g][2] == n2){
                              R_parall = R_parall + (one / Z[stoi(ZameshRef[ci][g][1].substr(1))]);
                              for (int k = 0; k < max_line; k++)
                                   ZameshRef[ci][g][k] = '0';
                         }
                         if (ZameshRef[ci][g][0] == n2 && ZameshRef[ci][g][2] == n1)
                              for (int k = 0; k < max_line; k++)
                                   ZameshRef[ci][g][k] = '0';
                    }

                    complex< double > *Z1 = new complex< double >[1 + z_sum + 1]; //Обьявление вспомогательного массива сопротивлений
                    for (int i = 0; i < (1 + z_sum); i++)
                         Z1[i] = Z[i];//Запись старого массива в новый
                    
                    Z1[z_sum + 1] = one / R_parall; //Запись в новый массив сопротивления 
                    z_sum++;
                    int count_one = 0;
                    int count_two = 0;
                    //Добавление линии в схему замещения
                    for (int g = 0; g < rows; g++){
                         if (ZameshRef[ci][g][0] == "0" && ZameshRef[ci][g][2] == "0"){
                              ZameshRef[ci][g][0] = n1;
                              ZameshRef[ci][g][1] = "R" + to_string(z_sum);
                              ZameshRef[ci][g][2] = n2;
                              break;
                         }
                    }
                    for (int g = 0; g < rows; g++){
                         if (ZameshRef[ci][g][0] == "0" && ZameshRef[ci][g][2] == "0"){
                              ZameshRef[ci][g][0] = n2;
                              ZameshRef[ci][g][1] = "R" + to_string(z_sum);
                              ZameshRef[ci][g][2] = n1;
                              break;
                         }
                    }
                    delete[] Z;
                    Z = Z1;
               }
          }
     }
}

void Check_Summing_in_parall(string ***&Zamesh, int &rows, int &max_line, int &ci, bool &check_of_necessity)
{
     //Функция проверки необходимости выполнения параллельного сложения элементов
     int count_parall_line = 0;
     for (int j = 0; j < rows - 1; j++){
          count_parall_line = 0;
          if (Zamesh[ci][j][0][0] == 'N' && Zamesh[ci][j][2][0] == 'N'){
               int count_parall_line = 1;
               for (int g = j + 1; g < rows; g++)
                    if (Zamesh[ci][g][0] == Zamesh[ci][j][0] && Zamesh[ci][g][2] == Zamesh[ci][j][2])
                         count_parall_line++;
               if (count_parall_line > 1) //условие параллельности ветвей
                    check_of_necessity = 1;
          }
     }
}

void Triangle_Star(string ***&Zamesh, int &iteration_sum, int &rows, int &max_line, int &iteration_sum2, int &rows2, int &max_line2, int &ci, int &z_sum, complex< double > *&Z, string &num_1, string &num_2, string &num_3)
{
     //Функция преобразования элементов из треугольника в звезду
     for (int j = 0; j < rows; j++)
          for (int k = 0; k < max_line; k++)     
               Zamesh[ci][j][k] = Zamesh[ci - 1][j][k];
     
     
     num_1 = "0"; num_2 = "0"; num_3 = "0";

     bool count_one = 0;
     //Поиск треугольника
     for (int j = 0; j < rows; j++){
          if ((num_1 == "0") || (num_2 == "0") || (num_3 == "0")){
               num_1 = Zamesh[ci][j][0];
               for (int g = 0; g < rows; g++){
                    if (Zamesh[ci][j][2] == Zamesh[ci][g][0] && Zamesh[ci][g][2] != Zamesh[ci][j][0])//поиск строки с num_2
                    {
                         num_2 = Zamesh[ci][j][2];
                         for (int h = 0; h < rows; h++){
                              if (Zamesh[ci][g][2] == Zamesh[ci][h][0] && Zamesh[ci][h][2] == Zamesh[ci][j][0] && Zamesh[ci][h][0] != Zamesh[ci][j][0] && Zamesh[ci][h][0] != Zamesh[ci][g][0])//поиск строки с num_3
                              {
                                   num_3 = Zamesh[ci][g][2];
                                   count_one = 1;
                                   break;
                              }
                         }
                    }
                    if (count_one) break;
               }
          }
          if (count_one) break;
     }

     //Объявление вспомогательного массива сопротивлений
     complex< double > *Z2 = new complex< double >[z_sum + 1 + 3];

     //Объявление вспомогательных переменных для записи сопротивлениий треугольника и звезды
     complex< double > num_1_2_R_t, num_2_3_R_t, num_3_1_R_t;
     complex< double > num_1_R_s, num_2_R_s, num_3_R_s;

     for (int i = 0; i < (1 + z_sum); i++)
          Z2[i] = Z[i];//Запись старого массива в новый
     
     //Расчёт сопротивлений звезды
     if ((num_1 != "0") && (num_2 != "0") && (num_3 != "0")){
          //Запись значений сопротивлений треугольника в вспомогательные переменные
          for (int j = 0; j < rows; j++){
               if ((Zamesh[ci][j][0] == num_1) && (Zamesh[ci][j][1][0] == 'R') && (Zamesh[ci][j][2] == num_2))
                    num_1_2_R_t = Z2[stoi(Zamesh[ci][j][1].substr(1))];
               if ((Zamesh[ci][j][0] == num_1) && (Zamesh[ci][j][1][0] == 'R') && (Zamesh[ci][j][2] == num_3))
                    num_3_1_R_t = Z2[stoi(Zamesh[ci][j][1].substr(1))];
               if ((Zamesh[ci][j][0] == num_2) && (Zamesh[ci][j][1][0] == 'R') && (Zamesh[ci][j][2] == num_3))
                    num_2_3_R_t = Z2[stoi(Zamesh[ci][j][1].substr(1))];
          }

          //Подстчёт сопротивлений по формуле
          num_1_R_s = (num_1_2_R_t* num_3_1_R_t) / (num_1_2_R_t + num_3_1_R_t + num_2_3_R_t);
          num_2_R_s = (num_1_2_R_t* num_2_3_R_t) / (num_1_2_R_t + num_3_1_R_t + num_2_3_R_t);
          num_3_R_s = (num_2_3_R_t* num_3_1_R_t) / (num_1_2_R_t + num_3_1_R_t + num_2_3_R_t);

          //Запись сопротивлений звезды в массив сопротивлений
          Z2[1 + z_sum] = num_1_R_s;
          Z2[1 + z_sum + 1] = num_2_R_s;
          Z2[1 + z_sum + 2] = num_3_R_s;
     }

     rows2 = rows + 6;
     delete[] Z;
     Z = Z2;
}

void Triangle_Star2(string ***&Zamesh, int &iteration_sum, int &rows, int &max_line, int &ci, int &z_sum, complex< double > *&Z, string &num_1, string &num_2, string &num_3)
{
     //Функция преобразования элементов из треугольника в звезду
     string num_N = "N0";
     for (int j = 0; j < (rows); j++)
          if ((Zamesh[ci][j][0][0] == 'N') && (stoi(Zamesh[ci][j][0].substr(1))) >(stoi(num_N.substr(1))))
               num_N = Zamesh[ci][j][0];
     num_N = "N" + to_string((stoi(num_N.substr(1))) + 1);

     //Удаление старых связей треугольника
     for (int j = 0; j < rows; j++)
          if ((Zamesh[ci][j][0][0] == 'N') && (Zamesh[ci][j][2][0] == 'N'))
               if ((Zamesh[ci][j][0] == num_1) && (Zamesh[ci][j][2] == num_2) || (Zamesh[ci][j][0] == num_1) && (Zamesh[ci][j][2] == num_3) ||
                    (Zamesh[ci][j][0] == num_2) && (Zamesh[ci][j][2] == num_1) || (Zamesh[ci][j][0] == num_2) && (Zamesh[ci][j][2] == num_3) ||
                    (Zamesh[ci][j][0] == num_3) && (Zamesh[ci][j][2] == num_1) || (Zamesh[ci][j][0] == num_3) && (Zamesh[ci][j][2] == num_2))
                    for (int k = 0; k < max_line; k++)
                         Zamesh[ci][j][k] = "0";

     //Внесение новых строк в массив схемы замещнения
     Zamesh[ci][rows - 6][0] = num_1; Zamesh[ci][rows - 6][1] = "R" + to_string(1 + z_sum); Zamesh[ci][rows - 6][2] = num_N;
     Zamesh[ci][rows - 5][0] = num_2; Zamesh[ci][rows - 5][1] = "R" + to_string(1 + z_sum + 1); Zamesh[ci][rows - 5][2] = num_N;
     Zamesh[ci][rows - 4][0] = num_3; Zamesh[ci][rows - 4][1] = "R" + to_string(1 + z_sum + 2); Zamesh[ci][rows - 4][2] = num_N;
     Zamesh[ci][rows - 3][0] = num_N; Zamesh[ci][rows - 3][1] = "R" + to_string(1 + z_sum); Zamesh[ci][rows - 3][2] = num_1;
     Zamesh[ci][rows - 2][0] = num_N; Zamesh[ci][rows - 2][1] = "R" + to_string(1 + z_sum + 1); Zamesh[ci][rows - 2][2] = num_2;
     Zamesh[ci][rows - 1][0] = num_N; Zamesh[ci][rows - 1][1] = "R" + to_string(1 + z_sum + 2); Zamesh[ci][rows - 1][2] = num_3;

     for (int j = 0; j < (rows); j++)
          if ((Zamesh[ci][j][0] == "0") || (Zamesh[ci][j][0] == ""))
               for (int g = j + 1; g < (rows); g++)
                    if ((Zamesh[ci][j][0] != "0") && (Zamesh[ci][j][0] != ""))
                         for (int k = 0; j < max_line; j++)
                              Zamesh[ci][j][k] = Zamesh[ci][g][k];
     z_sum = z_sum + 3;
}

void Check_Triangle_Star(string ***&Zamesh, int &rows, int &max_line, int &ci, bool &check_of_necessity)
{
     //Функция проверки необходимости выполнения преобразования Треугольник-Звезда
     string num_1 = "0";
     string num_2 = "0";
     string num_3 = "0";
     //Поиск треугольника
     for (int j = 0; j < rows; j++){
          if ((num_1 == "0") || (num_2 == "0") || (num_3 == "0")){
               num_1 = Zamesh[ci][j][0];
               for (int g = 0; g < rows; g++){
                    if (Zamesh[ci][j][2] == Zamesh[ci][g][0] && Zamesh[ci][g][2] != Zamesh[ci][j][0])//поиск строки с num_2
                    {
                         num_2 = Zamesh[ci][j][2];
                         for (int h = 0; h < rows; h++)
                              if (Zamesh[ci][g][2] == Zamesh[ci][h][0] && Zamesh[ci][h][2] == Zamesh[ci][j][0] && Zamesh[ci][h][0] != Zamesh[ci][j][0] && Zamesh[ci][h][0] != Zamesh[ci][g][0])//поиск строки с num_3
                                   num_3 = Zamesh[ci][g][2];
                    }
               }
          }
     }
     if ((num_1 != "0") && (num_2 != "0") && (num_3 != "0"))//условия существования треугольника
          check_of_necessity++;
}

void Delete_node1(string ***&Zamesh, int &iteration_sum, int &rows, int &max_line, int &ci, string &node_with_kz, int &z2, string &n1, string &n2, string &n3, int &nk2, int &nk3)
{
     //Функция удаления лишних узлов
     for (int j = 0; j < rows; j++)
          for (int k = 0; k < max_line; k++)
               Zamesh[ci][j][k] = Zamesh[ci - 1][j][k];

     for (int j = 0; j < rows; j++)
          for (int k = 0; k < max_line; k++)
               if (Zamesh[ci][j][k] == "")
                    Zamesh[ci][j][k] = "0";

     for (int j = 0; j < rows; j++){
          n1 = "0"; n2 = "0"; n3 = "0";
          int count_one = 0;
          int count_two = 0;
          int count_elements = 0;
          int count_h = 0;
          if (Zamesh[ci][j][0][0] == 'N' && Zamesh[ci][j][0] != node_with_kz)
          {
               n1 = Zamesh[ci][j][0];//узел, который подлежит удалению
               if ((j + 1) < rows)
                    for (int g = 0; g < rows; g++)//счётчик связей
                         if (Zamesh[ci][g][0] == n1)
                              count_one++;

               if (count_one == 2) //если узел подлежит удалению
               {
                    j = rows + 1;//искуственный выход из цикла
                    for (int h = 0; h < rows; h++){
                         if (Zamesh[ci][h][0] == n1) // если в строке найден n1 на месте 0
                         {
                              for (int k = 1; k < max_line; k++){
                                   if (Zamesh[ci][h][k][0] == 'R')    //подсчёт сопротивлений
                                        count_elements++;
                                   if ((Zamesh[ci][h][k][0] == 'N') || (Zamesh[ci][h][k][0] == 'E')) //фиксация узла n2
                                   {
                                        n2 = Zamesh[ci][h][k];
                                        nk2 = k;
                                        count_h = h;
                                        count_two++;
                                   }
                              }
                         }
                         if (count_two == 1) break;
                    }
                    if ((count_h + 1) < rows){
                         for (int f = count_h + 1; f < rows; f++){
                              if (Zamesh[ci][f][0] == n1) // если в строке найден n1 на месте 0
                              {
                                   for (int k = 1; k < max_line; k++){
                                        if (Zamesh[ci][f][k][0] == 'R')    //подсчёт сопротивлений
                                             count_elements++;
                                        if (Zamesh[ci][f][k][0] == 'N' || Zamesh[ci][f][k][0] == 'E')  //фиксация узла n3
                                        {
                                             n3 = Zamesh[ci][f][k];
                                             nk3 = k;
                                             count_two++;
                                        }
                                   }
                              }
                              if (count_two == 2) break; //выход из цикла
                         }
                    }
                    if ((count_elements + 2) > z2) //пересчёт длинны строки
                         z2 = count_elements + 2;
               }
          }
     }
}

void Delete_node2(string ***&Zamesh, int &iteration_sum, int &rows, int &max_line, int &ci, int &z_sum, string &n1, string &n2, string &n3, int &nk2, int &nk3)
{
     //Функция удаления лишних узлов
     string *Z1 = new string[1 + z_sum]; //Обьявление вспомогательного массива сопротивлений
     int count_one = 0;
     int count_two = 0;
     for (int i = 0; i < (1 + z_sum); i++)
          Z1[i] = "0";

     if (n2[0] == 'E' && n3[0] == 'N'){
          int nkbuf = 0;
          string n23buf = "0";
          n23buf = n3;
          n3 = n2;
          n2 = n23buf;
          nkbuf = nk3;
          nk3 = nk2;
          nk2 = nkbuf;
     }

     for (int j = 0; j < rows; j++) //запись сопротивлений в Z1
     {
          if ((Zamesh[ci][j][0] == n2) && (Zamesh[ci][j][nk2] == n1))
               for (int k = 1; k < (nk2); k++)
                    Z1[k - 1] = Zamesh[ci][j][k];
          if ((Zamesh[ci][j][0] == n1) && (Zamesh[ci][j][nk2] == n3))
               for (int k = 1; k < (nk3); k++)
                    Z1[k - 2 + nk2] = Zamesh[ci][j][k];
     }

     for (int j = 0; j < rows; j++) //Удаление строк
     {
          if (Zamesh[ci][j][0] == n1 || Zamesh[ci][j][nk2] == n1 || Zamesh[ci][j][nk3] == n1) //условие удаления строки
               for (int k = 0; k < max_line; k++)
                    Zamesh[ci][j][k] = "0";
     }
     for (int g = 0; g < rows; g++) //Запись строки
     {
          if (Zamesh[ci][g][0] == "0"){
               Zamesh[ci][g][0] = n2;
               Zamesh[ci][g][nk2 + nk3 - 1] = n3;
               for (int k = 1; k < (nk2 + nk3 - 1); k++)
                    Zamesh[ci][g][k] = Z1[k - 1];
               break;
          }
     }
     if (n2[0] == 'N' && n3[0] == 'N'){
          for (int g = 0; g < rows; g++) //Запись строки
          {
               if (Zamesh[ci][g][0] == "0"){
                    Zamesh[ci][g][0] = n3;
                    Zamesh[ci][g][nk2 + nk3 - 1] = n2;
                    for (int k = 1; k < (nk2 + nk3 - 1); k++)
                         Zamesh[ci][g][k] = Z1[nk2 + nk3 - 1 - k - 1];
                    break;
               }
          }
     }
}

void Check_Delete_node(string ***&Zamesh, int &rows, int &max_line, int &ci, bool &check_of_necessity, string &node_with_kz)
{
     //Функция проверки необходимости удаления узлов
     for (int j = 0; j < rows; j++){
          int count_one = 0;
          if (Zamesh[ci][j][0][0] == 'N' && Zamesh[ci][j][0] != node_with_kz){
               for (int g = 0; g < rows; g++)//счётчик связей
                    if (Zamesh[ci][g][0] == Zamesh[ci][j][0] && g != j)
                         count_one++;
               if (count_one == 1 || count_one == 0)
                    check_of_necessity = 1;
          }
     }
}

void Sources_parall(string ***&Zamesh, int &iteration_sum, int &rows, int &max_line, int &ci, double **&E, int &z_sum, complex< double > *&Z, int &source_sum, int &sourсe_parameter)
{
     //Функция параллельного сложения источников
     for (int j = 0; j < rows; j++)
          for (int k = 0; k < max_line; k++)
               Zamesh[ci][j][k] = Zamesh[ci - 1][j][k];//Запись старой иттерации в новую

     string count_e_first = "0";
     string count_n_first = "7";
     string count_e_second = "0";
     int count_j_first = 0;
     int count_j_second = 0;
     bool count_second = 0;

     for (int j = 0; j < rows; j++){
          count_e_first = "0";
          count_n_first = "0";
          count_j_first = 0;
          count_second = 0;

          if (Zamesh[ci][j][2][0] == 'E'){
               count_e_first = Zamesh[ci][j][2];
               count_n_first = Zamesh[ci][j][0];
               count_j_first = j;
          }

          if (count_e_first != "0"){
               if (j + 1 < rows){
                    for (int g = j + 1; g < rows; g++){
                         if (Zamesh[ci][g][0][0] == 'N' && Zamesh[ci][g][2][0] == 'E' && Zamesh[ci][g][0] == Zamesh[ci][j][0] && Zamesh[ci][g][2] != Zamesh[ci][j][2]){
                              count_e_second = Zamesh[ci][g][2];
                              count_second = 1;
                              count_j_second = g;
                         }
                    }
               }
          }
          if (count_second == 1) j = rows + 1;
     }

     if (count_e_first != "0" && count_e_second != "0")
     {
          complex< double > *Z1 = new complex< double >[1 + z_sum + 1]; //Обьявление вспомогательного массива сопротивлений
          for (int i = 0; i < (1 + z_sum); i++)
               Z1[i] = Z[i];//Запись старого массива в новый
          
          complex< double > RE1 = Z[stoi(Zamesh[ci][count_j_first][1].substr(1))];
          complex< double > RE2 = Z[stoi(Zamesh[ci][count_j_second][1].substr(1))];
          Z1[z_sum + 1] = RE1 * RE2 / (RE1 + RE2); //Расчёт нового сопротивления 
          z_sum++;

          double **E1 = new double*[source_sum + 1 + 1];    //Обьявление вспомогательного массива источников                                          
          for (int i = 0; i < (source_sum + 1 + 1); i++)
               E1[i] = new double[sourсe_parameter];

          for (int j = 0; j < (source_sum + 1); j++)
               for (int k = 0; k < sourсe_parameter; k++)
                    E1[j][k] = E[j][k];//Запись старого массива в новый

          E1[source_sum + 1][0] = 0;
          E1[source_sum + 1][1] = 0;
          E1[source_sum + 1][2] = 0;
          E1[source_sum + 1][3] = (E1[stoi(count_e_first.substr(1))][3] * RE2.imag() + E1[stoi(count_e_second.substr(1))][3] * RE1.imag()) / (RE1.imag() + RE2.imag());

          for (int k = 0; k < max_line; k++)//удаление строк с источниками
          {
               Zamesh[ci][count_j_first][k] = "0";
               Zamesh[ci][count_j_second][k] = "0";
          }

          //Добавление новой связи с новым  источником
          Zamesh[ci][count_j_first][0] = count_n_first;
          Zamesh[ci][count_j_first][1] = "R" + to_string(z_sum);
          Zamesh[ci][count_j_first][2] = "E" + to_string(source_sum + 1);

          delete[] Z;
          Z = Z1;
          for (int i = 0; i < source_sum; i++)
               delete[] E[i];
          delete[] E;
          source_sum++;
          E = E1;
     }



}

void Check_Sources_parall(string ***&Zamesh, int &rows, int &max_line, int &ci, bool &check_of_necessity)
{
     //Функция проверки необходимости параллельного сложения источников
     for (int j = 0; j < rows; j++)
          if (Zamesh[ci][j][0][0] == 'N' && Zamesh[ci][j][2][0] == 'E')
               if (j + 1 < rows)
                    for (int g = (j + 1); g < rows; g++)
                         if (Zamesh[ci][g][0][0] == 'N' && Zamesh[ci][g][2][0] == 'E' && Zamesh[ci][g][0] == Zamesh[ci][j][0] && Zamesh[ci][g][2] != Zamesh[ci][j][2])
                              check_of_necessity = 1;
}

void Check_exit(string ***&Zamesh, int &rows, int &max_line, int &ci, bool &check_of_goal, string &node_with_kz)
{
     //Функция выхода из цикла проведения преобразований
     int count_nozero_ralations = 0;
     int count_kznode_ralations = 0;
     for (int j = 0; j < rows; j++)//Подсчёт количества ненулевых связей
          if (Zamesh[ci][j][0][0] == 'N')
               count_nozero_ralations++;
     for (int j = 0; j < rows; j++)//Подсчёт количества связей узла с КЗ
          if (Zamesh[ci][j][0] == node_with_kz)
               count_kznode_ralations++;
     if (count_nozero_ralations == 1 && count_kznode_ralations == 1)
          for (int j = 0; j < rows; j++)
               if (Zamesh[ci][j][0] == node_with_kz && Zamesh[ci][j][2][0] == 'E')
                    check_of_goal = 1;
}

void main()
{
     //исходные данные
     int source_sum = 5; //начальное количество источников E1, E2, E3 ... 
     int sourсe_parameter = 4; //количество параметров источника Pн, cosf, Uн, x"d, x2, x/r
     int z_sum = 16;//начальное количество сопротивлений
     string node_with_kz = "N5";//узел с КЗ
     
     //вспомогательные переменные
     int x = 1, y = 17, z = 6;
     int x2 = x, y2 = y, z2 = z;
     int R_in_row = 0;//количество "R" в строке
     int N_in_row = 0;//количество "N" в строке
     int new_Z = 0; //количество новых сопротивлений в массиве Z
     int new_Z_count = 0;// счётчик добавлений
     int ci = 0; //текущая иттерация current iteration
     int equality_number = 0;//количество одинаковых иттераций
     bool check_of_necessity = 0;//триггер необходимости выполнения функции
     bool check_of_goal = 0;//триггер достижения цели
     string log = "0";//для записи порядка операций
     double Start, Finish;//Время старта, время финиша
     double Duration;//Продолжительность
     string num_1 = "0";     //переменные для записи узлов треугольника
     string num_2 = "0";
     string num_3 = "0";
     int nk2 = 0;          
     int nk3 = 0;

     //объявление массива схемы замещения
     string ***Zamesh = new string**[x];
     for (int i = 0; i < x; i++){
          Zamesh[i] = new string*[y];
          for (int j = 0; j < y; j++)
               Zamesh[i][j] = new string[z];
     }

     //объявление массива сопротивлений
     complex< double > *Z = new complex< double >[z_sum + 1];

     //объявление массива источников
     double **E = new double*[source_sum + 1];                                  //Объявление массива указателей                              
     for (int i = 0; i < (source_sum + 1); i++)                                   //Объявление массивов одномерных строк                              
          E[i] = new double[sourсe_parameter];

     //Заполнение массива Zamesh
     FillZamesh(Zamesh, x, y, z, ci); 

     //Заполнение массива Z
     FillZ(Z, z_sum); 

     //Заполнение массива E
     FillE(E, source_sum, sourсe_parameter); 

     Start = omp_get_wtime();//Начало отсчёта времени
     do
     {
          //Сложение последовательных сопротилвений
          check_of_necessity = 0;
          Check_Summing_in_series(Zamesh, y, z, ci, check_of_necessity);
          if (check_of_necessity)
          {
               x2++; ci++;
               ReCreate(Zamesh, x, y, z, x2, y2, z2); //Переобъявление массива схемы замещения
               x = x2; y = y2; z = z2;
               Summing_in_series(y, z, ci, x, source_sum, sourсe_parameter, Zamesh, new_Z, new_Z_count, R_in_row, N_in_row, z_sum, Z);
               log = log + "-Pos";
          }

          //Сложение параллельных сопротилвений
          check_of_necessity = 0;
          Check_Summing_in_parall(Zamesh, y, z, ci, check_of_necessity);
          if (check_of_necessity)
          {
               x2++; ci++;
               ReCreate(Zamesh, x, y, z, x2, y2, z2); //Переобъявление массива схемы замещения
               x = x2; y = y2; z = z2;
               Summing_in_parall(y, z, ci, x, source_sum, sourсe_parameter, Zamesh, R_in_row, N_in_row, z_sum, Z);
               log = log + "-Par";
          }

          //Сложение последовательных сопротилвений
          check_of_necessity = 0;
          Check_Summing_in_series(Zamesh, y, z, ci, check_of_necessity);
          if (check_of_necessity)
          {
               x2++; ci++;
               ReCreate(Zamesh, x, y, z, x2, y2, z2); //Переобъявление массива схемы замещения
               x = x2; y = y2; z = z2;
               Summing_in_series(y, z, ci, x, source_sum, sourсe_parameter, Zamesh, new_Z, new_Z_count, R_in_row, N_in_row, z_sum, Z);
               log = log + "-Pos";
          }

          //Треугольник-Звезда
          check_of_necessity = 0;
          Check_Triangle_Star(Zamesh, y, z, ci, check_of_necessity);
          if (check_of_necessity)
          {
               x2++; ci++;
               ReCreate(Zamesh, x, y, z, x2, y2, z2); //Переобъявление массива схемы замещения
               x = x2; y = y2; z = z2;
               Triangle_Star(Zamesh, x, y, z, x2, y2, z2, ci, z_sum, Z, num_1, num_2, num_3);
               ReCreate(Zamesh, x, y, z, x2, y2, z2); //Переобъявление массива схемы замещения
               x = x2; y = y2; z = z2;
               Triangle_Star2(Zamesh, x, y, z, ci, z_sum, Z, num_1, num_2, num_3);
               log = log + "-TrZ";
          }

          //Сложение последовательных сопротилвений
          check_of_necessity = 0;
          Check_Summing_in_series(Zamesh, y, z, ci, check_of_necessity);
          if (check_of_necessity)
          {
               x2++; ci++;
               ReCreate(Zamesh, x, y, z, x2, y2, z2); //Переобъявление массива схемы замещения
               x = x2; y = y2; z = z2;
               Summing_in_series(y, z, ci, x, source_sum, sourсe_parameter, Zamesh, new_Z, new_Z_count, R_in_row, N_in_row, z_sum, Z);
               log = log + "-Pos";
          }

          //Удаление лишнего узла
          check_of_necessity = 0;
          Check_Delete_node(Zamesh, y, z, ci, check_of_necessity, node_with_kz);
          if (check_of_necessity)
          {
               x2++; ci++;
               ReCreate(Zamesh, x, y, z, x2, y2, z2); //Переобъявление массива схемы замещения
               x = x2; y = y2; z = z2;
               Delete_node1(Zamesh, x, y, z, ci, node_with_kz, z2, num_1, num_2, num_3, nk2, nk3);
               ReCreate(Zamesh, x, y, z, x2, y2, z2); //Переобъявление массива схемы замещения
               x = x2; y = y2; z = z2;
               Delete_node2(Zamesh, x, y, z, ci, z_sum, num_1, num_2, num_3, nk2, nk3);
               log = log + "-Del";
          }

          //Сложение последовательных сопротилвений
          check_of_necessity = 0;
          Check_Summing_in_series(Zamesh, y, z, ci, check_of_necessity);
          if (check_of_necessity)
          {
               x2++; ci++;
               ReCreate(Zamesh, x, y, z, x2, y2, z2); //Переобъявление массива схемы замещения
               x = x2; y = y2; z = z2;
               Summing_in_series(y, z, ci, x, source_sum, sourсe_parameter, Zamesh, new_Z, new_Z_count, R_in_row, N_in_row, z_sum, Z);
               log = log + "-Pos";
          }

          //Сложение параллельных источников
          check_of_necessity = 0;
          Check_Sources_parall(Zamesh, y, z, ci, check_of_necessity);
          if (check_of_necessity)
          {
               x2++; ci++;
               ReCreate(Zamesh, x, y, z, x2, y2, z2); //Переобъявление массива схемы замещения
               x = x2; y = y2; z = z2;
               Sources_parall(Zamesh, x, y, z, ci, E, z_sum, Z, source_sum, sourсe_parameter);
               log = log + "-Sour";
          }

          Check_exit(Zamesh, y, z, ci, check_of_goal, node_with_kz);
     }
     while (!check_of_goal);
     //ShowArrayToFile(Zamesh, x, y, z);
     cout << "===================Array Zamesh===================" << endl;
     ShowArray(Zamesh, x, y, z);
     cout << "===================Array Z===================" << endl;
     ShowArrayZ(Z, z_sum);
     cout << endl;
     cout << endl;
     cout << "===================Array E===================" << endl;
     ShowArrayE(E, source_sum, sourсe_parameter);
     cout << endl;
     cout << endl;
     cout << "log: " << log << endl;
     cout << endl;

     Finish = omp_get_wtime();
     Duration = (Finish - Start);
     cout << "Duration = " << Duration << endl;
     cout << endl;

     //Удаление массива источников
     for (int i = 0; i < source_sum; i++)
          delete[] E[i];
     delete[] E;

     //Удаление массива сопротивлений
     delete[] Z;

     //Удаление массива схемы замещения
     for (int i = 0; i < x; i++){
          for (int j = 0; j < y; j++)
               delete[] Zamesh[i][j];
          delete[] Zamesh[i];
     }
     delete[] Zamesh;
     _getch();
}
Comments: