dlib for dcu, version=19.24

.gitignore

+**/.idea
+*~
+*.swp
+*.o
+*.so
+*.pyc
+build
+docs
+dist
+*.egg-info/
+**/.vscode
+.clang-tidy

LICENSE

-123456

MANIFEST.in

+#
+# MANIFEST.in
+#
+# Manifest template for creating the dlib source distribution.
+
+include MANIFEST.in
+include setup.py
+include README.md
+
+# sources
+recursive-include dlib **
+recursive-include python_examples *.txt *.py 
+recursive-include tools/python **
+
+prune tools/python/build*
+prune dlib/cmake_utils/*/build*
+prune dlib/test
+
+global-exclude *.pyc

README.md

+# dlib C++ library  [![GitHub Actions C++ Status](https://github.com/davisking/dlib/actions/workflows/build_cpp.yml/badge.svg)](https://github.com/davisking/dlib/actions/workflows/build_cpp.yml) [![GitHub Actions Python Status](https://github.com/davisking/dlib/actions/workflows/build_python.yml/badge.svg)](https://github.com/davisking/dlib/actions/workflows/build_python.yml)
+
+Dlib is a modern C++ toolkit containing machine learning algorithms and tools for creating complex software in C++ to solve real world problems.
+See [http://dlib.net](http://dlib.net) for the main project documentation and API reference.
+
+## Compiling dlib C++ example programs
+
+Go into the examples folder and type:
+
+DCU编译之前，需要准备编译环境  
+[environment_prepare](environment_prepare.md)
+
+```shell
+mkdir build; cd build; 
+cmake .. -DCMAKE_CXX_COMPILER=/opt/dtk/bin/hipcc
+cmake --build . -j16 --verbose
+```
+
+That will build all the examples.
+If you have a CPU that supports AVX instructions then turn them on like this:
+
+```shell
+mkdir build; cd build; cmake .. -DUSE_AVX_INSTRUCTIONS=1; cmake --build .
+```
+
+Doing so will make some things run faster.
+
+Finally, Visual Studio users should usually do everything in 64bit mode. By default Visual Studio is 32bit, both in its outputs and its own execution, so you have to explicitly
+tell it to use 64bits. Since it's not the 1990s anymore you probably want to use 64bits. Do that with a cmake invocation like this:
+
+```shell
+cmake .. -G "Visual Studio 14 2015 Win64" -T host=x64 
+```
+
+## Compiling your own C++ programs that use dlib
+
+The examples folder has a [CMake tutorial](https://github.com/davisking/dlib/blob/master/examples/CMakeLists.txt) that tells you what to do. There are also additional instructions
+on the [dlib web site](http://dlib.net/compile.html).
+
+```shell
+vcpkg install dlib
+```
+
+## Compiling dlib Python API
+
+Before you can run the Python example programs you must compile dlib. Type:
+
+```shell
+python setup.py install --set CMAKE_CXX_COMPILER=/opt/dtk/bin/hipcc
+```
+
+## Running the unit test suite
+
+Type the following to compile and run the dlib unit test suite:
+
+```shell
+cd dlib/test
+mkdir build
+cd build
+
+cmake .. -DCMAKE_CXX_COMPILER=/opt/dtk/bin/hipcc
+cmake --build . -j16 --config Release --verbose
+
+./dtest --runall
+./dtest -d --test_dnn
+```
+
+Note that on windows your compiler might put the test executable in a subfolder called `Release`. If that's the case then you have to go to that folder before running the test.
+
+This library is licensed under the Boost Software License, which can be found in [dlib/LICENSE.txt](https://github.com/davisking/dlib/blob/master/dlib/LICENSE.txt). The long and
+short of the license is that you can use dlib however you like, even in closed source commercial software.
+
+## dlib sponsors
+
+This research is based in part upon work supported by the Office of the Director of National Intelligence (ODNI), Intelligence Advanced Research Projects Activity (IARPA) under
+contract number 2014-14071600010. The views and conclusions contained herein are those of the authors and should not be interpreted as necessarily representing the official
+policies or endorsements, either expressed or implied, of ODNI, IARPA, or the U.S. Government.
+

README_HIP.md

+# DLIB
+
+## 环境配置
+
+使用DCU编译之前，需要准备编译环境。参考
+[environment prepare](environment_prepare.md)
+
+## 使用源码安装
+
+### 编译环境准备（以dtk-23.04版本为例）
+
+- 拉取 apex 代码
+
+  ```
+  git clone -b dtk-23.04 http://developer.hpccube.com/codes/aicomponent/dlib.git
+  ```
+- 在[开发者社区](https://developer.hpccube.com/tool/#sdk) DCU Toolkit 中下载 DTK-23.04 解压至 /opt/ 路径下，并建立软链接
+
+  ```
+  cd /opt && ln -s dtk-23.04 dtk
+  ```
+
+- 导入环境变量以及安装必要依赖库
+
+  ```shell
+  source /opt/dtk/env.sh
+  ```
+
+### 编译安装
+
+#### 使用cmake编译
+
+```shell
+mkdir build; cd build; 
+cmake .. -DCMAKE_CXX_COMPILER=/opt/dtk/bin/hipcc
+
+cmake --build . -j16 #--verbose
+```
+
+#### 单元测试
+
+Running the unit test suite.
+Type the following to compile and run the dlib unit test suite:
+
+- 编译单元测试
+
+```shell
+cd dlib/test
+mkdir build
+cd build
+
+cmake .. -DCMAKE_CXX_COMPILER=/opt/dtk/bin/hipcc
+cmake --build . -j16 --config Release #--verbose
+```
+
+- 进行单元测试
+
+```shell
+./dtest --runall    # 全部测试
+./dtest -d --test_dnn    # 测试单个测试单元
+```
+
+#### 编译 dlib Python API
+
+```shell
+python setup.py install --set CMAKE_CXX_COMPILER=/opt/dtk/bin/hipcc
+```

dlib/LICENSE.txt

+Boost Software License - Version 1.0 - August 17th, 2003
+
+Permission is hereby granted, free of charge, to any person or organization
+obtaining a copy of the software and accompanying documentation covered by
+this license (the "Software") to use, reproduce, display, distribute,
+execute, and transmit the Software, and to prepare derivative works of the
+Software, and to permit third-parties to whom the Software is furnished to
+do so, all subject to the following:
+
+The copyright notices in the Software and this entire statement, including
+the above license grant, this restriction and the following disclaimer,
+must be included in all copies of the Software, in whole or in part, and
+all derivative works of the Software, unless such copies or derivative
+works are solely in the form of machine-executable object code generated by
+a source language processor.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE, TITLE AND NON-INFRINGEMENT. IN NO EVENT
+SHALL THE COPYRIGHT HOLDERS OR ANYONE DISTRIBUTING THE SOFTWARE BE LIABLE
+FOR ANY DAMAGES OR OTHER LIABILITY, WHETHER IN CONTRACT, TORT OR OTHERWISE,
+ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+DEALINGS IN THE SOFTWARE.
\ No newline at end of file

dlib/all/source.cpp

+// Copyright (C) 2006  Davis E. King (davis@dlib.net)
+// License: Boost Software License   See LICENSE.txt for the full license.
+#ifndef DLIB_ALL_SOURCe_
+#define DLIB_ALL_SOURCe_
+
+#if defined(DLIB_ALGs_) || defined(DLIB_PLATFORm_)
+#include "../dlib_basic_cpp_build_tutorial.txt"
+#endif
+
+// ISO C++ code
+#include "../base64/base64_kernel_1.cpp"
+#include "../bigint/bigint_kernel_1.cpp"
+#include "../bigint/bigint_kernel_2.cpp"
+#include "../bit_stream/bit_stream_kernel_1.cpp"
+#include "../entropy_decoder/entropy_decoder_kernel_1.cpp"
+#include "../entropy_decoder/entropy_decoder_kernel_2.cpp"
+#include "../entropy_encoder/entropy_encoder_kernel_1.cpp"
+#include "../entropy_encoder/entropy_encoder_kernel_2.cpp"
+#include "../md5/md5_kernel_1.cpp"
+#include "../tokenizer/tokenizer_kernel_1.cpp"
+#include "../unicode/unicode.cpp"
+#include "../test_for_odr_violations.cpp"
+
+
+
+
+#ifndef DLIB_ISO_CPP_ONLY
+// Code that depends on OS specific APIs
+
+// include this first so that it can disable the older version
+// of the winsock API when compiled in windows.
+#include "../sockets/sockets_kernel_1.cpp"
+#include "../bsp/bsp.cpp"
+
+#include "../dir_nav/dir_nav_kernel_1.cpp"
+#include "../dir_nav/dir_nav_kernel_2.cpp"
+#include "../dir_nav/dir_nav_extensions.cpp"
+#include "../linker/linker_kernel_1.cpp"
+#include "../logger/extra_logger_headers.cpp"
+#include "../logger/logger_kernel_1.cpp"
+#include "../logger/logger_config_file.cpp"
+#include "../misc_api/misc_api_kernel_1.cpp"
+#include "../misc_api/misc_api_kernel_2.cpp"
+#include "../sockets/sockets_extensions.cpp"
+#include "../sockets/sockets_kernel_2.cpp"
+#include "../sockstreambuf/sockstreambuf.cpp"
+#include "../sockstreambuf/sockstreambuf_unbuffered.cpp"
+#include "../server/server_kernel.cpp"
+#include "../server/server_iostream.cpp"
+#include "../server/server_http.cpp"
+#include "../threads/multithreaded_object_extension.cpp"
+#include "../threads/threaded_object_extension.cpp"
+#include "../threads/threads_kernel_1.cpp"
+#include "../threads/threads_kernel_2.cpp"
+#include "../threads/threads_kernel_shared.cpp"
+#include "../threads/thread_pool_extension.cpp"
+#include "../threads/async.cpp"
+#include "../timer/timer.cpp"
+#include "../stack_trace.cpp"
+
+#ifdef DLIB_PNG_SUPPORT
+#include "../image_loader/png_loader.cpp"
+#include "../image_saver/save_png.cpp"
+#endif
+
+#ifdef DLIB_JPEG_SUPPORT
+#include "../image_loader/jpeg_loader.cpp"
+#include "../image_saver/save_jpeg.cpp"
+#endif
+
+#ifndef DLIB_NO_GUI_SUPPORT
+#include "../gui_widgets/fonts.cpp"
+#include "../gui_widgets/widgets.cpp"
+#include "../gui_widgets/drawable.cpp"
+#include "../gui_widgets/canvas_drawing.cpp"
+#include "../gui_widgets/style.cpp"
+#include "../gui_widgets/base_widgets.cpp"
+#include "../gui_core/gui_core_kernel_1.cpp"
+#include "../gui_core/gui_core_kernel_2.cpp"
+#endif // DLIB_NO_GUI_SUPPORT
+
+#include "../rocm/cpu_dlib.cpp"
+#include "../rocm/tensor_tools.cpp"
+#include "../data_io/image_dataset_metadata.cpp"
+#include "../data_io/mnist.cpp"
+#include "../data_io/cifar.cpp"
+#include "../svm/auto.cpp"
+#include "../global_optimization/global_function_search.cpp"
+#include "../filtering/kalman_filter.cpp"
+
+#endif // DLIB_ISO_CPP_ONLY
+
+
+
+
+
+#define DLIB_ALL_SOURCE_END
+
+#endif // DLIB_ALL_SOURCe_
+

dlib/any.h

+// Copyright (C) 2010  Davis E. King (davis@dlib.net)
+// License: Boost Software License   See LICENSE.txt for the full license.
+#ifndef DLIB_AnY_
+#define DLIB_AnY_
+
+#include "any/any.h"
+#include "any/any_trainer.h"
+#include "any/any_decision_function.h"
+#include "any/any_function.h"
+
+#endif // DLIB_AnY_
+
+

dlib/any/any.h

+// Copyright (C) 2010  Davis E. King (davis@dlib.net)
+// License: Boost Software License   See LICENSE.txt for the full license.
+#ifndef DLIB_AnY_H_
+#define DLIB_AnY_H_
+
+#include "any_abstract.h"
+#include <memory>
+#include "storage.h"
+
+namespace dlib
+{
+// ----------------------------------------------------------------------------------------
+
+    class any
+    {
+    public:
+        any()                               = default;
+        any(const any& other)               = default;
+        any& operator=(const any& other)    = default;
+        any(any&& other)                    = default;
+        any& operator=(any&& other)         = default;
+
+        template<
+            typename T,
+            std::enable_if_t<!std::is_same<std::decay_t<T>, any>::value, bool> = true
+        >
+        any(T&& item)
+        : storage{std::forward<T>(item)}
+        {
+        }
+
+        template<
+            typename T,
+            typename T_ = std::decay_t<T>,
+            std::enable_if_t<!std::is_same<T_, any>::value, bool> = true
+        >
+        any& operator=(T&& item)
+        {
+            if (contains<T_>())
+                storage.unsafe_get<T_>() = std::forward<T>(item);
+            else
+                *this = std::move(any{std::forward<T>(item)});
+            return *this;
+        }
+
+        bool is_empty() const { return storage.is_empty(); }
+        void clear()          { storage.clear(); }
+        void swap (any& item) { std::swap(*this, item); }
+
+        template<typename T>      bool contains() const { return storage.contains<T>();}
+        template <typename T>       T& cast_to()        { return storage.cast_to<T>(); }
+        template <typename T> const T& cast_to() const  { return storage.cast_to<T>(); }
+        template <typename T>       T& get()            { return storage.get<T>(); }
+
+    private:
+        te::storage_heap storage;
+    };
+
+// ----------------------------------------------------------------------------------------
+
+    template <typename T> T& any_cast(any& a) { return a.cast_to<T>(); }
+    template <typename T> const T& any_cast(const any& a) { return a.cast_to<T>(); }
+
+// ----------------------------------------------------------------------------------------
+
+}
+
+
+#endif // DLIB_AnY_H_
+
+
+

dlib/any/any_abstract.h

+// Copyright (C) 2010  Davis E. King (davis@dlib.net)
+// License: Boost Software License   See LICENSE.txt for the full license.
+#undef DLIB_AnY_ABSTRACT_H_
+#ifdef DLIB_AnY_ABSTRACT_H_
+
+#include <typeinfo>
+
+namespace dlib
+{
+
+// ----------------------------------------------------------------------------------------
+
+    class bad_any_cast : public std::bad_cast 
+    {
+        /*!
+            WHAT THIS OBJECT REPRESENTS
+                This object is the exception class used by the any object.
+                It is used to indicate when someone attempts to cast an any
+                object into a type which isn't contained in the any object.
+        !*/
+
+    public:
+          virtual const char* what() const throw() { return "bad_any_cast"; }
+    };
+
+// ----------------------------------------------------------------------------------------
+
+    class any
+    {
+        /*!
+            INITIAL VALUE
+                - is_empty() == true
+                - for all T: contains<T>() == false
+
+            WHAT THIS OBJECT REPRESENTS
+                This object is basically a type-safe version of a void*.  In particular,
+                it is a container which can contain only one object but the object may
+                be of any type.  
+
+                It is somewhat like the type_safe_union except you don't have to declare 
+                the set of possible content types beforehand.  So in some sense this is 
+                like a less type-strict version of the type_safe_union.
+        !*/
+
+    public:
+
+        any(
+        );
+        /*!
+            ensures
+                - this object is properly initialized
+        !*/
+
+        any (
+            const any& item
+        );
+        /*!
+            ensures
+                - copies the state of item into *this.  
+                - Note that *this and item will contain independent copies of the
+                  contents of item.  That is, this function performs a deep
+                  copy and therefore does not result in *this containing
+                  any kind of reference to item.
+        !*/
+
+        any_function (
+            any_function&& item
+        );
+        /*!
+            ensures
+                - #item.is_empty() == true
+                - moves item into *this.
+        !*/
+
+        template < typename T >
+        any (
+            const T& item
+        );
+        /*!
+            ensures
+                - #contains<T>() == true
+                - #cast_to<T>() == item
+                  (i.e. a copy of item will be stored in *this)
+        !*/
+
+        void clear (
+        );
+        /*!
+            ensures
+                - #*this will have its default value.  I.e. #is_empty() == true
+        !*/
+
+        template <typename T>
+        bool contains (
+        ) const;
+        /*!
+            ensures
+                - if (this object currently contains an object of type T) then
+                    - returns true
+                - else
+                    - returns false
+        !*/
+
+        bool is_empty(
+        ) const;
+        /*!
+            ensures
+                - if (this object contains any kind of object) then
+                    - returns false 
+                - else
+                    - returns true 
+        !*/
+
+        template <typename T>
+        T& cast_to(
+        );
+        /*!
+            ensures
+                - if (contains<T>() == true) then
+                    - returns a non-const reference to the object contained within *this
+                - else
+                    - throws bad_any_cast
+        !*/
+
+        template <typename T>
+        const T& cast_to(
+        ) const;
+        /*!
+            ensures
+                - if (contains<T>() == true) then
+                    - returns a const reference to the object contained within *this
+                - else
+                    - throws bad_any_cast
+        !*/
+
+        template <typename T>
+        T& get(
+        );
+        /*!
+            ensures
+                - #is_empty() == false
+                - #contains<T>() == true
+                - if (contains<T>() == true)
+                    - returns a non-const reference to the object contained in *this.
+                - else
+                    - Constructs an object of type T inside *this
+                    - Any previous object stored in this any object is destructed and its
+                      state is lost.
+                    - returns a non-const reference to the newly created T object.
+        !*/
+
+        any& operator= (
+            const any& item
+        );
+        /*!
+            ensures
+                - copies the state of item into *this.  
+                - Note that *this and item will contain independent copies of the
+                  contents of item.  That is, this function performs a deep
+                  copy and therefore does not result in *this containing
+                  any kind of reference to item.
+        !*/
+
+        void swap (
+            any& item
+        );
+        /*!
+            ensures
+                - swaps *this and item
+                - does not invalidate pointers or references to the object contained 
+                  inside *this or item.  Moreover, a pointer or reference to the object in 
+                  *this will now refer to the contents of #item and vice versa.
+        !*/
+
+    };
+
+// ----------------------------------------------------------------------------------------
+
+    template <
+        typename T
+        > 
+    T& any_cast(
+        any& a
+    ) { return a.cast_to<T>(); }
+    /*!
+        ensures
+            - returns a.cast_to<T>()
+    !*/
+
+// ----------------------------------------------------------------------------------------
+
+    template <
+        typename T
+        > 
+    const T& any_cast(
+        const any& a
+    ) { return a.cast_to<T>(); }
+    /*!
+        ensures
+            - returns a.cast_to<T>()
+    !*/
+
+// ----------------------------------------------------------------------------------------
+
+}
+
+#endif // DLIB_AnY_ABSTRACT_H_
+
+

dlib/any/any_decision_function.h

+// Copyright (C) 2010  Davis E. King (davis@dlib.net)
+// License: Boost Software License   See LICENSE.txt for the full license.
+#ifndef DLIB_AnY_DECISION_FUNCTION_Hh_
+#define DLIB_AnY_DECISION_FUNCTION_Hh_
+
+#include "any_decision_function_abstract.h"
+#include "any_function.h"
+#include "../algs.h"
+
+namespace dlib
+{
+
+// ----------------------------------------------------------------------------------------
+
+    template <class sample_type, class result_type = double>
+    using any_decision_function = any_function<result_type(const sample_type&)>;
+
+// ----------------------------------------------------------------------------------------
+
+}
+
+
+#endif // DLIB_AnY_DECISION_FUNCTION_Hh_

dlib/any/any_decision_function_abstract.h

+// Copyright (C) 2010  Davis E. King (davis@dlib.net)
+// License: Boost Software License   See LICENSE.txt for the full license.
+#undef DLIB_AnY_DECISION_FUNCTION_ABSTRACT_H_
+#ifdef DLIB_AnY_DECISION_FUNCTION_ABSTRACT_H_
+
+#include "any_function_abstract.h"
+#include "../algs.h"
+
+namespace dlib
+{
+
+// ----------------------------------------------------------------------------------------
+
+    template <class sample_type, class result_type = double>
+    using any_decision_function = any_function<result_type(const sample_type&)>;
+
+// ----------------------------------------------------------------------------------------
+
+}
+
+#endif // DLIB_AnY_DECISION_FUNCTION_ABSTRACT_H_
+
+
+

dlib/any/any_function.h

+// Copyright (C) 2011  Davis E. King (davis@dlib.net)
+// License: Boost Software License   See LICENSE.txt for the full license.
+#ifndef DLIB_AnY_FUNCTION_Hh_
+#define DLIB_AnY_FUNCTION_Hh_
+
+#include "../assert.h"
+#include "../functional.h"
+#include "any.h"
+#include "any_function_abstract.h"
+
+namespace dlib
+{
+
+// ----------------------------------------------------------------------------------------
+
+    template <
+        class Storage, 
+        class F
+    > 
+    class any_function_basic;
+
+    template <
+        class Storage,
+        class R, 
+        class... Args
+    > 
+    class any_function_basic<Storage, R(Args...)> 
+    {
+    private:
+        template<class F>
+        using is_valid = std::enable_if_t<!std::is_same<std::decay_t<F>, any_function_basic>::value &&
+                                          dlib::is_invocable_r<R, F, Args...>::value,
+                                          bool>;
+
+        template<typename Func>
+        static auto make_invoker()
+        {
+            return [](void* self, Args... args) -> R {
+                return dlib::invoke(*reinterpret_cast<std::add_pointer_t<Func>>(self),
+                                    std::forward<Args>(args)...);
+            };
+        }
+
+        Storage str;
+        R (*func)(void*, Args...) = nullptr;
+
+    public:
+
+        using result_type = R;
+        
+        constexpr any_function_basic(std::nullptr_t) noexcept {}
+        constexpr any_function_basic()                                              = default;
+        constexpr any_function_basic(const any_function_basic& other)               = default;
+        constexpr any_function_basic& operator=(const any_function_basic& other)    = default;
+
+        constexpr any_function_basic(any_function_basic&& other) 
+        :   str{std::move(other.str)}, 
+            func{std::exchange(other.func, nullptr)} 
+        {
+        }
+
+        constexpr any_function_basic& operator=(any_function_basic&& other)
+        {
+            if (this != &other)
+            {
+                str     = std::move(other.str);
+                func    = std::exchange(other.func, nullptr);
+            }
+
+            return *this;
+        }
+
+        template<class F, is_valid<F> = true>
+        any_function_basic(
+            F&& f
+        ) : str{std::forward<F>(f)},
+            func{make_invoker<F&&>()}
+        {
+        }
+
+        template<class F, is_valid<F> = true>
+        any_function_basic(
+            F* f
+        ) : str{f},
+            func{make_invoker<F*>()}
+        {
+        }
+
+        R operator()(Args... args) const {
+            return func(const_cast<void*>(str.get_ptr()), std::forward<Args>(args)...);
+        }
+
+        void clear()                            { str.clear(); }
+        void swap (any_function_basic& item)    { std::swap(*this, item); }
+        bool is_empty()          const noexcept { return str.is_empty() || func == nullptr; }
+        bool is_set()            const noexcept { return !is_empty(); }
+        explicit operator bool() const noexcept { return is_set(); }
+
+        template <typename T>     bool contains() const { return str.template contains<T>();}
+        template <typename T>       T& cast_to()        { return str.template cast_to<T>(); }
+        template <typename T> const T& cast_to() const  { return str.template cast_to<T>(); }
+        template <typename T>       T& get()            { return str.template get<T>(); }
+    };
+
+// ----------------------------------------------------------------------------------------
+
+    template <class T, class Storage, class F> 
+    T& any_cast(any_function_basic<Storage, F>& a) { return a.template cast_to<T>(); }
+
+    template <class T, class Storage, class F> 
+    const T& any_cast(const any_function_basic<Storage, F>& a) { return a.template cast_to<T>(); }
+
+// ----------------------------------------------------------------------------------------
+
+    template <class F> 
+    using any_function = any_function_basic<te::storage_sbo<16>, F>;
+
+    template <class F> 
+    using any_function_view = any_function_basic<te::storage_view, F>;
+
+// ----------------------------------------------------------------------------------------
+
+}
+
+#endif // DLIB_AnY_FUNCTION_Hh_
+

dlib/any/any_function_abstract.h

+// Copyright (C) 2011  Davis E. King (davis@dlib.net)
+// License: Boost Software License   See LICENSE.txt for the full license.
+#undef DLIB_AnY_FUNCTION_ABSTRACT_H_
+#ifdef DLIB_AnY_FUNCTION_ABSTRACT_H_
+
+#include "any_abstract.h"
+#include "../algs.h"
+
+namespace dlib
+{
+
+// ----------------------------------------------------------------------------------------
+
+    template <
+        class Storage, 
+        typename function_type
+        >
+    class any_function_basic
+    {
+        /*!
+            REQUIREMENTS ON Storage
+                This must be one of the storage types from dlib/any/storage.hh
+                E.g. storage_heap, storage_stack, etc.
+
+                It determines the method by which any_function_basic holds onto the function it uses.
+
+            REQUIREMENTS ON function_type
+                This type should be a function signature.  Some examples are:
+                    void (int,int)  // a function returning nothing and taking two ints
+                    void ()         // a function returning nothing and taking no arguments
+                    char (double&)  // a function returning a char and taking a reference to a double
+
+                The number of arguments in the function must be no greater than 10.
+
+            INITIAL VALUE
+                - is_empty() == true
+                - for all T: contains<T>() == false
+
+            WHAT THIS OBJECT REPRESENTS
+                This object is a version of dlib::any that is restricted to containing 
+                elements which are some kind of function object with an operator() which
+                matches the function signature defined by function_type.
+
+
+                Here is an example:
+                    #include <iostream>
+                    #include <string>
+                    #include "dlib/any.h"
+                    using namespace std;
+                    void print_message(string str) { cout << str << endl; }
+
+                    int main()
+                    {
+                        dlib::any_function<void(string)> f;
+                        f = print_message;
+                        f("hello world"); // calls print_message("hello world")
+                    }
+
+                Note that any_function_basic objects can be used to store general function 
+                objects (i.e. defined by a class with an overloaded operator()) in
+                addition to regular global functions.  
+        !*/
+
+    public:
+
+        // This is the type of object returned by function_type functions.
+        typedef result_type_for_function_type result_type;
+
+        any_function_basic(
+        );
+        /*!
+            ensures
+                - this object is properly initialized
+        !*/
+
+        any_function_basic (
+            const any_function_basic& item
+        );
+        /*!
+            ensures
+                - copies the state of item into *this.  
+                - Note that *this and item will contain independent copies of the
+                  contents of item.  That is, this function performs a deep
+                  copy and therefore does not result in *this containing
+                  any kind of reference to item.
+        !*/
+
+        any_function_basic (
+            any_function_basic&& item
+        );
+        /*!
+            ensures
+                - moves item into *this.
+                - The exact move semantics are determined by which Storage type is used.  E.g. 
+                  storage_heap will result in #item.is_empty()==true but storage_view would result
+                  in #item.is_empty() == false
+        !*/
+
+        template < typename Funct >
+        any_function_basic (
+            Funct&& funct 
+        );
+        /*!
+            ensures
+                - #contains<T>() == true
+                - #cast_to<T>() == item
+                  (i.e. calling operator() will invoke funct())
+        !*/
+
+        void clear (
+        );
+        /*!
+            ensures
+                - #*this will have its default value.  I.e. #is_empty() == true
+        !*/
+
+        template <typename T>
+        bool contains (
+        ) const;
+        /*!
+            ensures
+                - if (this object currently contains an object of type T) then
+                    - returns true
+                - else
+                    - returns false
+        !*/
+
+        bool is_empty(
+        ) const;
+        /*!
+            ensures
+                - if (this object contains any kind of object) then
+                    - returns false 
+                - else
+                    - returns true 
+        !*/
+
+        bool is_set (
+        ) const;
+        /*!
+            ensures
+                - returns !is_empty()
+        !*/
+
+        explicit operator bool(
+        ) const;
+        /*!
+            ensures
+                - returns is_set()
+        !*/
+
+        result_type operator(Args... args) (
+        ) const;
+        /*!
+            requires
+                - is_empty() == false
+                - the signature defined by function_type takes no arguments
+            ensures
+                - Let F denote the function object contained within *this.  Then
+                  this function performs:
+                    return F(std::forward<Args>(args)...)
+        !*/
+
+        template <typename T>
+        T& cast_to(
+        );
+        /*!
+            ensures
+                - if (contains<T>() == true) then
+                    - returns a non-const reference to the object contained within *this
+                - else
+                    - throws bad_any_cast
+        !*/
+
+        template <typename T>
+        const T& cast_to(
+        ) const;
+        /*!
+            ensures
+                - if (contains<T>() == true) then
+                    - returns a const reference to the object contained within *this
+                - else
+                    - throws bad_any_cast
+        !*/
+
+        template <typename T>
+        T& get(
+        );
+        /*!
+            ensures
+                - #is_empty() == false
+                - #contains<T>() == true
+                - if (contains<T>() == true)
+                    - returns a non-const reference to the object contained in *this.
+                - else
+                    - Constructs an object of type T inside *this
+                    - Any previous object stored in this any_function_basic object is destructed and its
+                      state is lost.
+                    - returns a non-const reference to the newly created T object.
+        !*/
+
+        any_function_basic& operator= (
+            const any_function_basic& item
+        );
+        /*!
+            ensures
+                - copies the state of item into *this.  
+                - Note that the type of copy is determined by the Storage template argument.  E.g.
+                  storage_sbo will result in a deep copy, while storage_view would result in *this
+                  and item referring to the same underlying function.
+        !*/
+
+        void swap (
+            any_function_basic& item
+        );
+        /*!
+            ensures
+                - swaps *this and item
+        !*/
+
+    };
+
+// ----------------------------------------------------------------------------------------
+
+    template <
+        typename T,
+        typename function_type
+        > 
+    T& any_cast(
+        any_function_basic<function_type>& a
+    ) { return a.cast_to<T>(); }
+    /*!
+        ensures
+            - returns a.cast_to<T>()
+    !*/
+
+// ----------------------------------------------------------------------------------------
+
+    template <
+        typename T,
+        typename function_type
+        > 
+    const T& any_cast(
+        const any_function_basic<function_type>& a
+    ) { return a.cast_to<T>(); }
+    /*!
+        ensures
+            - returns a.cast_to<T>()
+    !*/
+
+// ----------------------------------------------------------------------------------------
+
+    /*!A any_function
+
+        A version of any_function_basic (defined above) that owns the function it contains.  Uses
+        the small buffer optimization to make working with small lambdas faster.
+    !*/
+    template <class F> 
+    using any_function = any_function_basic<te::storage_sbo<16>, F>;
+
+    /*!A any_function_view
+
+        A version of any_function_basic (defined above) that *DOES NOT* own the function it
+        contains.  It merely holds a pointer to the function given to its constructor. 
+    !*/
+    template <class F> 
+    using any_function_view = any_function_basic<te::storage_view, F>;
+
+// ----------------------------------------------------------------------------------------
+
+}
+
+#endif // DLIB_AnY_FUNCTION_ABSTRACT_H_
+

dlib/any/any_trainer.h

+// Copyright (C) 2010  Davis E. King (davis@dlib.net)
+// License: Boost Software License   See LICENSE.txt for the full license.
+#ifndef DLIB_AnY_TRAINER_H_
+#define DLIB_AnY_TRAINER_H_
+
+#include "any.h"
+#include "any_decision_function.h"
+#include "any_trainer_abstract.h"
+#include <vector>
+
+namespace dlib
+{
+
+// ----------------------------------------------------------------------------------------
+
+    template <
+        typename sample_type_,
+        typename scalar_type_ = double
+    >
+    class any_trainer
+    {
+    public:
+        using sample_type = sample_type_;
+        using scalar_type = scalar_type_;
+        using mem_manager_type = default_memory_manager;
+        using trained_function_type = any_decision_function<sample_type, scalar_type>;
+
+        any_trainer()                                       = default;
+        any_trainer(const any_trainer& other)               = default;
+        any_trainer& operator=(const any_trainer& other)    = default;
+        any_trainer(any_trainer&& other)                    = default;
+        any_trainer& operator=(any_trainer&& other)         = default;
+
+        template <
+            class T,
+            class T_ = std::decay_t<T>,
+            std::enable_if_t<!std::is_same<T_,any_trainer>::value, bool> = true
+        >
+        any_trainer (
+            T&& item
+        ) : storage{std::forward<T>(item)},
+            train_func{[](
+                const void* ptr,
+                const std::vector<sample_type>& samples,
+                const std::vector<scalar_type>& labels
+            ) -> trained_function_type {
+                const T_& f = *reinterpret_cast<const T_*>(ptr);
+                return f.train(samples, labels);
+            }}
+        {
+        }
+
+        template <
+            class T,
+            class T_ = std::decay_t<T>,
+            std::enable_if_t<!std::is_same<T_,any_trainer>::value, bool> = true
+        >
+        any_trainer& operator= (
+            T&& item
+        )
+        {
+            if (contains<T_>())
+                storage.unsafe_get<T_>() = std::forward<T>(item);
+            else
+                *this = std::move(any_trainer{std::forward<T>(item)});
+            return *this;
+        }
+
+        trained_function_type train (
+            const std::vector<sample_type>& samples,
+            const std::vector<scalar_type>& labels
+        ) const
+        {
+            // make sure requires clause is not broken
+            DLIB_ASSERT(is_empty() == false,
+                "\t trained_function_type any_trainer::train()"
+                << "\n\t You can't call train() on an empty any_trainer"
+                << "\n\t this: " << this
+                );
+
+            return train_func(storage.get_ptr(), samples, labels);
+        }
+
+        bool is_empty() const { return storage.is_empty(); }
+        void clear()          { storage.clear(); }
+        void swap (any_trainer& item) { std::swap(*this, item); }
+
+        template <typename T>     bool contains() const { return storage.contains<T>();}
+        template <typename T>       T& cast_to()        { return storage.cast_to<T>(); }
+        template <typename T> const T& cast_to() const  { return storage.cast_to<T>(); }
+        template <typename T>       T& get()            { return storage.get<T>(); }
+
+    private:
+        te::storage_heap storage;
+        trained_function_type (*train_func) (
+            const void* self,
+            const std::vector<sample_type>& samples,
+            const std::vector<scalar_type>& labels
+        ) = nullptr;
+    };
+
+// ----------------------------------------------------------------------------------------
+
+    template <typename T, typename U, typename V> 
+    T& any_cast(any_trainer<U,V>& a) { return a.template cast_to<T>(); }
+
+    template <typename T, typename U, typename V> 
+    const T& any_cast(const any_trainer<U,V>& a) { return a.template cast_to<T>(); }
+
+// ----------------------------------------------------------------------------------------
+
+}
+
+
+#endif // DLIB_AnY_TRAINER_H_
+
+
+
+

dlib/any/any_trainer_abstract.h

+// Copyright (C) 2010  Davis E. King (davis@dlib.net)
+// License: Boost Software License   See LICENSE.txt for the full license.
+#undef DLIB_AnY_TRAINER_ABSTRACT_H_
+#ifdef DLIB_AnY_TRAINER_ABSTRACT_H_
+
+#include "any_abstract.h"
+#include "../algs.h"
+#include "any_decision_function_abstract.h"
+#include <vector>
+
+namespace dlib
+{
+
+// ----------------------------------------------------------------------------------------
+
+    template <
+        typename sample_type_,
+        typename scalar_type_ = double
+        >
+    class any_trainer
+    {
+        /*!
+            INITIAL VALUE
+                - is_empty() == true
+                - for all T: contains<T>() == false
+
+            WHAT THIS OBJECT REPRESENTS
+                This object is a version of dlib::any that is restricted to containing 
+                elements which are some kind of object with a .train() method compatible 
+                with the following signature: 
+
+                    decision_function train(
+                        const std::vector<sample_type>& samples,
+                        const std::vector<scalar_type>& labels
+                    ) const
+
+                    Where decision_function is a type capable of being stored in an
+                    any_decision_function<sample_type,scalar_type> object.
+
+                any_trainer is intended to be used to contain objects such as the svm_nu_trainer
+                and other similar types which represent supervised machine learning algorithms.   
+                It allows you to write code which contains and processes these trainer objects 
+                without needing to know the specific types of trainer objects used.
+        !*/
+
+    public:
+
+        typedef sample_type_ sample_type;
+        typedef scalar_type_ scalar_type;
+        typedef default_memory_manager mem_manager_type;
+        typedef any_decision_function<sample_type, scalar_type> trained_function_type;
+
+        any_trainer(
+        );
+        /*!
+            ensures
+                - this object is properly initialized
+        !*/
+
+        any_trainer (
+            const any_trainer& item
+        );
+        /*!
+            ensures
+                - copies the state of item into *this.  
+                - Note that *this and item will contain independent copies of the
+                  contents of item.  That is, this function performs a deep
+                  copy and therefore does not result in *this containing
+                  any kind of reference to item.
+        !*/
+
+        any_trainer (
+            any_trainer&& item
+        );
+        /*!
+            ensures
+                - #item.is_empty() == true
+                - moves item into *this.
+        !*/
+
+        template < typename T >
+        any_trainer (
+            const T& item
+        );
+        /*!
+            ensures
+                - #contains<T>() == true
+                - #cast_to<T>() == item
+                  (i.e. a copy of item will be stored in *this)
+        !*/
+
+        void clear (
+        );
+        /*!
+            ensures
+                - #*this will have its default value.  I.e. #is_empty() == true
+        !*/
+
+        template <typename T>
+        bool contains (
+        ) const;
+        /*!
+            ensures
+                - if (this object currently contains an object of type T) then
+                    - returns true
+                - else
+                    - returns false
+        !*/
+
+        bool is_empty(
+        ) const;
+        /*!
+            ensures
+                - if (this object contains any kind of object) then
+                    - returns false 
+                - else
+                    - returns true
+        !*/
+
+        trained_function_type train (
+            const std::vector<sample_type>& samples,
+            const std::vector<scalar_type>& labels
+        ) const
+        /*!
+            requires
+                - is_empty() == false
+            ensures
+                - Let TRAINER denote the object contained within *this.  Then
+                  this function performs:
+                    return TRAINER.train(samples, labels)
+        !*/
+
+        template <typename T>
+        T& cast_to(
+        );
+        /*!
+            ensures
+                - if (contains<T>() == true) then
+                    - returns a non-const reference to the object contained within *this
+                - else
+                    - throws bad_any_cast
+        !*/
+
+        template <typename T>
+        const T& cast_to(
+        ) const;
+        /*!
+            ensures
+                - if (contains<T>() == true) then
+                    - returns a const reference to the object contained within *this
+                - else
+                    - throws bad_any_cast
+        !*/
+
+        template <typename T>
+        T& get(
+        );
+        /*!
+            ensures
+                - #is_empty() == false
+                - #contains<T>() == true
+                - if (contains<T>() == true)
+                    - returns a non-const reference to the object contained in *this.
+                - else
+                    - Constructs an object of type T inside *this
+                    - Any previous object stored in this any_trainer object is destructed and its
+                      state is lost.
+                    - returns a non-const reference to the newly created T object.
+        !*/
+
+        any_trainer& operator= (
+            const any_trainer& item
+        );
+        /*!
+            ensures
+                - copies the state of item into *this.  
+                - Note that *this and item will contain independent copies of the
+                  contents of item.  That is, this function performs a deep
+                  copy and therefore does not result in *this containing
+                  any kind of reference to item.
+        !*/
+
+        void swap (
+            any_trainer& item
+        );
+        /*!
+            ensures
+                - swaps *this and item
+        !*/
+
+    };
+
+// ----------------------------------------------------------------------------------------
+
+    template <
+        typename sample_type,
+        typename scalar_type
+        >
+    inline void swap (
+        any_trainer<sample_type,scalar_type>& a,
+        any_trainer<sample_type,scalar_type>& b
+    ) { a.swap(b); }
+    /*!
+        provides a global swap function
+    !*/
+
+// ----------------------------------------------------------------------------------------
+
+    template <
+        typename T,
+        typename sample_type,
+        typename scalar_type
+        > 
+    T& any_cast(
+        any_trainer<sample_type,scalar_type>& a
+    ) { return a.cast_to<T>(); }
+    /*!
+        ensures
+            - returns a.cast_to<T>()
+    !*/
+
+// ----------------------------------------------------------------------------------------
+
+    template <
+        typename T,
+        typename sample_type,
+        typename scalar_type
+        > 
+    const T& any_cast(
+        const any_trainer<sample_type,scalar_type>& a
+    ) { return a.cast_to<T>(); }
+    /*!
+        ensures
+            - returns a.cast_to<T>()
+    !*/
+
+// ----------------------------------------------------------------------------------------
+
+}
+
+#endif // DLIB_AnY_TRAINER_ABSTRACT_H_
+
+

dlib/array.h

+// Copyright (C) 2003  Davis E. King (davis@dlib.net)
+// License: Boost Software License   See LICENSE.txt for the full license.
+#ifndef DLIB_ARRAy_
+#define DLIB_ARRAy_
+
+#include "array/array_kernel.h"
+#include "array/array_tools.h"
+
+#endif // DLIB_ARRAy_
+