From b5ea7328126e7059cc47bf02b3d68c8e28726fb6 Mon Sep 17 00:00:00 2001 From: Alexandre Hoffmann Date: Fri, 24 Jul 2026 08:35:42 +0200 Subject: [PATCH 01/13] Add adaptQuadrature function template declaration --- include/LNIT/AdaptiveQuadratures/AdaptiveQuadratureBase.hpp | 2 ++ 1 file changed, 2 insertions(+) diff --git a/include/LNIT/AdaptiveQuadratures/AdaptiveQuadratureBase.hpp b/include/LNIT/AdaptiveQuadratures/AdaptiveQuadratureBase.hpp index 04629dd..7283fea 100644 --- a/include/LNIT/AdaptiveQuadratures/AdaptiveQuadratureBase.hpp +++ b/include/LNIT/AdaptiveQuadratures/AdaptiveQuadratureBase.hpp @@ -168,6 +168,8 @@ class AdaptiveQuadratureBase constexpr std::span getSubIntervals() const { return m_intervals; } private: + template LongScalar addaptQuadrature(const Function& func); + std::vector m_intervals; std::vector m_subIntergrals; std::vector m_subIntergralsErr; From ecbf6fd2e7a3df939037b0a0cfdca2381e5c5471 Mon Sep 17 00:00:00 2001 From: Alexandre Hoffmann Date: Fri, 24 Jul 2026 08:35:46 +0200 Subject: [PATCH 02/13] Refactor integrate method to use addaptQuadrature Refactored integrate method to use addaptQuadrature for adaptive integration. --- .../AdaptiveQuadratureBase_impl.hpp | 62 ++++++++++--------- 1 file changed, 34 insertions(+), 28 deletions(-) diff --git a/include/LNIT/AdaptiveQuadratures/AdaptiveQuadratureBase_impl.hpp b/include/LNIT/AdaptiveQuadratures/AdaptiveQuadratureBase_impl.hpp index 907469c..0eb9330 100644 --- a/include/LNIT/AdaptiveQuadratures/AdaptiveQuadratureBase_impl.hpp +++ b/include/LNIT/AdaptiveQuadratures/AdaptiveQuadratureBase_impl.hpp @@ -27,6 +27,38 @@ AdaptiveQuadratureBase::AdaptiveQuadratureBase(const Size& maxIt, const m_subIntergralsErr.reserve(maxIt); } +template template +auto AdaptiveQuadratureBase::addaptQuadrature(const Function& func) -> LongScalar +{ + for (m_it=0; m_it!=m_maxIt; ++m_it) + { + const LongScalar I = getEstimatedIntegral(); + const LongScalar err = getEstimatedError(); + + if (m_out) { fmt::print(m_out, "{} {:10.4e} {:10.4e} {:10.4e} {:10.4e}\n", m_it, Scalar(I), Scalar(err), Scalar(abs(I))*m_relativeTol, Scalar(m_absoluteTol)); } + + if (not isfinite(I)) { return I; } + if (err < abs(I)*LongScalar(m_relativeTol) or err < LongScalar(m_absoluteTol)) { m_hasConverged = true; return I; } + + // we find the interval over which the integral is the least accurate + const const_Iterator maxErrIt = std::ranges::max_element(m_subIntergralsErr); + const Size maxErrIdx = Size(std::ranges::distance(m_subIntergralsErr.begin(), maxErrIt)); + // we split it in two + const auto& [a, b] = m_intervals[maxErrIdx]; + + Scalar midPoint = std::midpoint(a, b); // non-const because I want to move it when I do not need it. + // first interval + m_intervals[maxErrIdx] = Interval(a, midPoint); + std::tie(m_subIntergrals[maxErrIdx], m_subIntergralsErr[maxErrIdx]) = estimateIntegral(f, a, midPoint); + // second interval + std::tie(res, estimatedErr) = estimateIntegral(f, midPoint, b); + m_intervals.emplace_back(std::move(midPoint), b); + m_subIntergrals.push_back(res); + m_subIntergralsErr.push_back(estimatedErr); + } + return getEstimatedIntegral(); +} + template template auto AdaptiveQuadratureBase::integrate(const Function& f, const Scalar& xmin, const Scalar& xmax) -> LongScalar { @@ -52,7 +84,7 @@ auto AdaptiveQuadratureBase::integrate(const Function& f, const Scalar& m_intervals.reserve(N); m_subIntergrals.reserve(N); m_subIntergralsErr.reserve(N); - + for (Size i=0; i!=N; ++i) { const Scalar x_i = xmin + Scalar(i)*(xmax - xmin) / Scalar(N); @@ -64,34 +96,8 @@ auto AdaptiveQuadratureBase::integrate(const Function& f, const Scalar& m_subIntergrals.push_back(res); m_subIntergralsErr.push_back(estimatedErr); } - - for (m_it=0; m_it!=m_maxIt; ++m_it) - { - const LongScalar I = getEstimatedIntegral(); - const LongScalar err = getEstimatedError(); - if (m_out) { fmt::print(m_out, "{} {:10.4e} {:10.4e} {:10.4e} {:10.4e}\n", m_it, Scalar(I), Scalar(err), Scalar(abs(I))*m_relativeTol, Scalar(m_absoluteTol)); } - - if (not isfinite(I)) { return I; } - if (err < abs(I)*LongScalar(m_relativeTol) or err < LongScalar(m_absoluteTol)) { m_hasConverged = true; return I; } - - // we find the interval over which the integral is the least accurate - const const_Iterator maxErrIt = std::ranges::max_element(m_subIntergralsErr); - const Size maxErrIdx = Size(std::ranges::distance(m_subIntergralsErr.begin(), maxErrIt)); - // we split it in two - const auto& [a, b] = m_intervals[maxErrIdx]; - - Scalar midPoint = std::midpoint(a, b); // non-const because I want to move it when I do not need it. - // first interval - m_intervals[maxErrIdx] = Interval(a, midPoint); - std::tie(m_subIntergrals[maxErrIdx], m_subIntergralsErr[maxErrIdx]) = estimateIntegral(f, a, midPoint); - // second interval - std::tie(res, estimatedErr) = estimateIntegral(f, midPoint, b); - m_intervals.emplace_back(std::move(midPoint), b); - m_subIntergrals.push_back(res); - m_subIntergralsErr.push_back(estimatedErr); - } - return getEstimatedIntegral(); + return addaptQuadrature(func); } template template From 830df5bbe0360cf31f5c7cfb900fd9054b8267ec Mon Sep 17 00:00:00 2001 From: Alexandre Hoffmann Date: Fri, 24 Jul 2026 08:53:24 +0200 Subject: [PATCH 03/13] Refactor adaptive quadrature implementation Refactor adaptive quadrature methods to improve clarity and reduce redundancy. --- .../AdaptiveQuadratureBase_impl.hpp | 18 ++++++++++-------- 1 file changed, 10 insertions(+), 8 deletions(-) diff --git a/include/LNIT/AdaptiveQuadratures/AdaptiveQuadratureBase_impl.hpp b/include/LNIT/AdaptiveQuadratures/AdaptiveQuadratureBase_impl.hpp index 0eb9330..e74b62c 100644 --- a/include/LNIT/AdaptiveQuadratures/AdaptiveQuadratureBase_impl.hpp +++ b/include/LNIT/AdaptiveQuadratures/AdaptiveQuadratureBase_impl.hpp @@ -30,6 +30,16 @@ AdaptiveQuadratureBase::AdaptiveQuadratureBase(const Size& maxIt, const template template auto AdaptiveQuadratureBase::addaptQuadrature(const Function& func) -> LongScalar { + using std::abs; + using std::isfinite; + + using const_Iterator = typename std::vector::const_iterator; + + m_hasConverged = false; + + if (m_out) { fmt::print(m_out, "#NumericalIntegrator addapting quadrature over [{}, {}]\n", xmin, xmax); } + if (m_out) { fmt::print(m_out, "#Iteration integral estimated_error relative_tol absolute_tol\n"); } + for (m_it=0; m_it!=m_maxIt; ++m_it) { const LongScalar I = getEstimatedIntegral(); @@ -63,12 +73,7 @@ template template auto AdaptiveQuadratureBase::integrate(const Function& f, const Scalar& xmin, const Scalar& xmax) -> LongScalar { using std::ceil; - using std::abs; - using std::isfinite; - - using const_Iterator = typename std::vector::const_iterator; - m_hasConverged = false; m_intervals.clear(); m_subIntergrals.clear(); m_subIntergralsErr.clear(); @@ -76,9 +81,6 @@ auto AdaptiveQuadratureBase::integrate(const Function& f, const Scalar& LongScalar res; LongScalar estimatedErr; - if (m_out) { fmt::print(m_out, "#NumericalIntegrator addapting quadrature over [{}, {}]\n", xmin, xmax); } - if (m_out) { fmt::print(m_out, "#Iteration integral estimated_error relative_tol absolute_tol\n"); } - const Size N = Size(ceil(getMaxDeltaX(xmin, xmax))); m_intervals.reserve(N); From ea5bfadd08af1e5e3a76dd74da761023898c4b98 Mon Sep 17 00:00:00 2001 From: Alexandre Hoffmann Date: Fri, 24 Jul 2026 08:55:34 +0200 Subject: [PATCH 04/13] Remove duplicate output message for quadrature --- .../LNIT/AdaptiveQuadratures/AdaptiveQuadratureBase_impl.hpp | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/include/LNIT/AdaptiveQuadratures/AdaptiveQuadratureBase_impl.hpp b/include/LNIT/AdaptiveQuadratures/AdaptiveQuadratureBase_impl.hpp index e74b62c..35c807f 100644 --- a/include/LNIT/AdaptiveQuadratures/AdaptiveQuadratureBase_impl.hpp +++ b/include/LNIT/AdaptiveQuadratures/AdaptiveQuadratureBase_impl.hpp @@ -37,7 +37,6 @@ auto AdaptiveQuadratureBase::addaptQuadrature(const Function& func) -> m_hasConverged = false; - if (m_out) { fmt::print(m_out, "#NumericalIntegrator addapting quadrature over [{}, {}]\n", xmin, xmax); } if (m_out) { fmt::print(m_out, "#Iteration integral estimated_error relative_tol absolute_tol\n"); } for (m_it=0; m_it!=m_maxIt; ++m_it) @@ -99,6 +98,7 @@ auto AdaptiveQuadratureBase::integrate(const Function& f, const Scalar& m_subIntergralsErr.push_back(estimatedErr); } + if (m_out) { fmt::print(m_out, "#NumericalIntegrator addapting quadrature over [{}, {}]\n", xmin, xmax); } return addaptQuadrature(func); } From 12c500d5baca10f78ad1e25f8994a6675cb7cb3b Mon Sep 17 00:00:00 2001 From: Alexandre Hoffmann Date: Fri, 24 Jul 2026 10:42:09 +0200 Subject: [PATCH 05/13] Fix parameter name in addaptQuadrature method --- .../LNIT/AdaptiveQuadratures/AdaptiveQuadratureBase_impl.hpp | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/include/LNIT/AdaptiveQuadratures/AdaptiveQuadratureBase_impl.hpp b/include/LNIT/AdaptiveQuadratures/AdaptiveQuadratureBase_impl.hpp index 35c807f..4e93d33 100644 --- a/include/LNIT/AdaptiveQuadratures/AdaptiveQuadratureBase_impl.hpp +++ b/include/LNIT/AdaptiveQuadratures/AdaptiveQuadratureBase_impl.hpp @@ -28,7 +28,7 @@ AdaptiveQuadratureBase::AdaptiveQuadratureBase(const Size& maxIt, const } template template -auto AdaptiveQuadratureBase::addaptQuadrature(const Function& func) -> LongScalar +auto AdaptiveQuadratureBase::addaptQuadrature(const Function& f) -> LongScalar { using std::abs; using std::isfinite; @@ -99,7 +99,7 @@ auto AdaptiveQuadratureBase::integrate(const Function& f, const Scalar& } if (m_out) { fmt::print(m_out, "#NumericalIntegrator addapting quadrature over [{}, {}]\n", xmin, xmax); } - return addaptQuadrature(func); + return addaptQuadrature(f); } template template From c817cd20e66ae2713307c8ffbdb780e80bde4bf9 Mon Sep 17 00:00:00 2001 From: Alexandre Hoffmann Date: Fri, 24 Jul 2026 10:44:29 +0200 Subject: [PATCH 06/13] Refactor variable declaration for estimated error --- .../LNIT/AdaptiveQuadratures/AdaptiveQuadratureBase_impl.hpp | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/include/LNIT/AdaptiveQuadratures/AdaptiveQuadratureBase_impl.hpp b/include/LNIT/AdaptiveQuadratures/AdaptiveQuadratureBase_impl.hpp index 4e93d33..7b85662 100644 --- a/include/LNIT/AdaptiveQuadratures/AdaptiveQuadratureBase_impl.hpp +++ b/include/LNIT/AdaptiveQuadratures/AdaptiveQuadratureBase_impl.hpp @@ -60,7 +60,7 @@ auto AdaptiveQuadratureBase::addaptQuadrature(const Function& f) -> Lon m_intervals[maxErrIdx] = Interval(a, midPoint); std::tie(m_subIntergrals[maxErrIdx], m_subIntergralsErr[maxErrIdx]) = estimateIntegral(f, a, midPoint); // second interval - std::tie(res, estimatedErr) = estimateIntegral(f, midPoint, b); + const auto [res, estimatedErr] = estimateIntegral(f, midPoint, b); m_intervals.emplace_back(std::move(midPoint), b); m_subIntergrals.push_back(res); m_subIntergralsErr.push_back(estimatedErr); From af3fbacfc3a051657e0817202854a3a7989488ff Mon Sep 17 00:00:00 2001 From: Alexandre Hoffmann Date: Fri, 24 Jul 2026 10:57:03 +0200 Subject: [PATCH 07/13] Potential fix for pull request finding Co-authored-by: Copilot Autofix powered by AI <175728472+Copilot@users.noreply.github.com> --- include/LNIT/AdaptiveQuadratures/AdaptiveQuadratureBase.hpp | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/include/LNIT/AdaptiveQuadratures/AdaptiveQuadratureBase.hpp b/include/LNIT/AdaptiveQuadratures/AdaptiveQuadratureBase.hpp index 7283fea..ccdff68 100644 --- a/include/LNIT/AdaptiveQuadratures/AdaptiveQuadratureBase.hpp +++ b/include/LNIT/AdaptiveQuadratures/AdaptiveQuadratureBase.hpp @@ -168,7 +168,7 @@ class AdaptiveQuadratureBase constexpr std::span getSubIntervals() const { return m_intervals; } private: - template LongScalar addaptQuadrature(const Function& func); + template LongScalar adaptQuadrature(const Function& func); std::vector m_intervals; std::vector m_subIntergrals; From 5d0eae0aa9dd24cbada455bdcba13ae4228e25f4 Mon Sep 17 00:00:00 2001 From: Alexandre Hoffmann Date: Fri, 24 Jul 2026 10:57:28 +0200 Subject: [PATCH 08/13] Potential fix for pull request finding Co-authored-by: Copilot Autofix powered by AI <175728472+Copilot@users.noreply.github.com> --- .../LNIT/AdaptiveQuadratures/AdaptiveQuadratureBase_impl.hpp | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/include/LNIT/AdaptiveQuadratures/AdaptiveQuadratureBase_impl.hpp b/include/LNIT/AdaptiveQuadratures/AdaptiveQuadratureBase_impl.hpp index 7b85662..416e163 100644 --- a/include/LNIT/AdaptiveQuadratures/AdaptiveQuadratureBase_impl.hpp +++ b/include/LNIT/AdaptiveQuadratures/AdaptiveQuadratureBase_impl.hpp @@ -28,7 +28,7 @@ AdaptiveQuadratureBase::AdaptiveQuadratureBase(const Size& maxIt, const } template template -auto AdaptiveQuadratureBase::addaptQuadrature(const Function& f) -> LongScalar +auto AdaptiveQuadratureBase::adaptQuadrature(const Function& f) -> LongScalar { using std::abs; using std::isfinite; From afe3eee353d38737fb54162184b943730249e070 Mon Sep 17 00:00:00 2001 From: Alexandre Hoffmann Date: Fri, 24 Jul 2026 10:57:51 +0200 Subject: [PATCH 09/13] Potential fix for pull request finding Co-authored-by: Copilot Autofix powered by AI <175728472+Copilot@users.noreply.github.com> --- .../LNIT/AdaptiveQuadratures/AdaptiveQuadratureBase_impl.hpp | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/include/LNIT/AdaptiveQuadratures/AdaptiveQuadratureBase_impl.hpp b/include/LNIT/AdaptiveQuadratures/AdaptiveQuadratureBase_impl.hpp index 416e163..2a23147 100644 --- a/include/LNIT/AdaptiveQuadratures/AdaptiveQuadratureBase_impl.hpp +++ b/include/LNIT/AdaptiveQuadratures/AdaptiveQuadratureBase_impl.hpp @@ -98,8 +98,8 @@ auto AdaptiveQuadratureBase::integrate(const Function& f, const Scalar& m_subIntergralsErr.push_back(estimatedErr); } - if (m_out) { fmt::print(m_out, "#NumericalIntegrator addapting quadrature over [{}, {}]\n", xmin, xmax); } - return addaptQuadrature(f); + if (m_out) { fmt::print(m_out, "#NumericalIntegrator adapting quadrature over [{}, {}]\n", xmin, xmax); } + return adaptQuadrature(f); } template template From f54b823885c75c2e3ed83d89567d93d65f5dbb3f Mon Sep 17 00:00:00 2001 From: Alexandre Hoffmann Date: Fri, 24 Jul 2026 11:39:34 +0200 Subject: [PATCH 10/13] Implement integrateWithHints method for quadrature --- .../AdaptiveQuadratureBase_impl.hpp | 79 ++++++++++++++++++- 1 file changed, 78 insertions(+), 1 deletion(-) diff --git a/include/LNIT/AdaptiveQuadratures/AdaptiveQuadratureBase_impl.hpp b/include/LNIT/AdaptiveQuadratures/AdaptiveQuadratureBase_impl.hpp index 2a23147..88db4d8 100644 --- a/include/LNIT/AdaptiveQuadratures/AdaptiveQuadratureBase_impl.hpp +++ b/include/LNIT/AdaptiveQuadratures/AdaptiveQuadratureBase_impl.hpp @@ -102,13 +102,90 @@ auto AdaptiveQuadratureBase::integrate(const Function& f, const Scalar& return adaptQuadrature(f); } +template template +auto AdaptiveQuadratureBase::integrateWithHints(const Function& f, const std::span mu, const Scalar& sigma) -> LongScalar +{ + using std::abs; + using std::isfinite; + using std::swap; + + using Iterator = typename std::vector::iterator; + + constexpr Size scal = 3; + + GaussLaguerreQuadrature gLaguerreQuad; + + m_intervals.clear(); + m_subIntergrals.clear(); + m_subIntergralsErr.clear(); + + m_intervals.reserve(2*mu.size()); + + // First pass, we compute intervals near the peaks on which the function is not null. + for (const double& mu_i : mu) + { + Interval curr(mu_i - scal*sigma, mu_i + scal*sigma); + + if (curr.first > curr.second) { swap(curr.first, curr.second); } + + LongScalar leftIntegral = gLaguerreQuad.integrateLeftInfinite(f, curr.first); + while (isfinite(leftIntegral) and abs(leftIntegral) >= NumTraits::epsilon) + { + curr.first -= scal*sigma; + leftIntegral = gLaguerreQuad.integrateLeftInfinite(f, curr.first); + assert(curr.first <= curr.second); + } + + if (not isfinite(leftIntegral)) { return NumTraits::NaN; } + + LongScalar rightIntegral = gLaguerreQuad.integrateRightInfinite(f, curr.second); + while (isfinite(rightIntegral) and abs(rightIntegral) >= NumTraits::epsilon) + { + curr.second += scal*sigma; + rightIntegral = gLaguerreQuad.integrateRightInfinite(f, curr.second); + assert(curr.first <= curr.second); + } + + if (not isfinite(rightIntegral)) { return NumTraits::NaN; } + + Iterator firstInterval = m_intervals.begin(); + while (firstInterval != m_intervals.end() and firstInterval->second < curr.first) { ++firstInterval; } + + Iterator boundInterval = firstInterval; + for ( ;boundInterval != m_intervals.end() and boundInterval->first <= curr.second; ++boundInterval) + { + curr.first = std::min(curr.first, boundInterval->first); + curr.second = std::max(curr.second, boundInterval->second); + } + + const Iterator it = m_intervals.erase(firstInterval, boundInterval); + m_intervals.insert(it, curr); + } + + LongScalar res; + LongScalar estimatedErr; + + m_subIntergrals.reserve(m_intervals.size()); + m_subIntergralsErr.reserve(m_intervals.size()); + + for (const auto& [xmin, xmax] : m_intervals) + { + std::tie(res, estimatedErr) = estimateIntegral(f, xmin, xmax); + + m_subIntergrals.push_back(res); + m_subIntergralsErr.push_back(estimatedErr); + } + + if (m_out) { fmt::print(m_out, "#NumericalIntegrator adapting quadrature over {}\n", m_intervals); } + return adaptQuadrature(f); +} + template template auto AdaptiveQuadratureBase::integrateLeftInfinite(const Function& f, const Scalar& xmax) -> LongScalar { using std::isfinite; using std::abs; - GaussLaguerreQuadrature gLaguerreQuad; Scalar xmin = -1; From 2165495bc3a7afaa9fcdf358473676d3feb0dc4e Mon Sep 17 00:00:00 2001 From: Alexandre Hoffmann Date: Fri, 24 Jul 2026 11:40:22 +0200 Subject: [PATCH 11/13] Add integrateWithHints method declaration --- include/LNIT/AdaptiveQuadratures/AdaptiveQuadratureBase.hpp | 4 +++- 1 file changed, 3 insertions(+), 1 deletion(-) diff --git a/include/LNIT/AdaptiveQuadratures/AdaptiveQuadratureBase.hpp b/include/LNIT/AdaptiveQuadratures/AdaptiveQuadratureBase.hpp index ccdff68..4990a9f 100644 --- a/include/LNIT/AdaptiveQuadratures/AdaptiveQuadratureBase.hpp +++ b/include/LNIT/AdaptiveQuadratures/AdaptiveQuadratureBase.hpp @@ -76,7 +76,9 @@ class AdaptiveQuadratureBase * @return Approximation of the integral. */ template LongScalar integrate(const Function& f, const Scalar& xmin, const Scalar& xmax); - + + template template LongScalar integrateWithHints(const Function& f, const std::span mu, const Scalar& sigma); + /** * @brief Perform adaptive quadrature on (-inf, xmax]. * From dc2e60300ba42e5453ded91fdfc8605d0632bdea Mon Sep 17 00:00:00 2001 From: Alexandre Hoffmann Date: Fri, 24 Jul 2026 12:11:11 +0200 Subject: [PATCH 12/13] corrected integrateWithHints template declaration --- include/LNIT/AdaptiveQuadratures/AdaptiveQuadratureBase.hpp | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/include/LNIT/AdaptiveQuadratures/AdaptiveQuadratureBase.hpp b/include/LNIT/AdaptiveQuadratures/AdaptiveQuadratureBase.hpp index 4990a9f..799e2ee 100644 --- a/include/LNIT/AdaptiveQuadratures/AdaptiveQuadratureBase.hpp +++ b/include/LNIT/AdaptiveQuadratures/AdaptiveQuadratureBase.hpp @@ -77,7 +77,7 @@ class AdaptiveQuadratureBase */ template LongScalar integrate(const Function& f, const Scalar& xmin, const Scalar& xmax); - template template LongScalar integrateWithHints(const Function& f, const std::span mu, const Scalar& sigma); + template LongScalar integrateWithHints(const Function& f, const std::span mu, const Scalar& sigma); /** * @brief Perform adaptive quadrature on (-inf, xmax]. From d0ad859a5e1bbe77c5dc5e4e2bd0d19b6950d8ca Mon Sep 17 00:00:00 2001 From: Alexandre Hoffmann Date: Fri, 24 Jul 2026 12:22:39 +0200 Subject: [PATCH 13/13] Add assertion for sigma in AdaptiveQuadratureBase_impl --- .../LNIT/AdaptiveQuadratures/AdaptiveQuadratureBase_impl.hpp | 2 ++ 1 file changed, 2 insertions(+) diff --git a/include/LNIT/AdaptiveQuadratures/AdaptiveQuadratureBase_impl.hpp b/include/LNIT/AdaptiveQuadratures/AdaptiveQuadratureBase_impl.hpp index 88db4d8..8297c1f 100644 --- a/include/LNIT/AdaptiveQuadratures/AdaptiveQuadratureBase_impl.hpp +++ b/include/LNIT/AdaptiveQuadratures/AdaptiveQuadratureBase_impl.hpp @@ -113,6 +113,8 @@ auto AdaptiveQuadratureBase::integrateWithHints(const Function& f, cons constexpr Size scal = 3; + assert(sigma > Scalar{}); + GaussLaguerreQuadrature gLaguerreQuad; m_intervals.clear();