Merge pull request #1331 from boostorg/fix_missing_headers

mborland · web-flow · commit 6ee28f29f688 · 2025-10-23T15:24:50.000+02:00
Fix missing headers and types
diff --git a/include/boost/math/interpolators/cubic_hermite.hpp b/include/boost/math/interpolators/cubic_hermite.hpp
@@ -8,6 +8,7 @@
 #define BOOST_MATH_INTERPOLATORS_CUBIC_HERMITE_HPP
 #include <memory>
 #include <boost/math/interpolators/detail/cubic_hermite_detail.hpp>
+#include <cstdint>
 
 namespace boost {
 namespace math {
@@ -41,7 +42,7 @@ class cubic_hermite {
         impl_->push_back(x, y, dydx);
     }
 
-    int64_t bytes() const
+    std::int64_t bytes() const
     {
         return impl_->bytes() + sizeof(impl_);
     }
@@ -80,7 +81,7 @@ class cardinal_cubic_hermite {
         return os;
     }
 
-    int64_t bytes() const
+    std::int64_t bytes() const
     {
         return impl_->bytes() + sizeof(impl_);
     }
@@ -121,7 +122,7 @@ class cardinal_cubic_hermite_aos {
         return os;
     }
 
-    int64_t bytes() const
+    std::int64_t bytes() const
     {
         return impl_->bytes() + sizeof(impl_);
     }
diff --git a/include/boost/math/interpolators/detail/barycentric_rational_detail.hpp b/include/boost/math/interpolators/detail/barycentric_rational_detail.hpp
@@ -12,6 +12,7 @@
 #include <utility> // for std::move
 #include <algorithm> // for std::is_sorted
 #include <string>
+#include <cstdint>
 #include <boost/math/special_functions/fpclassify.hpp>
 #include <boost/math/tools/assert.hpp>
 
@@ -100,22 +101,22 @@ template<class Real>
 void barycentric_rational_imp<Real>::calculate_weights(size_t approximation_order)
 {
     using std::abs;
-    int64_t n = m_x.size();
+    std::int64_t n = m_x.size();
     m_w.resize(n, 0);
-    for(int64_t k = 0; k < n; ++k)
+    for(std::int64_t k = 0; k < n; ++k)
     {
-        int64_t i_min = (std::max)(k - static_cast<int64_t>(approximation_order), static_cast<int64_t>(0));
-        int64_t i_max = k;
+        std::int64_t i_min = (std::max)(k - static_cast<std::int64_t>(approximation_order), static_cast<std::int64_t>(0));
+        std::int64_t i_max = k;
         if (k >= n - (std::ptrdiff_t)approximation_order)
         {
             i_max = n - approximation_order - 1;
         }
 
-        for(int64_t i = i_min; i <= i_max; ++i)
+        for(std::int64_t i = i_min; i <= i_max; ++i)
         {
             Real inv_product = 1;
-            int64_t j_max = (std::min)(static_cast<int64_t>(i + approximation_order), static_cast<int64_t>(n - 1));
-            for(int64_t j = i; j <= j_max; ++j)
+            std::int64_t j_max = (std::min)(static_cast<std::int64_t>(i + approximation_order), static_cast<std::int64_t>(n - 1));
+            for(std::int64_t j = i; j <= j_max; ++j)
             {
                 if (j == k)
                 {
diff --git a/include/boost/math/interpolators/detail/cardinal_quintic_b_spline_detail.hpp b/include/boost/math/interpolators/detail/cardinal_quintic_b_spline_detail.hpp
@@ -7,6 +7,7 @@
 #ifndef BOOST_MATH_INTERPOLATORS_CARDINAL_QUINTIC_B_SPLINE_DETAIL_HPP
 #define BOOST_MATH_INTERPOLATORS_CARDINAL_QUINTIC_B_SPLINE_DETAIL_HPP
 #include <cmath>
+#include <cstdint>
 #include <vector>
 #include <utility>
 #include <boost/math/special_functions/cardinal_b_spline.hpp>
@@ -157,7 +158,7 @@ class cardinal_quintic_b_spline_detail
 
         m_alpha[n+3] = rhs[n+3]/diagonal[n+3];
         m_alpha[n+2] = rhs[n+2] - first_superdiagonal[n+2]*m_alpha[n+3];
-        for (int64_t i = int64_t(n+1); i >= 0; --i) {
+        for (std::int64_t i = std::int64_t(n+1); i >= 0; --i) {
             m_alpha[i] = rhs[i] - first_superdiagonal[i]*m_alpha[i+1] - second_superdiagonal[i]*m_alpha[i+2];
         }
 
@@ -176,10 +177,10 @@ class cardinal_quintic_b_spline_detail
         Real x = (t-m_t0)*m_inv_h;
         // Support of B_5 is [-3, 3]. So -3 < x - j + 2 < 3, so x-1 < j < x+5.
         // TODO: Zero pad m_alpha so that only the domain check is necessary.
-        int64_t j_min = (std::max)(int64_t(0), int64_t(ceil(x-1)));
-        int64_t j_max = (std::min)(int64_t(m_alpha.size() - 1), int64_t(floor(x+5)) );
+        std::int64_t j_min = (std::max)(std::int64_t(0), std::int64_t(ceil(x-1)));
+        std::int64_t j_max = (std::min)(std::int64_t(m_alpha.size() - 1), std::int64_t(floor(x+5)) );
         Real s = 0;
-        for (int64_t j = j_min; j <= j_max; ++j) {
+        for (std::int64_t j = j_min; j <= j_max; ++j) {
             // TODO: Use Cox 1972 to generate all integer translates of B5 simultaneously.
             s += m_alpha[j]*cardinal_b_spline<5, Real>(x - j + 2);
         }
@@ -196,10 +197,10 @@ class cardinal_quintic_b_spline_detail
         }
         Real x = (t-m_t0)*m_inv_h;
         // Support of B_5 is [-3, 3]. So -3 < x - j + 2 < 3, so x-1 < j < x+5
-        int64_t j_min = (std::max)(int64_t(0), int64_t(ceil(x-1)));
-        int64_t j_max = (std::min)(int64_t(m_alpha.size() - 1), int64_t(floor(x+5)) );
+        std::int64_t j_min = (std::max)(std::int64_t(0), std::int64_t(ceil(x-1)));
+        std::int64_t j_max = (std::min)(std::int64_t(m_alpha.size() - 1), std::int64_t(floor(x+5)) );
         Real s = 0;
-        for (int64_t j = j_min; j <= j_max; ++j) {
+        for (std::int64_t j = j_min; j <= j_max; ++j) {
             s += m_alpha[j]*cardinal_b_spline_prime<5, Real>(x - j + 2);
         }
         return s*m_inv_h;
@@ -216,10 +217,10 @@ class cardinal_quintic_b_spline_detail
         }
         Real x = (t-m_t0)*m_inv_h;
         // Support of B_5 is [-3, 3]. So -3 < x - j + 2 < 3, so x-1 < j < x+5
-        int64_t j_min = (std::max)(int64_t(0), int64_t(ceil(x-1)));
-        int64_t j_max = (std::min)(int64_t(m_alpha.size() - 1), int64_t(floor(x+5)) );
+        std::int64_t j_min = (std::max)(std::int64_t(0), std::int64_t(ceil(x-1)));
+        std::int64_t j_max = (std::min)(std::int64_t(m_alpha.size() - 1), std::int64_t(floor(x+5)) );
         Real s = 0;
-        for (int64_t j = j_min; j <= j_max; ++j) {
+        for (std::int64_t j = j_min; j <= j_max; ++j) {
             s += m_alpha[j]*cardinal_b_spline_double_prime<5, Real>(x - j + 2);
         }
         return s*m_inv_h*m_inv_h;
diff --git a/include/boost/math/interpolators/detail/cubic_hermite_detail.hpp b/include/boost/math/interpolators/detail/cubic_hermite_detail.hpp
@@ -12,6 +12,7 @@
 #include <iostream>
 #include <sstream>
 #include <limits>
+#include <cstdint>
 
 namespace boost {
 namespace math {
@@ -154,7 +155,7 @@ class cubic_hermite_detail {
         return x_.size();
     }
 
-    int64_t bytes() const
+    std::int64_t bytes() const
     {
         return 3*x_.size()*sizeof(Real) + 3*sizeof(x_);
     }
@@ -278,7 +279,7 @@ class cardinal_cubic_hermite_detail {
         return y_.size();
     }
 
-    int64_t bytes() const
+    std::int64_t bytes() const
     {
         return 2*y_.size()*sizeof(Real) + 2*sizeof(y_) + 2*sizeof(Real);
     }
@@ -413,7 +414,7 @@ class cardinal_cubic_hermite_detail_aos {
         return dat_.size();
     }
 
-    int64_t bytes() const
+    std::int64_t bytes() const
     {
         return dat_.size()*dat_[0].size()*sizeof(Real) + sizeof(dat_) + 2*sizeof(Real);
     }
diff --git a/include/boost/math/interpolators/detail/quintic_hermite_detail.hpp b/include/boost/math/interpolators/detail/quintic_hermite_detail.hpp
@@ -11,6 +11,7 @@
 #include <sstream>
 #include <limits>
 #include <cmath>
+#include <cstdint>
 
 namespace boost {
 namespace math {
@@ -193,7 +194,7 @@ class quintic_hermite_detail {
         return os;
     }
 
-    int64_t bytes() const
+    std::int64_t bytes() const
     {
         return 4*x_.size()*sizeof(x_);
     }
@@ -380,7 +381,7 @@ class cardinal_quintic_hermite_detail {
         return d2ydx2;
     }
 
-    int64_t bytes() const
+    std::int64_t bytes() const
     {
         return 3*y_.size()*sizeof(Real) + 2*sizeof(Real);
     }
@@ -561,7 +562,7 @@ class cardinal_quintic_hermite_detail_aos {
         return d2ydx2;
     }
 
-    int64_t bytes() const
+    std::int64_t bytes() const
     {
         return data_.size()*data_[0].size()*sizeof(Real) + 2*sizeof(Real);
     }
diff --git a/include/boost/math/interpolators/detail/septic_hermite_detail.hpp b/include/boost/math/interpolators/detail/septic_hermite_detail.hpp
@@ -11,6 +11,7 @@
 #include <sstream>
 #include <limits>
 #include <cmath>
+#include <cstdint>
 
 namespace boost {
 namespace math {
@@ -189,7 +190,7 @@ class septic_hermite_detail {
         return os;
     }
 
-    int64_t bytes()
+    std::int64_t bytes()
     {
         return 5*x_.size()*sizeof(Real) + 5*sizeof(x_);
     }
@@ -419,7 +420,7 @@ class cardinal_septic_hermite_detail {
         return d2ydx2;
     }
 
-    int64_t bytes() const
+    std::int64_t bytes() const
     {
         return 4*y_.size()*sizeof(Real) + 2*sizeof(Real) + 4*sizeof(y_);
     }
@@ -629,7 +630,7 @@ class cardinal_septic_hermite_detail_aos {
         return d2ydx2;
     }
 
-    int64_t bytes() const
+    std::int64_t bytes() const
     {
         return data_.size()*data_[0].size()*sizeof(Real) + 2*sizeof(Real) + sizeof(data_);
     }
diff --git a/include/boost/math/interpolators/detail/vector_barycentric_rational_detail.hpp b/include/boost/math/interpolators/detail/vector_barycentric_rational_detail.hpp
@@ -8,6 +8,7 @@
 #ifndef BOOST_MATH_INTERPOLATORS_VECTOR_BARYCENTRIC_RATIONAL_DETAIL_HPP
 #define BOOST_MATH_INTERPOLATORS_VECTOR_BARYCENTRIC_RATIONAL_DETAIL_HPP
 
+#include <cstdint>
 #include <cmath>
 #include <vector>
 #include <utility> // for std::move
@@ -64,22 +65,22 @@ void vector_barycentric_rational_imp<TimeContainer, SpaceContainer>::calculate_w
 {
     using Real = typename TimeContainer::value_type;
     using std::abs;
-    int64_t n = t_.size();
+    std::int64_t n = t_.size();
     w_.resize(n, Real(0));
-    for(int64_t k = 0; k < n; ++k)
+    for(std::int64_t k = 0; k < n; ++k)
     {
-        int64_t i_min = (std::max)(k - static_cast<int64_t>(approximation_order), static_cast<int64_t>(0));
-        int64_t i_max = k;
+        std::int64_t i_min = (std::max)(k - static_cast<std::int64_t>(approximation_order), static_cast<std::int64_t>(0));
+        std::int64_t i_max = k;
         if (k >= n - (std::ptrdiff_t)approximation_order)
         {
             i_max = n - approximation_order - 1;
         }
 
-        for(int64_t i = i_min; i <= i_max; ++i)
+        for(std::int64_t i = i_min; i <= i_max; ++i)
         {
             Real inv_product = 1;
-            int64_t j_max = (std::min)(static_cast<int64_t>(i + approximation_order), static_cast<int64_t>(n - 1));
-            for(int64_t j = i; j <= j_max; ++j)
+            std::int64_t j_max = (std::min)(static_cast<std::int64_t>(i + approximation_order), static_cast<std::int64_t>(n - 1));
+            for(std::int64_t j = i; j <= j_max; ++j)
             {
                 if (j == k)
                 {
diff --git a/include/boost/math/interpolators/quintic_hermite.hpp b/include/boost/math/interpolators/quintic_hermite.hpp
@@ -10,6 +10,7 @@
 #include <algorithm>
 #include <stdexcept>
 #include <memory>
+#include <cstdint>
 #include <boost/math/interpolators/detail/quintic_hermite_detail.hpp>
 
 namespace boost {
@@ -50,7 +51,7 @@ class quintic_hermite {
         impl_->push_back(x, y, dydx, d2ydx2);
     }
 
-    int64_t bytes() const
+    std::int64_t bytes() const
     {
         return impl_->bytes() + sizeof(impl_);
     }
@@ -85,7 +86,7 @@ class cardinal_quintic_hermite {
         return impl_->double_prime(x);
     }
 
-    int64_t bytes() const
+    std::int64_t bytes() const
     {
         return impl_->bytes() + sizeof(impl_);
     }
@@ -123,7 +124,7 @@ class cardinal_quintic_hermite_aos {
         return impl_->double_prime(x);
     }
 
-    int64_t bytes() const
+    std::int64_t bytes() const
     {
         return impl_->bytes() + sizeof(impl_);
     }
diff --git a/include/boost/math/interpolators/septic_hermite.hpp b/include/boost/math/interpolators/septic_hermite.hpp
@@ -9,6 +9,7 @@
 #include <algorithm>
 #include <stdexcept>
 #include <memory>
+#include <cstdint>
 #include <boost/math/interpolators/detail/septic_hermite_detail.hpp>
 
 namespace boost {
@@ -47,7 +48,7 @@ class septic_hermite
         return os;
     }
 
-    int64_t bytes() const
+    std::int64_t bytes() const
     {
         return impl_->bytes() + sizeof(impl_);
     }
@@ -87,7 +88,7 @@ class cardinal_septic_hermite
         return impl_->double_prime(x);
     }
 
-    int64_t bytes() const
+    std::int64_t bytes() const
     {
         return impl_->bytes() + sizeof(impl_);
     }
@@ -126,7 +127,7 @@ class cardinal_septic_hermite_aos {
         return impl_->double_prime(x);
     }
 
-    int64_t bytes() const
+    std::int64_t bytes() const
     {
         return impl_.size() + sizeof(impl_);
     }
diff --git a/include/boost/math/quadrature/naive_monte_carlo.hpp b/include/boost/math/quadrature/naive_monte_carlo.hpp

Original file line number	Diff line number	Diff line change
`@@ -8,6 +8,7 @@`
`8`	`8`	`#define BOOST_MATH_INTERPOLATORS_CUBIC_HERMITE_HPP`
`9`	`9`	`#include <memory>`
`10`	`10`	`#include <boost/math/interpolators/detail/cubic_hermite_detail.hpp>`
	`11`	`+#include <cstdint>`
`11`	`12`
`12`	`13`	`namespace boost {`
`13`	`14`	`namespace math {`
`@@ -41,7 +42,7 @@ class cubic_hermite {`
`41`	`42`	`impl_->push_back(x, y, dydx);`
`42`	`43`	`}`
`43`	`44`
`44`		`- int64_t bytes() const`
	`45`	`+ std::int64_t bytes() const`
`45`	`46`	`{`
`46`	`47`	`return impl_->bytes() + sizeof(impl_);`
`47`	`48`	`}`
`@@ -80,7 +81,7 @@ class cardinal_cubic_hermite {`
`80`	`81`	`return os;`
`81`	`82`	`}`
`82`	`83`
`83`		`- int64_t bytes() const`
	`84`	`+ std::int64_t bytes() const`
`84`	`85`	`{`
`85`	`86`	`return impl_->bytes() + sizeof(impl_);`
`86`	`87`	`}`
`@@ -121,7 +122,7 @@ class cardinal_cubic_hermite_aos {`
`121`	`122`	`return os;`
`122`	`123`	`}`
`123`	`124`
`124`		`- int64_t bytes() const`
	`125`	`+ std::int64_t bytes() const`
`125`	`126`	`{`
`126`	`127`	`return impl_->bytes() + sizeof(impl_);`
`127`	`128`	`}`
Original file line number	Diff line number	Diff line change
`@@ -12,6 +12,7 @@`
`12`	`12`	`#include <utility> // for std::move`
`13`	`13`	`#include <algorithm> // for std::is_sorted`
`14`	`14`	`#include <string>`
	`15`	`+#include <cstdint>`
`15`	`16`	`#include <boost/math/special_functions/fpclassify.hpp>`
`16`	`17`	`#include <boost/math/tools/assert.hpp>`
`17`	`18`
`@@ -100,22 +101,22 @@ template<class Real>`
`100`	`101`	`void barycentric_rational_imp<Real>::calculate_weights(size_t approximation_order)`
`101`	`102`	`{`
`102`	`103`	`using std::abs;`
`103`		`- int64_t n = m_x.size();`
	`104`	`+ std::int64_t n = m_x.size();`
`104`	`105`	`m_w.resize(n, 0);`
`105`		`- for(int64_t k = 0; k < n; ++k)`
	`106`	`+ for(std::int64_t k = 0; k < n; ++k)`
`106`	`107`	`{`
`107`		`- int64_t i_min = (std::max)(k - static_cast<int64_t>(approximation_order), static_cast<int64_t>(0));`
`108`		`- int64_t i_max = k;`
	`108`	`+ std::int64_t i_min = (std::max)(k - static_cast<std::int64_t>(approximation_order), static_cast<std::int64_t>(0));`
	`109`	`+ std::int64_t i_max = k;`
`109`	`110`	`if (k >= n - (std::ptrdiff_t)approximation_order)`
`110`	`111`	`{`
`111`	`112`	`i_max = n - approximation_order - 1;`
`112`	`113`	`}`
`113`	`114`
`114`		`- for(int64_t i = i_min; i <= i_max; ++i)`
	`115`	`+ for(std::int64_t i = i_min; i <= i_max; ++i)`
`115`	`116`	`{`
`116`	`117`	`Real inv_product = 1;`
`117`		`- int64_t j_max = (std::min)(static_cast<int64_t>(i + approximation_order), static_cast<int64_t>(n - 1));`
`118`		`- for(int64_t j = i; j <= j_max; ++j)`
	`118`	`+ std::int64_t j_max = (std::min)(static_cast<std::int64_t>(i + approximation_order), static_cast<std::int64_t>(n - 1));`
	`119`	`+ for(std::int64_t j = i; j <= j_max; ++j)`
`119`	`120`	`{`
`120`	`121`	`if (j == k)`
`121`	`122`	`{`
Original file line number	Diff line number	Diff line change
`@@ -11,6 +11,7 @@`
`11`	`11`	`#include <sstream>`
`12`	`12`	`#include <limits>`
`13`	`13`	`#include <cmath>`
	`14`	`+#include <cstdint>`
`14`	`15`
`15`	`16`	`namespace boost {`
`16`	`17`	`namespace math {`
`@@ -193,7 +194,7 @@ class quintic_hermite_detail {`
`193`	`194`	`return os;`
`194`	`195`	`}`
`195`	`196`
`196`		`- int64_t bytes() const`
	`197`	`+ std::int64_t bytes() const`
`197`	`198`	`{`
`198`	`199`	`return 4x_.size()sizeof(x_);`
`199`	`200`	`}`
`@@ -380,7 +381,7 @@ class cardinal_quintic_hermite_detail {`
`380`	`381`	`return d2ydx2;`
`381`	`382`	`}`
`382`	`383`
`383`		`- int64_t bytes() const`
	`384`	`+ std::int64_t bytes() const`
`384`	`385`	`{`
`385`	`386`	`return 3y_.size()sizeof(Real) + 2*sizeof(Real);`
`386`	`387`	`}`
`@@ -561,7 +562,7 @@ class cardinal_quintic_hermite_detail_aos {`
`561`	`562`	`return d2ydx2;`
`562`	`563`	`}`
`563`	`564`
`564`		`- int64_t bytes() const`
	`565`	`+ std::int64_t bytes() const`
`565`	`566`	`{`
`566`	`567`	`return data_.size()data_[0].size()sizeof(Real) + 2*sizeof(Real);`
`567`	`568`	`}`
Original file line number	Diff line number	Diff line change
`@@ -8,6 +8,7 @@`
`8`	`8`	`#ifndef BOOST_MATH_INTERPOLATORS_VECTOR_BARYCENTRIC_RATIONAL_DETAIL_HPP`
`9`	`9`	`#define BOOST_MATH_INTERPOLATORS_VECTOR_BARYCENTRIC_RATIONAL_DETAIL_HPP`
`10`	`10`
	`11`	`+#include <cstdint>`
`11`	`12`	`#include <cmath>`
`12`	`13`	`#include <vector>`
`13`	`14`	`#include <utility> // for std::move`
`@@ -64,22 +65,22 @@ void vector_barycentric_rational_imp<TimeContainer, SpaceContainer>::calculate_w`
`64`	`65`	`{`
`65`	`66`	`using Real = typename TimeContainer::value_type;`
`66`	`67`	`using std::abs;`
`67`		`- int64_t n = t_.size();`
	`68`	`+ std::int64_t n = t_.size();`
`68`	`69`	`w_.resize(n, Real(0));`
`69`		`- for(int64_t k = 0; k < n; ++k)`
	`70`	`+ for(std::int64_t k = 0; k < n; ++k)`
`70`	`71`	`{`
`71`		`- int64_t i_min = (std::max)(k - static_cast<int64_t>(approximation_order), static_cast<int64_t>(0));`
`72`		`- int64_t i_max = k;`
	`72`	`+ std::int64_t i_min = (std::max)(k - static_cast<std::int64_t>(approximation_order), static_cast<std::int64_t>(0));`
	`73`	`+ std::int64_t i_max = k;`
`73`	`74`	`if (k >= n - (std::ptrdiff_t)approximation_order)`
`74`	`75`	`{`
`75`	`76`	`i_max = n - approximation_order - 1;`
`76`	`77`	`}`
`77`	`78`
`78`		`- for(int64_t i = i_min; i <= i_max; ++i)`
	`79`	`+ for(std::int64_t i = i_min; i <= i_max; ++i)`
`79`	`80`	`{`
`80`	`81`	`Real inv_product = 1;`
`81`		`- int64_t j_max = (std::min)(static_cast<int64_t>(i + approximation_order), static_cast<int64_t>(n - 1));`
`82`		`- for(int64_t j = i; j <= j_max; ++j)`
	`82`	`+ std::int64_t j_max = (std::min)(static_cast<std::int64_t>(i + approximation_order), static_cast<std::int64_t>(n - 1));`
	`83`	`+ for(std::int64_t j = i; j <= j_max; ++j)`
`83`	`84`	`{`
`84`	`85`	`if (j == k)`
`85`	`86`	`{`
Original file line number	Diff line number	Diff line change
`@@ -10,6 +10,7 @@`
`10`	`10`	`#include <algorithm>`
`11`	`11`	`#include <stdexcept>`
`12`	`12`	`#include <memory>`
	`13`	`+#include <cstdint>`
`13`	`14`	`#include <boost/math/interpolators/detail/quintic_hermite_detail.hpp>`
`14`	`15`
`15`	`16`	`namespace boost {`
`@@ -50,7 +51,7 @@ class quintic_hermite {`
`50`	`51`	`impl_->push_back(x, y, dydx, d2ydx2);`
`51`	`52`	`}`
`52`	`53`
`53`		`- int64_t bytes() const`
	`54`	`+ std::int64_t bytes() const`
`54`	`55`	`{`
`55`	`56`	`return impl_->bytes() + sizeof(impl_);`
`56`	`57`	`}`
`@@ -85,7 +86,7 @@ class cardinal_quintic_hermite {`
`85`	`86`	`return impl_->double_prime(x);`
`86`	`87`	`}`
`87`	`88`
`88`		`- int64_t bytes() const`
	`89`	`+ std::int64_t bytes() const`
`89`	`90`	`{`
`90`	`91`	`return impl_->bytes() + sizeof(impl_);`
`91`	`92`	`}`
`@@ -123,7 +124,7 @@ class cardinal_quintic_hermite_aos {`
`123`	`124`	`return impl_->double_prime(x);`
`124`	`125`	`}`
`125`	`126`
`126`		`- int64_t bytes() const`
	`127`	`+ std::int64_t bytes() const`
`127`	`128`	`{`
`128`	`129`	`return impl_->bytes() + sizeof(impl_);`
`129`	`130`	`}`
Original file line number	Diff line number	Diff line change
`@@ -9,6 +9,7 @@`
`9`	`9`	`#include <algorithm>`
`10`	`10`	`#include <stdexcept>`
`11`	`11`	`#include <memory>`
	`12`	`+#include <cstdint>`
`12`	`13`	`#include <boost/math/interpolators/detail/septic_hermite_detail.hpp>`
`13`	`14`
`14`	`15`	`namespace boost {`
`@@ -47,7 +48,7 @@ class septic_hermite`
`47`	`48`	`return os;`
`48`	`49`	`}`
`49`	`50`
`50`		`- int64_t bytes() const`
	`51`	`+ std::int64_t bytes() const`
`51`	`52`	`{`
`52`	`53`	`return impl_->bytes() + sizeof(impl_);`
`53`	`54`	`}`
`@@ -87,7 +88,7 @@ class cardinal_septic_hermite`
`87`	`88`	`return impl_->double_prime(x);`
`88`	`89`	`}`
`89`	`90`
`90`		`- int64_t bytes() const`
	`91`	`+ std::int64_t bytes() const`
`91`	`92`	`{`
`92`	`93`	`return impl_->bytes() + sizeof(impl_);`
`93`	`94`	`}`
`@@ -126,7 +127,7 @@ class cardinal_septic_hermite_aos {`
`126`	`127`	`return impl_->double_prime(x);`
`127`	`128`	`}`
`128`	`129`
`129`		`- int64_t bytes() const`
	`130`	`+ std::int64_t bytes() const`
`130`	`131`	`{`
`131`	`132`	`return impl_.size() + sizeof(impl_);`
`132`	`133`	`}`