f

Author: ewarchul

CMakeLists.txt

@@ -41,7 +41,7 @@ file(
 include_directories(${CMAKE_CURRENT_SOURCE_DIR}/include)
 add_library(cecxx SHARED ${SOURCES} ${HEADERS})
 generate_export_header(cecxx)
-target_compile_options(cecxx PRIVATE -Wall -Wpedantic -Wextra -O3)
+target_compile_options(cecxx PRIVATE -Wall -Wpedantic -Wextra -Ofast)
 target_include_directories(cecxx PRIVATE ${CMAKE_CURRENT_SOURCE_DIR}/include)
 set_target_properties(cecxx PROPERTIES LINKER_LANGUAGE CXX CXX_STANDARD 20)
 
@@ -81,4 +81,4 @@ install(DIRECTORY ${PROJECT_SOURCE_DIR}/data DESTINATION share/cecxx)
 add_executable(main main.cpp)
 target_link_libraries(main cecxx fmt::fmt)
 set_target_properties(main PROPERTIES CXX_STANDARD 20)
-target_compile_options(main PRIVATE -Wall -Wextra -Wpedantic -O3)
+target_compile_options(main PRIVATE -Wall -Wextra -Wpedantic -Ofast)

include/cecxx/detail/benchmark/cec2017/cec2017.hpp

@@ -5,13 +5,20 @@
 #include "cecxx/detail/benchmark/cec2017/consts.hpp"
 #include "cecxx/detail/benchmark/invoke.hpp"
 #include "cecxx/detail/context.hpp"
+#include "cecxx/problem/multimodal/ackley.hpp"
 #include "cecxx/problem/multimodal/bi_rastrigin.hpp"
+#include "cecxx/problem/multimodal/discus.hpp"
+#include "cecxx/problem/multimodal/escaffer.hpp"
+#include "cecxx/problem/multimodal/grie_rosen.hpp"
+#include "cecxx/problem/multimodal/hgbat.hpp"
+#include "cecxx/problem/multimodal/katsuura.hpp"
 #include "cecxx/problem/multimodal/levy.hpp"
 #include "cecxx/problem/multimodal/rastrigin.hpp"
 #include "cecxx/problem/multimodal/rosenbrock.hpp"
 #include "cecxx/problem/multimodal/schaffer.hpp"
 #include "cecxx/problem/multimodal/schwefel.hpp"
 #include "cecxx/problem/multimodal/step_rastrigin.hpp"
+#include "cecxx/problem/multimodal/weierstrass.hpp"
 #include "cecxx/problem/multimodal/zakharov.hpp"
 #include "cecxx/problem/unimodal/bent_cigar.hpp"
 #include "cecxx/problem/unimodal/ellips.hpp"
@@ -62,36 +69,54 @@ auto dispatch_problem(problem_context_view ctx, const int fn, const auto& input)
         {0.3, 0.3, 0.4}, ctx, {.rot = do_affine_trans::yes, .shift = do_affine_trans::yes}, {1.0, 10.0, 1.0});
   case 13:
     return invoke_hybrid_problem(
-        input, {problem::unimodal::bent_cigar, problem::multimodal::rosenbrock, problem::multimodal::legacy::bi_rastrigin},
+        input,
+        {problem::unimodal::bent_cigar, problem::multimodal::rosenbrock, problem::multimodal::legacy::bi_rastrigin},
         {0.3, 0.3, 0.4}, ctx, {.rot = do_affine_trans::yes, .shift = do_affine_trans::yes}, {1.0, 2.048 / 100.0, 1.0});
   case 14:
-    return invoke_hybrid_problem(
-        input, {problem::unimodal::ellips, problem::multimodal::schwefel, problem::unimodal::bent_cigar},
-        {0.3, 0.3, 0.4}, ctx, {.rot = do_affine_trans::yes, .shift = do_affine_trans::yes}, {1.0, 10.0, 1.0});
+    return invoke_hybrid_problem(input,
+                                 {problem::unimodal::ellips, problem::multimodal::ackley,
+                                  problem::multimodal::legacy::schaffer, problem::multimodal::rastrigin},
+                                 {0.2, 0.2, 0.2, 0.4}, ctx,
+                                 {.rot = do_affine_trans::yes, .shift = do_affine_trans::yes}, {1.0, 10.0, 1.0});
   case 15:
-    return invoke_hybrid_problem(
-        input, {problem::unimodal::ellips, problem::multimodal::schwefel, problem::unimodal::bent_cigar},
-        {0.3, 0.3, 0.4}, ctx, {.rot = do_affine_trans::yes, .shift = do_affine_trans::yes}, {1.0, 10.0, 1.0});
+    return invoke_hybrid_problem(input,
+                                 {problem::unimodal::bent_cigar, problem::multimodal::hgbat,
+                                  problem::multimodal::rastrigin, problem::multimodal::rosenbrock},
+                                 {0.2, 0.2, 0.3, 0.3}, ctx,
+                                 {.rot = do_affine_trans::yes, .shift = do_affine_trans::yes}, {1.0, 10.0, 1.0});
   case 16:
-    return invoke_hybrid_problem(
-        input, {problem::unimodal::ellips, problem::multimodal::schwefel, problem::unimodal::bent_cigar},
-        {0.3, 0.3, 0.4}, ctx, {.rot = do_affine_trans::yes, .shift = do_affine_trans::yes}, {1.0, 10.0, 1.0});
+    return invoke_hybrid_problem(input,
+                                 {problem::multimodal::escaffer, problem::multimodal::hgbat,
+                                  problem::multimodal::rosenbrock, problem::multimodal::schwefel},
+                                 {0.2, 0.2, 0.3, 0.3}, ctx,
+                                 {.rot = do_affine_trans::yes, .shift = do_affine_trans::yes}, {1.0, 10.0, 1.0});
   case 17:
     return invoke_hybrid_problem(
-        input, {problem::unimodal::ellips, problem::multimodal::schwefel, problem::unimodal::bent_cigar},
-        {0.3, 0.3, 0.4}, ctx, {.rot = do_affine_trans::yes, .shift = do_affine_trans::yes}, {1.0, 10.0, 1.0});
+        input,
+        {problem::multimodal::katsuura, problem::multimodal::ackley, problem::multimodal::grie_rosen,
+         problem::multimodal::schwefel, problem::multimodal::rastrigin},
+        {0.1, 0.2, 0.2, 0.2, 0.3}, ctx, {.rot = do_affine_trans::yes, .shift = do_affine_trans::yes}, {1.0, 10.0, 1.0});
   case 18:
     return invoke_hybrid_problem(
-        input, {problem::unimodal::ellips, problem::multimodal::schwefel, problem::unimodal::bent_cigar},
-        {0.3, 0.3, 0.4}, ctx, {.rot = do_affine_trans::yes, .shift = do_affine_trans::yes}, {1.0, 10.0, 1.0});
+        input,
+        {problem::unimodal::ellips, problem::multimodal::ackley, problem::multimodal::rastrigin,
+         problem::multimodal::hgbat, problem::multimodal::discus},
+        {0.2, 0.2, 0.2, 0.2, 0.2}, ctx, {.rot = do_affine_trans::yes, .shift = do_affine_trans::yes}, {1.0, 10.0, 1.0});
   case 19:
     return invoke_hybrid_problem(
-        input, {problem::unimodal::ellips, problem::multimodal::schwefel, problem::unimodal::bent_cigar},
-        {0.3, 0.3, 0.4}, ctx, {.rot = do_affine_trans::yes, .shift = do_affine_trans::yes}, {1.0, 10.0, 1.0});
+        input,
+        {problem::unimodal::bent_cigar, problem::multimodal::rastrigin, problem::multimodal::grie_rosen,
+         problem::multimodal::weierstrass, problem::multimodal::escaffer},
+        {0.2, 0.2, 0.2, 0.2, 0.2}, ctx, {.rot = do_affine_trans::yes, .shift = do_affine_trans::yes}, {1.0, 10.0, 1.0});
   case 20:
     return invoke_hybrid_problem(
-        input, {problem::unimodal::ellips, problem::multimodal::schwefel, problem::unimodal::bent_cigar},
-        {0.3, 0.3, 0.4}, ctx, {.rot = do_affine_trans::yes, .shift = do_affine_trans::yes}, {1.0, 10.0, 1.0});
+        input,
+        {problem::multimodal::hgbat, problem::multimodal::katsuura, problem::multimodal::ackley,
+         problem::multimodal::rastrigin, problem::multimodal::rastrigin, problem::multimodal::schwefel,
+         problem::multimodal::rastrigin},
+        // problem::multimodal::legacy::schaffer},
+        {0.1, 0.1, 0.2, 0.2, 0.2, 0.2}, ctx, {.rot = do_affine_trans::yes, .shift = do_affine_trans::yes},
+        {1.0, 10.0, 1.0});
     // case 21:
     //   cec2017_cf01(input.data(), output.data(), input.size(), ctx.shift(fn), ctx.rotate(fn),
     //                to_underlying(do_shift::yes));

include/cecxx/detail/benchmark/invoke.hpp

@@ -6,6 +6,7 @@
 #include <span>
 
 #include "cecxx/detail/context.hpp"
+#include "cecxx/detail/eval_func.hpp"
 #include "cecxx/detail/legacy/affine_trans.h"
 #include "cecxx/detail/types.hpp"
 
@@ -16,11 +17,10 @@ auto invoke_basic_problem(auto&& fn, std::span<const double> input, problem_cont
   auto y = std::vector<double>(nrow);
   auto z = std::vector<double>(nrow);
   sr_func(input, z, *ctx.shift, *ctx.rotate, mask.rate, mask.shift, mask.rot, y);
-
   return fn(z);
 }
 
-auto calc_hybrid_chunks(std::ranges::range auto&& mix_ratios, const int dim) {
+auto calc_hybrid_chunks(std::ranges::range auto&& mix_ratios, const std::integral auto dim) {
   const auto fn_num = mix_ratios.size();
   auto chunk_size = std::vector<double>(fn_num);
   double acc{};
@@ -48,13 +48,25 @@ auto invoke_hybrid_problem(std::span<const double> input, std::vector<evaluation
 
   const auto [sizes, offsets] = calc_hybrid_chunks(std::move(ratios), input.size());
 
+  auto fn_idxs = std::vector<int>(compounds.size());
+  std::iota(fn_idxs.begin(), fn_idxs.end(), 0);
+
   auto partial_eval = std::vector<double>(compounds.size());
-  for (auto fn_idx{0u}; fn_idx < compounds.size(); ++fn_idx) {
+  std::for_each(fn_idxs.begin(), fn_idxs.end(), [&](const auto fn_idx) {
     const auto& fn = compounds[fn_idx];
     auto xs = std::span{y}.subspan(offsets[fn_idx], sizes[fn_idx]);
     std::for_each(xs.begin(), xs.end(), [s = scales[fn_idx]](auto& elem) { elem *= s; });
-    partial_eval[fn_idx] = fn(xs);
-  }
+    partial_eval[fn_idx] = std::visit(
+        overloaded{
+            [&](std::function<double(std::span<const double>)> fn) { return fn(xs); },
+            [&](std::function<double(std::span<const double>, problem_context_view, affine_mask_t)> fn) {
+              return fn(xs, ctx, {.rot = do_affine_trans::no, .shift = do_affine_trans::no});
+            },
+            [&](std::function<double(std::span<const double>, problem_context_view, affine_mask_t, std::vector<double>)>
+                    fn) { return fn(xs, ctx, mask, y); },
+        },
+        std::move(fn));
+  });
 
   return std::accumulate(partial_eval.begin(), partial_eval.end(), 0.0, std::plus{});
 }

include/cecxx/detail/eval_func.hpp

@@ -0,0 +1,21 @@
+#pragma once
+
+#include <functional>
+#include <span>
+#include <variant>
+#include <vector>
+
+#include "cecxx/detail/context.hpp"
+#include "cecxx/detail/types.hpp"
+
+namespace cecxx::detail {
+
+template<class... Ts>
+struct overloaded : Ts... { using Ts::operator()...; };
+
+using evaluation_function_t = std::variant<
+    std::function<double(std::span<const double>)>,
+    std::function<double(std::span<const double>, problem_context_view, affine_mask_t)>,
+    std::function<double(std::span<const double>, problem_context_view, affine_mask_t, std::vector<double>)>>;
+
+}  // namespace cecxx::detail

include/cecxx/detail/types.hpp

@@ -1,15 +1,11 @@
 #pragma once
 
 #include <vector>
-#include <span>
-#include <functional>
 
 namespace cecxx::detail {
 using fn_num = int;
 template <typename T> using table_data = std::vector<T>;
 
-using evaluation_function_t = std::function<double(std::span<const double>)>;
-
 enum class table_type_t { rotate, shift, shuffle };
 
 enum class do_affine_trans : int { yes = 1, no = 0 };
@@ -21,5 +17,4 @@ struct affine_mask_t {
   double rate{1.0};
 };
 
-
 }  // namespace cecxx::detail

include/cecxx/problem/multimodal/discus.hpp

@@ -3,7 +3,7 @@
 #include <cmath>
 #include <span>
 
-namespace cecxx::problem::multimodalinput {
+namespace cecxx::problem::multimodal {
 auto discus(std::span<const double> input) -> double {
   auto output = std::pow(10.0, 6.0) * input[0] * input[0];
   for (auto i = 1u; i < input.size(); i++) {

include/cecxx/problem/unimodal/sphere.hpp

@@ -7,7 +7,7 @@ namespace cecxx::problem::unimodal {
 
 auto sphere(std::span<const double> input) -> double {
   auto output{0.0};
-  for (double x : input) {
+  for (const auto& x : input) {
     output += x * x;
   }
 

main.cpp

@@ -10,7 +10,7 @@
 #include "cecxx/cecxx.hpp"
 
 const auto CEC_STORAGE = std::filesystem::path{"/home/ewarchul/open-source/optim/cec/data"};
-constexpr auto DIMENSION{10};
+constexpr auto DIMENSION{100};
 
 namespace rv = ranges::views;
 
@@ -24,7 +24,7 @@ auto main() -> int {
 
     // Evaluate given input on each optimization problem from CEC2017
     const auto start = std::chrono::system_clock::now();
-    for (const auto& fn : rv::closed_iota(1, 20)) {
+    for (const auto& fn : rv::closed_iota(1, 19)) {
       auto output = cec2017_eval(fn, input);
       fmt::println("fn = {}, output = {}", fn, output);
     }

src/legacy/affine_trans.cpp

@@ -14,18 +14,17 @@ void shufflefunc(std::span<const double> input, std::span<double> output, std::s
   }
 }
 
-
 void shiftfunc(std::span<const double> input, std::span<double> output, std::span<const double> shift_vec) {
-  for (auto i = 0; i < output.size(); i++) {
+  for (auto i = 0u; i < output.size(); i++) {
     output[i] = input[i] - shift_vec[i];
   }
 }
 
 void rotatefunc(std::span<const double> input, std::span<double> output, std::span<const double> rotate_mat) {
   const auto nrow = output.size();
-  for (auto i = 0; i < nrow; i++) {
+  for (auto i = 0u; i < nrow; i++) {
     output[i] = 0;
-    for (auto j = 0; j < nrow; j++) {
+    for (auto j = 0u; j < nrow; j++) {
       output[i] = output[i] + input[j] * rotate_mat[i * nrow + j];
     }
   }
@@ -38,24 +37,24 @@ void sr_func(std::span<const double> input, std::span<double> sr_x, std::span<co
   if (to_underlying(shift) == 1) {
     if (to_underlying(rotate) == 1) {
       shiftfunc(input, output, shit_vec);
-      for (auto i = 0; i < nrow; i++) {
+      for (auto i = 0u; i < nrow; i++) {
         output[i] = output[i] * sh_rate;
       }
       rotatefunc(output, sr_x, rot_mat);
     } else {
       shiftfunc(input, sr_x, shit_vec);
-      for (auto i = 0; i < nrow; i++) {
+      for (auto i = 0u; i < nrow; i++) {
         sr_x[i] = sr_x[i] * sh_rate;
       }
     }
   } else {
     if (to_underlying(rotate) == 1) {
-      for (auto i = 0; i < nrow; i++) {
+      for (auto i = 0u; i < nrow; i++) {
         output[i] = input[i] * sh_rate;
       }
       rotatefunc(output, sr_x, rot_mat);
     } else
-      for (auto i = 0; i < nrow; i++) {
+      for (auto i = 0u; i < nrow; i++) {
         sr_x[i] = input[i] * sh_rate;
       }
   }
@@ -69,11 +68,11 @@ void cf_cal(std::span<const double> input, std::span<double> output, std::span<c
   for (auto i = 0; i < cf_num; i++) {
     fit[i] += bias[i];
     w[i] = 0;
-    for (auto j = 0; j < nrow; j++) {
+    for (auto j = 0u; j < nrow; j++) {
       w[i] += pow(input[j] - shift_vec[i * nrow + j], 2.0);
     }
     if (w[i] != 0) {
-      w[i] = pow(1.0 / w[i], 0.5) * exp(-w[i] / 2.0 / nrow / pow(delta[i], 2.0));
+      w[i] = pow(1.0 / w[i], 0.5) * exp(-w[i] / 2.0 / static_cast<double>(nrow) / pow(delta[i], 2.0));
     } else {
       w[i] = INF;
     }