Added missing dlib namespace

dlib/numerical_integration/integrate_function_adapt_simpson.h

@@ -7,72 +7,75 @@
 
 // ----------------------------------------------------------------------------------------
 
-template <typename T, typename funct>
-T impl_adapt_simp_stop(const funct& f, T a, T b, T fa, T fm, T fb, T is, int cnt)
+namespace dlib
 {
-    const int MAXINT = 500;
-   
-    T m   = (a + b)/2.0;
-    T h   = (b - a)/4.0;
-    T fml = f(a + h);
-    T fmr = f(b - h);
-    T i1 = h/1.5*(fa+4.0*fm+fb);
-    T i2 = h/3.0*(fa+4.0*(fml+fmr)+2.0*fm+fb);
-    i1 = (16.0*i2 - i1)/15.0;
-    T Q = 0;
-
-    if ((std::abs(i1-i2) <= std::abs(is)) || (m <= a) || (b <= m))
+    template <typename T, typename funct>
+    T impl_adapt_simp_stop(const funct& f, T a, T b, T fa, T fm, T fb, T is, int cnt)
     {
-        Q = i1;
-    }
-    else 
-    {
-        if(cnt < MAXINT)
+        const int MAXINT = 500;
+
+        T m   = (a + b)/2.0;
+        T h   = (b - a)/4.0;
+        T fml = f(a + h);
+        T fmr = f(b - h);
+        T i1 = h/1.5*(fa+4.0*fm+fb);
+        T i2 = h/3.0*(fa+4.0*(fml+fmr)+2.0*fm+fb);
+        i1 = (16.0*i2 - i1)/15.0;
+        T Q = 0;
+
+        if ((std::abs(i1-i2) <= std::abs(is)) || (m <= a) || (b <= m))
+        {
+            Q = i1;
+        }
+        else 
         {
-            cnt = cnt + 1;
+            if(cnt < MAXINT)
+            {
+                cnt = cnt + 1;
 
-            Q = impl_adapt_simp_stop(f,a,m,fa,fml,fm,is,cnt) 
-              + impl_adapt_simp_stop(f,m,b,fm,fmr,fb,is,cnt); 
+                Q = impl_adapt_simp_stop(f,a,m,fa,fml,fm,is,cnt) 
+                    + impl_adapt_simp_stop(f,m,b,fm,fmr,fb,is,cnt); 
+            }
         }
-    }
 
-    return Q;
-}
+        return Q;
+    }
 
 // ----------------------------------------------------------------------------------------
 
-template <typename T, typename funct>
-T integrate_function_adapt_simp(
-    const funct& f,
-    T a,
-    T b,
-    T tol = 1e-10
-)
-{
-    T eps = std::numeric_limits<T>::epsilon();
-    if(tol < eps)
+    template <typename T, typename funct>
+    T integrate_function_adapt_simp(
+        const funct& f,
+        T a,
+        T b,
+        T tol = 1e-10
+    )
     {
-        tol = eps;
-    }
+        T eps = std::numeric_limits<T>::epsilon();
+        if(tol < eps)
+        {
+            tol = eps;
+        }
 
-    const T ba = b-a;
-    const T fa = f(a);
-    const T fb = f(b);
-    const T fm = f((a+b)/2);
+        const T ba = b-a;
+        const T fa = f(a);
+        const T fb = f(b);
+        const T fm = f((a+b)/2);
 
-    T is = ba/8*(fa+fb+fm+ f(a + 0.9501*ba) + f(a + 0.2311*ba) + f(a + 0.6068*ba)
-                           + f(a + 0.4860*ba) + f(a + 0.8913*ba));
+        T is = ba/8*(fa+fb+fm+ f(a + 0.9501*ba) + f(a + 0.2311*ba) + f(a + 0.6068*ba)
+            + f(a + 0.4860*ba) + f(a + 0.8913*ba));
 
-    if(is == 0)
-    {
-        is = b-a;
-    }
+        if(is == 0)
+        {
+            is = b-a;
+        }
 
-    is = is*tol;
+        is = is*tol;
 
-    int cnt = 0;
+        int cnt = 0;
 
-    return impl_adapt_simp_stop(f, a, b, fa, fm, fb, is, cnt);
+        return impl_adapt_simp_stop(f, a, b, fa, fm, fb, is, cnt);
+    }
 }
 
 // ----------------------------------------------------------------------------------------

dlib/numerical_integration/integrate_function_adapt_simpson_abstract.h

@@ -3,27 +3,32 @@
 #undef DLIB_INTEGRATE_FUNCTION_ADAPT_SIMPSON_ABSTRACT__
 #ifdef DLIB_INTEGRATE_FUNCTION_ADAPT_SIMPSON_ABSTRACT__
 
-template <typename T, typename funct>
-T integrate_function_adapt_simp(
-    const funct& f, 
-    T a, 
-    T b, 
-    T tol = 1e-10
-);
-/*!
-    requires 
-        - b > a
-        - tol > 0
-        - T should be either float, double, or long double
-        - The expression f(a) should be a valid expression that evaluates to a T.
-          I.e. f() should be a real valued function of a single variable.
-    ensures
-        - returns an approximation of the integral of f over the domain [a,b] using the
-          adaptive Simpson method outlined in Gander, W. and W. Gautshi, "Adaptive
-          Quadrature -- Revisited" BIT, Vol. 40, (2000), pp.84-101
-        - tol is a tolerance parameter that determines the overall accuracy of approximated
-          integral.  We suggest a default value of 1e-10 for tol. 
-!*/
+namespace dlib
+{
+
+    template <typename T, typename funct>
+    T integrate_function_adapt_simp(
+        const funct& f, 
+        T a, 
+        T b, 
+        T tol = 1e-10
+    );
+    /*!
+        requires 
+            - b > a
+            - tol > 0
+            - T should be either float, double, or long double
+            - The expression f(a) should be a valid expression that evaluates to a T.
+              I.e. f() should be a real valued function of a single variable.
+        ensures
+            - returns an approximation of the integral of f over the domain [a,b] using the
+              adaptive Simpson method outlined in Gander, W. and W. Gautshi, "Adaptive
+              Quadrature -- Revisited" BIT, Vol. 40, (2000), pp.84-101
+            - tol is a tolerance parameter that determines the overall accuracy of
+              approximated integral.  We suggest a default value of 1e-10 for tol. 
+    !*/
+
+}
 
 #endif // DLIB_INTEGRATE_FUNCTION_ADAPT_SIMPSON__