Disable CacheFunction when compiled with AppleClang≤10

libKriging · Jan 12, 2023 · 0b56f09 · 0b56f09
1 parent 95e066f
commit 0b56f09
Show file tree

Hide file tree

Showing 6 changed files with 52 additions and 25 deletions.
diff --git a/CMakeLists.txt b/CMakeLists.txt
@@ -307,6 +307,13 @@ set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} ${LIBKRIGING_CXX_FLAGS}")
 
 #------------------------------------------------------
 
+# Workaround for AppleClang 10 in CRAN automated build
+if (CMAKE_CXX_COMPILER_ID STREQUAL "AppleClang" AND CMAKE_CXX_COMPILER_VERSION VERSION_LESS "11")
+    add_definitions(-DLIBKRIGING_DISABLE_CACHE)
+endif()
+
+#------------------------------------------------------
+
 # search for clang-tidy (while be used while adding library or executable)
 find_program(CLANG_TIDY clang-tidy)
 if (CLANG_TIDY)

diff --git a/src/lib/Kriging.cpp b/src/lib/Kriging.cpp
@@ -864,7 +864,7 @@ LIBKRIGING_EXPORT void Kriging::fit(const arma::colvec& y,
   m_objective = objective;
   if (objective.compare("LL") == 0) {
     if (Optim::reparametrize) {
-      fit_ofn = CacheFunction{
+      fit_ofn = CacheFunction(
           [this](const arma::vec& _gamma, arma::vec* grad_out, arma::mat* hess_out, Kriging::OKModel* okm_data) {
             // Change variable for opt: . -> 1/exp(.)
             // DEBUG: if (Optim::log_level>3) arma::cout << "> gamma: " << _gamma << arma::endl;
@@ -881,9 +881,9 @@ LIBKRIGING_EXPORT void Kriging::fit(const arma::colvec& y,
               *hess_out = -Optim::reparam_from_deriv2(_theta, *grad_out, *hess_out);
             }
             return -ll;
-          }};
+          });
     } else {
-      fit_ofn = CacheFunction{
+      fit_ofn = CacheFunction(
           [this](const arma::vec& _gamma, arma::vec* grad_out, arma::mat* hess_out, Kriging::OKModel* okm_data) {
             const arma::vec _theta = _gamma;
             // DEBUG: if (Optim::log_level>3) arma::cout << "> theta: " << _theta << arma::endl;
@@ -898,11 +898,11 @@ LIBKRIGING_EXPORT void Kriging::fit(const arma::colvec& y,
               *hess_out = -*hess_out;
             }
             return -ll;
-          }};
+          });
     }
   } else if (objective.compare("LOO") == 0) {
     if (Optim::reparametrize) {
-      fit_ofn = CacheFunction{
+      fit_ofn = CacheFunction(
           [this](const arma::vec& _gamma, arma::vec* grad_out, arma::mat* /*hess_out*/, Kriging::OKModel* okm_data) {
             // Change variable for opt: . -> 1/exp(.)
             // DEBUG: if (Optim::log_level>3) arma::cout << "> gamma: " << _gamma << arma::endl;
@@ -915,9 +915,9 @@ LIBKRIGING_EXPORT void Kriging::fit(const arma::colvec& y,
               *grad_out = Optim::reparam_from_deriv(_theta, *grad_out);
             }
             return loo;
-          }};
+          });
     } else {
-      fit_ofn = CacheFunction{
+      fit_ofn = CacheFunction(
           [this](const arma::vec& _gamma, arma::vec* grad_out, arma::mat* /*hess_out*/, Kriging::OKModel* okm_data) {
             const arma::vec _theta = _gamma;
             // DEBUG: if (Optim::log_level>3) arma::cout << "> theta: " << _theta << arma::endl;
@@ -928,13 +928,13 @@ LIBKRIGING_EXPORT void Kriging::fit(const arma::colvec& y,
             //   *grad_out = *grad_out; // so not necessary
             //  }
             return loo;
-          }};
+          });
     }
   } else if (objective.compare("LMP") == 0) {
     // Our impl. of https://github.com/cran/RobustGaSP/blob/5cf21658e6a6e327be6779482b93dfee25d24592/R/rgasp.R#L303
     //@see Mengyang Gu, Xiao-jing Wang and Jim Berger, 2018, Annals of Statistics.
     if (Optim::reparametrize) {
-      fit_ofn = CacheFunction{
+      fit_ofn = CacheFunction(
           [this](const arma::vec& _gamma, arma::vec* grad_out, arma::mat* /*hess_out*/, Kriging::OKModel* okm_data) {
             // Change variable for opt: . -> 1/exp(.)
             // DEBUG: if (Optim::log_level>3) arma::cout << "> gamma: " << _gamma << arma::endl;
@@ -947,9 +947,9 @@ LIBKRIGING_EXPORT void Kriging::fit(const arma::colvec& y,
               *grad_out = -Optim::reparam_from_deriv(_theta, *grad_out);
             }
             return -lmp;
-          }};
+          });
     } else {
-      fit_ofn = CacheFunction{
+      fit_ofn = CacheFunction(
           [this](const arma::vec& _gamma, arma::vec* grad_out, arma::mat* /*hess_out*/, Kriging::OKModel* okm_data) {
             const arma::vec _theta = _gamma;
             // DEBUG: if (Optim::log_level>3) arma::cout << "> theta: " << _theta << arma::endl;
@@ -960,7 +960,7 @@ LIBKRIGING_EXPORT void Kriging::fit(const arma::colvec& y,
               *grad_out = -*grad_out;
             }
             return -lmp;
-          }};
+          });
     }
   } else
     throw std::invalid_argument("Unsupported fit objective: " + objective + " (supported are: LL, LOO, LMP)");

diff --git a/src/lib/NoiseKriging.cpp b/src/lib/NoiseKriging.cpp
@@ -269,7 +269,7 @@ LIBKRIGING_EXPORT void NoiseKriging::fit(const arma::colvec& y,
   m_objective = objective;
   if (objective.compare("LL") == 0) {
     if (Optim::reparametrize) {
-      fit_ofn = CacheFunction{[this](const arma::vec& _gamma, arma::vec* grad_out, NoiseKriging::OKModel* okm_data) {
+      fit_ofn = CacheFunction([this](const arma::vec& _gamma, arma::vec* grad_out, NoiseKriging::OKModel* okm_data) {
         // Change variable for opt: . -> 1/exp(.)
         // DEBUG: if (Optim::log_level>3) arma::cout << "> gamma: " << _gamma << arma::endl;
         const arma::vec _theta_sigma2 = Optim::reparam_from(_gamma);
@@ -281,9 +281,9 @@ LIBKRIGING_EXPORT void NoiseKriging::fit(const arma::colvec& y,
           *grad_out = -Optim::reparam_from_deriv(_theta_sigma2, *grad_out);
         }
         return -ll;
-      }};
+      });
     } else {
-      fit_ofn = CacheFunction{[this](const arma::vec& _gamma, arma::vec* grad_out, NoiseKriging::OKModel* okm_data) {
+      fit_ofn = CacheFunction([this](const arma::vec& _gamma, arma::vec* grad_out, NoiseKriging::OKModel* okm_data) {
         const arma::vec _theta_sigma2 = _gamma;
         // DEBUG: if (Optim::log_level>3) arma::cout << "> theta_alpha: " << _theta_sigma2 << arma::endl;
         double ll = this->_logLikelihood(_theta_sigma2, grad_out, okm_data);
@@ -293,7 +293,7 @@ LIBKRIGING_EXPORT void NoiseKriging::fit(const arma::colvec& y,
           *grad_out = -*grad_out;
         }
         return -ll;
-      }};
+      });
     }
   } else
     throw std::invalid_argument("Unsupported fit objective: " + objective + " (supported are: LL)");

diff --git a/src/lib/NuggetKriging.cpp b/src/lib/NuggetKriging.cpp
@@ -513,7 +513,7 @@ LIBKRIGING_EXPORT void NuggetKriging::fit(const arma::colvec& y,
   m_objective = objective;
   if (objective.compare("LL") == 0) {
     if (Optim::reparametrize) {
-      fit_ofn = CacheFunction{[this](const arma::vec& _gamma, arma::vec* grad_out, NuggetKriging::OKModel* okm_data) {
+      fit_ofn = CacheFunction([this](const arma::vec& _gamma, arma::vec* grad_out, NuggetKriging::OKModel* okm_data) {
         // Change variable for opt: . -> 1/exp(.)
         // DEBUG: if (Optim::log_level>3) arma::cout << "> gamma: " << _gamma << arma::endl;
         const arma::vec _theta_alpha = Optim::reparam_from(_gamma);
@@ -525,9 +525,9 @@ LIBKRIGING_EXPORT void NuggetKriging::fit(const arma::colvec& y,
           *grad_out = -Optim::reparam_from_deriv(_theta_alpha, *grad_out);
         }
         return -ll;
-      }};
+      });
     } else {
-      fit_ofn = CacheFunction{[this](const arma::vec& _gamma, arma::vec* grad_out, NuggetKriging::OKModel* okm_data) {
+      fit_ofn = CacheFunction([this](const arma::vec& _gamma, arma::vec* grad_out, NuggetKriging::OKModel* okm_data) {
         const arma::vec _theta_alpha = _gamma;
         // DEBUG: if (Optim::log_level>3) arma::cout << "> theta_alpha: " << _theta_alpha << arma::endl;
         double ll = this->_logLikelihood(_theta_alpha, grad_out, okm_data);
@@ -537,13 +537,13 @@ LIBKRIGING_EXPORT void NuggetKriging::fit(const arma::colvec& y,
           *grad_out = -*grad_out;
         }
         return -ll;
-      }};
+      });
     }
   } else if (objective.compare("LMP") == 0) {
     // Our impl. of https://github.com/cran/RobustGaSP/blob/5cf21658e6a6e327be6779482b93dfee25d24592/R/rgasp.R#L303
     //@see Mengyang Gu, Xiao-jing Wang and Jim Berger, 2018, Annals of Statistics.
     if (Optim::reparametrize) {
-      fit_ofn = CacheFunction{[this](const arma::vec& _gamma, arma::vec* grad_out, NuggetKriging::OKModel* okm_data) {
+      fit_ofn = CacheFunction([this](const arma::vec& _gamma, arma::vec* grad_out, NuggetKriging::OKModel* okm_data) {
         // Change variable for opt: . -> 1/exp(.)
         // DEBUG: if (Optim::log_level>3) arma::cout << "> gamma: " << _gamma << arma::endl;
         const arma::vec _theta_alpha = Optim::reparam_from(_gamma);
@@ -555,9 +555,9 @@ LIBKRIGING_EXPORT void NuggetKriging::fit(const arma::colvec& y,
           *grad_out = -Optim::reparam_from_deriv(_theta_alpha, *grad_out);
         }
         return -lmp;
-      }};
+      });
     } else {
-      fit_ofn = CacheFunction{[this](const arma::vec& _gamma, arma::vec* grad_out, NuggetKriging::OKModel* okm_data) {
+      fit_ofn = CacheFunction([this](const arma::vec& _gamma, arma::vec* grad_out, NuggetKriging::OKModel* okm_data) {
         const arma::vec _theta_alpha = _gamma;
         // DEBUG: if (Optim::log_level>3) arma::cout << "> theta_alpha: " << _theta_alpha << arma::endl;
         double lmp = this->_logMargPost(_theta_alpha, grad_out, okm_data);
@@ -567,7 +567,7 @@ LIBKRIGING_EXPORT void NuggetKriging::fit(const arma::colvec& y,
           *grad_out = -*grad_out;
         }
         return -lmp;
-      }};
+      });
     }
   } else
     throw std::invalid_argument("Unsupported fit objective: " + objective + " (supported are: LL, LMP)");

diff --git a/src/lib/include/libKriging/CacheFunction.hpp b/src/lib/include/libKriging/CacheFunction.hpp
@@ -60,6 +60,8 @@ class CacheFunctionCommon {
 
 std::ostream& operator<<(std::ostream& o, const CacheFunctionCommon::CacheStat&);
 
+/* ----------------------------------------------------------------------------------------------------------------- */
+#ifndef LIBKRIGING_DISABLE_CACHE
 /* ----------------------------------------------------------------------------------------------------------------- */
 
 template <typename Callable, typename Signature, typename... Contexts>
@@ -126,4 +128,18 @@ class CacheFunction<Callable, std::function<R(Args...)>, Contexts...> : public C
 template <typename F, typename... Contexts>
 CacheFunction(const F& f, const Contexts&...) -> CacheFunction<F, decltype(std::function{f}), Contexts...>;
 
+/* ----------------------------------------------------------------------------------------------------------------- */
+
+#else /* LIBKRIGING_DISABLE_CACHE */
+
+/* ----------------------------------------------------------------------------------------------------------------- */
+
+#define CacheFunction(x) (x)
+
+/* ----------------------------------------------------------------------------------------------------------------- */
+
+#endif /* LIBKRIGING_DISABLE_CACHE */
+
+/* ----------------------------------------------------------------------------------------------------------------- */
+
 #endif  // LIBKRIGING_SRC_LIB_CACHE_HPP
diff --git a/tests/CacheFunctionTest.cpp b/tests/CacheFunctionTest.cpp
@@ -3,6 +3,8 @@
 #include <tuple>
 #include "libKriging/CacheFunction.hpp"
 
+#ifndef LIBKRIGING_DISABLE_CACHE
+
 TEST_CASE("Cache of 0-arg function", "[core]") {
   auto f = []() -> double { return 1; };
 
@@ -187,4 +189,6 @@ TEST_CASE("Cache function behaves like std::function", "[core]") {
   REQUIRE(stat.max_hit == 1);
   REQUIRE(stat.total_hit == 2);
   REQUIRE(stat.cache_size == 2);
-}
+}
+
+#endif /* LIBKRIGING_DISABLE_CACHE */