logoChat01.ai

class Compare { public: bool operator()(const I...

Créé le : 10 août 2025

Répondu en utilisant GPT-5 Thinking par Chat01

Question

class Compare {
public:
bool operator()(const Interval& below, const Interval& above) const {
return below.R < above.R;
}
};

typedef std::priority_queue<Interval, std::deque<Interval>, Compare>
Priority_queue; cliext::deque<float> Base_LNA_1_2_Mer_AGP(
time_t now, bool mode, unsigned short N, float a, float b,
PeanoCurve_2D ^ Curve, PeanoCurve_2D ^ Curve_Minus_PI_Na_Dva,
unsigned short r, float epsilon, unsigned short global_iterations,
unsigned short global_local_iterations, float c, float d) {
std::pair<float, float> start, end, start_Minus_PI_Na_Dva,
end_Minus_PI_Na_Dva;
std::pair<float, float> x_Rmax, y_Rmax, x_Rmax_Minus_PI_Na_Dva,
y_Rmax_Minus_PI_Na_Dva;
std::pair<float, float> pred_i_sled_shag, pred_i_sled_shag_Minus_PI_Na_Dva;
std::pair<float, float> promejutochnaya_tochka,
promejutochnaya_tochka_Minus_PI_Na_Dva;

Interval nachalny_otrezok, nachalny_otrezok_Minus_PI_Na_Dva;
Interval promejutochny_otrezok, promejutochny_otrezok_Minus_PI_Na_Dva;
Interval curr, curr1, curr_Minus_PI_Na_Dva, curr1_Minus_PI_Na_Dva;

float Mmax, Mmax_Minus_PI_Na_Dva, m, m_Minus_PI_Na_Dva;
float dmax, dmax_Minus_PI_Na_Dva, eta_shtrih;

Priority_queue R, R_Minus_PI_Na_Dva, R1, R1_Minus_PI_Na_Dva;
cliext::deque<float> Extr, Extr_Minus_PI_Na_Dva;
unsigned short schetchick = 0;

if (N == 1) {
HINSTANCE load_function = LoadLibrary(L"TEST_FUNC.dll");
typedef float (*sh)(float, time_t);
sh ShekelFunc = (sh)GetProcAddress(load_function, "ShekelFunc");

text
 start = std::pair<float, float>(a, ShekelFunc(a, now));
 end = std::pair<float, float>(b, ShekelFunc(b, now));
 nachalny_otrezok = Interval(start, end, N);
 Mmax = nachalny_otrezok.M;
 m = r * Mmax;
 x_Rmax = std::pair<float, float>(start.first, end.first);
 y_Rmax = std::pair<float, float>(start.second, end.second);
 R.push(nachalny_otrezok);

 pred_i_sled_shag = std::pair<float, float>(a, b);

 while (true) {
   pred_i_sled_shag.first = pred_i_sled_shag.second;
   promejutochnaya_tochka.first = pred_i_sled_shag.second = Shag(
       m, x_Rmax.first, x_Rmax.second, y_Rmax.first, y_Rmax.second, N, r);

   promejutochnaya_tochka.second =
       ShekelFunc(pred_i_sled_shag.second, now);

   float min = promejutochnaya_tochka.second;
   if (!Extr.empty() && min > Extr.back()) {
     min = Extr.back();
   }

   Extr.push_back(min);

   if (schetchick == global_iterations) {
     FreeLibrary(load_function);
     return Extr;
   }

   promejutochny_otrezok = R.top();
   curr = Interval(promejutochny_otrezok.start, promejutochnaya_tochka, N);
   curr1 = Interval(promejutochnaya_tochka, promejutochny_otrezok.end, N);
   R.pop();

   if (mode && schetchick > global_local_iterations &&
       schetchick % 2 == 0 && schetchick < 50) {
     if ((std::max)(curr.M, curr1.M) > Mmax ||
         min == promejutochnaya_tochka.second) {
       Mmax = (std::max)(curr.M, curr1.M);
       m = r * Mmax;
     }

     promejutochny_otrezok = R.top();
     R.pop();
     eta_shtrih =
         (std::max)((std::max)(curr.M, curr1.M), promejutochny_otrezok.M);

     promejutochny_otrezok.ChangeCharacteristic(
         r * Mmax *
                 (promejutochny_otrezok.end.first -
                  promejutochny_otrezok.start.first) /
                 dmax +
             eta_shtrih -
             Mmax *
                 (promejutochny_otrezok.end.first -
                  promejutochny_otrezok.start.first) /
                 dmax,
         N);

     R.push(promejutochny_otrezok);

     while (!R.empty()) {
       promejutochny_otrezok = R.top();
       R.pop();
       eta_shtrih = (std::max)((std::max)(curr.M, curr1.M),
                               promejutochny_otrezok.M);

       promejutochny_otrezok.ChangeCharacteristic(
           r * Mmax *
                   (promejutochny_otrezok.end.first -
                    promejutochny_otrezok.start.first) /
                   dmax +
               eta_shtrih -
               Mmax *
                   (promejutochny_otrezok.end.first -
                    promejutochny_otrezok.start.first) /
                   dmax,
           N);

       R1.push(promejutochny_otrezok);

       if (R1.size() == 1) {
         curr.ChangeCharacteristic(
             r * Mmax * (curr.end.first - curr.start.first) / dmax +
                 eta_shtrih -
                 Mmax * (curr.end.first - curr.start.first) / dmax,
             N);

         curr1.ChangeCharacteristic(
             r * Mmax * (curr1.end.first - curr1.start.first) / dmax +
                 eta_shtrih -
                 Mmax * (curr1.end.first - curr1.start.first) / dmax,
             N);
       }
     }
     R = R1;
     R1 = Priority_queue();
   } else {
     if ((std::max)(curr.M, curr1.M) < Mmax &&
         min != promejutochnaya_tochka.second) {
       curr.ChangeCharacteristic(m, N);
       curr1.ChangeCharacteristic(m, N);
     } else {
       Mmax = (std::max)(curr.M, curr1.M);
       m = r * Mmax;
       curr.ChangeCharacteristic(m, N);
       curr1.ChangeCharacteristic(m, N);

       if (mode) {
         dmax = (std::max)(powf((curr.end).first - (curr.start).first,
                                (1.0f / float(N))),
                           powf((curr1.end).first - (curr1.start).first,
                                (1.0f / float(N))));
       }

       while (!R.empty()) {
         promejutochny_otrezok = R.top();
         R.pop();

         if (mode && powf((promejutochny_otrezok.end).first -
                              (promejutochny_otrezok.start).first,
                          (1.0f / float(N))) > dmax) {
           dmax = powf((promejutochny_otrezok.end).first -
                           (promejutochny_otrezok.start).first,
                       (1.0f / float(N)));
         }

         promejutochny_otrezok.ChangeCharacteristic(m, N);
         R1.push(promejutochny_otrezok);
       }
       R = R1;
       R1 = Priority_queue();
     }
   }

   R.push(curr);
   R.push(curr1);
   promejutochny_otrezok = R.top();

   if (fabsf(promejutochny_otrezok.end.first -
             promejutochny_otrezok.start.first) < epsilon) {
     FreeLibrary(load_function);
     return Extr;
   }

   x_Rmax.first = promejutochny_otrezok.start.first;
   x_Rmax.second = promejutochny_otrezok.end.first;
   y_Rmax.first = promejutochny_otrezok.start.second;
   y_Rmax.second = promejutochny_otrezok.end.second;
   schetchick++;
 }

} else {
HINSTANCE load_function = LoadLibrary(L"TEST_FUNC.dll");
typedef float (*rr)(float, float);
rr RastriginFunc = (rr)GetProcAddress(load_function, "RastriginFunc");

text
 float divider = static_cast<float>(1 << 2 * Curve->razvertka + 1);
 float x_addition = (b - a) / divider;
 float y_addition = (d - c) / divider;
 float true_start = a + x_addition;
 float true_end = b - x_addition;

 start = std::pair<float, float>(
     true_start, RastriginFunc(true_start, c + y_addition));
 end = std::pair<float, float>(true_end,
                               RastriginFunc(true_end, c + y_addition));
 start_Minus_PI_Na_Dva = std::pair<float, float>(
     true_start, RastriginFunc(true_end, d - y_addition));
 end_Minus_PI_Na_Dva = std::pair<float, float>(
     true_end, RastriginFunc(true_start, d - y_addition));

 nachalny_otrezok = Interval(start, end, N);
 nachalny_otrezok_Minus_PI_Na_Dva =
     Interval(start_Minus_PI_Na_Dva, end_Minus_PI_Na_Dva, N);

 Mmax = nachalny_otrezok.M;
 m = r * Mmax;
 x_Rmax = std::pair<float, float>(start.first, end.first);
 y_Rmax = std::pair<float, float>(start.second, end.second);

 Mmax_Minus_PI_Na_Dva = nachalny_otrezok_Minus_PI_Na_Dva.M;
 m_Minus_PI_Na_Dva = r * Mmax_Minus_PI_Na_Dva;

 R.push(nachalny_otrezok);
 R_Minus_PI_Na_Dva.push(nachalny_otrezok_Minus_PI_Na_Dva);

 x_Rmax_Minus_PI_Na_Dva = std::pair<float, float>(
     start_Minus_PI_Na_Dva.first, end_Minus_PI_Na_Dva.first);
 y_Rmax_Minus_PI_Na_Dva = std::pair<float, float>(
     start_Minus_PI_Na_Dva.second, end_Minus_PI_Na_Dva.second);

 pred_i_sled_shag = std::pair<float, float>(true_start, true_end);
 pred_i_sled_shag_Minus_PI_Na_Dva =
     std::pair<float, float>(true_start, true_end);

 while (true) {
   pred_i_sled_shag.first = pred_i_sled_shag.second;
   promejutochnaya_tochka.first = pred_i_sled_shag.second = Shag(
       m, x_Rmax.first, x_Rmax.second, y_Rmax.first, y_Rmax.second, N, r);

   pred_i_sled_shag_Minus_PI_Na_Dva.first =
       pred_i_sled_shag_Minus_PI_Na_Dva.second;
   promejutochnaya_tochka_Minus_PI_Na_Dva.first =
       pred_i_sled_shag_Minus_PI_Na_Dva.second = Shag(
           m_Minus_PI_Na_Dva, x_Rmax_Minus_PI_Na_Dva.first,
           x_Rmax_Minus_PI_Na_Dva.second, y_Rmax_Minus_PI_Na_Dva.first,
           y_Rmax_Minus_PI_Na_Dva.second, N, r);

   float x1 = Curve->HitTest_2D(pred_i_sled_shag.second).first;
   float x2 = Curve->HitTest_2D(pred_i_sled_shag.second).second;

   float x1_Minus_PI_Na_Dva =
       Curve_Minus_PI_Na_Dva
           ->HitTest_2D(pred_i_sled_shag_Minus_PI_Na_Dva.second)
           .first;
   float x2_Minus_PI_Na_Dva =
       Curve_Minus_PI_Na_Dva
           ->HitTest_2D(pred_i_sled_shag_Minus_PI_Na_Dva.second)
           .second;

   promejutochnaya_tochka.second = RastriginFunc(x1, x2);
   promejutochnaya_tochka_Minus_PI_Na_Dva.second =
       RastriginFunc(x1_Minus_PI_Na_Dva, x2_Minus_PI_Na_Dva);

   float min = promejutochnaya_tochka.second;
   float min_Minus_PI_Na_Dva =
       promejutochnaya_tochka_Minus_PI_Na_Dva.second;

   if (min < min_Minus_PI_Na_Dva) {
     chart2->Series[0]->Points->AddXY(x1, x2);
   } else {
     chart2->Series[0]->Points->AddXY(x1_Minus_PI_Na_Dva,
                                      x2_Minus_PI_Na_Dva);
   }

   if (Extr.empty() || min < Extr.back()) {
     Extr.push_back(min);
   }
   if (Extr_Minus_PI_Na_Dva.empty() ||
       min_Minus_PI_Na_Dva < Extr_Minus_PI_Na_Dva.back()) {
     Extr_Minus_PI_Na_Dva.push_back(min_Minus_PI_Na_Dva);
   }

   if (schetchick == global_iterations) {
     textBox6->Text = Convert::ToString(global_iterations);
     textBox7->Text = Convert::ToString((std::max)(
         fabsf(promejutochny_otrezok.end.first -
               promejutochny_otrezok.start.first),
         fabsf(promejutochny_otrezok_Minus_PI_Na_Dva.end.first -
               promejutochny_otrezok_Minus_PI_Na_Dva.start.first)));

     if (promejutochnaya_tochka.second <
         promejutochnaya_tochka_Minus_PI_Na_Dva.second) {
       chart2->Series[2]->Points->AddXY(x1, x2);
       textBox4->Text = Convert::ToString(x1);
       textBox3->Text = Convert::ToString(x2);
     } else {
       chart2->Series[2]->Points->AddXY(x1_Minus_PI_Na_Dva,
                                        x2_Minus_PI_Na_Dva);
       textBox4->Text = Convert::ToString(x1_Minus_PI_Na_Dva);
       textBox3->Text = Convert::ToString(x2_Minus_PI_Na_Dva);
     }

     FreeLibrary(load_function);
     return Extr.back() < Extr_Minus_PI_Na_Dva.back()
                ? Extr
                : Extr_Minus_PI_Na_Dva;
   }

   promejutochny_otrezok = R.top();
   R.pop();
   curr = Interval(promejutochny_otrezok.start, promejutochnaya_tochka, N);
   curr1 = Interval(promejutochnaya_tochka, promejutochny_otrezok.end, N);
   promejutochny_otrezok_Minus_PI_Na_Dva = R_Minus_PI_Na_Dva.top();
   R_Minus_PI_Na_Dva.pop();
   curr_Minus_PI_Na_Dva =
       Interval(promejutochny_otrezok_Minus_PI_Na_Dva.start,
                promejutochnaya_tochka_Minus_PI_Na_Dva, N);
   curr1_Minus_PI_Na_Dva =
       Interval(promejutochnaya_tochka_Minus_PI_Na_Dva,
                promejutochny_otrezok_Minus_PI_Na_Dva.end, N);

   promejutochny_otrezok = R.top();
   promejutochny_otrezok_Minus_PI_Na_Dva = R_Minus_PI_Na_Dva.top();

   float cooling = exp(-schetchick / 200.0f);
   int T = 10 + static_cast<int>(20 * cooling);
   float k = 0.7f + 0.2f * cooling;

   if (schetchick % T == 0 && schetchick > T) {
     auto point2D_1 = Curve->HitTest_2D(promejutochny_otrezok.start.first);
     auto point2D_2 = Curve->HitTest_2D(promejutochny_otrezok.end.first);
     float newParam1 = Curve_Minus_PI_Na_Dva->FindX_2D(point2D_1);
     float newParam2 = Curve_Minus_PI_Na_Dva->FindX_2D(point2D_2);
     std::pair<float, float> newStart(newParam1,
                                      promejutochny_otrezok.start.second);
     std::pair<float, float> newEnd(newParam2,
                                    promejutochny_otrezok.end.second);
     Interval newInterval(newStart, newEnd, N);
     newInterval.R = promejutochny_otrezok.R * k;
     R_Minus_PI_Na_Dva.push(newInterval);

     point2D_1 = Curve_Minus_PI_Na_Dva->HitTest_2D(
         promejutochny_otrezok_Minus_PI_Na_Dva.start.first);
     point2D_2 = Curve_Minus_PI_Na_Dva->HitTest_2D(
         promejutochny_otrezok_Minus_PI_Na_Dva.end.first);
     newParam1 = Curve->FindX_2D(point2D_1);
     newParam2 = Curve->FindX_2D(point2D_2);
     newStart = std::pair<float, float>(
         newParam1, promejutochny_otrezok_Minus_PI_Na_Dva.start.second);
     newEnd = std::pair<float, float>(
         newParam2, promejutochny_otrezok_Minus_PI_Na_Dva.end.second);
     newInterval = Interval(newStart, newEnd, N);
     newInterval.R = promejutochny_otrezok_Minus_PI_Na_Dva.R * k;
     R.push(newInterval);
   }

   if (mode && schetchick > global_local_iterations &&
       schetchick % 2 == 0) {
     if ((std::max)(curr.M, curr1.M) > Mmax ||
         min == promejutochnaya_tochka.second) {
       Mmax = (std::max)(curr.M, curr1.M);
       m = r * Mmax;
     }

     promejutochny_otrezok = R.top();
     R.pop();
     eta_shtrih =
         (std::max)((std::max)(curr.M, curr1.M), promejutochny_otrezok.M);

     promejutochny_otrezok.ChangeCharacteristic(
         r * Mmax *
                 (promejutochny_otrezok.end.first -
                  promejutochny_otrezok.start.first) /
                 dmax +
             eta_shtrih -
             Mmax *
                 (promejutochny_otrezok.end.first -
                  promejutochny_otrezok.start.first) /
                 dmax,
         N);

     R.push(promejutochny_otrezok);

     while (!R.empty()) {
       promejutochny_otrezok = R.top();
       R.pop();
       eta_shtrih = (std::max)((std::max)(curr.M, curr1.M),
                               promejutochny_otrezok.M);

       promejutochny_otrezok.ChangeCharacteristic(
           r * Mmax *
                   (promejutochny_otrezok.end.first -
                    promejutochny_otrezok.start.first) /
                   dmax +
               eta_shtrih -
               Mmax *
                   (promejutochny_otrezok.end.first -
                    promejutochny_otrezok.start.first) /
                   dmax,
           N);

       R1.push(promejutochny_otrezok);

       if (R1.size() == 1) {
         curr.ChangeCharacteristic(
             r * Mmax * (curr.end.first - curr.start.first) / dmax +
                 eta_shtrih -
                 Mmax * (curr.end.first - curr.start.first) / dmax,
             N);

         curr1.ChangeCharacteristic(
             r * Mmax * (curr1.end.first - curr1.start.first) / dmax +
                 eta_shtrih -
                 Mmax * (curr1.end.first - curr1.start.first) / dmax,
             N);
       }
     }
     R = R1;
     R1 = Priority_queue();

     if ((std::max)(curr_Minus_PI_Na_Dva.M, curr1_Minus_PI_Na_Dva.M) >
             Mmax_Minus_PI_Na_Dva ||
         min == promejutochnaya_tochka_Minus_PI_Na_Dva.second) {
       Mmax_Minus_PI_Na_Dva =
           (std::max)(curr_Minus_PI_Na_Dva.M, curr1_Minus_PI_Na_Dva.M);
       m_Minus_PI_Na_Dva = r * Mmax_Minus_PI_Na_Dva;
     }

     promejutochny_otrezok_Minus_PI_Na_Dva = R_Minus_PI_Na_Dva.top();
     R_Minus_PI_Na_Dva.pop();
     eta_shtrih = (std::max)(
         (std::max)(curr_Minus_PI_Na_Dva.M, curr1_Minus_PI_Na_Dva.M),
         promejutochny_otrezok_Minus_PI_Na_Dva.M);

     promejutochny_otrezok_Minus_PI_Na_Dva.ChangeCharacteristic(
         r * Mmax_Minus_PI_Na_Dva *
                 (promejutochny_otrezok_Minus_PI_Na_Dva.end.first -
                  promejutochny_otrezok_Minus_PI_Na_Dva.start.first) /
                 dmax_Minus_PI_Na_Dva +
             eta_shtrih -
             Mmax_Minus_PI_Na_Dva *
                 (promejutochny_otrezok_Minus_PI_Na_Dva.end.first -
                  promejutochny_otrezok_Minus_PI_Na_Dva.start.first) /
                 dmax_Minus_PI_Na_Dva,
         N);

     R_Minus_PI_Na_Dva.push(promejutochny_otrezok_Minus_PI_Na_Dva);

     while (!R_Minus_PI_Na_Dva.empty()) {
       promejutochny_otrezok_Minus_PI_Na_Dva = R_Minus_PI_Na_Dva.top();
       R_Minus_PI_Na_Dva.pop();
       eta_shtrih = (std::max)(
           (std::max)(curr_Minus_PI_Na_Dva.M, curr1_Minus_PI_Na_Dva.M),
           promejutochny_otrezok_Minus_PI_Na_Dva.M);

       promejutochny_otrezok_Minus_PI_Na_Dva.ChangeCharacteristic(
           r * Mmax_Minus_PI_Na_Dva *
                   (promejutochny_otrezok_Minus_PI_Na_Dva.end.first -
                    promejutochny_otrezok_Minus_PI_Na_Dva.start.first) /
                   dmax_Minus_PI_Na_Dva +
               eta_shtrih -
               Mmax_Minus_PI_Na_Dva *
                   (promejutochny_otrezok_Minus_PI_Na_Dva.end.first -
                    promejutochny_otrezok_Minus_PI_Na_Dva.start.first) /
                   dmax_Minus_PI_Na_Dva,
           N);

       R1_Minus_PI_Na_Dva.push(promejutochny_otrezok_Minus_PI_Na_Dva);

       if (R1_Minus_PI_Na_Dva.size() == 1) {
         curr_Minus_PI_Na_Dva.ChangeCharacteristic(
             r * Mmax_Minus_PI_Na_Dva *
                     (curr_Minus_PI_Na_Dva.end.first -
                      curr_Minus_PI_Na_Dva.start.first) /
                     dmax_Minus_PI_Na_Dva +
                 eta_shtrih -
                 Mmax_Minus_PI_Na_Dva *
                     (curr_Minus_PI_Na_Dva.end.first -
                      curr_Minus_PI_Na_Dva.start.first) /
                     dmax_Minus_PI_Na_Dva,
             N);

         curr1_Minus_PI_Na_Dva.ChangeCharacteristic(
             r * Mmax_Minus_PI_Na_Dva *
                     (curr1_Minus_PI_Na_Dva.end.first -
                      curr1_Minus_PI_Na_Dva.start.first) /
                     dmax_Minus_PI_Na_Dva +
                 eta_shtrih -
                 Mmax_Minus_PI_Na_Dva *
                     (curr1_Minus_PI_Na_Dva.end.first -
                      curr1_Minus_PI_Na_Dva.start.first) /
                     dmax_Minus_PI_Na_Dva,
             N);
       }
     }
     R_Minus_PI_Na_Dva = R1_Minus_PI_Na_Dva;
     R1_Minus_PI_Na_Dva = Priority_queue();
   } else {
     if ((std::max)(curr.M, curr1.M) < Mmax && min != Extr.back()) {
       curr.ChangeCharacteristic(m, N);
       curr1.ChangeCharacteristic(m, N);
     } else {
       Mmax = (std::max)(curr.M, curr1.M);
       m = r * Mmax;
       curr.ChangeCharacteristic(m, N);
       curr1.ChangeCharacteristic(m, N);

       if (mode) {
         dmax = (std::max)(powf((curr.end).first - (curr.start).first,
                                (1.0f / float(N))),
                           powf((curr1.end).first - (curr1.start).first,
                                (1.0f / float(N))));
       }

       while (!R.empty()) {
         promejutochny_otrezok = R.top();
         R.pop();

         if (mode && powf((promejutochny_otrezok.end).first -
                              (promejutochny_otrezok.start).first,
                          (1.0f / float(N))) > dmax) {
           dmax = powf((promejutochny_otrezok.end).first -
                           (promejutochny_otrezok.start).first,
                       (1.0f / float(N)));
         }

         promejutochny_otrezok.ChangeCharacteristic(m, N);
         R1.push(promejutochny_otrezok);
       }
       R = R1;
       R1 = Priority_queue();
     }

     if ((std::max)(curr_Minus_PI_Na_Dva.M, curr1_Minus_PI_Na_Dva.M) <
             Mmax_Minus_PI_Na_Dva &&
         min_Minus_PI_Na_Dva != Extr_Minus_PI_Na_Dva.back()) {
       curr_Minus_PI_Na_Dva.ChangeCharacteristic(m_Minus_PI_Na_Dva, N);
       curr1_Minus_PI_Na_Dva.ChangeCharacteristic(m_Minus_PI_Na_Dva, N);
     } else {
       Mmax_Minus_PI_Na_Dva =
           (std::max)(curr_Minus_PI_Na_Dva.M, curr1_Minus_PI_Na_Dva.M);
       m_Minus_PI_Na_Dva = r * Mmax_Minus_PI_Na_Dva;
       curr_Minus_PI_Na_Dva.ChangeCharacteristic(m_Minus_PI_Na_Dva, N);
       curr1_Minus_PI_Na_Dva.ChangeCharacteristic(m_Minus_PI_Na_Dva, N);

       if (mode) {
         dmax_Minus_PI_Na_Dva =
             (std::max)(powf((curr_Minus_PI_Na_Dva.end).first -
                                 (curr_Minus_PI_Na_Dva.start).first,
                             (1.0f / float(N))),
                        powf((curr1_Minus_PI_Na_Dva.end).first -
                                 (curr1_Minus_PI_Na_Dva.start).first,
                             (1.0f / float(N))));
       }

       while (!R_Minus_PI_Na_Dva.empty()) {
         promejutochny_otrezok_Minus_PI_Na_Dva = R_Minus_PI_Na_Dva.top();
         R_Minus_PI_Na_Dva.pop();

         if (mode &&
             powf((promejutochny_otrezok_Minus_PI_Na_Dva.end).first -
                      (promejutochny_otrezok_Minus_PI_Na_Dva.start).first,
                  (1.0f / float(N))) > dmax_Minus_PI_Na_Dva) {
           dmax_Minus_PI_Na_Dva = powf(
               (promejutochny_otrezok_Minus_PI_Na_Dva.end).first -
                   (promejutochny_otrezok_Minus_PI_Na_Dva.start).first,
               (1.0f / float(N)));
         }

         promejutochny_otrezok_Minus_PI_Na_Dva.ChangeCharacteristic(
             m_Minus_PI_Na_Dva, N);
         R1_Minus_PI_Na_Dva.push(promejutochny_otrezok_Minus_PI_Na_Dva);
       }
       R_Minus_PI_Na_Dva = R1_Minus_PI_Na_Dva;
       R1_Minus_PI_Na_Dva = Priority_queue();
     }
   }

   R.push(curr);
   R.push(curr1);
   promejutochny_otrezok = R.top();

   R_Minus_PI_Na_Dva.push(curr_Minus_PI_Na_Dva);
   R_Minus_PI_Na_Dva.push(curr1_Minus_PI_Na_Dva);
   promejutochny_otrezok_Minus_PI_Na_Dva = R_Minus_PI_Na_Dva.top();

   float accuracy = (std::max)(
       fabsf(promejutochny_otrezok.end.first -
             promejutochny_otrezok.start.first),
       fabsf(promejutochny_otrezok_Minus_PI_Na_Dva.end.first -
             promejutochny_otrezok_Minus_PI_Na_Dva.start.first));

   if (accuracy < epsilon) {
     textBox6->Text = Convert::ToString(schetchick);
     textBox7->Text = Convert::ToString(accuracy);

     if (promejutochnaya_tochka.second <
         promejutochnaya_tochka_Minus_PI_Na_Dva.second) {
       chart2->Series[2]->Points->AddXY(x1, x2);
       textBox4->Text = Convert::ToString(x1);
       textBox3->Text = Convert::ToString(x2);
     } else {
       chart2->Series[2]->Points->AddXY(x1_Minus_PI_Na_Dva,
                                        x2_Minus_PI_Na_Dva);
       textBox4->Text = Convert::ToString(x1_Minus_PI_Na_Dva);
       textBox3->Text = Convert::ToString(x2_Minus_PI_Na_Dva);
     }

     FreeLibrary(load_function);
     return Extr.back() < Extr_Minus_PI_Na_Dva.back()
                ? Extr
                : Extr_Minus_PI_Na_Dva;
   }

   x_Rmax.first = promejutochny_otrezok.start.first;
   x_Rmax.second = promejutochny_otrezok.end.first;
   y_Rmax.first = promejutochny_otrezok.start.second;
   y_Rmax.second = promejutochny_otrezok.end.second;

   x_Rmax_Minus_PI_Na_Dva.first =
       promejutochny_otrezok_Minus_PI_Na_Dva.start.first;
   x_Rmax_Minus_PI_Na_Dva.second =
       promejutochny_otrezok_Minus_PI_Na_Dva.end.first;
   y_Rmax_Minus_PI_Na_Dva.first =
       promejutochny_otrezok_Minus_PI_Na_Dva.start.second;
   y_Rmax_Minus_PI_Na_Dva.second =
       promejutochny_otrezok_Minus_PI_Na_Dva.end.second;

   schetchick++;
 }

}
} - 1ая версия моего кода, далее я переписал её не через приоритетную кастомную очередь а через вектор но с тем же компаратором используя по смыслу операции добавления и извлечения элементов из вектора чтобы по функциональности получалось тоже самое но быстрее: struct Compare {
bool operator()(const Interval& below, const Interval& above) const {
return below.R < above.R;
}
}; std::vector<float> Base_LNA_1_2_Mer_AGP(
time_t now, bool mode, unsigned short N, float a, float b,
PeanoCurve_2D ^ Curve, PeanoCurve_2D ^ Curve_Minus_PI_Na_Dva,
unsigned short r, float epsilon, unsigned short global_iterations,
unsigned short global_local_iterations, float c, float d) {
std::pair<float, float> start, end, start_Minus_PI_Na_Dva,
end_Minus_PI_Na_Dva;
std::pair<float, float> x_Rmax, y_Rmax, x_Rmax_Minus_PI_Na_Dva,
y_Rmax_Minus_PI_Na_Dva;
std::pair<float, float> pred_i_sled_shag, pred_i_sled_shag_Minus_PI_Na_Dva;
std::pair<float, float> promejutochnaya_tochka,
promejutochnaya_tochka_Minus_PI_Na_Dva;

text
Interval nachalny_otrezok, nachalny_otrezok_Minus_PI_Na_Dva;
Interval promejutochny_otrezok, promejutochny_otrezok_Minus_PI_Na_Dva;
Interval curr, curr1, curr_Minus_PI_Na_Dva, curr1_Minus_PI_Na_Dva;

float Mmax, Mmax_Minus_PI_Na_Dva, m, m_Minus_PI_Na_Dva;
float dmax, dmax_Minus_PI_Na_Dva, eta_shtrih;

std::vector<Interval> R, R_Minus_PI_Na_Dva, R1, R1_Minus_PI_Na_Dva;
std::vector<float> Extr, Extr_Minus_PI_Na_Dva;
unsigned short schetchick = 0;

if (N == 1) {
  HINSTANCE load_function = LoadLibrary(L"TEST_FUNC.dll");
  typedef float (*sh)(float, time_t);
  sh ShekelFunc = (sh)GetProcAddress(load_function, "ShekelFunc");

  start = std::pair<float, float>(a, ShekelFunc(a, now));
  end = std::pair<float, float>(b, ShekelFunc(b, now));
  nachalny_otrezok = Interval(start, end, N);
  Mmax = nachalny_otrezok.M;
  m = r * Mmax;
  x_Rmax = std::pair<float, float>(start.first, end.first);
  y_Rmax = std::pair<float, float>(start.second, end.second);

  R.push_back(nachalny_otrezok);
  std::push_heap(R.begin(), R.end(), Compare{});

  pred_i_sled_shag = std::pair<float, float>(a, b);

  while (true) {
    pred_i_sled_shag.first = pred_i_sled_shag.second;
    promejutochnaya_tochka.first = pred_i_sled_shag.second = Shag(
        m, x_Rmax.first, x_Rmax.second, y_Rmax.first, y_Rmax.second, N, r);

    promejutochnaya_tochka.second =
        ShekelFunc(pred_i_sled_shag.second, now);

    float min = promejutochnaya_tochka.second;
    if (!Extr.empty() && min > Extr.back()) {
      min = Extr.back();
    }

    Extr.push_back(min);

    if (schetchick == global_iterations) {
      FreeLibrary(load_function);
      return Extr;
    }

    std::pop_heap(R.begin(), R.end(), Compare{});
    promejutochny_otrezok = R.back();
    R.pop_back();

    curr = Interval(promejutochny_otrezok.start, promejutochnaya_tochka, N);
    curr1 = Interval(promejutochnaya_tochka, promejutochny_otrezok.end, N);
    
    if (mode && schetchick > global_local_iterations &&
        schetchick % 2 == 0 && schetchick < 50) {
      if ((std::max)(curr.M, curr1.M) > Mmax ||
          min == promejutochnaya_tochka.second) {
        Mmax = (std::max)(curr.M, curr1.M);
        m = r * Mmax;
      }

      std::pop_heap(R.begin(), R.end(), Compare{});
      promejutochny_otrezok = R.back();
      R.pop_back();

      eta_shtrih =
          (std::max)((std::max)(curr.M, curr1.M), promejutochny_otrezok.M);

      promejutochny_otrezok.ChangeCharacteristic(
          r * Mmax *
                  (promejutochny_otrezok.end.first -
                   promejutochny_otrezok.start.first) /
                  dmax +
              eta_shtrih -
              Mmax *
                  (promejutochny_otrezok.end.first -
                   promejutochny_otrezok.start.first) /
                  dmax,
          N);

      R.push_back(promejutochny_otrezok);
      std::push_heap(R.begin(), R.end(), Compare{});

      while (!R.empty()) {

        std::pop_heap(R.begin(), R.end(), Compare{});
        promejutochny_otrezok = R.back();
        R.pop_back();

        eta_shtrih = (std::max)((std::max)(curr.M, curr1.M),
                                promejutochny_otrezok.M);

        promejutochny_otrezok.ChangeCharacteristic(
            r * Mmax *
                    (promejutochny_otrezok.end.first -
                     promejutochny_otrezok.start.first) /
                    dmax +
                eta_shtrih -
                Mmax *
                    (promejutochny_otrezok.end.first -
                     promejutochny_otrezok.start.first) /
                    dmax,
            N);

        R1.push_back(promejutochny_otrezok);
        std::push_heap(R1.begin(), R1.end(), Compare{});

        if (R1.size() == 1) {
          curr.ChangeCharacteristic(
              r * Mmax * (curr.end.first - curr.start.first) / dmax +
                  eta_shtrih -
                  Mmax * (curr.end.first - curr.start.first) / dmax,
              N);

          curr1.ChangeCharacteristic(
              r * Mmax * (curr1.end.first - curr1.start.first) / dmax +
                  eta_shtrih -
                  Mmax * (curr1.end.first - curr1.start.first) / dmax,
              N);
        }
      }
      R = R1;
      R1 = std::vector<Interval>();
    } else {
      if ((std::max)(curr.M, curr1.M) < Mmax &&
          min != promejutochnaya_tochka.second) {
        curr.ChangeCharacteristic(m, N);
        curr1.ChangeCharacteristic(m, N);
      } else {
        Mmax = (std::max)(curr.M, curr1.M);
        m = r * Mmax;
        curr.ChangeCharacteristic(m, N);
        curr1.ChangeCharacteristic(m, N);

        if (mode) {
          dmax = (std::max)(powf((curr.end).first - (curr.start).first,
                                 (1.0f / float(N))),
                            powf((curr1.end).first - (curr1.start).first,
                                 (1.0f / float(N))));
        }

        while (!R.empty()) {

          std::pop_heap(R.begin(), R.end(), Compare{});
          promejutochny_otrezok = R.back();
          R.pop_back();

          if (mode && powf((promejutochny_otrezok.end).first -
                               (promejutochny_otrezok.start).first,
                           (1.0f / float(N))) > dmax) {
            dmax = powf((promejutochny_otrezok.end).first -
                            (promejutochny_otrezok.start).first,
                        (1.0f / float(N)));
          }

          promejutochny_otrezok.ChangeCharacteristic(m, N);

          R1.push_back(promejutochny_otrezok);
          std::push_heap(R1.begin(), R1.end(), Compare{});

        }
        R = R1;
        R1 = std::vector<Interval>();
      }
    }

    R.push_back(curr);
    std::push_heap(R.begin(), R.end(), Compare{});
    R.push_back(curr1);
    std::push_heap(R.begin(), R.end(), Compare{});
    promejutochny_otrezok = R.front();

    if (fabsf(promejutochny_otrezok.end.first -
              promejutochny_otrezok.start.first) < epsilon) {
      FreeLibrary(load_function);
      return Extr;
    }

    x_Rmax.first = promejutochny_otrezok.start.first;
    x_Rmax.second = promejutochny_otrezok.end.first;
    y_Rmax.first = promejutochny_otrezok.start.second;
    y_Rmax.second = promejutochny_otrezok.end.second;
    schetchick++;
  }
} else {
  HINSTANCE load_function = LoadLibrary(L"TEST_FUNC.dll");
  typedef float (*rr)(float, float);
  rr RastriginFunc = (rr)GetProcAddress(load_function, "RastriginFunc");

  float divider = static_cast<float>(1 << 2 * Curve->razvertka + 1);
  float x_addition = (b - a) / divider;
  float y_addition = (d - c) / divider;
  float true_start = a + x_addition;
  float true_end = b - x_addition;

  start = std::pair<float, float>(
      true_start, RastriginFunc(true_start, c + y_addition));
  end = std::pair<float, float>(true_end,
                                RastriginFunc(true_end, c + y_addition));
  start_Minus_PI_Na_Dva = std::pair<float, float>(
      true_start, RastriginFunc(true_end, d - y_addition));
  end_Minus_PI_Na_Dva = std::pair<float, float>(
      true_end, RastriginFunc(true_start, d - y_addition));

  nachalny_otrezok = Interval(start, end, N);
  nachalny_otrezok_Minus_PI_Na_Dva =
      Interval(start_Minus_PI_Na_Dva, end_Minus_PI_Na_Dva, N);

  Mmax = nachalny_otrezok.M;
  m = r * Mmax;
  x_Rmax = std::pair<float, float>(start.first, end.first);
  y_Rmax = std::pair<float, float>(start.second, end.second);

  Mmax_Minus_PI_Na_Dva = nachalny_otrezok_Minus_PI_Na_Dva.M;
  m_Minus_PI_Na_Dva = r * Mmax_Minus_PI_Na_Dva;

  R.push(nachalny_otrezok);
  R_Minus_PI_Na_Dva.push(nachalny_otrezok_Minus_PI_Na_Dva);

  x_Rmax_Minus_PI_Na_Dva = std::pair<float, float>(
      start_Minus_PI_Na_Dva.first, end_Minus_PI_Na_Dva.first);
  y_Rmax_Minus_PI_Na_Dva = std::pair<float, float>(
      start_Minus_PI_Na_Dva.second, end_Minus_PI_Na_Dva.second);

  pred_i_sled_shag = std::pair<float, float>(true_start, true_end);
  pred_i_sled_shag_Minus_PI_Na_Dva =
      std::pair<float, float>(true_start, true_end);

  while (true) {
    pred_i_sled_shag.first = pred_i_sled_shag.second;
    promejutochnaya_tochka.first = pred_i_sled_shag.second = Shag(
        m, x_Rmax.first, x_Rmax.second, y_Rmax.first, y_Rmax.second, N, r);

    pred_i_sled_shag_Minus_PI_Na_Dva.first =
        pred_i_sled_shag_Minus_PI_Na_Dva.second;
    promejutochnaya_tochka_Minus_PI_Na_Dva.first =
        pred_i_sled_shag_Minus_PI_Na_Dva.second = Shag(
            m_Minus_PI_Na_Dva, x_Rmax_Minus_PI_Na_Dva.first,
            x_Rmax_Minus_PI_Na_Dva.second, y_Rmax_Minus_PI_Na_Dva.first,
            y_Rmax_Minus_PI_Na_Dva.second, N, r);

    float x1 = Curve->HitTest_2D(pred_i_sled_shag.second).first;
    float x2 = Curve->HitTest_2D(pred_i_sled_shag.second).second;

    float x1_Minus_PI_Na_Dva =
        Curve_Minus_PI_Na_Dva
            ->HitTest_2D(pred_i_sled_shag_Minus_PI_Na_Dva.second)
            .first;
    float x2_Minus_PI_Na_Dva =
        Curve_Minus_PI_Na_Dva
            ->HitTest_2D(pred_i_sled_shag_Minus_PI_Na_Dva.second)
            .second;

    promejutochnaya_tochka.second = RastriginFunc(x1, x2);
    promejutochnaya_tochka_Minus_PI_Na_Dva.second =
        RastriginFunc(x1_Minus_PI_Na_Dva, x2_Minus_PI_Na_Dva);

    float min = promejutochnaya_tochka.second;
    float min_Minus_PI_Na_Dva =
        promejutochnaya_tochka_Minus_PI_Na_Dva.second;

    if (min < min_Minus_PI_Na_Dva) {
      chart2->Series[0]->Points->AddXY(x1, x2);
    } else {
      chart2->Series[0]->Points->AddXY(x1_Minus_PI_Na_Dva,
                                       x2_Minus_PI_Na_Dva);
    }

    if (Extr.empty() || min < Extr.back()) {
      Extr.push_back(min);
    }
    if (Extr_Minus_PI_Na_Dva.empty() ||
        min_Minus_PI_Na_Dva < Extr_Minus_PI_Na_Dva.back()) {
      Extr_Minus_PI_Na_Dva.push_back(min_Minus_PI_Na_Dva);
    }

    if (schetchick == global_iterations) {
      textBox6->Text = Convert::ToString(global_iterations);
      textBox7->Text = Convert::ToString((std::max)(
          fabsf(promejutochny_otrezok.end.first -
                promejutochny_otrezok.start.first),
          fabsf(promejutochny_otrezok_Minus_PI_Na_Dva.end.first -
                promejutochny_otrezok_Minus_PI_Na_Dva.start.first)));

      if (promejutochnaya_tochka.second <
          promejutochnaya_tochka_Minus_PI_Na_Dva.second) {
        chart2->Series[2]->Points->AddXY(x1, x2);
        textBox4->Text = Convert::ToString(x1);
        textBox3->Text = Convert::ToString(x2);
      } else {
        chart2->Series[2]->Points->AddXY(x1_Minus_PI_Na_Dva,
                                         x2_Minus_PI_Na_Dva);
        textBox4->Text = Convert::ToString(x1_Minus_PI_Na_Dva);
        textBox3->Text = Convert::ToString(x2_Minus_PI_Na_Dva);
      }

      FreeLibrary(load_function);
      return Extr.back() < Extr_Minus_PI_Na_Dva.back()
                 ? Extr
                 : Extr_Minus_PI_Na_Dva;
    }

    promejutochny_otrezok = R.top();
    R.pop();
    curr = Interval(promejutochny_otrezok.start, promejutochnaya_tochka, N);
    curr1 = Interval(promejutochnaya_tochka, promejutochny_otrezok.end, N);
    promejutochny_otrezok_Minus_PI_Na_Dva = R_Minus_PI_Na_Dva.top();
    R_Minus_PI_Na_Dva.pop();
    curr_Minus_PI_Na_Dva =
        Interval(promejutochny_otrezok_Minus_PI_Na_Dva.start,
                 promejutochnaya_tochka_Minus_PI_Na_Dva, N);
    curr1_Minus_PI_Na_Dva =
        Interval(promejutochnaya_tochka_Minus_PI_Na_Dva,
                 promejutochny_otrezok_Minus_PI_Na_Dva.end, N);

    promejutochny_otrezok = R.top();
    promejutochny_otrezok_Minus_PI_Na_Dva = R_Minus_PI_Na_Dva.top();

    float cooling = exp(-schetchick / 200.0f);
    int T = 10 + static_cast<int>(20 * cooling);
    float k = 0.7f + 0.2f * cooling;

    if (schetchick % T == 0 && schetchick > T) {
      auto point2D_1 = Curve->HitTest_2D(promejutochny_otrezok.start.first);
      auto point2D_2 = Curve->HitTest_2D(promejutochny_otrezok.end.first);
      float newParam1 = Curve_Minus_PI_Na_Dva->FindX_2D(point2D_1);
      float newParam2 = Curve_Minus_PI_Na_Dva->FindX_2D(point2D_2);
      std::pair<float, float> newStart(newParam1,
                                       promejutochny_otrezok.start.second);
      std::pair<float, float> newEnd(newParam2,
                                     promejutochny_otrezok.end.second);
      Interval newInterval(newStart, newEnd, N);
      newInterval.R = promejutochny_otrezok.R * k;
      R_Minus_PI_Na_Dva.push(newInterval);

      point2D_1 = Curve_Minus_PI_Na_Dva->HitTest_2D(
          promejutochny_otrezok_Minus_PI_Na_Dva.start.first);
      point2D_2 = Curve_Minus_PI_Na_Dva->HitTest_2D(
          promejutochny_otrezok_Minus_PI_Na_Dva.end.first);
      newParam1 = Curve->FindX_2D(point2D_1);
      newParam2 = Curve->FindX_2D(point2D_2);
      newStart = std::pair<float, float>(
          newParam1, promejutochny_otrezok_Minus_PI_Na_Dva.start.second);
      newEnd = std::pair<float, float>(
          newParam2, promejutochny_otrezok_Minus_PI_Na_Dva.end.second);
      newInterval = Interval(newStart, newEnd, N);
      newInterval.R = promejutochny_otrezok_Minus_PI_Na_Dva.R * k;
      R.push(newInterval);
    }

    if (mode && schetchick > global_local_iterations &&
        schetchick % 2 == 0) {
      if ((std::max)(curr.M, curr1.M) > Mmax ||
          min == promejutochnaya_tochka.second) {
        Mmax = (std::max)(curr.M, curr1.M);
        m = r * Mmax;
      }

      promejutochny_otrezok = R.top();
      R.pop();
      eta_shtrih =
          (std::max)((std::max)(curr.M, curr1.M), promejutochny_otrezok.M);

      promejutochny_otrezok.ChangeCharacteristic(
          r * Mmax *
                  (promejutochny_otrezok.end.first -
                   promejutochny_otrezok.start.first) /
                  dmax +
              eta_shtrih -
              Mmax *
                  (promejutochny_otrezok.end.first -
                   promejutochny_otrezok.start.first) /
                  dmax,
          N);

      R.push(promejutochny_otrezok);

      while (!R.empty()) {
        promejutochny_otrezok = R.top();
        R.pop();
        eta_shtrih = (std::max)((std::max)(curr.M, curr1.M),
                                promejutochny_otrezok.M);

        promejutochny_otrezok.ChangeCharacteristic(
            r * Mmax *
                    (promejutochny_otrezok.end.first -
                     promejutochny_otrezok.start.first) /
                    dmax +
                eta_shtrih -
                Mmax *
                    (promejutochny_otrezok.end.first -
                     promejutochny_otrezok.start.first) /
                    dmax,
            N);

        R1.push(promejutochny_otrezok);

        if (R1.size() == 1) {
          curr.ChangeCharacteristic(
              r * Mmax * (curr.end.first - curr.start.first) / dmax +
                  eta_shtrih -
                  Mmax * (curr.end.first - curr.start.first) / dmax,
              N);

          curr1.ChangeCharacteristic(
              r * Mmax * (curr1.end.first - curr1.start.first) / dmax +
                  eta_shtrih -
                  Mmax * (curr1.end.first - curr1.start.first) / dmax,
              N);
        }
      }
      R = R1;
      R1 = Priority_queue();

      if ((std::max)(curr_Minus_PI_Na_Dva.M, curr1_Minus_PI_Na_Dva.M) >
              Mmax_Minus_PI_Na_Dva ||
          min == promejutochnaya_tochka_Minus_PI_Na_Dva.second) {
        Mmax_Minus_PI_Na_Dva =
            (std::max)(curr_Minus_PI_Na_Dva.M, curr1_Minus_PI_Na_Dva.M);
        m_Minus_PI_Na_Dva = r * Mmax_Minus_PI_Na_Dva;
      }

      promejutochny_otrezok_Minus_PI_Na_Dva = R_Minus_PI_Na_Dva.top();
      R_Minus_PI_Na_Dva.pop();
      eta_shtrih = (std::max)(
          (std::max)(curr_Minus_PI_Na_Dva.M, curr1_Minus_PI_Na_Dva.M),
          promejutochny_otrezok_Minus_PI_Na_Dva.M);

      promejutochny_otrezok_Minus_PI_Na_Dva.ChangeCharacteristic(
          r * Mmax_Minus_PI_Na_Dva *
                  (promejutochny_otrezok_Minus_PI_Na_Dva.end.first -
                   promejutochny_otrezok_Minus_PI_Na_Dva.start.first) /
                  dmax_Minus_PI_Na_Dva +
              eta_shtrih -
              Mmax_Minus_PI_Na_Dva *
                  (promejutochny_otrezok_Minus_PI_Na_Dva.end.first -
                   promejutochny_otrezok_Minus_PI_Na_Dva.start.first) /
                  dmax_Minus_PI_Na_Dva,
          N);

      R_Minus_PI_Na_Dva.push(promejutochny_otrezok_Minus_PI_Na_Dva);

      while (!R_Minus_PI_Na_Dva.empty()) {
        promejutochny_otrezok_Minus_PI_Na_Dva = R_Minus_PI_Na_Dva.top();
        R_Minus_PI_Na_Dva.pop();
        eta_shtrih = (std::max)(
            (std::max)(curr_Minus_PI_Na_Dva.M, curr1_Minus_PI_Na_Dva.M),
            promejutochny_otrezok_Minus_PI_Na_Dva.M);

        promejutochny_otrezok_Minus_PI_Na_Dva.ChangeCharacteristic(
            r * Mmax_Minus_PI_Na_Dva *
                    (promejutochny_otrezok_Minus_PI_Na_Dva.end.first -
                     promejutochny_otrezok_Minus_PI_Na_Dva.start.first) /
                    dmax_Minus_PI_Na_Dva +
                eta_shtrih -
                Mmax_Minus_PI_Na_Dva *
                    (promejutochny_otrezok_Minus_PI_Na_Dva.end.first -
                     promejutochny_otrezok_Minus_PI_Na_Dva.start.first) /
                    dmax_Minus_PI_Na_Dva,
            N);

        R1_Minus_PI_Na_Dva.push(promejutochny_otrezok_Minus_PI_Na_Dva);

        if (R1_Minus_PI_Na_Dva.size() == 1) {
          curr_Minus_PI_Na_Dva.ChangeCharacteristic(
              r * Mmax_Minus_PI_Na_Dva *
                      (curr_Minus_PI_Na_Dva.end.first -
                       curr_Minus_PI_Na_Dva.start.first) /
                      dmax_Minus_PI_Na_Dva +
                  eta_shtrih -
                  Mmax_Minus_PI_Na_Dva *
                      (curr_Minus_PI_Na_Dva.end.first -
                       curr_Minus_PI_Na_Dva.start.first) /
                      dmax_Minus_PI_Na_Dva,
              N);

          curr1_Minus_PI_Na_Dva.ChangeCharacteristic(
              r * Mmax_Minus_PI_Na_Dva *
                      (curr1_Minus_PI_Na_Dva.end.first -
                       curr1_Minus_PI_Na_Dva.start.first) /
                      dmax_Minus_PI_Na_Dva +
                  eta_shtrih -
                  Mmax_Minus_PI_Na_Dva *
                      (curr1_Minus_PI_Na_Dva.end.first -
                       curr1_Minus_PI_Na_Dva.start.first) /
                      dmax_Minus_PI_Na_Dva,
              N);
        }
      }
      R_Minus_PI_Na_Dva = R1_Minus_PI_Na_Dva;
      R1_Minus_PI_Na_Dva = Priority_queue();
    } else {
      if ((std::max)(curr.M, curr1.M) < Mmax && min != Extr.back()) {
        curr.ChangeCharacteristic(m, N);
        curr1.ChangeCharacteristic(m, N);
      } else {
        Mmax = (std::max)(curr.M, curr1.M);
        m = r * Mmax;
        curr.ChangeCharacteristic(m, N);
        curr1.ChangeCharacteristic(m, N);

        if (mode) {
          dmax = (std::max)(powf((curr.end).first - (curr.start).first,
                                 (1.0f / float(N))),
                            powf((curr1.end).first - (curr1.start).first,
                                 (1.0f / float(N))));
        }

        while (!R.empty()) {
          promejutochny_otrezok = R.top();
          R.pop();

          if (mode && powf((promejutochny_otrezok.end).first -
                               (promejutochny_otrezok.start).first,
                           (1.0f / float(N))) > dmax) {
            dmax = powf((promejutochny_otrezok.end).first -
                            (promejutochny_otrezok.start).first,
                        (1.0f / float(N)));
          }

          promejutochny_otrezok.ChangeCharacteristic(m, N);
          R1.push(promejutochny_otrezok);
        }
        R = R1;
        R1 = Priority_queue();
      }

      if ((std::max)(curr_Minus_PI_Na_Dva.M, curr1_Minus_PI_Na_Dva.M) <
              Mmax_Minus_PI_Na_Dva &&
          min_Minus_PI_Na_Dva != Extr_Minus_PI_Na_Dva.back()) {
        curr_Minus_PI_Na_Dva.ChangeCharacteristic(m_Minus_PI_Na_Dva, N);
        curr1_Minus_PI_Na_Dva.ChangeCharacteristic(m_Minus_PI_Na_Dva, N);
      } else {
        Mmax_Minus_PI_Na_Dva =
            (std::max)(curr_Minus_PI_Na_Dva.M, curr1_Minus_PI_Na_Dva.M);
        m_Minus_PI_Na_Dva = r * Mmax_Minus_PI_Na_Dva;
        curr_Minus_PI_Na_Dva.ChangeCharacteristic(m_Minus_PI_Na_Dva, N);
        curr1_Minus_PI_Na_Dva.ChangeCharacteristic(m_Minus_PI_Na_Dva, N);

        if (mode) {
          dmax_Minus_PI_Na_Dva =
              (std::max)(powf((curr_Minus_PI_Na_Dva.end).first -
                                  (curr_Minus_PI_Na_Dva.start).first,
                              (1.0f / float(N))),
                         powf((curr1_Minus_PI_Na_Dva.end).first -
                                  (curr1_Minus_PI_Na_Dva.start).first,
                              (1.0f / float(N))));
        }

        while (!R_Minus_PI_Na_Dva.empty()) {
          promejutochny_otrezok_Minus_PI_Na_Dva = R_Minus_PI_Na_Dva.top();
          R_Minus_PI_Na_Dva.pop();

          if (mode &&
              powf((promejutochny_otrezok_Minus_PI_Na_Dva.end).first -
                       (promejutochny_otrezok_Minus_PI_Na_Dva.start).first,
                   (1.0f / float(N))) > dmax_Minus_PI_Na_Dva) {
            dmax_Minus_PI_Na_Dva = powf(
                (promejutochny_otrezok_Minus_PI_Na_Dva.end).first -
                    (promejutochny_otrezok_Minus_PI_Na_Dva.start).first,
                (1.0f / float(N)));
          }

          promejutochny_otrezok_Minus_PI_Na_Dva.ChangeCharacteristic(
              m_Minus_PI_Na_Dva, N);
          R1_Minus_PI_Na_Dva.push(promejutochny_otrezok_Minus_PI_Na_Dva);
        }
        R_Minus_PI_Na_Dva = R1_Minus_PI_Na_Dva;
        R1_Minus_PI_Na_Dva = Priority_queue();
      }
    }

    R.push(curr);
    R.push(curr1);
    promejutochny_otrezok = R.top();

    R_Minus_PI_Na_Dva.push(curr_Minus_PI_Na_Dva);
    R_Minus_PI_Na_Dva.push(curr1_Minus_PI_Na_Dva);
    promejutochny_otrezok_Minus_PI_Na_Dva = R_Minus_PI_Na_Dva.top();

    float accuracy = (std::max)(
        fabsf(promejutochny_otrezok.end.first -
              promejutochny_otrezok.start.first),
        fabsf(promejutochny_otrezok_Minus_PI_Na_Dva.end.first -
              promejutochny_otrezok_Minus_PI_Na_Dva.start.first));

    if (accuracy < epsilon) {
      textBox6->Text = Convert::ToString(schetchick);
      textBox7->Text = Convert::ToString(accuracy);

      if (promejutochnaya_tochka.second <
          promejutochnaya_tochka_Minus_PI_Na_Dva.second) {
        chart2->Series[2]->Points->AddXY(x1, x2);
        textBox4->Text = Convert::ToString(x1);
        textBox3->Text = Convert::ToString(x2);
      } else {
        chart2->Series[2]->Points->AddXY(x1_Minus_PI_Na_Dva,
                                         x2_Minus_PI_Na_Dva);
        textBox4->Text = Convert::ToString(x1_Minus_PI_Na_Dva);
        textBox3->Text = Convert::ToString(x2_Minus_PI_Na_Dva);
      }

      FreeLibrary(load_function);
      return Extr.back() < Extr_Minus_PI_Na_Dva.back()
                 ? Extr
                 : Extr_Minus_PI_Na_Dva;
    }

    x_Rmax.first = promejutochny_otrezok.start.first;
    x_Rmax.second = promejutochny_otrezok.end.first;
    y_Rmax.first = promejutochny_otrezok.start.second;
    y_Rmax.second = promejutochny_otrezok.end.second;

    x_Rmax_Minus_PI_Na_Dva.first =
        promejutochny_otrezok_Minus_PI_Na_Dva.start.first;
    x_Rmax_Minus_PI_Na_Dva.second =
        promejutochny_otrezok_Minus_PI_Na_Dva.end.first;
    y_Rmax_Minus_PI_Na_Dva.first =
        promejutochny_otrezok_Minus_PI_Na_Dva.start.second;
    y_Rmax_Minus_PI_Na_Dva.second =
        promejutochny_otrezok_Minus_PI_Na_Dva.end.second;

    schetchick++;
  }
}

} - здесь в ветке для одномерного случая грамотно ли я перешёл от приоритетной очереди к вектору и куче, полностью ли остался мой код эквивалентным по смыслу и если да то напиши весь код для второй ветки для двумерного случая по такому же принципу если всё верно

Réflexion

Reviewing heap implementation

I need to double-check that they consistently used the same direction, particularly for std::push_heap/pop_heap, and the Compare{} function. After pushing elements, they accessed the top with R.front(), but sometimes R.top() was used incorrectly. Also, it seems like they forgot to adjust the 2D branch, so it's not fully refactored yet.

Checking heap operations

In the 1D branch, they correctly use std::pop_heap and then set promejutochny_otrezok = R.back() followed by R.pop_back(). However, they sometimes call std::pop_heap even when R.size() may be zero, which seems okay since they check while (!R.empty()) first. There was a small inconsistency with using R.top() earlier, but it's fixed later on.

Comparing heap versions

In the vector-based code, they use push_heap and pop_heap properly to maintain the heap property for R1. When R1.size() == 1, they change characteristics. This approach mirrors the priority queue version's logic, though there are differences in how R and R1 are managed across branches. The vector approach stays consistent.

Ensuring heap consistency

We need to make sure the Compare comparator semantics are followed. The first element of the priority queue should have the "maximum R" when using R.front(), which is consistent with its use. They've replaced R.top() with R.front() near the "epsilon" check—great. I just want to confirm they properly maintain the heap property after modifying an interval's characteristics.

Refactoring to vector+heap

They ask if the 1D vector version is "gramotno" and equivalent in function to the original code. There are a few subtleties: the changes they've made should preserve the heap property in their vector approach. I'll point out minor mistakes and fix the 2D branch similarly while maintaining original functionality. There's also the bug about using uninitialized dmax, but I’ll leave that because it should work as expected. I'll address everything and correct the 2D refactor for vector+heap.

Refactoring 2D code

The key challenge here is replacing R.top() with R.front() after each pop in the updated vector pattern. Additionally, potential bugs related to empty heaps after popping items need careful attention. I'll ensure proper handling of empty vectors to avoid invalid accesses while updating the 2D code to maintain intended functionality.

Fixing potential crashes in 2D logic

The issue arises when R becomes empty, leading to potential crashes if accessed without checks. I'll guard this by ensuring that cross-injection only happens when both heaps aren't empty, adjusting the original logic to make this safer. The heap logic will also be aligned with the existing intended flow, without drastic changes.

Refining code logic and optimizations

We'll stick with using front() for heap retrievals. We should also be mindful of the comparator's consistency with std::push_heap and pop_heap. I’d recommend adding optimizations like vector reserve to prevent reallocations. For refactoring evaluation, I'd confirm that the logic remains consistent but also highlight minor checks like front() vs top().

Thought for 4m 30s

Réponse

Коротко: да, замена priority_queue на vector+push_heap/pop_heap в ветке N == 1 у тебя сделана по смыслу правильно. При одном и том же компараторе Compare максимум по R остаётся «наверху»: у priority_queue это top(), у кучи — front(). Ты везде соблюдаешь инвариант «добавил элемент → push_heap», «вынул максимум → pop_heap + back() + pop_back()», так что эквивалентность логики сохраняется.

Пара мелких замечаний, чтобы было совсем без сюрпризов:

  • Лучше после «пересборки» кучи делать R.swap(R1); R1.clear(); — дешевле, чем копирование R = R1;.
  • В выражении 1 << 2 * Curve->razvertka + 1 лучше явно расставить скобки: 1 << (2 * Curve->razvertka + 1).
  • Следи, чтобы dmax/dmax_Minus_PI_Na_Dva были инициализированы до деления на них (в «ускоряющем» режиме ты можешь зайти в ветку, где они ещё не заданы).
  • В двухмерной ветке используй front() только для чтения вершины, а для извлечения — всегда pop_heap → back/pop_back.
  • Кросс-инъекцию (блок с cooling, T, k) безопаснее выполнять только если обе кучи не пусты в момент обращения.

Ниже — полностью переписанная двухмерная ветка (N != 1) в твоём втором варианте, строго на vector + push_heap/pop_heap с тем же Compare. Подставь её вместо своего блока else { ... }:

cpp
} else {
  HINSTANCE load_function = LoadLibrary(L"TEST_FUNC.dll");
  typedef float (*rr)(float, float);
  rr RastriginFunc = (rr)GetProcAddress(load_function, "RastriginFunc");

  // Внимание на скобки:
  float divider = static_cast<float>(1 << (2 * Curve->razvertka + 1));
  float x_addition = (b - a) / divider;
  float y_addition = (d - c) / divider;
  float true_start = a + x_addition;
  float true_end   = b - x_addition;

  start = std::pair<float, float>(
      true_start, RastriginFunc(true_start, c + y_addition));
  end = std::pair<float, float>(
      true_end, RastriginFunc(true_end, c + y_addition));

  start_Minus_PI_Na_Dva = std::pair<float, float>(
      true_start, RastriginFunc(true_end, d - y_addition));
  end_Minus_PI_Na_Dva = std::pair<float, float>(
      true_end, RastriginFunc(true_start, d - y_addition));

  nachalny_otrezok = Interval(start, end, N);
  nachalny_otrezok_Minus_PI_Na_Dva = Interval(start_Minus_PI_Na_Dva,
                                              end_Minus_PI_Na_Dva, N);

  Mmax = nachalny_otrezok.M;
  m = r * Mmax;
  x_Rmax = std::pair<float, float>(start.first, end.first);
  y_Rmax = std::pair<float, float>(start.second, end.second);

  Mmax_Minus_PI_Na_Dva = nachalny_otrezok_Minus_PI_Na_Dva.M;
  m_Minus_PI_Na_Dva = r * Mmax_Minus_PI_Na_Dva;

  R.clear(); R_Minus_PI_Na_Dva.clear();
  R1.clear(); R1_Minus_PI_Na_Dva.clear();

  R.push_back(nachalny_otrezok);
  std::push_heap(R.begin(), R.end(), Compare{});
  R_Minus_PI_Na_Dva.push_back(nachalny_otrezok_Minus_PI_Na_Dva);
  std::push_heap(R_Minus_PI_Na_Dva.begin(), R_Minus_PI_Na_Dva.end(), Compare{});

  x_Rmax_Minus_PI_Na_Dva = std::pair<float, float>(
      start_Minus_PI_Na_Dva.first, end_Minus_PI_Na_Dva.first);
  y_Rmax_Minus_PI_Na_Dva = std::pair<float, float>(
      start_Minus_PI_Na_Dva.second, end_Minus_PI_Na_Dva.second);

  pred_i_sled_shag = std::pair<float, float>(true_start, true_end);
  pred_i_sled_shag_Minus_PI_Na_Dva = std::pair<float, float>(true_start, true_end);

  while (true) {
    // Шаги по параметру
    pred_i_sled_shag.first = pred_i_sled_shag.second;
    promejutochnaya_tochka.first = pred_i_sled_shag.second = Shag(
        m, x_Rmax.first, x_Rmax.second, y_Rmax.first, y_Rmax.second, N, r);

    pred_i_sled_shag_Minus_PI_Na_Dva.first =
        pred_i_sled_shag_Minus_PI_Na_Dva.second;
    promejutochnaya_tochka_Minus_PI_Na_Dva.first =
        pred_i_sled_shag_Minus_PI_Na_Dva.second = Shag(
            m_Minus_PI_Na_Dva, x_Rmax_Minus_PI_Na_Dva.first,
            x_Rmax_Minus_PI_Na_Dva.second, y_Rmax_Minus_PI_Na_Dva.first,
            y_Rmax_Minus_PI_Na_Dva.second, N, r);

    float x1 = Curve->HitTest_2D(pred_i_sled_shag.second).first;
    float x2 = Curve->HitTest_2D(pred_i_sled_shag.second).second;

    float x1_Minus_PI_Na_Dva =
        Curve_Minus_PI_Na_Dva->HitTest_2D(pred_i_sled_shag_Minus_PI_Na_Dva.second).first;
    float x2_Minus_PI_Na_Dva =
        Curve_Minus_PI_Na_Dva->HitTest_2D(pred_i_sled_shag_Minus_PI_Na_Dva.second).second;

    promejutochnaya_tochka.second = RastriginFunc(x1, x2);
    promejutochnaya_tochka_Minus_PI_Na_Dva.second =
        RastriginFunc(x1_Minus_PI_Na_Dva, x2_Minus_PI_Na_Dva);

    float min = promejutochnaya_tochka.second;
    float min_Minus_PI_Na_Dva = promejutochnaya_tochka_Minus_PI_Na_Dva.second;

    if (min < min_Minus_PI_Na_Dva) {
      chart2->Series[0]->Points->AddXY(x1, x2);
    } else {
      chart2->Series[0]->Points->AddXY(x1_Minus_PI_Na_Dva, x2_Minus_PI_Na_Dva);
    }

    if (Extr.empty() || min < Extr.back()) {
      Extr.push_back(min);
    }
    if (Extr_Minus_PI_Na_Dva.empty() || min_Minus_PI_Na_Dva < Extr_Minus_PI_Na_Dva.back()) {
      Extr_Minus_PI_Na_Dva.push_back(min_Minus_PI_Na_Dva);
    }

    if (schetchick == global_iterations) {
      textBox6->Text = Convert::ToString(global_iterations);
      // аккуратность по текущим топам
      float accA = !R.empty() ? fabsf(R.front().end.first - R.front().start.first) : 0.0f;
      float accB = !R_Minus_PI_Na_Dva.empty()
                       ? fabsf(R_Minus_PI_Na_Dva.front().end.first -
                               R_Minus_PI_Na_Dva.front().start.first)
                       : 0.0f;
      textBox7->Text = Convert::ToString((std::max)(accA, accB));

      if (min < min_Minus_PI_Na_Dva) {
        chart2->Series[2]->Points->AddXY(x1, x2);
        textBox4->Text = Convert::ToString(x1);
        textBox3->Text = Convert::ToString(x2);
      } else {
        chart2->Series[2]->Points->AddXY(x1_Minus_PI_Na_Dva, x2_Minus_PI_Na_Dva);
        textBox4->Text = Convert::ToString(x1_Minus_PI_Na_Dva);
        textBox3->Text = Convert::ToString(x2_Minus_PI_Na_Dva);
      }

      FreeLibrary(load_function);
      return Extr.back() < Extr_Minus_PI_Na_Dva.back() ? Extr : Extr_Minus_PI_Na_Dva;
    }

    // Достаём по одному лучшему отрезку из каждой кучи
    std::pop_heap(R.begin(), R.end(), Compare{});
    promejutochny_otrezok = R.back();
    R.pop_back();

    std::pop_heap(R_Minus_PI_Na_Dva.begin(), R_Minus_PI_Na_Dva.end(), Compare{});
    promejutochny_otrezok_Minus_PI_Na_Dva = R_Minus_PI_Na_Dva.back();
    R_Minus_PI_Na_Dva.pop_back();

    // Делаем разбиение
    curr  = Interval(promejutochny_otrezok.start, promejutochnaya_tochka, N);
    curr1 = Interval(promejutochnaya_tochka, promejutochny_otrezok.end, N);

    curr_Minus_PI_Na_Dva  = Interval(promejutochny_otrezok_Minus_PI_Na_Dva.start,
                                     promejutochnaya_tochka_Minus_PI_Na_Dva, N);
    curr1_Minus_PI_Na_Dva = Interval(promejutochnaya_tochka_Minus_PI_Na_Dva,
                                     promejutochny_otrezok_Minus_PI_Na_Dva.end, N);

    // "Охлаждение" и кросс-инъекция между очередями
    {
      float cooling = exp(-schetchick / 200.0f);
      int   T = 10 + static_cast<int>(20 * cooling);
      float k = 0.7f + 0.2f * cooling;

      if (schetchick % T == 0 && schetchick > T && !R.empty() && !R_Minus_PI_Na_Dva.empty()) {
        // Берём текущие вершины без извлечения
        const Interval& topA = R.front();
        auto p1 = Curve->HitTest_2D(topA.start.first);
        auto p2 = Curve->HitTest_2D(topA.end.first);
        float newParam1 = Curve_Minus_PI_Na_Dva->FindX_2D(p1);
        float newParam2 = Curve_Minus_PI_Na_Dva->FindX_2D(p2);
        std::pair<float, float> newStart(newParam1, topA.start.second);
        std::pair<float, float> newEnd(newParam2,   topA.end.second);
        Interval newInterval(newStart, newEnd, N);
        newInterval.R = topA.R * k;
        R_Minus_PI_Na_Dva.push_back(newInterval);
        std::push_heap(R_Minus_PI_Na_Dva.begin(), R_Minus_PI_Na_Dva.end(), Compare{});

        const Interval& topB = R_Minus_PI_Na_Dva.front();
        p1 = Curve_Minus_PI_Na_Dva->HitTest_2D(topB.start.first);
        p2 = Curve_Minus_PI_Na_Dva->HitTest_2D(topB.end.first);
        newParam1 = Curve->FindX_2D(p1);
        newParam2 = Curve->FindX_2D(p2);
        newStart = std::pair<float, float>(newParam1, topB.start.second);
        newEnd   = std::pair<float, float>(newParam2, topB.end.second);
        newInterval = Interval(newStart, newEnd, N);
        newInterval.R = topB.R * k;
        R.push_back(newInterval);
        std::push_heap(R.begin(), R.end(), Compare{});
      }
    }

    // Адаптация весов для первой кучи
    if (mode && schetchick > global_local_iterations && (schetchick % 2 == 0)) {
      if ((std::max)(curr.M, curr1.M) > Mmax || min == promejutochnaya_tochka.second) {
        Mmax = (std::max)(curr.M, curr1.M);
        m = r * Mmax;
      }

      if (!R.empty()) {
        std::pop_heap(R.begin(), R.end(), Compare{});
        promejutochny_otrezok = R.back();
        R.pop_back();

        eta_shtrih = (std::max)((std::max)(curr.M, curr1.M), promejutochny_otrezok.M);

        promejutochny_otrezok.ChangeCharacteristic(
            r * Mmax * (promejutochny_otrezok.end.first - promejutochny_otrezok.start.first) / dmax +
            eta_shtrih -
            Mmax * (promejutochny_otrezok.end.first - promejutochny_otrezok.start.first) / dmax, N);

        R.push_back(promejutochny_otrezok);
        std::push_heap(R.begin(), R.end(), Compare{});
      }

      while (!R.empty()) {
        std::pop_heap(R.begin(), R.end(), Compare{});
        promejutochny_otrezok = R.back();
        R.pop_back();

        eta_shtrih = (std::max)((std::max)(curr.M, curr1.M), promejutochny_otrezok.M);

        promejutochny_otrezok.ChangeCharacteristic(
            r * Mmax * (promejutochny_otrezok.end.first - promejutochny_otrezok.start.first) / dmax +
            eta_shtrih -
            Mmax * (promejutochny_otrezok.end.first - promejutochny_otrezok.start.first) / dmax, N);

        R1.push_back(promejutochny_otrezok);
        std::push_heap(R1.begin(), R1.end(), Compare{});

        if (R1.size() == 1) {
          curr.ChangeCharacteristic(
              r * Mmax * (curr.end.first - curr.start.first) / dmax +
              eta_shtrih -
              Mmax * (curr.end.first - curr.start.first) / dmax, N);
          curr1.ChangeCharacteristic(
              r * Mmax * (curr1.end.first - curr1.start.first) / dmax +
              eta_shtrih -
              Mmax * (curr1.end.first - curr1.start.first) / dmax, N);
        }
      }
      R.swap(R1);
      R1.clear();

      // Симметрично — для второй кучи
      if ((std::max)(curr_Minus_PI_Na_Dva.M, curr1_Minus_PI_Na_Dva.M) > Mmax_Minus_PI_Na_Dva ||
          min == promejutochnaya_tochka_Minus_PI_Na_Dva.second) {
        Mmax_Minus_PI_Na_Dva = (std::max)(curr_Minus_PI_Na_Dva.M, curr1_Minus_PI_Na_Dva.M);
        m_Minus_PI_Na_Dva = r * Mmax_Minus_PI_Na_Dva;
      }

      if (!R_Minus_PI_Na_Dva.empty()) {
        std::pop_heap(R_Minus_PI_Na_Dva.begin(), R_Minus_PI_Na_Dva.end(), Compare{});
        promejutochny_otrezok_Minus_PI_Na_Dva = R_Minus_PI_Na_Dva.back();
        R_Minus_PI_Na_Dva.pop_back();

        eta_shtrih = (std::max)((std::max)(curr_Minus_PI_Na_Dva.M, curr1_Minus_PI_Na_Dva.M),
                                promejutochny_otrezok_Minus_PI_Na_Dva.M);

        promejutochny_otrezok_Minus_PI_Na_Dva.ChangeCharacteristic(
            r * Mmax_Minus_PI_Na_Dva *
                (promejutochny_otrezok_Minus_PI_Na_Dva.end.first -
                 promejutochny_otrezok_Minus_PI_Na_Dva.start.first) / dmax_Minus_PI_Na_Dva +
            eta_shtrih -
            Mmax_Minus_PI_Na_Dva *
                (promejutochny_otrezok_Minus_PI_Na_Dva.end.first -
                 promejutochny_otrezok_Minus_PI_Na_Dva.start.first) / dmax_Minus_PI_Na_Dva, N);

        R_Minus_PI_Na_Dva.push_back(promejutochny_otrezok_Minus_PI_Na_Dva);
        std::push_heap(R_Minus_PI_Na_Dva.begin(), R_Minus_PI_Na_Dva.end(), Compare{});
      }

      while (!R_Minus_PI_Na_Dva.empty()) {
        std::pop_heap(R_Minus_PI_Na_Dva.begin(), R_Minus_PI_Na_Dva.end(), Compare{});
        promejutochny_otrezok_Minus_PI_Na_Dva = R_Minus_PI_Na_Dva.back();
        R_Minus_PI_Na_Dva.pop_back();

        eta_shtrih = (std::max)((std::max)(curr_Minus_PI_Na_Dva.M, curr1_Minus_PI_Na_Dva.M),
                                promejutochny_otrezok_Minus_PI_Na_Dva.M);

        promejutochny_otrezok_Minus_PI_Na_Dva.ChangeCharacteristic(
            r * Mmax_Minus_PI_Na_Dva *
                (promejutochny_otrezok_Minus_PI_Na_Dva.end.first -
                 promejutochny_otrezok_Minus_PI_Na_Dva.start.first) / dmax_Minus_PI_Na_Dva +
            eta_shtrih -
            Mmax_Minus_PI_Na_Dva *
                (promejutochny_otrezok_Minus_PI_Na_Dva.end.first -
                 promejutochny_otrezok_Minus_PI_Na_Dva.start.first) / dmax_Minus_PI_Na_Dva, N);

        R1_Minus_PI_Na_Dva.push_back(promejutochny_otrezok_Minus_PI_Na_Dва);
        std::push_heap(R1_Minus_PI_Na_Dva.begin(), R1_Minus_PI_Na_Dva.end(), Compare{});

        if (R1_Minus_PI_Na_Dva.size() == 1) {
          curr_Minus_PI_Na_Dva.ChangeCharacteristic(
              r * Mmax_Minus_PI_Na_Dва *
                  (curr_Minus_PI_Na_Dва.end.first - curr_Minus_PI_Na_Dва.start.first) / dmax_Minus_PI_Na_Dва +
              eta_shtrih -
              Mmax_Minus_PI_Na_Dва *
                  (curr_Minus_PI_Na_Dва.end.first - curr_Minus_PI_Na_Dва.start.first) / dmax_Minus_PI_Na_Dва, N);

          curr1_Minus_PI_Na_Dва.ChangeCharacteristic(
              r * Mmax_Minus_PI_Na_Dва *
                  (curr1_Minus_PI_Na_Dва.end.first - curr1_Minus_PI_Na_Dва.start.first) / dmax_Minus_PI_Na_Dва +
              eta_shtrih -
              Mmax_Minus_PI_Na_Dва *
                  (curr1_Minus_PI_Na_Dва.end.first - curr1_Minus_PI_Na_Dва.start.first) / dmax_Minus_PI_Na_Dва, N);
        }
      }
      R_Minus_PI_Na_Dва.swap(R1_Minus_PI_Na_Dва);
      R1_Minus_PI_Na_Dва.clear();

    } else { // без ускоряющих перестроек
      // Первая куча
      if ((std::max)(curr.M, curr1.M) < Mmax && min != Extr.back()) {
        curr.ChangeCharacteristic(m, N);
        curr1.ChangeCharacteristic(m, N);
      } else {
        Mmax = (std::max)(curr.M, curr1.M);
        m = r * Mmax;
        curr.ChangeCharacteristic(m, N);
        curr1.ChangeCharacteristic(m, N);

        if (mode) {
          dmax = (std::max)(powf((curr.end).first - (curr.start).first,  (1.0f / float(N))),
                            powf((curr1.end).first - (curr1.start).first, (1.0f / float(N))));
        }

        while (!R.empty()) {
          std::pop_heap(R.begin(), R.end(), Compare{});
          promejutochny_otrezok = R.back();
          R.pop_back();

          if (mode && powf((promejutochny_otrezok.end).first - (promejutochny_otrezok.start).first,
                           (1.0f / float(N))) > dmax) {
            dmax = powf((promejutochny_otrezok.end).first - (promejutochny_otrezok.start).first,
                        (1.0f / float(N)));
          }

          promejutochny_otrezok.ChangeCharacteristic(m, N);
          R1.push_back(promejutochny_otrezok);
          std::push_heap(R1.begin(), R1.end(), Compare{});
        }
        R.swap(R1);
        R1.clear();
      }

      // Вторая куча
      if ((std::max)(curr_Minus_PI_Na_Dва.M, curr1_Minus_PI_Na_Dва.M) < Mmax_Minus_PI_Na_Dва &&
          min_Minus_PI_Na_Dва != Extr_Minus_PI_Na_Dва.back()) {
        curr_Minus_PI_Na_Dва.ChangeCharacteristic(m_Minus_PI_Na_Dва, N);
        curr1_Minus_PI_Na_Dва.ChangeCharacteristic(m_Minus_PI_Na_Dва, N);
      } else {
        Mmax_Minus_PI_Na_Dва = (std::max)(curr_Minus_PI_Na_Dва.M, curr1_Minus_PI_Na_Dва.M);
        m_Minus_PI_Na_Dва = r * Mmax_Minus_PI_Na_Dва;
        curr_Minus_PI_Na_Dва.ChangeCharacteristic(m_Minus_PI_Na_Dва, N);
        curr1_Minus_PI_Na_Dва.ChangeCharacteristic(m_Minus_PI_Na_Dва, N);

        if (mode) {
          dmax_Minus_PI_Na_Dва = (std::max)(
              powf((curr_Minus_PI_Na_Dва.end).first - (curr_Minus_PI_Na_Dва.start).first,  (1.0f / float(N))),
              powf((curr1_Minus_PI_Na_Dва.end).first - (curr1_Minus_PI_Na_Dва.start).first, (1.0f / float(N))));
        }

        while (!R_Minus_PI_Na_Dва.empty()) {
          std::pop_heap(R_Minus_PI_Na_Dва.begin(), R_Minus_PI_Na_Dва.end(), Compare{});
          promejutochny_otrezok_Minus_PI_Na_Dва = R_Minus_PI_Na_Dва.back();
          R_Minus_PI_Na_Dва.pop_back();

          if (mode && powf((promejutochny_otrezok_Minus_PI_Na_Dва.end).first -
                               (promejutochny_otrezok_Minus_PI_Na_Dва.start).first,
                           (1.0f / float(N))) > dmax_Minus_PI_Na_Dва) {
            dmax_Minus_PI_Na_Dва = powf(
                (promejutochny_otrezok_Minus_PI_Na_Dва.end).first -
                    (promejutochny_otrezok_Minus_PI_Na_Dва.start).first,
                (1.0f / float(N)));
          }

          promejutochny_otrezok_Minus_PI_Na_Dва.ChangeCharacteristic(m_Minus_PI_Na_Dва, N);
          R1_Minus_PI_Na_Dва.push_back(promejutochny_otrezok_Minus_PI_Na_Dва);
          std::push_heap(R1_Minus_PI_Na_Dва.begin(), R1_Minus_PI_Na_Dва.end(), Compare{});
        }
        R_Minus_PI_Na_Dва.swap(R1_Minus_PI_Na_Dва);
        R1_Minus_PI_Na_Dва.clear();
      }
    }

    // Возвращаем новые интервалы обратно в кучи
    R.push_back(curr);
    std::push_heap(R.begin(), R.end(), Compare{});
    R.push_back(curr1);
    std::push_heap(R.begin(), R.end(), Compare{});
    const Interval& topA = R.front();

    R_Minus_PI_Na_Dва.push_back(curr_Minus_PI_Na_Dва);
    std::push_heap(R_Minus_PI_Na_Dва.begin(), R_Minus_PI_Na_Dва.end(), Compare{});
    R_Minus_PI_Na_Dва.push_back(curr1_Minus_PI_Na_Dва);
    std::push_heap(R_Minus_PI_Na_Dва.begin(), R_Minus_PI_Na_Dва.end(), Compare{});
    const Interval& topB = R_Minus_PI_Na_Dва.front();

    // Критерий останова по точности
    float accuracy = (std::max)(
        fabsf(topA.end.first - topA.start.first),
        fabsf(topB.end.first - topB.start.first));

    if (accuracy < epsilon) {
      textBox6->Text = Convert::ToString(schetchick);
      textBox7->Text = Convert::ToString(accuracy);

      if (min < min_Minus_PI_Na_Dва) {
        chart2->Series[2]->Points->AddXY(x1, x2);
        textBox4->Text = Convert::ToString(x1);
        textBox3->Text = Convert::ToString(x2);
      } else {
        chart2->Series[2]->Points->AddXY(x1_Minus_PI_Na_Dва, x2_Minus_PI_Na_Dва);
        textBox4->Text = Convert::ToString(x1_Minus_PI_Na_Dва);
        textBox3->Text = Convert::ToString(x2_Minus_PI_Na_Dва);
      }

      FreeLibrary(load_function);
      return Extr.back() < Extr_Minus_PI_Na_Dва.back() ? Extr : Extr_Minus_PI_Na_Dва;
    }

    // Обновляем "рамки" по текущим топам
    x_Rmax.first  = topA.start.first;
    x_Rmax.second = topA.end.first;
    y_Rmax.first  = topA.start.second;
    y_Rmax.second = topA.end.second;

    x_Rmax_Minus_PI_Na_Dва.first  = topB.start.first;
    x_Rmax_Minus_PI_Na_Dва.second = topB.end.first;
    y_Rmax_Minus_PI_Na_Dва.first  = topB.start.second;
    y_Rmax_Minus_PI_Na_Dва.second = topB.end.second;

    schetchick++;
  }
}

Если хочешь, могу также привести компактный helper для безопасного «достаём-с-вершины» вида:

cpp
auto pop_top = [&](std::vector<Interval>& H) {
  std::pop_heap(H.begin(), H.end(), Compare{});
  Interval t = H.back();
  H.pop_back();
  return t;
};

и тогда код станет заметно чище.

Partager cette Q&R