Refacto integrate with hints

.github/workflows/ci.yml

@@ -0,0 +1,86 @@
+name: C/C++ CI
+
+on:
+  push:
+    branches: [ "main" ]
+  pull_request:
+    branches: [ "main" ]
+
+jobs:
+  build:
+    strategy:
+      matrix:
+        os: [ubuntu-latest]
+        compiler: [g++-14, clang++-18]
+        build_type: [Debug, Release]
+
+    runs-on: ${{ matrix.os }}
+
+    steps:
+      - uses: actions/checkout@v4
+
+      - name: Install toolchain and dependencies
+        run: |
+          sudo apt-get update
+          sudo apt-get install -y g++-14 clang-18 libfmt-dev
+
+      - name: Configure & build
+        run: |
+          cmake -B build \
+            -DCMAKE_BUILD_TYPE=${{ matrix.build_type }} \
+            -DCMAKE_CXX_COMPILER=${{ matrix.compiler }} \
+            -DLNIT_BUILD_DEMO=ON \
+            -DLNIT_BUILD_BENCHMARK=ON
+          cmake --build build --parallel
+
+  benchmark:
+    # only track regressions from main; PRs/forks shouldn't push to gh-pages
+    if: github.event_name == 'push' && github.ref == 'refs/heads/main'
+    runs-on: ubuntu-latest
+    permissions:
+      contents: write
+
+    steps:
+      - uses: actions/checkout@v4
+
+      - name: Install toolchain and dependencies
+        run: |
+          sudo apt-get update
+          sudo apt-get install -y g++-14 libfmt-dev
+
+      - name: Configure & build benchmarks
+        run: |
+          cmake -B build \
+            -DCMAKE_BUILD_TYPE=Release \
+            -DCMAKE_CXX_COMPILER=g++-14 \
+            -DLNIT_BUILD_BENCHMARK=ON
+          cmake --build build --parallel
+
+      - name: Run benchmarks
+        run: |
+          ./build/benchmark/benchmark_addaptiveQuadratures --benchmark_format=json --benchmark_out=bench_addaptiveQuadratures_result.json
+          ./build/benchmark/benchmark_LevermoreLikePDF --benchmark_format=json --benchmark_out=bench_LevermoreLikePDF_result.json
+
+      - name: Store adaptive quadratures benchmark & detect regressions
+        uses: benchmark-action/github-action-benchmark@v1
+        with:
+          tool: 'googlecpp'
+          name: 'Adaptive Quadratures'
+          output-file-path: bench_addaptiveQuadratures_result.json
+          github-token: ${{ secrets.GITHUB_TOKEN }}
+          auto-push: true
+          alert-threshold: '150%'
+          comment-on-alert: true
+          fail-on-alert: true
+
+      - name: Store Levermore-like PDF benchmark & detect regressions
+        uses: benchmark-action/github-action-benchmark@v1
+        with:
+          tool: 'googlecpp'
+          name: 'Levermore-like PDF'
+          output-file-path: bench_LevermoreLikePDF_result.json
+          github-token: ${{ secrets.GITHUB_TOKEN }}
+          auto-push: true
+          alert-threshold: '150%'
+          comment-on-alert: true
+          fail-on-alert: true

include/LNIT/AdaptiveQuadratures/AdaptiveQuadratureBase.hpp

@@ -65,7 +65,7 @@ class AdaptiveQuadratureBase
 	 * 
 	 * @return Pair (integral, estimated error).
 	 */
-	template<class Function> constexpr std::pair<LongScalar, LongScalar> estimateIntegral(const Function& f, const Scalar& xmin, const Scalar& xmax) { return derived().estimateIntegralImpl(f, xmin, xmax); }
+	template<class Function> constexpr std::pair<LongScalar, LongScalar> estimateIntegral(Function&& f, const Scalar& xmin, const Scalar& xmax) { return derived().estimateIntegralImpl(std::forward<Function>(f), xmin, xmax); }
 
 	/**
 	 * @brief Perform adaptive quadrature on [xmin, xmax].
@@ -75,8 +75,10 @@ class AdaptiveQuadratureBase
 	 * @param xmax Upper bound of interval.
 	 * @return Approximation of the integral.
 	 */
-	template<class Function> LongScalar integrate(const Function& f, const Scalar& xmin, const Scalar& xmax);
-
+	template<class Function> LongScalar integrate(Function&& f, const Scalar& xmin, const Scalar& xmax);
+
+	template<class Function> LongScalar integrateWithHints(Function&& f, const std::span<const Scalar> mu, const Scalar& sigma);
+
 	/**
 	 * @brief Perform adaptive quadrature on (-inf, xmax].
 	 * 
@@ -92,7 +94,7 @@ class AdaptiveQuadratureBase
 	 * @param xmax Upper bound of interval.
 	 * @return Approximation of the integral.
 	 */
-	template<class Function> LongScalar integrateLeftInfinite(const Function& f, const Scalar& xmax);
+	template<class Function> LongScalar integrateLeftInfinite(Function&& f, const Scalar& xmax);
 
 	/**
 	 * @brief Perform adaptive quadrature on [xmin, inf).
@@ -109,7 +111,7 @@ class AdaptiveQuadratureBase
 	 * @param xmax Upper bound of interval.
 	 * @return Approximation of the integral.
 	 */
-	template<class Function> LongScalar integrateRightInfinite(const Function& f, const Scalar& xmin);
+	template<class Function> LongScalar integrateRightInfinite(Function&& f, const Scalar& xmin);
 
 	/**
      * @brief Perform adaptive quadrature on (-inf, inf).
@@ -124,7 +126,7 @@ class AdaptiveQuadratureBase
 	 * \f]
 	 * Finally addapt the quadrature over [xmin, xmax].
      */
-	template<class Function> LongScalar integrate(const Function& f);
+	template<class Function> LongScalar integrate(Function&& f);
 
 	/**
 	 * @brief Perform adaptive quadrature on (-inf, inf) using a coordinate-remapping technique.
@@ -139,9 +141,9 @@ class AdaptiveQuadratureBase
 	 * \int_{-1}^{1} f(x(t))\frac{1 + t^2}{(1 - t^2)^2} dt.
 	 * \f]
 	 */
-	template<class Function> LongScalar remapAndIntegrate(const Function& f);
+	template<class Function> LongScalar remapAndIntegrate(Function&& f);
 
-	template<class Function> std::invoke_result_t<Function, Scalar> integrateWithoutAdaptation(const Function& f) const;
+	template<class Function> std::invoke_result_t<Function, Scalar> integrateWithoutAdaptation(Function&& f) const;
 
 	constexpr Size   getMaxIt()       const { return m_maxIt; }       ///<  @brief Maximum iterations allowed.
 	constexpr Size   getNits()        const { return m_it; }          ///<  @brief Number of iterations performed.
@@ -168,6 +170,8 @@ class AdaptiveQuadratureBase
 
 	constexpr std::span<const Interval> getSubIntervals() const { return m_intervals; }
 private:
+	template<class Function> LongScalar adaptQuadrature(Function&& func);
+
 	std::vector<Interval>   m_intervals;
 	std::vector<LongScalar> m_subIntergrals;
 	std::vector<LongScalar> m_subIntergralsErr;