Upload folder using huggingface_hub

dlibs/CMakeLists.txt

@@ -0,0 +1,37 @@
+cmake_minimum_required(VERSION 2.8.12)
+
+project(dlib_project)
+
+
+
+#############################################################################
+#                                                                           #
+#  READ examples/CMakeLists.txt TO SEE HOW TO USE DLIB FROM C++ WITH CMAKE  #
+#                                                                           #
+#############################################################################
+
+
+
+
+
+get_directory_property(has_parent PARENT_DIRECTORY)
+if(NOT has_parent)
+   # When you call add_subdirectory(dlib) from a parent CMake project dlib's
+   # CMake scripts will assume you want to statically compile dlib into
+   # whatever you are building rather than create a standalone copy of dlib.
+   # This means CMake will build dlib as a static library, disable dlib's
+   # install targets so they don't clutter your project, and adjust a few other
+   # minor things that are convenient when statically building dlib as part of
+   # your own projects.
+   #
+   # On the other hand, if there is no parent CMake project or if
+   # DLIB_IN_PROJECT_BUILD is set to false, CMake will compile dlib as a normal
+   # standalone library (either shared or static, based on the state of CMake's
+   # BUILD_SHARED_LIBS flag), and include the usual install targets so you can
+   # install dlib on your computer via `make install`.  Since the only reason
+   # to build this CMakeLists.txt (the one you are reading right now) by itself
+   # is if you want to install dlib, we indicate as such by setting
+   # DLIB_IN_PROJECT_BUILD to false.
+   set(DLIB_IN_PROJECT_BUILD false)
+endif()
+add_subdirectory(dlib)

dlibs/ISSUE_TEMPLATE.md

@@ -0,0 +1,31 @@
+IF YOU ARE REPORTING A BUG OR PROBLEM WITH DLIB THEN FILL OUT THE ENTIRE TEMPLATE BELOW.  ISSUES ASKING QUESTIONS ABOUT WHY SOMETHING DOESN'T WORK THAT FAIL TO FILL OUT THE ENTIRE TEMPLATE WILL BE CLOSED.
+
+It is OK to suggest interesting improvements to dlib, even if you are not volunteering to implement them.  **However, the issue tracker is not a code writing service, do not ask for someone to write code for you.**  E.g. Do not ask for feature improvements to the example programs. **If there is some feature improvement you want in an example program then it's up to you to write it**.  
+
+Before you ask a question, check Google for a solution, [the dlib FAQ](http://dlib.net/faq.html), or consult the dlib documentation.  Every single function in dlib is documented in detail.  If you obviously haven't read the documentation your issue will be closed.  
+
+If you aren't reporting a bug or problem with dlib then delete this template and write whatever you want here.
+ 
+<!-- ================================================================== -->
+<!-- ==================  BUG/PROBLEM REPORT TEMPLATE ================== -->
+<!-- ================================================================== -->
+
+
+<!-- Delete the above instructions and then provide a general summary of the issue in the Title above.  Then fill out the template below.  FAILURE TO FILL OUT EVERY PART WILL RESULT IN YOUR ISSUE BEING CLOSED -->
+
+## Expected Behavior
+<!--- Tell us what should happen.  What were you doing?  What part of dlib are you using?  What do you think should happen? -->
+
+## Current Behavior
+<!--- Tell us what happens instead of the expected behavior.  If you get an error, include the entire error message in the bug report.  DO NOT POST SCREEN SHOTS.  Paste in the text instead.   If the issue is some kind of build problem, include the entire CMake output along with the error message. -->
+
+## Steps to Reproduce
+<!--- Provide an unambiguous set of steps to reproduce this problem.  What exactly do I have to type to reproduce your error?  If you don't post complete instructions you are much less likely to get help. -->
+
+
+
+* **Version**: <!-- What version of dlib? -->
+* **Where did you get dlib**: <!-- Did you get it from an official source like dlib.net, this github repo, or somewhere else? -->
+* **Platform**: <!-- include something like `lsb_release -a` output, or if Windows, version and 32-bit or
+  64-bit -->
+* **Compiler**: <!-- What compiler are you using?  What version of that compiler? -->

dlibs/LICENSE.txt

@@ -0,0 +1,23 @@
+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.

dlibs/MANIFEST.in

@@ -0,0 +1,17 @@
+#
+# 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/test

dlibs/README.md

@@ -0,0 +1,70 @@
+# dlib C++ library [![Travis Status](https://travis-ci.org/davisking/dlib.svg?branch=master)](https://travis-ci.org/davisking/dlib)
+
+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:
+
+```bash
+mkdir build; cd build; cmake .. ; cmake --build .
+```
+
+That will build all the examples.
+If you have a CPU that supports AVX instructions then turn them on like this:
+
+```bash
+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:
+```bash
+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).
+
+Alternatively, if you are using the [vcpkg](https://github.com/Microsoft/vcpkg/) dependency manager you can download and install dlib with CMake integration in a single command:
+```bash
+vcpkg install dlib
+```
+
+## Compiling dlib Python API
+
+Before you can run the Python example programs you must compile dlib. Type:
+
+```bash
+python setup.py install
+```
+
+
+## Running the unit test suite
+
+Type the following to compile and run the dlib unit test suite:
+
+```bash
+cd dlib/test
+mkdir build
+cd build
+cmake ..
+cmake --build . --config Release
+./dtest --runall
+```
+
+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.
+
+Version: 19.22
+Date:    Sun Mar 28 09:22:07 EDT 2021
+Mercurial Revision ID: f152a78a56bce7a6603a247bea96f353e0662e63

dlibs/dlib/CMakeLists.txt

@@ -0,0 +1,1001 @@
+#
+# This is a CMake makefile.  You can find the cmake utility and
+# information about it at http://www.cmake.org
+#
+
+
+cmake_minimum_required(VERSION 2.8.12)
+
+set(CMAKE_DISABLE_SOURCE_CHANGES ON)
+set(CMAKE_DISABLE_IN_SOURCE_BUILD ON)
+
+if(POLICY CMP0048)
+   cmake_policy(SET CMP0048 NEW)
+endif()
+if(POLICY CMP0077)
+   cmake_policy(SET CMP0077 NEW)
+endif()
+
+project(dlib)
+
+set(CPACK_PACKAGE_NAME "dlib")
+set(CPACK_PACKAGE_VERSION_MAJOR "19")
+set(CPACK_PACKAGE_VERSION_MINOR "22")
+set(CPACK_PACKAGE_VERSION_PATCH "0")
+set(VERSION ${CPACK_PACKAGE_VERSION_MAJOR}.${CPACK_PACKAGE_VERSION_MINOR}.${CPACK_PACKAGE_VERSION_PATCH})
+# Only print these messages once, even if dlib is added multiple times via add_subdirectory()
+if (NOT TARGET dlib)
+   message(STATUS "Using CMake version: ${CMAKE_VERSION}")
+   message(STATUS "Compiling dlib version: ${VERSION}")
+endif()
+
+
+include(cmake_utils/set_compiler_specific_options.cmake)
+
+
+# Adhere to GNU filesystem layout conventions
+include(GNUInstallDirs)
+
+if (POLICY CMP0063)
+   # This policy tells cmake to really honor CXX_VISIBILITY_PRESET rather than
+   # ignore it for backwards compatibility.
+   cmake_policy(SET CMP0063 NEW)
+endif()
+if (POLICY CMP0075)
+   cmake_policy(SET CMP0075 NEW)
+endif()
+
+# default to a Release build (except if CMAKE_BUILD_TYPE is set)
+include(cmake_utils/release_build_by_default)
+include(cmake_utils/use_cpp_11.cmake)
+
+# Set DLIB_VERSION in the including CMake file so they can use it to do whatever they want. 
+get_directory_property(has_parent PARENT_DIRECTORY)
+if(has_parent)
+   set(DLIB_VERSION ${VERSION} PARENT_SCOPE)
+   if (NOT DEFINED DLIB_IN_PROJECT_BUILD)
+      set(DLIB_IN_PROJECT_BUILD true)
+   endif()
+endif()
+
+if (COMMAND pybind11_add_module AND MSVC)
+   # True when building a python extension module using Visual Studio.  We care
+   # about this because a huge number of windows users have broken systems, and
+   # in particular, they have broken or incompatibly installed copies of things
+   # like libjpeg or libpng.  So if we detect we are in this mode we will never
+   # ever link to those libraries.  Instead, we link to the copy included with
+   # dlib.
+   set (BUILDING_PYTHON_IN_MSVC true)
+else()
+   set (BUILDING_PYTHON_IN_MSVC false)
+endif()
+
+if (DLIB_IN_PROJECT_BUILD)
+
+   # Check if we are being built as part of a pybind11 module. 
+   if (COMMAND pybind11_add_module)
+      set(CMAKE_POSITION_INDEPENDENT_CODE True)
+      if (CMAKE_COMPILER_IS_GNUCXX)
+         # Just setting CMAKE_POSITION_INDEPENDENT_CODE should be enough to set
+         # -fPIC for GCC but sometimes it still doesn't get set, so make sure it
+         # does.
+         add_definitions("-fPIC")
+      endif()
+      # Make DLIB_ASSERT statements not abort the python interpreter, but just return an error.
+      list(APPEND active_preprocessor_switches "-DDLIB_NO_ABORT_ON_2ND_FATAL_ERROR")
+   endif()
+
+   # DLIB_IN_PROJECT_BUILD==true means you are using dlib by invoking
+   # add_subdirectory(dlib) in the parent project. In this case, we always want
+   # to build dlib as a static library so the parent project doesn't need to
+   # deal with some random dlib shared library file.  It is much better to
+   # statically compile dlib into the parent project.  So the following bit of
+   # CMake ensures that happens.  However, we have to take care to compile dlib
+   # with position independent code if appropriate (i.e. if the parent project
+   # is a shared library).
+   if (BUILD_SHARED_LIBS)
+      if (CMAKE_COMPILER_IS_GNUCXX)
+         # Just setting CMAKE_POSITION_INDEPENDENT_CODE should be enough to set
+         # -fPIC for GCC but sometimes it still doesn't get set, so make sure it
+         # does.
+         add_definitions("-fPIC")
+      endif()
+      set(CMAKE_POSITION_INDEPENDENT_CODE true)
+   endif()
+
+   # Tell cmake to build dlib as a static library
+   set(BUILD_SHARED_LIBS false)
+
+elseif(BUILD_SHARED_LIBS)
+   if (MSVC)
+      message(FATAL_ERROR "Building dlib as a standalone dll is not supported when using Visual Studio.  You are highly encouraged to use static linking instead.  See https://github.com/davisking/dlib/issues/1483 for a discussion.") 
+   endif()
+endif()
+
+
+if (CMAKE_VERSION VERSION_LESS "3.9.0")
+   # Set only because there are old target_link_libraries() statements in the
+   # FindCUDA.cmake file that comes with CMake that error out if the new behavior
+   # is used.  In newer versions of CMake we can instead set CUDA_LINK_LIBRARIES_KEYWORD which fixes this issue.
+   cmake_policy(SET CMP0023 OLD)
+else()
+   set(CUDA_LINK_LIBRARIES_KEYWORD PUBLIC)
+endif()
+
+
+macro (enable_preprocessor_switch option_name)
+   list(APPEND active_preprocessor_switches "-D${option_name}")
+endmacro()
+
+macro (disable_preprocessor_switch option_name)
+   if (active_preprocessor_switches)
+      list(REMOVE_ITEM active_preprocessor_switches "-D${option_name}")
+   endif()
+endmacro()
+
+macro (toggle_preprocessor_switch option_name)
+   if (${option_name})
+      enable_preprocessor_switch(${option_name})
+   else()
+      disable_preprocessor_switch(${option_name})
+   endif()
+endmacro()
+
+
+
+# Suppress superfluous randlib warnings about libdlib.a having no symbols on MacOSX.
+if (APPLE)
+   set(CMAKE_C_ARCHIVE_CREATE   "<CMAKE_AR> Scr <TARGET> <LINK_FLAGS> <OBJECTS>")
+   set(CMAKE_CXX_ARCHIVE_CREATE "<CMAKE_AR> Scr <TARGET> <LINK_FLAGS> <OBJECTS>")
+   set(CMAKE_C_ARCHIVE_FINISH   "<CMAKE_RANLIB> -no_warning_for_no_symbols -c <TARGET>")
+   set(CMAKE_CXX_ARCHIVE_FINISH "<CMAKE_RANLIB> -no_warning_for_no_symbols -c <TARGET>")
+endif()
+
+# Don't try to call add_library(dlib) and setup dlib's stuff if it has already
+# been done by some other part of the current cmake project.  We do this
+# because it avoids getting warnings/errors about cmake policy CMP0002.  This
+# happens when a project tries to call add_subdirectory() on dlib more than
+# once.  This most often happens when the top level of a project depends on two
+# or more other things which both depend on dlib. 
+if (NOT TARGET dlib)
+
+   set (DLIB_ISO_CPP_ONLY_STR 
+      "Enable this if you don't want to compile any non-ISO C++ code (i.e. you don't use any of the API Wrappers)" )
+   set (DLIB_NO_GUI_SUPPORT_STR 
+      "Enable this if you don't want to compile any of the dlib GUI code" )
+   set (DLIB_ENABLE_STACK_TRACE_STR 
+      "Enable this if you want to turn on the DLIB_STACK_TRACE macros" )
+   set (DLIB_USE_BLAS_STR
+      "Disable this if you don't want to use a BLAS library" )
+   set (DLIB_USE_LAPACK_STR
+      "Disable this if you don't want to use a LAPACK library" )
+   set (DLIB_USE_CUDA_STR
+      "Disable this if you don't want to use NVIDIA CUDA" )
+   set (DLIB_USE_MKL_SEQUENTIAL_STR
+      "Enable this if you have MKL installed and want to use the sequential version instead of the multi-core version." )
+   set (DLIB_USE_MKL_WITH_TBB_STR
+      "Enable this if you have MKL installed and want to use the tbb version instead of the openmp version." )
+   set (DLIB_PNG_SUPPORT_STR
+      "Disable this if you don't want to link against libpng" )
+   set (DLIB_GIF_SUPPORT_STR
+      "Disable this if you don't want to link against libgif" )
+   set (DLIB_JPEG_SUPPORT_STR
+      "Disable this if you don't want to link against libjpeg" )
+   set (DLIB_LINK_WITH_SQLITE3_STR
+      "Disable this if you don't want to link against sqlite3" )
+   #set (DLIB_USE_FFTW_STR "Disable this if you don't want to link against fftw" )
+   set (DLIB_USE_MKL_FFT_STR
+      "Disable this is you don't want to use the MKL DFTI FFT implementation" )
+   set (DLIB_ENABLE_ASSERTS_STR
+      "Enable this if you want to turn on the DLIB_ASSERT macro" )
+
+
+   option(DLIB_ENABLE_ASSERTS ${DLIB_ENABLE_ASSERTS_STR} OFF)
+   option(DLIB_ISO_CPP_ONLY ${DLIB_ISO_CPP_ONLY_STR} OFF)
+   toggle_preprocessor_switch(DLIB_ISO_CPP_ONLY)
+   option(DLIB_NO_GUI_SUPPORT ${DLIB_NO_GUI_SUPPORT_STR} OFF)
+   toggle_preprocessor_switch(DLIB_NO_GUI_SUPPORT)
+   option(DLIB_ENABLE_STACK_TRACE ${DLIB_ENABLE_STACK_TRACE_STR} OFF)
+   toggle_preprocessor_switch(DLIB_ENABLE_STACK_TRACE)
+   option(DLIB_USE_MKL_SEQUENTIAL ${DLIB_USE_MKL_SEQUENTIAL_STR} OFF)
+   option(DLIB_USE_MKL_WITH_TBB ${DLIB_USE_MKL_WITH_TBB_STR} OFF)
+
+   if(DLIB_ENABLE_ASSERTS)
+      # Set these variables so they are set in the config.h.in file when dlib
+      # is installed.
+      set (DLIB_DISABLE_ASSERTS false)
+      set (ENABLE_ASSERTS true) 
+      enable_preprocessor_switch(ENABLE_ASSERTS)
+      disable_preprocessor_switch(DLIB_DISABLE_ASSERTS)
+   else()
+      # Set these variables so they are set in the config.h.in file when dlib
+      # is installed.
+      set (DLIB_DISABLE_ASSERTS true)
+      set (ENABLE_ASSERTS false) 
+      disable_preprocessor_switch(ENABLE_ASSERTS)
+      # Never force the asserts off when doing an in project build.  The only
+      # time this matters is when using visual studio.  The visual studio IDE
+      # has a drop down that lets the user select either release or debug
+      # builds.  The DLIB_ASSERT macro is setup to enable/disable automatically
+      # based on this drop down (via preprocessor magic).  However, if
+      # DLIB_DISABLE_ASSERTS is defined it permanently disables asserts no
+      # matter what, which would defeat the visual studio drop down.  So here
+      # we make a point to not do that kind of severe disabling when in a
+      # project build.  It should also be pointed out that DLIB_DISABLE_ASSERTS
+      # is only needed when building and installing dlib as a separately
+      # installed library.  It doesn't matter when doing an in project build. 
+      if (NOT DLIB_IN_PROJECT_BUILD)
+         enable_preprocessor_switch(DLIB_DISABLE_ASSERTS)
+      endif()
+   endif()
+
+   if (DLIB_ISO_CPP_ONLY)
+      option(DLIB_JPEG_SUPPORT ${DLIB_JPEG_SUPPORT_STR} OFF)
+      option(DLIB_LINK_WITH_SQLITE3 ${DLIB_LINK_WITH_SQLITE3_STR} OFF)
+      option(DLIB_USE_BLAS ${DLIB_USE_BLAS_STR} OFF)
+      option(DLIB_USE_LAPACK ${DLIB_USE_LAPACK_STR} OFF)
+      option(DLIB_USE_CUDA ${DLIB_USE_CUDA_STR} OFF)
+      option(DLIB_PNG_SUPPORT ${DLIB_PNG_SUPPORT_STR} OFF)
+      option(DLIB_GIF_SUPPORT ${DLIB_GIF_SUPPORT_STR} OFF)
+      #option(DLIB_USE_FFTW ${DLIB_USE_FFTW_STR} OFF)
+      option(DLIB_USE_MKL_FFT ${DLIB_USE_MKL_FFT_STR} OFF)
+   else()
+      option(DLIB_JPEG_SUPPORT ${DLIB_JPEG_SUPPORT_STR} ON)
+      option(DLIB_LINK_WITH_SQLITE3 ${DLIB_LINK_WITH_SQLITE3_STR} ON)
+      option(DLIB_USE_BLAS ${DLIB_USE_BLAS_STR} ON)
+      option(DLIB_USE_LAPACK ${DLIB_USE_LAPACK_STR} ON)
+      option(DLIB_USE_CUDA ${DLIB_USE_CUDA_STR} ON)
+      option(DLIB_PNG_SUPPORT ${DLIB_PNG_SUPPORT_STR} ON)
+      option(DLIB_GIF_SUPPORT ${DLIB_GIF_SUPPORT_STR} ON)
+      #option(DLIB_USE_FFTW ${DLIB_USE_FFTW_STR} ON)
+      option(DLIB_USE_MKL_FFT ${DLIB_USE_MKL_FFT_STR} ON)
+   endif()
+   toggle_preprocessor_switch(DLIB_JPEG_SUPPORT)
+   toggle_preprocessor_switch(DLIB_USE_BLAS)
+   toggle_preprocessor_switch(DLIB_USE_LAPACK)
+   toggle_preprocessor_switch(DLIB_USE_CUDA)
+   toggle_preprocessor_switch(DLIB_PNG_SUPPORT) 
+   toggle_preprocessor_switch(DLIB_GIF_SUPPORT) 
+   #toggle_preprocessor_switch(DLIB_USE_FFTW)
+   toggle_preprocessor_switch(DLIB_USE_MKL_FFT)
+
+
+   set(source_files 
+      base64/base64_kernel_1.cpp
+      bigint/bigint_kernel_1.cpp
+      bigint/bigint_kernel_2.cpp
+      bit_stream/bit_stream_kernel_1.cpp
+      entropy_decoder/entropy_decoder_kernel_1.cpp
+      entropy_decoder/entropy_decoder_kernel_2.cpp
+      entropy_encoder/entropy_encoder_kernel_1.cpp
+      entropy_encoder/entropy_encoder_kernel_2.cpp
+      gui_widgets/fonts.cpp
+      md5/md5_kernel_1.cpp
+      tokenizer/tokenizer_kernel_1.cpp
+      unicode/unicode.cpp
+      test_for_odr_violations.cpp
+      )
+
+
+   set(dlib_needed_libraries)
+   set(dlib_needed_includes)
+
+   if (DLIB_ISO_CPP_ONLY)
+      add_library(dlib ${source_files} )
+   else()
+
+      set(source_files ${source_files}
+         sockets/sockets_kernel_1.cpp
+         bsp/bsp.cpp
+         dir_nav/dir_nav_kernel_1.cpp
+         dir_nav/dir_nav_kernel_2.cpp
+         dir_nav/dir_nav_extensions.cpp
+         linker/linker_kernel_1.cpp
+         logger/extra_logger_headers.cpp
+         logger/logger_kernel_1.cpp
+         logger/logger_config_file.cpp
+         misc_api/misc_api_kernel_1.cpp
+         misc_api/misc_api_kernel_2.cpp
+         sockets/sockets_extensions.cpp
+         sockets/sockets_kernel_2.cpp
+         sockstreambuf/sockstreambuf.cpp
+         sockstreambuf/sockstreambuf_unbuffered.cpp
+         server/server_kernel.cpp
+         server/server_iostream.cpp
+         server/server_http.cpp
+         threads/multithreaded_object_extension.cpp
+         threads/threaded_object_extension.cpp
+         threads/threads_kernel_1.cpp
+         threads/threads_kernel_2.cpp
+         threads/threads_kernel_shared.cpp
+         threads/thread_pool_extension.cpp
+         threads/async.cpp
+         timer/timer.cpp
+         stack_trace.cpp
+         cuda/cpu_dlib.cpp
+         cuda/tensor_tools.cpp
+         data_io/image_dataset_metadata.cpp
+         data_io/mnist.cpp
+         data_io/cifar.cpp
+         global_optimization/global_function_search.cpp
+         filtering/kalman_filter.cpp
+         svm/auto.cpp
+         )
+
+      if(UNIX)
+         set(CMAKE_THREAD_PREFER_PTHREAD ON)
+         find_package(Threads REQUIRED)
+         set(dlib_needed_libraries ${dlib_needed_libraries} ${CMAKE_THREAD_LIBS_INIT})
+      endif()
+
+      # we want to link to the right stuff depending on our platform.  
+      if (WIN32 AND NOT CYGWIN) ###############################################################################
+         if (DLIB_NO_GUI_SUPPORT)
+            set (dlib_needed_libraries ws2_32 winmm)
+         else()
+            set (dlib_needed_libraries ws2_32 winmm comctl32 gdi32 imm32)
+         endif()
+      elseif(APPLE) ############################################################################
+         set(CMAKE_MACOSX_RPATH 1)
+         if (NOT DLIB_NO_GUI_SUPPORT)
+            find_package(X11 QUIET)
+            if (X11_FOUND)
+               # If both X11 and anaconda are installed, it's possible for the
+               # anaconda path to appear before /opt/X11, so we remove anaconda.
+               foreach (ITR ${X11_INCLUDE_DIR})
+                  if ("${ITR}" MATCHES "(.*)(Ana|ana|mini)conda(.*)")
+                     list (REMOVE_ITEM X11_INCLUDE_DIR ${ITR})
+                  endif ()
+               endforeach(ITR)
+               include_directories(${X11_INCLUDE_DIR})
+               set (dlib_needed_libraries ${dlib_needed_libraries} ${X11_LIBRARIES})
+            else()
+               find_library(xlib X11)
+               # Make sure X11 is in the include path.  Note that we look for
+               # Xlocale.h rather than Xlib.h because it avoids finding a partial
+               # copy of the X11 headers on systems with anaconda installed.
+               find_path(xlib_path Xlocale.h
+                  PATHS 
+                  /Developer/SDKs/MacOSX10.4u.sdk/usr/X11R6/include
+                  /opt/local/include
+                  PATH_SUFFIXES X11
+                  )
+               if (xlib AND xlib_path)
+                  get_filename_component(x11_path ${xlib_path} PATH CACHE)
+                  include_directories(${x11_path})
+                  set(dlib_needed_libraries ${dlib_needed_libraries} ${xlib} )
+                  set(X11_FOUND 1)
+               endif()
+            endif()
+            if (NOT X11_FOUND)
+               message(" *****************************************************************************")
+               message(" *** DLIB GUI SUPPORT DISABLED BECAUSE X11 DEVELOPMENT LIBRARIES NOT FOUND ***")
+               message(" *** Make sure XQuartz is installed if you want GUI support.               ***")
+               message(" *** You can download XQuartz from: https://www.xquartz.org/               ***")
+               message(" *****************************************************************************")
+               set(DLIB_NO_GUI_SUPPORT ON CACHE STRING ${DLIB_NO_GUI_SUPPORT_STR} FORCE )
+               enable_preprocessor_switch(DLIB_NO_GUI_SUPPORT)
+            endif()
+         endif()
+
+         mark_as_advanced(xlib xlib_path x11_path)
+      else () ##################################################################################
+         # link to the socket library if it exists.  this is something you need on solaris
+         find_library(socketlib socket)
+         if (socketlib)
+            set (dlib_needed_libraries ${dlib_needed_libraries} ${socketlib})
+         endif ()
+
+         if (NOT DLIB_NO_GUI_SUPPORT)
+            include(FindX11)
+            if (X11_FOUND)
+               include_directories(${X11_INCLUDE_DIR})
+               set (dlib_needed_libraries ${dlib_needed_libraries} ${X11_LIBRARIES})
+            else()
+               message(" *****************************************************************************")
+               message(" *** DLIB GUI SUPPORT DISABLED BECAUSE X11 DEVELOPMENT LIBRARIES NOT FOUND ***")
+               message(" *** Make sure libx11-dev is installed if you want GUI support.            ***")
+               message(" *** On Ubuntu run: sudo apt-get install libx11-dev                        ***")
+               message(" *****************************************************************************")
+               set(DLIB_NO_GUI_SUPPORT ON CACHE STRING ${DLIB_NO_GUI_SUPPORT_STR} FORCE )
+               enable_preprocessor_switch(DLIB_NO_GUI_SUPPORT)
+            endif()
+         endif()
+
+         mark_as_advanced(nsllib socketlib)
+      endif () ##################################################################################
+
+      if (NOT DLIB_NO_GUI_SUPPORT)
+         set(source_files ${source_files}
+            gui_widgets/widgets.cpp
+            gui_widgets/drawable.cpp
+            gui_widgets/canvas_drawing.cpp
+            gui_widgets/style.cpp
+            gui_widgets/base_widgets.cpp
+            gui_core/gui_core_kernel_1.cpp
+            gui_core/gui_core_kernel_2.cpp
+            )
+      endif()
+
+      INCLUDE (CheckFunctionExists)
+
+      if (DLIB_GIF_SUPPORT)
+         find_package(GIF QUIET)
+         if (GIF_FOUND)
+            set (dlib_needed_includes ${dlib_needed_includes} ${GIF_INCLUDE_DIR})
+            set (dlib_needed_libraries ${dlib_needed_libraries} ${GIF_LIBRARY})
+         else()
+            set(DLIB_GIF_SUPPORT OFF CACHE STRING ${DLIB_GIF_SUPPORT_STR} FORCE )
+            toggle_preprocessor_switch(DLIB_GIF_SUPPORT)
+         endif()
+      endif()
+
+      if (DLIB_PNG_SUPPORT)
+         include(cmake_utils/find_libpng.cmake)
+         if (PNG_FOUND)
+            include_directories(${PNG_INCLUDE_DIR})
+            set (dlib_needed_libraries ${dlib_needed_libraries} ${PNG_LIBRARIES})
+         else()
+            # If we can't find libpng then statically compile it in.
+            include_directories(external/libpng external/zlib)
+            set(source_files ${source_files}
+               external/libpng/arm/arm_init.c
+               external/libpng/arm/filter_neon_intrinsics.c
+               external/libpng/png.c
+               external/libpng/pngerror.c
+               external/libpng/pngget.c
+               external/libpng/pngmem.c
+               external/libpng/pngpread.c
+               external/libpng/pngread.c
+               external/libpng/pngrio.c
+               external/libpng/pngrtran.c
+               external/libpng/pngrutil.c
+               external/libpng/pngset.c
+               external/libpng/pngtrans.c
+               external/libpng/pngwio.c
+               external/libpng/pngwrite.c
+               external/libpng/pngwtran.c
+               external/libpng/pngwutil.c
+               external/zlib/adler32.c
+               external/zlib/compress.c
+               external/zlib/crc32.c
+               external/zlib/deflate.c
+               external/zlib/gzclose.c
+               external/zlib/gzlib.c
+               external/zlib/gzread.c
+               external/zlib/gzwrite.c
+               external/zlib/infback.c
+               external/zlib/inffast.c
+               external/zlib/inflate.c
+               external/zlib/inftrees.c
+               external/zlib/trees.c
+               external/zlib/uncompr.c
+               external/zlib/zutil.c
+               )
+
+            include(cmake_utils/check_if_neon_available.cmake)
+            if (ARM_NEON_IS_AVAILABLE)
+               message (STATUS "NEON instructions will be used for libpng.")
+               enable_language(ASM)
+               set(source_files ${source_files}
+                  external/libpng/arm/arm_init.c
+                  external/libpng/arm/filter_neon_intrinsics.c
+                  external/libpng/arm/filter_neon.S
+                  )
+               set_source_files_properties(external/libpng/arm/filter_neon.S PROPERTIES COMPILE_FLAGS "${CMAKE_ASM_FLAGS} ${CMAKE_CXX_FLAGS} -x assembler-with-cpp")
+            endif()
+         endif()
+         set(source_files ${source_files}
+            image_loader/png_loader.cpp
+            image_saver/save_png.cpp
+            )
+      endif()
+
+      if (DLIB_JPEG_SUPPORT)
+         include(cmake_utils/find_libjpeg.cmake)
+         if (JPEG_FOUND)
+            include_directories(${JPEG_INCLUDE_DIR})
+            set (dlib_needed_libraries ${dlib_needed_libraries} ${JPEG_LIBRARY})
+         else()
+            # If we can't find libjpeg then statically compile it in.
+            add_definitions(-DDLIB_JPEG_STATIC)
+            set(source_files ${source_files}
+              external/libjpeg/jaricom.c
+              external/libjpeg/jcapimin.c
+              external/libjpeg/jcapistd.c
+              external/libjpeg/jcarith.c
+              external/libjpeg/jccoefct.c
+              external/libjpeg/jccolor.c
+              external/libjpeg/jcdctmgr.c
+              external/libjpeg/jchuff.c
+              external/libjpeg/jcinit.c
+              external/libjpeg/jcmainct.c
+              external/libjpeg/jcmarker.c
+              external/libjpeg/jcmaster.c
+              external/libjpeg/jcomapi.c
+              external/libjpeg/jcparam.c
+              external/libjpeg/jcprepct.c
+              external/libjpeg/jcsample.c
+              external/libjpeg/jdapimin.c
+              external/libjpeg/jdapistd.c
+              external/libjpeg/jdarith.c
+              external/libjpeg/jdatadst.c
+              external/libjpeg/jdatasrc.c
+              external/libjpeg/jdcoefct.c
+              external/libjpeg/jdcolor.c
+              external/libjpeg/jddctmgr.c
+              external/libjpeg/jdhuff.c
+              external/libjpeg/jdinput.c
+              external/libjpeg/jdmainct.c
+              external/libjpeg/jdmarker.c
+              external/libjpeg/jdmaster.c
+              external/libjpeg/jdmerge.c
+              external/libjpeg/jdpostct.c
+              external/libjpeg/jdsample.c
+              external/libjpeg/jerror.c
+              external/libjpeg/jfdctflt.c
+              external/libjpeg/jfdctfst.c
+              external/libjpeg/jfdctint.c
+              external/libjpeg/jidctflt.c
+              external/libjpeg/jidctfst.c
+              external/libjpeg/jidctint.c
+              external/libjpeg/jmemmgr.c
+              external/libjpeg/jmemnobs.c
+              external/libjpeg/jquant1.c
+              external/libjpeg/jquant2.c
+              external/libjpeg/jutils.c
+               )
+         endif()
+         set(source_files ${source_files}
+            image_loader/jpeg_loader.cpp
+            image_saver/save_jpeg.cpp
+            )
+      endif()
+
+
+      if (DLIB_USE_BLAS OR DLIB_USE_LAPACK OR DLIB_USE_MKL_FFT)
+         if (DLIB_USE_MKL_WITH_TBB AND DLIB_USE_MKL_SEQUENTIAL)
+            set(DLIB_USE_MKL_SEQUENTIAL OFF CACHE STRING ${DLIB_USE_MKL_SEQUENTIAL_STR} FORCE )
+            toggle_preprocessor_switch(DLIB_USE_MKL_SEQUENTIAL)
+            message(STATUS "Disabling DLIB_USE_MKL_SEQUENTIAL. It cannot be used simultaneously with DLIB_USE_MKL_WITH_TBB.")
+         endif()
+
+
+         # Try to find BLAS, LAPACK and MKL
+         include(cmake_utils/find_blas.cmake)
+
+         if (DLIB_USE_BLAS)
+            if (blas_found)
+               set (dlib_needed_libraries ${dlib_needed_libraries} ${blas_libraries})
+            else()
+               set(DLIB_USE_BLAS OFF CACHE STRING ${DLIB_USE_BLAS_STR} FORCE )
+               toggle_preprocessor_switch(DLIB_USE_BLAS)
+            endif()
+         endif()
+
+         if (DLIB_USE_LAPACK)
+            if (lapack_found)
+               set (dlib_needed_libraries ${dlib_needed_libraries} ${lapack_libraries})
+               if (lapack_with_underscore)
+                  set(LAPACK_FORCE_UNDERSCORE 1)
+                  enable_preprocessor_switch(LAPACK_FORCE_UNDERSCORE)
+               elseif (lapack_without_underscore)
+                  set(LAPACK_FORCE_NOUNDERSCORE 1)
+                  enable_preprocessor_switch(LAPACK_FORCE_NOUNDERSCORE)
+               endif ()
+            else()
+               set(DLIB_USE_LAPACK OFF CACHE STRING ${DLIB_USE_LAPACK_STR} FORCE )
+               toggle_preprocessor_switch(DLIB_USE_LAPACK)
+            endif()
+         endif()
+
+         if (DLIB_USE_MKL_FFT)
+            if (found_intel_mkl AND found_intel_mkl_headers)
+               set (dlib_needed_includes ${dlib_needed_includes} ${mkl_include_dir})
+               set (dlib_needed_libraries ${dlib_needed_libraries} ${mkl_libraries})
+            else()
+               set(DLIB_USE_MKL_FFT OFF CACHE STRING ${DLIB_USE_MKL_FFT_STR} FORCE )
+               toggle_preprocessor_switch(DLIB_USE_MKL_FFT)
+            endif()
+         endif()
+      endif()
+
+
+      if (DLIB_USE_CUDA)
+         find_package(CUDA 7.5)
+
+         if (CUDA_VERSION VERSION_GREATER 9.1 AND CMAKE_VERSION VERSION_LESS 3.12.2)
+            # This bit of weirdness is to work around a bug in cmake 
+            list(REMOVE_ITEM CUDA_CUBLAS_LIBRARIES "CUDA_cublas_device_LIBRARY-NOTFOUND")
+         endif()
+
+
+         if (CUDA_FOUND AND MSVC AND NOT CUDA_CUBLAS_LIBRARIES AND "${CMAKE_SIZEOF_VOID_P}" EQUAL "4")
+            message(WARNING "You have CUDA installed, but we can't use it unless you put visual studio in 64bit mode.")
+            set(CUDA_FOUND 0)
+         endif()
+
+         if (NOT CUDA_CUBLAS_LIBRARIES)
+            message(STATUS "Found CUDA, but CMake was unable to find the cuBLAS libraries that should be part of every basic CUDA "
+               "install. Your CUDA install is somehow broken or incomplete. Since cuBLAS is required for dlib to use CUDA we won't use CUDA.")
+            set(CUDA_FOUND 0)
+         endif()
+
+         if (CUDA_FOUND AND (NOT USING_OLD_VISUAL_STUDIO_COMPILER))
+
+            # There is some bug in cmake that causes it to mess up the
+            # -std=c++11 option if you let it propagate it to nvcc in some
+            # cases.  So instead we disable this and manually include
+            # things from CMAKE_CXX_FLAGS in the CUDA_NVCC_FLAGS list below.
+            if (APPLE)
+               set(CUDA_PROPAGATE_HOST_FLAGS OFF)
+               # Grab all the -D flags from CMAKE_CXX_FLAGS so we can pass them
+               # to nvcc.
+               string(REGEX MATCHALL "-D[^ ]*" FLAGS_FOR_NVCC "${CMAKE_CXX_FLAGS}")
+
+               # Check if we are being built as part of a pybind11 module. 
+               if (COMMAND pybind11_add_module)
+                  # Don't export unnecessary symbols.
+                  list(APPEND FLAGS_FOR_NVCC "-Xcompiler=-fvisibility=hidden")
+               endif()
+            endif()
+
+            set(CUDA_HOST_COMPILATION_CPP ON)
+            # Note that we add __STRICT_ANSI__ to avoid freaking out nvcc with gcc specific
+            # magic in the standard C++ header files (since nvcc uses gcc headers on
+            # linux).
+            list(APPEND CUDA_NVCC_FLAGS "-arch=sm_50;-D__STRICT_ANSI__;-D_MWAITXINTRIN_H_INCLUDED;-D_FORCE_INLINES;${FLAGS_FOR_NVCC}")
+            list(APPEND CUDA_NVCC_FLAGS ${active_preprocessor_switches})
+            if (NOT DLIB_IN_PROJECT_BUILD)
+               LIST(APPEND CUDA_NVCC_FLAGS -DDLIB__CMAKE_GENERATED_A_CONFIG_H_FILE)
+            endif()
+            if (NOT MSVC)
+               list(APPEND CUDA_NVCC_FLAGS "-std=c++11")
+            endif()
+            if (CMAKE_POSITION_INDEPENDENT_CODE)
+               # sometimes this setting isn't propagated to NVCC, which then causes the
+               # compile to fail.  So make sure it's propagated.
+               if (NOT MSVC) # Visual studio doesn't have -fPIC so don't do it in that case.
+                  list(APPEND CUDA_NVCC_FLAGS "-Xcompiler -fPIC")
+               endif()
+            endif()
+
+            include(cmake_utils/test_for_cudnn/find_cudnn.txt)
+
+            if (cudnn AND cudnn_include AND NOT DEFINED cuda_test_compile_worked AND NOT DEFINED cudnn_test_compile_worked)
+               # make sure cuda is really working by doing a test compile
+               message(STATUS "Building a CUDA test project to see if your compiler is compatible with CUDA...")
+
+               set(CUDA_TEST_CMAKE_FLAGS 
+                  "-DCMAKE_PREFIX_PATH=${CMAKE_PREFIX_PATH}"
+                  "-DCMAKE_INCLUDE_PATH=${CMAKE_INCLUDE_PATH}"
+                  "-DCMAKE_LIBRARY_PATH=${CMAKE_LIBRARY_PATH}")
+
+               if (NOT MSVC) # see https://github.com/davisking/dlib/issues/363
+                  list(APPEND CUDA_TEST_CMAKE_FLAGS "-DCUDA_HOST_COMPILER=${CUDA_HOST_COMPILER}")
+               endif()
+
+               try_compile(cuda_test_compile_worked 
+                  ${PROJECT_BINARY_DIR}/cuda_test_build 
+                  ${PROJECT_SOURCE_DIR}/cmake_utils/test_for_cuda cuda_test
+                  CMAKE_FLAGS ${CUDA_TEST_CMAKE_FLAGS}
+                  OUTPUT_VARIABLE try_compile_output_message
+                  )
+               if (NOT cuda_test_compile_worked)
+                  string(REPLACE "\n" "\n   ***   " try_compile_output_message "${try_compile_output_message}")
+                  message(STATUS "*****************************************************************************************************************")
+                  message(STATUS "*** CUDA was found but your compiler failed to compile a simple CUDA program so dlib isn't going to use CUDA. ")
+                  message(STATUS "*** The output of the failed CUDA test compile is shown below: ")
+                  message(STATUS "*** ")
+                  message(STATUS "***   ${try_compile_output_message}")
+                  message(STATUS "*****************************************************************************************************************")
+               else()
+                  message(STATUS "Building a cuDNN test project to check if you have the right version of cuDNN installed...")
+                  try_compile(cudnn_test_compile_worked 
+                     ${PROJECT_BINARY_DIR}/cudnn_test_build 
+                     ${PROJECT_SOURCE_DIR}/cmake_utils/test_for_cudnn cudnn_test
+                     CMAKE_FLAGS ${CUDA_TEST_CMAKE_FLAGS}
+                     OUTPUT_VARIABLE try_compile_output_message
+                     )
+                  if (NOT cudnn_test_compile_worked)
+                     string(REPLACE "\n" "\n   ***   " try_compile_output_message "${try_compile_output_message}")
+                     message(STATUS "*****************************************************************************************************")
+                     message(STATUS "*** Found cuDNN, but we failed to compile the dlib/cmake_utils/test_for_cudnn project. ")
+                     message(STATUS "*** You either have an unsupported version of cuDNN or something is wrong with your cudDNN install.")
+                     message(STATUS "*** Since a functional cuDNN is not found DLIB WILL NOT USE CUDA. ")
+                     message(STATUS "*** The output of the failed test_for_cudnn build is: ")
+                     message(STATUS "*** ")
+                     message(STATUS "***   ${try_compile_output_message}")
+                     message(STATUS "*****************************************************************************************************")
+                  endif()
+               endif()
+            endif()
+
+            # Find where cuSOLVER is since the FindCUDA cmake package doesn't
+            # bother to look for it in older versions of cmake.
+            if (NOT CUDA_cusolver_LIBRARY)
+               get_filename_component(cuda_blas_path "${CUDA_CUBLAS_LIBRARIES}" DIRECTORY)
+               find_library(CUDA_cusolver_LIBRARY cusolver HINTS ${cuda_blas_path})
+               # CUDA 10.1 doesn't install symbolic links to libcusolver.so in
+               # the usual place.  This is probably a bug in the cuda
+               # installer.  In any case, If we haven't found cusolver yet go
+               # look in the cuda install folder for it.  New versions of cmake
+               # do this correctly, but older versions need help.
+               if (NOT CUDA_cusolver_LIBRARY)
+                  find_library(CUDA_cusolver_LIBRARY cusolver HINTS 
+                     /usr/local/cuda/lib64/
+                     )
+               endif()
+               mark_as_advanced(CUDA_cusolver_LIBRARY)
+            endif()
+            # Also find OpenMP since cuSOLVER needs it.  Importantly, we only
+            # look for one to link to if our use of BLAS, specifically the
+            # Intel MKL, hasn't already decided what to use.  This is because
+            # it makes the MKL bug out if you link to another openmp lib other
+            # than Intel's when you use the MKL. I'm also not really sure when
+            # explicit linking to openmp became unnecessary, but for
+            # sufficiently older versions of cuda it was needed.  Then in
+            # versions of cmake newer than 3.11 linking to openmp started to
+            # mess up the switches passed to nvcc, so you can't just leave
+            # these "try to link to openmp" statements here going forward.  Fun
+            # times.
+            if (CUDA_VERSION VERSION_LESS "9.1" AND NOT openmp_libraries AND NOT MSVC AND NOT XCODE AND NOT APPLE)
+               find_package(OpenMP)
+               if (OPENMP_FOUND)
+                  set(openmp_libraries ${OpenMP_CXX_FLAGS}) 
+               else()
+                  message(STATUS "*** Didn't find OpenMP, which is required to use CUDA. ***")
+                  set(CUDA_FOUND 0)
+               endif()
+            endif()
+         endif()
+
+         if (CUDA_FOUND AND cudnn AND (NOT USING_OLD_VISUAL_STUDIO_COMPILER) AND cuda_test_compile_worked AND cudnn_test_compile_worked AND cudnn_include)
+            set(source_files ${source_files} 
+               cuda/cuda_dlib.cu 
+               cuda/cudnn_dlibapi.cpp
+               cuda/cublas_dlibapi.cpp
+               cuda/cusolver_dlibapi.cu
+               cuda/curand_dlibapi.cpp
+               cuda/cuda_data_ptr.cpp
+               cuda/gpu_data.cpp
+               )
+            set(dlib_needed_libraries ${dlib_needed_libraries} 
+               ${CUDA_CUBLAS_LIBRARIES} 
+               ${cudnn}
+               ${CUDA_curand_LIBRARY}
+               ${CUDA_cusolver_LIBRARY}
+               ${CUDA_CUDART_LIBRARY}
+               )
+            if(openmp_libraries)
+               list(APPEND dlib_needed_libraries ${openmp_libraries})
+            endif()
+
+            include_directories(${cudnn_include})
+            message(STATUS "Enabling CUDA support for dlib.  DLIB WILL USE CUDA")
+         else()
+            set(DLIB_USE_CUDA OFF CACHE STRING ${DLIB_USE_BLAS_STR} FORCE )
+            toggle_preprocessor_switch(DLIB_USE_CUDA)
+            if (USING_OLD_VISUAL_STUDIO_COMPILER)
+               message(STATUS "*** Dlib CUDA support requires C++11 but your compiler doesn't support it. ***")
+            endif()
+            if (NOT CUDA_FOUND)
+               message(STATUS "DID NOT FIND CUDA")
+            endif()
+            message(STATUS "Disabling CUDA support for dlib.  DLIB WILL NOT USE CUDA")
+         endif()
+      endif()
+
+
+      if (DLIB_LINK_WITH_SQLITE3)
+         find_library(sqlite sqlite3)
+         # make sure sqlite3.h is in the include path
+         find_path(sqlite_path sqlite3.h)
+         if (sqlite AND sqlite_path)
+            set(dlib_needed_includes ${dlib_needed_includes} ${sqlite_path})
+            set(dlib_needed_libraries ${dlib_needed_libraries} ${sqlite} )
+         else()
+            set(DLIB_LINK_WITH_SQLITE3 OFF CACHE STRING ${DLIB_LINK_WITH_SQLITE3_STR} FORCE )
+         endif()
+         mark_as_advanced(sqlite sqlite_path)
+      endif()
+
+
+
+      if (DLIB_USE_FFTW)
+         find_library(fftw fftw3)
+         # make sure fftw3.h is in the include path
+         find_path(fftw_path fftw3.h)
+         if (fftw AND fftw_path)
+            set(dlib_needed_includes ${dlib_needed_includes} ${fftw_path})
+            set(dlib_needed_libraries ${dlib_needed_libraries} ${fftw} )
+         else()
+            set(DLIB_USE_FFTW OFF CACHE STRING ${DLIB_USE_FFTW_STR} FORCE )
+            toggle_preprocessor_switch(DLIB_USE_FFTW)
+         endif()
+         mark_as_advanced(fftw fftw_path)
+      endif()
+
+
+
+      # Tell CMake to build dlib via add_library()/cuda_add_library()
+      if (DLIB_USE_CUDA)
+         # The old cuda_add_library() command doesn't support CMake's newer dependency
+         # stuff, so we have to set the include path manually still, which we do here.
+         include_directories(${dlib_needed_includes})
+         cuda_add_library(dlib ${source_files} )
+      else()
+         add_library(dlib ${source_files} )
+      endif()
+
+   endif ()  ##### end of if NOT DLIB_ISO_CPP_ONLY ##########################################################
+
+
+   target_include_directories(dlib
+      INTERFACE $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/..>
+      INTERFACE $<INSTALL_INTERFACE:include>
+      PUBLIC ${dlib_needed_includes}
+      )
+   target_link_libraries(dlib PUBLIC ${dlib_needed_libraries})
+   if (DLIB_IN_PROJECT_BUILD)
+      target_compile_options(dlib PUBLIC ${active_preprocessor_switches})
+   else()
+      # These are private in this case because they will be controlled by the
+      # contents of dlib/config.h once it's installed. But for in project
+      # builds, there is no real config.h so they are public in the above case.
+      target_compile_options(dlib PRIVATE ${active_preprocessor_switches})
+      # Do this so that dlib/config.h won't set DLIB_NOT_CONFIGURED. This will then allow
+      # the code in dlib/threads_kernel_shared.cpp to emit a linker error for users who
+      # don't use the configured config.h file generated by cmake.
+      target_compile_options(dlib PRIVATE -DDLIB__CMAKE_GENERATED_A_CONFIG_H_FILE)
+
+      # Do this so that dlib/config.h can record the version of dlib it's configured with
+      # and ultimately issue a linker error to people who try to use a binary dlib that is
+      # the wrong version.
+      set(DLIB_CHECK_FOR_VERSION_MISMATCH 
+         DLIB_VERSION_MISMATCH_CHECK__EXPECTED_VERSION_${CPACK_PACKAGE_VERSION_MAJOR}_${CPACK_PACKAGE_VERSION_MINOR}_${CPACK_PACKAGE_VERSION_PATCH})
+      target_compile_options(dlib PRIVATE "-DDLIB_CHECK_FOR_VERSION_MISMATCH=${DLIB_CHECK_FOR_VERSION_MISMATCH}")
+   endif()
+
+
+   # Allow the unit tests to ask us to compile the all/source.cpp file just to make sure it compiles.
+   if (DLIB_TEST_COMPILE_ALL_SOURCE_CPP)
+      add_library(dlib_all_source_cpp STATIC all/source.cpp) 
+      target_link_libraries(dlib_all_source_cpp dlib)
+      target_compile_options(dlib_all_source_cpp PUBLIC ${active_preprocessor_switches})
+      enable_cpp11_for_target(dlib_all_source_cpp)
+   endif()
+
+   enable_cpp11_for_target(dlib)
+   if((MSVC AND CMAKE_VERSION VERSION_LESS 3.11) OR CMAKE_VERSION VERSION_LESS 3.3)
+      target_compile_options(dlib PUBLIC ${active_compile_opts})
+      target_compile_options(dlib PRIVATE ${active_compile_opts_private})
+   else()
+      target_compile_options(dlib PUBLIC $<$<COMPILE_LANGUAGE:CXX>:${active_compile_opts}>)
+      target_compile_options(dlib PRIVATE $<$<COMPILE_LANGUAGE:CXX>:${active_compile_opts_private}>)
+   endif()
+
+   # Install the library
+   if (NOT DLIB_IN_PROJECT_BUILD)
+      string (REPLACE ";" " " pkg_config_dlib_needed_libraries "${dlib_needed_libraries}")
+      # Make the -I include options for pkg-config
+      foreach (ITR ${dlib_needed_includes})
+         set (pkg_config_dlib_needed_includes "${pkg_config_dlib_needed_includes} -I${ITR}")
+      endforeach()
+      set_target_properties(dlib PROPERTIES
+         VERSION ${VERSION})
+      install(TARGETS dlib
+         EXPORT dlib 
+         RUNTIME DESTINATION ${CMAKE_INSTALL_BINDIR} # Windows considers .dll to be runtime artifacts
+         LIBRARY DESTINATION ${CMAKE_INSTALL_LIBDIR}
+         ARCHIVE DESTINATION ${CMAKE_INSTALL_LIBDIR})
+
+      install(DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}/ DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}/dlib
+         FILES_MATCHING 
+            PATTERN "*.h" 
+            PATTERN "*.cmake"
+            PATTERN "*_tutorial.txt"
+            PATTERN "cassert"
+            PATTERN "cstring"
+            PATTERN "fstream"
+            PATTERN "iomanip"
+            PATTERN "iosfwd"
+            PATTERN "iostream"
+            PATTERN "istream"
+            PATTERN "locale"
+            PATTERN "ostream"
+            PATTERN "sstream"
+            REGEX "${CMAKE_CURRENT_BINARY_DIR}" EXCLUDE)
+
+
+      configure_file(${PROJECT_SOURCE_DIR}/config.h.in ${CMAKE_CURRENT_BINARY_DIR}/config.h)
+      # overwrite config.h with the configured one
+      install(FILES ${CMAKE_CURRENT_BINARY_DIR}/config.h DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}/dlib)
+
+      configure_file(${PROJECT_SOURCE_DIR}/revision.h.in ${CMAKE_CURRENT_BINARY_DIR}/revision.h)
+      install(FILES ${CMAKE_CURRENT_BINARY_DIR}/revision.h DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}/dlib)
+
+      ## Config.cmake generation and installation
+
+      set(ConfigPackageLocation "${CMAKE_INSTALL_LIBDIR}/cmake/dlib")
+      install(EXPORT dlib
+         NAMESPACE dlib::
+         DESTINATION ${ConfigPackageLocation})
+
+      configure_file(cmake_utils/dlibConfig.cmake.in "${CMAKE_CURRENT_BINARY_DIR}/config/dlibConfig.cmake" @ONLY)
+
+      include(CMakePackageConfigHelpers)
+      write_basic_package_version_file(
+         "${CMAKE_CURRENT_BINARY_DIR}/config/dlibConfigVersion.cmake"
+         VERSION ${VERSION}
+         COMPATIBILITY AnyNewerVersion
+         )
+
+      install(FILES 
+         "${CMAKE_CURRENT_BINARY_DIR}/config/dlibConfig.cmake" 
+         "${CMAKE_CURRENT_BINARY_DIR}/config/dlibConfigVersion.cmake" 
+         DESTINATION ${ConfigPackageLocation})
+
+      ## dlib-1.pc generation and installation
+
+      configure_file("cmake_utils/dlib.pc.in" "dlib-1.pc" @ONLY)
+      install(FILES "${CMAKE_CURRENT_BINARY_DIR}/dlib-1.pc"
+         DESTINATION "${CMAKE_INSTALL_LIBDIR}/pkgconfig")
+
+      # Add a cpack "package" target. This will create an archive containing
+      # the built library file, the header files, and cmake and pkgconfig
+      # configuration files.
+      include(CPack)
+
+   endif()
+
+endif()
+
+if (MSVC)
+   # Give the output library files names that are unique functions of the
+   # visual studio mode that compiled them.  We do this so that people who
+   # compile dlib and then copy the .lib files around (which they shouldn't be
+   # doing in the first place!) will hopefully be slightly less confused by
+   # what happens since, at the very least, the filenames will indicate what
+   # visual studio runtime they go with.
+   math(EXPR numbits ${CMAKE_SIZEOF_VOID_P}*8)
+   set_target_properties(dlib PROPERTIES DEBUG_POSTFIX "${VERSION}_debug_${numbits}bit_msvc${MSVC_VERSION}")
+   set_target_properties(dlib PROPERTIES RELEASE_POSTFIX "${VERSION}_release_${numbits}bit_msvc${MSVC_VERSION}")
+   set_target_properties(dlib PROPERTIES MINSIZEREL_POSTFIX "${VERSION}_minsizerel_${numbits}bit_msvc${MSVC_VERSION}")
+   set_target_properties(dlib PROPERTIES RELWITHDEBINFO_POSTFIX "${VERSION}_relwithdebinfo_${numbits}bit_msvc${MSVC_VERSION}")
+endif()
+
+# Check if we are being built as part of a pybind11 module. 
+if (COMMAND pybind11_add_module)
+   # Don't export unnecessary symbols.
+   set_target_properties(dlib PROPERTIES CXX_VISIBILITY_PRESET "hidden")
+   set_target_properties(dlib PROPERTIES CUDA_VISIBILITY_PRESET "hidden")
+endif()
+
+if (WIN32 AND mkl_iomp_dll)
+   # If we are using the Intel MKL on windows then try and copy the iomp dll
+   # file to the output folder.  We do this since a very large number of
+   # windows users don't understand that they need to add the Intel MKL's
+   # folders to their PATH to use the Intel MKL.  They then complain on the
+   # dlib forums.  Copying the Intel MKL dlls to the output directory removes
+   # the need to add the Intel MKL to the PATH.
+   if (CMAKE_LIBRARY_OUTPUT_DIRECTORY)
+      add_custom_command(TARGET dlib POST_BUILD
+         # In some newer versions of windows/visual studio the output Config folder doesn't
+         # exist at first, so you can't copy to it unless you make it yourself.  So make
+         # sure the target folder exists first.
+         COMMAND ${CMAKE_COMMAND} -E make_directory "${CMAKE_LIBRARY_OUTPUT_DIRECTORY}/"
+         COMMAND ${CMAKE_COMMAND} -E copy "${mkl_iomp_dll}" "${CMAKE_LIBRARY_OUTPUT_DIRECTORY}/"
+         )
+   else()
+      add_custom_command(TARGET dlib POST_BUILD
+         # In some newer versions of windows/visual studio the output Config folder doesn't
+         # exist at first, so you can't copy to it unless you make it yourself.  So make
+         # sure the target folder exists first.
+         COMMAND ${CMAKE_COMMAND} -E make_directory "${CMAKE_BINARY_DIR}/$<CONFIG>/"
+         COMMAND ${CMAKE_COMMAND} -E copy "${mkl_iomp_dll}" "${CMAKE_BINARY_DIR}/$<CONFIG>/"
+         )
+   endif()
+endif()
+
+add_library(dlib::dlib ALIAS dlib)

dlibs/dlib/LICENSE.txt

@@ -0,0 +1,23 @@
+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.

dlibs/dlib/algs.h

@@ -0,0 +1,1158 @@
+// Copyright (C) 2003  Davis E. King ([email protected])
+// License: Boost Software License   See LICENSE.txt for the full license.
+
+#ifdef DLIB_ALL_SOURCE_END
+#include "dlib_basic_cpp_build_tutorial.txt"
+#endif
+
+#ifndef DLIB_ALGs_
+#define DLIB_ALGs_
+
+// this file contains miscellaneous stuff                      
+
+// Give people who forget the -std=c++11 option a reminder
+#if (defined(__GNUC__) && ((__GNUC__ >= 4 && __GNUC_MINOR__ >= 8) || (__GNUC__ > 4))) || \
+    (defined(__clang__) && ((__clang_major__ >= 3 && __clang_minor__ >= 4) || (__clang_major__ >= 3)))
+    #if __cplusplus < 201103
+        #error "Dlib requires C++11 support.  Give your compiler the -std=c++11 option to enable it."
+    #endif
+#endif
+
+#if defined __NVCC__
+    // Disable the "statement is unreachable" message since it will go off on code that is
+    // actually reachable but just happens to not be reachable sometimes during certain
+    // template instantiations.
+    #pragma diag_suppress code_is_unreachable
+#endif
+
+
+#ifdef _MSC_VER
+
+#if  _MSC_VER < 1900
+#error "dlib versions newer than v19.1 use C++11 and therefore require Visual Studio 2015 or newer."
+#endif
+
+// Disable the following warnings for Visual Studio
+
+// this is to disable the "'this' : used in base member initializer list"
+// warning you get from some of the GUI objects since all the objects
+// require that their parent class be passed into their constructor. 
+// In this case though it is totally safe so it is ok to disable this warning.
+#pragma warning(disable : 4355)
+
+// This is a warning you get sometimes when Visual Studio performs a Koenig Lookup. 
+// This is a bug in visual studio.  It is a totally legitimate thing to 
+// expect from a compiler. 
+#pragma warning(disable : 4675)
+
+// This is a warning you get from visual studio 2005 about things in the standard C++
+// library being "deprecated."  I checked the C++ standard and it doesn't say jack 
+// about any of them (I checked the searchable PDF).   So this warning is total Bunk.
+#pragma warning(disable : 4996)
+
+// This is a warning you get from visual studio 2003:
+//    warning C4345: behavior change: an object of POD type constructed with an initializer 
+//    of the form () will be default-initialized.
+// I love it when this compiler gives warnings about bugs in previous versions of itself. 
+#pragma warning(disable : 4345)
+
+
+// Disable warnings about conversion from size_t to unsigned long and long.
+#pragma warning(disable : 4267)
+
+// Disable warnings about conversion from double to float  
+#pragma warning(disable : 4244)
+#pragma warning(disable : 4305)
+
+// Disable "warning C4180: qualifier applied to function type has no meaning; ignored".
+// This warning happens often in generic code that works with functions and isn't useful.
+#pragma warning(disable : 4180)
+
+// Disable "warning C4290: C++ exception specification ignored except to indicate a function is not __declspec(nothrow)"
+#pragma warning(disable : 4290)
+
+
+// DNN module uses template-based network declaration that leads to very long
+// type names. Visual Studio will produce Warning C4503 in such cases. https://msdn.microsoft.com/en-us/library/074af4b6.aspx says
+// that correct binaries are still produced even when this warning happens, but linker errors from visual studio, if they occur could be confusing.
+#pragma warning( disable: 4503 )
+
+
+#endif
+
+#ifdef __BORLANDC__
+// Disable the following warnings for the Borland Compilers
+//
+// These warnings just say that the compiler is refusing to inline functions with
+// loops or try blocks in them.  
+//
+#pragma option -w-8027
+#pragma option -w-8026 
+#endif
+
+#include <string>       // for the exceptions
+
+#ifdef __CYGWIN__
+namespace std
+{
+   typedef std::basic_string<wchar_t> wstring;
+}
+#endif
+
+#include "platform.h"
+#include "windows_magic.h"
+
+
+#include <algorithm>    // for std::swap
+#include <new>          // for std::bad_alloc
+#include <cstdlib>
+#include <stddef.h>
+#include <limits> // for std::numeric_limits for is_finite()
+#include "assert.h"
+#include "error.h"
+#include "noncopyable.h"
+#include "enable_if.h"
+#include "uintn.h"
+#include "numeric_constants.h"
+#include "memory_manager_stateless/memory_manager_stateless_kernel_1.h" // for the default memory manager
+
+
+
+// ----------------------------------------------------------------------------------------
+/*!A _dT !*/
+
+template <typename charT>
+inline charT _dTcast (const char a, const wchar_t b);
+template <>
+inline char _dTcast<char> (const char a, const wchar_t ) { return a; }
+template <>
+inline wchar_t _dTcast<wchar_t> (const char , const wchar_t b) { return b; }
+
+template <typename charT>
+inline const charT* _dTcast ( const char* a, const wchar_t* b);
+template <>
+inline const char* _dTcast<char> ( const char* a, const wchar_t* ) { return a; }
+template <>
+inline const wchar_t* _dTcast<wchar_t> ( const char* , const wchar_t* b) { return b; }
+
+
+#define _dT(charT,str) _dTcast<charT>(str,L##str) 
+/*!
+    requires
+        - charT == char or wchar_t
+        - str == a string or character literal
+    ensures
+        - returns the literal in the form of a charT type literal.
+!*/
+
+// ----------------------------------------------------------------------------------------
+
+
+
+namespace dlib
+{
+
+// ----------------------------------------------------------------------------------------
+
+    /*!A default_memory_manager
+
+        This memory manager just calls new and delete directly.  
+
+    !*/
+    typedef memory_manager_stateless_kernel_1<char> default_memory_manager;
+
+// ----------------------------------------------------------------------------------------
+
+    /*!A swap !*/
+    // make swap available in the dlib namespace
+    using std::swap;
+
+// ----------------------------------------------------------------------------------------
+
+    /*!
+        Here is where I define my return codes.  It is 
+        important that they all be < 0.
+    !*/
+
+    enum general_return_codes
+    {
+        TIMEOUT     = -1,
+        WOULDBLOCK  = -2,
+        OTHER_ERROR = -3,
+        SHUTDOWN    = -4,
+        PORTINUSE   = -5
+    };
+
+// ----------------------------------------------------------------------------------------
+
+    inline unsigned long square_root (
+        unsigned long value
+    )
+    /*!
+        requires
+            - value <= 2^32 - 1
+        ensures
+            - returns the square root of value.  if the square root is not an
+              integer then it will be rounded up to the nearest integer.
+    !*/
+    {
+        unsigned long x;
+
+        // set the initial guess for what the root is depending on 
+        // how big value is
+        if (value < 3)
+            return value;
+        else if (value < 4096) // 12
+            x = 45;
+        else if (value < 65536) // 16
+            x = 179;
+        else if (value < 1048576) // 20
+            x = 717;
+        else if (value < 16777216) // 24
+            x = 2867;
+        else if (value < 268435456) // 28
+            x = 11469;
+        else   // 32
+            x = 45875;
+
+
+
+        // find the root
+        x = (x + value/x)>>1;
+        x = (x + value/x)>>1;
+        x = (x + value/x)>>1;
+        x = (x + value/x)>>1;
+
+
+
+        if (x*x < value)
+            return x+1;
+        else
+            return x;
+    }
+
+// ----------------------------------------------------------------------------------------
+
+    template <
+        typename T
+        >    
+    void median (
+        T& one,
+        T& two,
+        T& three
+    );
+    /*!
+        requires
+            - T implements operator< 
+            - T is swappable by a global swap()
+        ensures
+            - #one is the median 
+            - #one, #two, and #three is some permutation of one, two, and three.  
+    !*/
+    
+    
+    template <
+        typename T
+        >
+    void median (
+        T& one,
+        T& two,
+        T& three
+    )    
+    {    
+        using std::swap;
+        using dlib::swap;
+
+        if ( one < two )
+        {
+            // one < two
+            if ( two < three )
+            {
+                // one < two < three : two
+                swap(one,two);
+                
+            }
+            else
+            {
+                // one < two >= three
+                if ( one < three)
+                {
+                    // three
+                    swap(three,one);
+                }
+            }
+            
+        }
+        else
+        {
+            // one >= two
+            if ( three < one )
+            {
+                // three <= one >= two
+                if ( three < two )
+                {
+                    // two
+                    swap(two,one);
+                }
+                else
+                {
+                    // three
+                    swap(three,one);
+                }
+            }
+        }        
+    }
+
+// ----------------------------------------------------------------------------------------
+
+    namespace relational_operators
+    {
+        template <
+            typename A,
+            typename B
+            >
+        constexpr bool operator> (
+            const A& a,
+            const B& b
+        ) { return b < a; }
+
+    // ---------------------------------
+
+        template <
+            typename A,
+            typename B
+            >
+        constexpr bool operator!= (
+            const A& a,
+            const B& b
+        ) { return !(a == b); }
+
+    // ---------------------------------
+
+        template <
+            typename A,
+            typename B
+            >
+        constexpr bool operator<= (
+            const A& a,
+            const B& b
+        ) { return !(b < a); }
+
+    // ---------------------------------
+
+        template <
+            typename A,
+            typename B
+            >
+        constexpr bool operator>= (
+            const A& a,
+            const B& b
+        ) { return !(a < b); }
+
+    }
+
+// ----------------------------------------------------------------------------------------
+
+    template <
+        typename T
+        >
+    void exchange (
+        T& a,
+        T& b
+    )
+    /*!
+        This function does the exact same thing that global swap does and it does it by
+        just calling swap.  But a lot of compilers have problems doing a Koenig Lookup
+        and the fact that this has a different name (global swap has the same name as
+        the member functions called swap) makes them compile right.
+
+        So this is a workaround but not too ugly of one.  But hopefully I get get
+        rid of this in a few years.  So this function is already deprecated. 
+
+        This also means you should NOT use this function in your own code unless
+        you have to support an old buggy compiler that benefits from this hack.
+    !*/
+    {
+        using std::swap;
+        using dlib::swap;
+        swap(a,b);
+    }
+
+// ----------------------------------------------------------------------------------------
+
+    /*!A is_pointer_type
+
+        This is a template where is_pointer_type<T>::value == true when T is a pointer 
+        type and false otherwise.
+    !*/
+
+    template <
+        typename T
+        >
+    class is_pointer_type
+    {
+    public:
+        enum { value = false };
+    private:
+        is_pointer_type();
+    };
+
+    template <
+        typename T
+        >
+    class is_pointer_type<T*>
+    {
+    public:
+        enum { value = true };
+    private:
+        is_pointer_type();
+    };
+
+// ----------------------------------------------------------------------------------------
+
+    /*!A is_const_type
+
+        This is a template where is_const_type<T>::value == true when T is a const 
+        type and false otherwise.
+    !*/
+
+    template <typename T>
+    struct is_const_type
+    {
+        static const bool value = false;
+    };
+    template <typename T>
+    struct is_const_type<const T>
+    {
+        static const bool value = true;
+    };
+    template <typename T>
+    struct is_const_type<const T&>
+    {
+        static const bool value = true;
+    };
+
+// ----------------------------------------------------------------------------------------
+
+    /*!A is_reference_type 
+
+        This is a template where is_reference_type<T>::value == true when T is a reference 
+        type and false otherwise.
+    !*/
+
+    template <typename T>
+    struct is_reference_type
+    {
+        static const bool value = false;
+    };
+
+    template <typename T> struct is_reference_type<const T&> { static const bool value = true; };
+    template <typename T> struct is_reference_type<T&> { static const bool value = true; };
+
+// ----------------------------------------------------------------------------------------
+
+    /*!A is_same_type 
+
+        This is a template where is_same_type<T,U>::value == true when T and U are the
+        same type and false otherwise.   
+    !*/
+
+    template <
+        typename T,
+        typename U
+        >
+    class is_same_type
+    {
+    public:
+        enum {value = false};
+    private:
+        is_same_type();
+    };
+
+    template <typename T>
+    class is_same_type<T,T>
+    {
+    public:
+        enum {value = true};
+    private:
+        is_same_type();
+    };
+
+// ----------------------------------------------------------------------------------------
+
+    /*!A is_float_type
+
+        This is a template that can be used to determine if a type is one of the built
+        int floating point types (i.e. float, double, or long double).
+    !*/
+
+    template < typename T > struct is_float_type  { const static bool value = false; };
+    template <> struct is_float_type<float>       { const static bool value = true; };
+    template <> struct is_float_type<double>      { const static bool value = true; };
+    template <> struct is_float_type<long double> { const static bool value = true; };
+
+// ----------------------------------------------------------------------------------------
+
+    /*!A is_convertible
+
+        This is a template that can be used to determine if one type is convertible 
+        into another type.
+
+        For example:
+            is_convertible<int,float>::value == true    // because ints are convertible to floats
+            is_convertible<int*,float>::value == false  // because int pointers are NOT convertible to floats
+    !*/
+
+    template <typename from, typename to>
+    struct is_convertible
+    {
+        struct yes_type { char a; };
+        struct no_type { yes_type a[2]; };
+        static const from& from_helper();
+        static yes_type test(to);
+        static no_type test(...);
+        const static bool value = sizeof(test(from_helper())) == sizeof(yes_type);
+    };
+
+// ----------------------------------------------------------------------------------------
+
+    struct general_ {};
+    struct special_ : general_ {};
+    template<typename> struct int_ { typedef int type; };
+
+// ----------------------------------------------------------------------------------------
+
+
+    /*!A is_same_object 
+
+        This is a templated function which checks if both of its arguments are actually
+        references to the same object.  It returns true if they are and false otherwise.
+
+    !*/
+
+    // handle the case where T and U are unrelated types.
+    template < typename T, typename U >
+    typename disable_if_c<is_convertible<T*, U*>::value || is_convertible<U*,T*>::value, bool>::type
+    is_same_object (
+        const T& a, 
+        const U& b
+    ) 
+    { 
+        return ((void*)&a == (void*)&b); 
+    }
+
+    // handle the case where T and U are related types because their pointers can be
+    // implicitly converted into one or the other.  E.g. a derived class and its base class. 
+    // Or where both T and U are just the same type.  This way we make sure that if there is a
+    // valid way to convert between these two pointer types then we will take that route rather
+    // than the void* approach used otherwise.
+    template < typename T, typename U >
+    typename enable_if_c<is_convertible<T*, U*>::value || is_convertible<U*,T*>::value, bool>::type
+    is_same_object (
+        const T& a, 
+        const U& b
+    ) 
+    { 
+        return (&a == &b); 
+    }
+
+// ----------------------------------------------------------------------------------------
+
+    /*!A is_unsigned_type 
+
+        This is a template where is_unsigned_type<T>::value == true when T is an unsigned
+        scalar type and false when T is a signed scalar type.
+    !*/
+    template <
+        typename T
+        >
+    struct is_unsigned_type
+    {
+        static const bool value = static_cast<T>((static_cast<T>(0)-static_cast<T>(1))) > 0;
+    };
+    template <> struct is_unsigned_type<long double> { static const bool value = false; };
+    template <> struct is_unsigned_type<double>      { static const bool value = false; };
+    template <> struct is_unsigned_type<float>       { static const bool value = false; };
+
+// ----------------------------------------------------------------------------------------
+
+    /*!A is_signed_type 
+
+        This is a template where is_signed_type<T>::value == true when T is a signed
+        scalar type and false when T is an unsigned scalar type.
+    !*/
+    template <
+        typename T
+        >
+    struct is_signed_type
+    {
+        static const bool value = !is_unsigned_type<T>::value;
+    };
+
+// ----------------------------------------------------------------------------------------
+
+    template <
+        typename T
+        >
+    class copy_functor
+    {
+    public:
+        void operator() (
+            const T& source, 
+            T& destination
+        ) const
+        {
+            destination = source;
+        }
+    };
+
+// ----------------------------------------------------------------------------------------
+
+    /*!A static_switch
+
+        To use this template you give it some number of boolean expressions and it
+        tells you which one of them is true.   If more than one of them is true then
+        it causes a compile time error.
+
+        for example:
+            static_switch<1 + 1 == 2, 4 - 1 == 4>::value == 1  // because the first expression is true
+            static_switch<1 + 1 == 3, 4 == 4>::value == 2      // because the second expression is true
+            static_switch<1 + 1 == 3, 4 == 5>::value == 0      // 0 here because none of them are true 
+            static_switch<1 + 1 == 2, 4 == 4>::value == compiler error  // because more than one expression is true 
+    !*/
+
+    template < bool v1 = 0, bool v2 = 0, bool v3 = 0, bool v4 = 0, bool v5 = 0,
+               bool v6 = 0, bool v7 = 0, bool v8 = 0, bool v9 = 0, bool v10 = 0, 
+               bool v11 = 0, bool v12 = 0, bool v13 = 0, bool v14 = 0, bool v15 = 0 >
+    struct static_switch; 
+
+    template <> struct static_switch<0,0,0,0,0,0,0,0,0,0,0,0,0,0,0> { const static int value = 0; };
+    template <> struct static_switch<1,0,0,0,0,0,0,0,0,0,0,0,0,0,0> { const static int value = 1; };
+    template <> struct static_switch<0,1,0,0,0,0,0,0,0,0,0,0,0,0,0> { const static int value = 2; };
+    template <> struct static_switch<0,0,1,0,0,0,0,0,0,0,0,0,0,0,0> { const static int value = 3; };
+    template <> struct static_switch<0,0,0,1,0,0,0,0,0,0,0,0,0,0,0> { const static int value = 4; };
+    template <> struct static_switch<0,0,0,0,1,0,0,0,0,0,0,0,0,0,0> { const static int value = 5; };
+    template <> struct static_switch<0,0,0,0,0,1,0,0,0,0,0,0,0,0,0> { const static int value = 6; };
+    template <> struct static_switch<0,0,0,0,0,0,1,0,0,0,0,0,0,0,0> { const static int value = 7; };
+    template <> struct static_switch<0,0,0,0,0,0,0,1,0,0,0,0,0,0,0> { const static int value = 8; };
+    template <> struct static_switch<0,0,0,0,0,0,0,0,1,0,0,0,0,0,0> { const static int value = 9; };
+    template <> struct static_switch<0,0,0,0,0,0,0,0,0,1,0,0,0,0,0> { const static int value = 10; };
+    template <> struct static_switch<0,0,0,0,0,0,0,0,0,0,1,0,0,0,0> { const static int value = 11; };
+    template <> struct static_switch<0,0,0,0,0,0,0,0,0,0,0,1,0,0,0> { const static int value = 12; };
+    template <> struct static_switch<0,0,0,0,0,0,0,0,0,0,0,0,1,0,0> { const static int value = 13; };
+    template <> struct static_switch<0,0,0,0,0,0,0,0,0,0,0,0,0,1,0> { const static int value = 14; };
+    template <> struct static_switch<0,0,0,0,0,0,0,0,0,0,0,0,0,0,1> { const static int value = 15; };
+
+// ----------------------------------------------------------------------------------------
+    /*!A is_built_in_scalar_type
+        
+        This is a template that allows you to determine if the given type is a built
+        in scalar type such as an int, char, float, short, etc.
+
+        For example, is_built_in_scalar_type<char>::value == true
+        For example, is_built_in_scalar_type<std::string>::value == false 
+    !*/
+
+    template <typename T> struct is_built_in_scalar_type        { const static bool value = false; };
+
+    template <> struct is_built_in_scalar_type<float>           { const static bool value = true; };
+    template <> struct is_built_in_scalar_type<double>          { const static bool value = true; };
+    template <> struct is_built_in_scalar_type<long double>     { const static bool value = true; };
+    template <> struct is_built_in_scalar_type<short>           { const static bool value = true; };
+    template <> struct is_built_in_scalar_type<int>             { const static bool value = true; };
+    template <> struct is_built_in_scalar_type<long>            { const static bool value = true; };
+    template <> struct is_built_in_scalar_type<unsigned short>  { const static bool value = true; };
+    template <> struct is_built_in_scalar_type<unsigned int>    { const static bool value = true; };
+    template <> struct is_built_in_scalar_type<unsigned long>   { const static bool value = true; };
+    template <> struct is_built_in_scalar_type<uint64>          { const static bool value = true; };
+    template <> struct is_built_in_scalar_type<int64>           { const static bool value = true; };
+    template <> struct is_built_in_scalar_type<char>            { const static bool value = true; };
+    template <> struct is_built_in_scalar_type<signed char>     { const static bool value = true; };
+    template <> struct is_built_in_scalar_type<unsigned char>   { const static bool value = true; };
+    // Don't define one for wchar_t when using a version of visual studio
+    // older than 8.0 (visual studio 2005) since before then they improperly set
+    // wchar_t to be a typedef rather than its own type as required by the C++ 
+    // standard.
+#if !defined(_MSC_VER) || _NATIVE_WCHAR_T_DEFINED
+    template <> struct is_built_in_scalar_type<wchar_t>         { const static bool value = true; };
+#endif
+
+// ----------------------------------------------------------------------------------------
+    
+    template <
+        typename T
+        >
+    typename enable_if<is_built_in_scalar_type<T>,bool>::type is_finite (
+        const T& value
+    )
+    /*!
+        requires
+            - value must be some kind of scalar type such as int or double
+        ensures
+            - returns true if value is a finite value (e.g. not infinity or NaN) and false
+              otherwise.
+    !*/
+    {
+        if (is_float_type<T>::value)
+            return -std::numeric_limits<T>::infinity() < value && value < std::numeric_limits<T>::infinity();
+        else
+            return true;
+    }
+
+// ----------------------------------------------------------------------------------------
+
+    /*!A promote 
+        
+        This is a template that takes one of the built in scalar types and gives you another
+        scalar type that should be big enough to hold sums of values from the original scalar 
+        type.  The new scalar type will also always be signed.
+
+        For example, promote<uint16>::type == int32
+    !*/
+
+    template <typename T, size_t s = sizeof(T)> struct promote;
+    template <typename T> struct promote<T,1> { typedef int32 type; };
+    template <typename T> struct promote<T,2> { typedef int32 type; };
+    template <typename T> struct promote<T,4> { typedef int64 type; };
+    template <typename T> struct promote<T,8> { typedef int64 type; };
+
+    template <> struct promote<float,sizeof(float)>             { typedef double type; };
+    template <> struct promote<double,sizeof(double)>           { typedef double type; };
+    template <> struct promote<long double,sizeof(long double)> { typedef long double type; };
+
+// ----------------------------------------------------------------------------------------
+    
+    /*!A assign_zero_if_built_in_scalar_type
+
+        This function assigns its argument the value of 0 if it is a built in scalar
+        type according to the is_built_in_scalar_type<> template.  If it isn't a
+        built in scalar type then it does nothing.
+    !*/
+
+    template <typename T> inline typename disable_if<is_built_in_scalar_type<T>,void>::type assign_zero_if_built_in_scalar_type (T&){}
+    template <typename T> inline typename enable_if<is_built_in_scalar_type<T>,void>::type assign_zero_if_built_in_scalar_type (T& a){a=0;}
+
+// ----------------------------------------------------------------------------------------
+
+    /*!A basic_type
+
+        This is a template that takes a type and strips off any const, volatile, or reference
+        qualifiers and gives you back the basic underlying type.  So for example:
+
+        basic_type<const int&>::type == int
+    !*/
+
+    template <typename T> struct basic_type { typedef T type; };
+    template <typename T> struct basic_type<const T> { typedef T type; };
+    template <typename T> struct basic_type<const T&> { typedef T type; };
+    template <typename T> struct basic_type<volatile const T&> { typedef T type; };
+    template <typename T> struct basic_type<T&> { typedef T type; };
+    template <typename T> struct basic_type<volatile T&> { typedef T type; };
+    template <typename T> struct basic_type<volatile T> { typedef T type; };
+    template <typename T> struct basic_type<volatile const T> { typedef T type; };
+
+// ----------------------------------------------------------------------------------------
+
+    template <typename T>
+    T put_in_range (
+        const T& a, 
+        const T& b, 
+        const T& val
+    )
+    /*!
+        requires
+            - T is a type that looks like double, float, int, or so forth
+        ensures
+            - if (val is within the range [a,b]) then
+                - returns val
+            - else 
+                - returns the end of the range [a,b] that is closest to val
+    !*/
+    {
+        if (a < b)
+        {
+            if (val < a)
+                return a;
+            else if (val > b)
+                return b;
+        }
+        else
+        {
+            if (val < b)
+                return b;
+            else if (val > a)
+                return a;
+        }
+
+        return val;
+    }
+
+    // overload for double 
+    inline double put_in_range(const double& a, const double& b, const double& val)
+    { return put_in_range<double>(a,b,val); }
+
+// ----------------------------------------------------------------------------------------
+
+    /*!A tabs 
+
+        This is a template to compute the absolute value a number at compile time.
+
+        For example,
+            abs<-4>::value == 4
+            abs<4>::value == 4
+    !*/
+
+    template <long x, typename enabled=void>
+    struct tabs { const static long value = x; };
+    template <long x>
+    struct tabs<x,typename enable_if_c<(x < 0)>::type> { const static long value = -x; };
+
+// ----------------------------------------------------------------------------------------
+
+    /*!A tmax
+
+        This is a template to compute the max of two values at compile time
+
+        For example,
+            abs<4,7>::value == 7
+    !*/
+
+    template <long x, long y, typename enabled=void>
+    struct tmax { const static long value = x; };
+    template <long x, long y>
+    struct tmax<x,y,typename enable_if_c<(y > x)>::type> { const static long value = y; };
+
+// ----------------------------------------------------------------------------------------
+
+    /*!A tmin 
+
+        This is a template to compute the min of two values at compile time
+
+        For example,
+            abs<4,7>::value == 4
+    !*/
+
+    template <long x, long y, typename enabled=void>
+    struct tmin { const static long value = x; };
+    template <long x, long y>
+    struct tmin<x,y,typename enable_if_c<(y < x)>::type> { const static long value = y; };
+
+// ----------------------------------------------------------------------------------------
+
+#define DLIB_MAKE_HAS_MEMBER_FUNCTION_TEST(testname, returnT, funct_name, args)                        \
+    struct _two_bytes_##testname { char a[2]; };                                                       \
+    template < typename T, returnT (T::*funct)args >                                                   \
+    struct _helper_##testname { typedef char type; };                                                  \
+    template <typename T>                                                                              \
+    static char _has_##testname##_helper( typename _helper_##testname<T,&T::funct_name >::type ) { return 0;} \
+    template <typename T>                                                                              \
+    static _two_bytes_##testname _has_##testname##_helper(int) { return _two_bytes_##testname();}             \
+    template <typename T> struct _##testname##workaroundbug {                                          \
+                const static unsigned long U = sizeof(_has_##testname##_helper<T>('a')); };            \
+    template <typename T, unsigned long U = _##testname##workaroundbug<T>::U >                         \
+    struct testname      { static const bool value = false; };                                         \
+    template <typename T>                                                                              \
+    struct testname<T,1> { static const bool value = true; };
+    /*!A DLIB_MAKE_HAS_MEMBER_FUNCTION_TEST
+
+        The DLIB_MAKE_HAS_MEMBER_FUNCTION_TEST() macro is used to define traits templates
+        that tell you if a class has a certain member function.  For example, to make a
+        test to see if a class has a public method with the signature void print(int) you
+        would say:
+            DLIB_MAKE_HAS_MEMBER_FUNCTION_TEST(has_print, void, print, (int))
+
+        Then you can check if a class, T, has this method by looking at the boolean value:
+            has_print<T>::value 
+        which will be true if the member function is in the T class.
+
+        Note that you can test for member functions taking no arguments by simply passing
+        in empty () like so:
+            DLIB_MAKE_HAS_MEMBER_FUNCTION_TEST(has_print, void, print, ())
+        This would test for a member of the form:
+            void print().
+
+        To test for const member functions you would use a statement such as this:
+            DLIB_MAKE_HAS_MEMBER_FUNCTION_TEST(has_print, void, print, ()const)
+        This would test for a member of the form: 
+            void print() const.
+
+        To test for const templated member functions you would use a statement such as this:
+            DLIB_MAKE_HAS_MEMBER_FUNCTION_TEST(has_print, void, template print<int>, ())
+        This would test for a member of the form: 
+            template <typename T> void print().
+    !*/
+
+// ----------------------------------------------------------------------------------------
+
+    /*!A is_function 
+        
+        This is a template that allows you to determine if the given type is a function.
+
+        For example,
+            void funct();
+
+            is_built_in_scalar_type<funct>::value == true
+            is_built_in_scalar_type<int>::value == false 
+    !*/
+
+    template <typename T> struct is_function { static const bool value = false; };
+    template <typename T> 
+    struct is_function<T (void)> { static const bool value = true; };
+    template <typename T, typename A0> 
+    struct is_function<T (A0)> { static const bool value = true; };
+    template <typename T, typename A0, typename A1> 
+    struct is_function<T (A0, A1)> { static const bool value = true; };
+    template <typename T, typename A0, typename A1, typename A2> 
+    struct is_function<T (A0, A1, A2)> { static const bool value = true; };
+    template <typename T, typename A0, typename A1, typename A2, typename A3> 
+    struct is_function<T (A0, A1, A2, A3)> { static const bool value = true; };
+    template <typename T, typename A0, typename A1, typename A2, typename A3, typename A4> 
+    struct is_function<T (A0, A1, A2, A3, A4)> { static const bool value = true; };
+    template <typename T, typename A0, typename A1, typename A2, typename A3, typename A4,
+                          typename A5> 
+    struct is_function<T (A0,A1,A2,A3,A4,A5)> { static const bool value = true; };
+    template <typename T, typename A0, typename A1, typename A2, typename A3, typename A4,
+                          typename A5, typename A6> 
+    struct is_function<T (A0,A1,A2,A3,A4,A5,A6)> { static const bool value = true; };
+    template <typename T, typename A0, typename A1, typename A2, typename A3, typename A4,
+                          typename A5, typename A6, typename A7> 
+    struct is_function<T (A0,A1,A2,A3,A4,A5,A6,A7)> { static const bool value = true; };
+    template <typename T, typename A0, typename A1, typename A2, typename A3, typename A4,
+                          typename A5, typename A6, typename A7, typename A8> 
+    struct is_function<T (A0,A1,A2,A3,A4,A5,A6,A7,A8)> { static const bool value = true; };
+    template <typename T, typename A0, typename A1, typename A2, typename A3, typename A4,
+                          typename A5, typename A6, typename A7, typename A8, typename A9> 
+    struct is_function<T (A0,A1,A2,A3,A4,A5,A6,A7,A8,A9)> { static const bool value = true; };
+
+
+    template <typename T> class funct_wrap0
+    {
+    public:
+        funct_wrap0(T (&f_)()):f(f_){}
+        T operator()() const { return f(); }
+    private:
+        T (&f)();
+    };
+    template <typename T, typename A0> class funct_wrap1
+    {
+    public:
+        funct_wrap1(T (&f_)(A0)):f(f_){}
+        T operator()(A0 a0) const { return f(a0); }
+    private:
+        T (&f)(A0);
+    };
+    template <typename T, typename A0, typename A1> class funct_wrap2
+    {
+    public:
+        funct_wrap2(T (&f_)(A0,A1)):f(f_){}
+        T operator()(A0 a0, A1 a1) const { return f(a0,a1); }
+    private:
+        T (&f)(A0,A1);
+    };
+    template <typename T, typename A0, typename A1, typename A2> class funct_wrap3
+    {
+    public:
+        funct_wrap3(T (&f_)(A0,A1,A2)):f(f_){}
+        T operator()(A0 a0, A1 a1, A2 a2) const { return f(a0,a1,a2); }
+    private:
+        T (&f)(A0,A1,A2);
+    };
+    template <typename T, typename A0, typename A1, typename A2, typename A3> class funct_wrap4
+    {
+    public:
+        funct_wrap4(T (&f_)(A0,A1,A2,A3)):f(f_){}
+        T operator()(A0 a0, A1 a1, A2 a2, A3 a3) const { return f(a0,a1,a2,a3); }
+    private:
+        T (&f)(A0,A1,A2,A3);
+    };
+    template <typename T, typename A0, typename A1, typename A2, typename A3, typename A4> class funct_wrap5
+    {
+    public:
+        funct_wrap5(T (&f_)(A0,A1,A2,A3,A4)):f(f_){}
+        T operator()(A0 a0, A1 a1, A2 a2, A3 a3, A4 a4) const { return f(a0,a1,a2,a3,a4); }
+    private:
+        T (&f)(A0,A1,A2,A3,A4);
+    };
+
+    /*!A wrap_function 
+        
+        This is a template that allows you to turn a global function into a 
+        function object.  The reason for this template's existence is so you can
+        do stuff like this:
+            
+            template <typename T>
+            void call_funct(const T& funct)
+            {  cout << funct(); }
+
+            std::string test() { return "asdfasf"; }
+
+            int main()
+            {
+                call_funct(wrap_function(test));
+            }
+
+        The above code doesn't work right on some compilers if you don't
+        use wrap_function.  
+    !*/
+
+    template <typename T>
+    funct_wrap0<T> wrap_function(T (&f)()) { return funct_wrap0<T>(f); }
+    template <typename T, typename A0>
+    funct_wrap1<T,A0> wrap_function(T (&f)(A0)) { return funct_wrap1<T,A0>(f); }
+    template <typename T, typename A0, typename A1>
+    funct_wrap2<T,A0,A1> wrap_function(T (&f)(A0, A1)) { return funct_wrap2<T,A0,A1>(f); }
+    template <typename T, typename A0, typename A1, typename A2>
+    funct_wrap3<T,A0,A1,A2> wrap_function(T (&f)(A0, A1, A2)) { return funct_wrap3<T,A0,A1,A2>(f); }
+    template <typename T, typename A0, typename A1, typename A2, typename A3>
+    funct_wrap4<T,A0,A1,A2,A3> wrap_function(T (&f)(A0, A1, A2, A3)) { return funct_wrap4<T,A0,A1,A2,A3>(f); }
+    template <typename T, typename A0, typename A1, typename A2, typename A3, typename A4>
+    funct_wrap5<T,A0,A1,A2,A3,A4> wrap_function(T (&f)(A0, A1, A2, A3, A4)) { return funct_wrap5<T,A0,A1,A2,A3,A4>(f); }
+
+// ----------------------------------------------------------------------------------------
+
+    template <unsigned long bSIZE>
+    class stack_based_memory_block : noncopyable
+    {
+        /*!
+            WHAT THIS OBJECT REPRESENTS
+                This object is a simple container for a block of memory
+                of bSIZE bytes.  This memory block is located on the stack
+                and properly aligned to hold any kind of object.
+        !*/
+    public:
+        static const unsigned long size = bSIZE;
+
+        stack_based_memory_block(): data(mem.data) {}
+
+        void* get () { return data; }
+        /*!
+            ensures
+                - returns a pointer to the block of memory contained in this object
+        !*/
+
+        const void* get () const { return data; }
+        /*!
+            ensures
+                - returns a pointer to the block of memory contained in this object
+        !*/
+
+    private:
+
+        // You obviously can't have a block of memory that has zero bytes in it.
+        COMPILE_TIME_ASSERT(bSIZE > 0);
+        
+        union mem_block
+        {
+            // All of this garbage is to make sure this union is properly aligned 
+            // (a union is always aligned such that everything in it would be properly
+            // aligned.  So the assumption here is that one of these objects has 
+            // a large enough alignment requirement to satisfy any object this
+            // block of memory might be cast into).
+            void* void_ptr;
+            int integer;
+            struct {
+                void (stack_based_memory_block::*callback)();
+                stack_based_memory_block* o; 
+            } stuff;
+            long double more_stuff;
+
+            uint64 var1;
+            uint32 var2;
+            double var3;
+
+            char data[size]; 
+        } mem;
+
+        // The reason for having this variable is that doing it this way avoids
+        // warnings from gcc about violations of strict-aliasing rules.
+        void* const data; 
+    };
+
+// ----------------------------------------------------------------------------------------
+
+    template <
+        typename T, 
+        typename F
+        >
+    auto max_scoring_element(
+        const T& container,
+        F score_func
+    ) -> decltype(std::make_pair(*container.begin(), 0.0))
+    /*!
+        requires
+            - container has .begin() and .end(), allowing it to be enumerated.
+            - score_func() is a function that takes an element of the container and returns a double.
+        ensures
+            - This function finds the element of container that has the largest score,
+              according to score_func(), and returns a std::pair containing that maximal
+              element along with the score.
+            - If the container is empty then make_pair(a default initialized object, -infinity) is returned.
+    !*/
+    {
+        double best_score = -std::numeric_limits<double>::infinity();
+        auto best_i = container.begin();
+        for (auto i = container.begin(); i != container.end(); ++i)
+        {
+            auto score = score_func(*i);
+            if (score > best_score)
+            {
+                best_score = score;
+                best_i = i;
+            }
+        }
+
+        using item_type = typename std::remove_reference<decltype(*best_i)>::type;
+
+        if (best_i == container.end())
+            return std::make_pair(item_type(), best_score);
+        else
+            return std::make_pair(*best_i, best_score);
+    }
+
+// ----------------------------------------------------------------------------------------
+
+    template <
+        typename T, 
+        typename F
+        >
+    auto min_scoring_element(
+        const T& container, 
+        F score_func
+    ) -> decltype(std::make_pair(*container.begin(), 0.0))
+    /*!
+        requires
+            - container has .begin() and .end(), allowing it to be enumerated.
+            - score_func() is a function that takes an element of the container and returns a double.
+        ensures
+            - This function finds the element of container that has the smallest score,
+              according to score_func(), and returns a std::pair containing that minimal
+              element along with the score.
+            - If the container is empty then make_pair(a default initialized object, infinity) is returned.
+    !*/
+    {
+        double best_score = std::numeric_limits<double>::infinity();
+        auto best_i = container.begin();
+        for (auto i = container.begin(); i != container.end(); ++i)
+        {
+            auto score = score_func(*i);
+            if (score < best_score)
+            {
+                best_score = score;
+                best_i = i;
+            }
+        }
+
+        using item_type = typename std::remove_reference<decltype(*best_i)>::type;
+
+        if (best_i == container.end())
+            return std::make_pair(item_type(), best_score);
+        else
+            return std::make_pair(*best_i, best_score);
+    }
+
+// ----------------------------------------------------------------------------------------
+
+}
+
+#endif // DLIB_ALGs_
+

dlibs/dlib/all/source.cpp

@@ -0,0 +1,100 @@
+// Copyright (C) 2006  Davis E. King ([email protected])
+// 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 "../cuda/cpu_dlib.cpp"
+#include "../cuda/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_
+

dlibs/dlib/any.h

@@ -0,0 +1,13 @@
+// Copyright (C) 2010  Davis E. King ([email protected])
+// 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_
+
+

dlibs/dlib/any/any.h

@@ -0,0 +1,183 @@
+// Copyright (C) 2010  Davis E. King ([email protected])
+// License: Boost Software License   See LICENSE.txt for the full license.
+#ifndef DLIB_AnY_H_
+#define DLIB_AnY_H_
+
+#include "any_abstract.h"
+#include "../algs.h"
+
+#include <memory>
+#include <typeinfo>
+
+namespace dlib
+{
+
+// ----------------------------------------------------------------------------------------
+
+    class bad_any_cast : public std::bad_cast 
+    {
+    public:
+          virtual const char * what() const throw()
+          {
+              return "bad_any_cast";
+          }
+    };
+
+// ----------------------------------------------------------------------------------------
+
+    class any
+    {
+
+    public:
+
+        any()
+        {
+        }
+
+        any (
+            const any& item
+        )
+        {
+            if (item.data)
+            {
+                item.data->copy_to(data);
+            }
+        }
+
+        template <typename T>
+        any (
+            const T& item
+        )
+        {
+            typedef typename basic_type<T>::type U;
+            data.reset(new derived<U>(item));
+        }
+
+        void clear (
+        )
+        {
+            data.reset();
+        }
+
+        template <typename T>
+        bool contains (
+        ) const
+        {
+            typedef typename basic_type<T>::type U;
+            return dynamic_cast<derived<U>*>(data.get()) != 0;
+        }
+
+        bool is_empty(
+        ) const
+        {
+            return data.get() == 0;
+        }
+
+        template <typename T>
+        T& cast_to(
+        ) 
+        {
+            typedef typename basic_type<T>::type U;
+            derived<U>* d = dynamic_cast<derived<U>*>(data.get());
+            if (d == 0)
+            {
+                throw bad_any_cast();
+            }
+
+            return d->item;
+        }
+
+        template <typename T>
+        const T& cast_to(
+        ) const
+        {
+            typedef typename basic_type<T>::type U;
+            derived<U>* d = dynamic_cast<derived<U>*>(data.get());
+            if (d == 0)
+            {
+                throw bad_any_cast();
+            }
+
+            return d->item;
+        }
+
+        template <typename T>
+        T& get(
+        ) 
+        {
+            typedef typename basic_type<T>::type U;
+            derived<U>* d = dynamic_cast<derived<U>*>(data.get());
+            if (d == 0)
+            {
+                d = new derived<U>();
+                data.reset(d);
+            }
+
+            return d->item;
+        }
+
+        any& operator= (
+            const any& item
+        )
+        {
+            any(item).swap(*this);
+            return *this;
+        }
+
+        void swap (
+            any& item
+        )
+        {
+            data.swap(item.data);
+        }
+
+    private:
+
+        struct base
+        {
+            virtual ~base() {}
+
+            virtual void copy_to (
+                std::unique_ptr<base>& dest
+            ) const = 0;
+        };
+
+        template <typename T>
+        struct derived : public base
+        {
+            T item;
+            derived() {}
+            derived(const T& val) : item(val) {}
+
+            virtual void copy_to (
+                std::unique_ptr<base>& dest
+            ) const
+            {
+                dest.reset(new derived<T>(item));
+            }
+        };
+
+        std::unique_ptr<base> data;
+    };
+
+// ----------------------------------------------------------------------------------------
+
+    inline void swap (
+        any& a,
+        any& b
+    ) { a.swap(b); }
+
+// ----------------------------------------------------------------------------------------
+
+    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_
+
+
+

dlibs/dlib/any/any_abstract.h

@@ -0,0 +1,210 @@
+// Copyright (C) 2010  Davis E. King ([email protected])
+// 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.
+        !*/
+
+        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.
+        !*/
+
+    };
+
+// ----------------------------------------------------------------------------------------
+
+    inline void swap (
+        any& a,
+        any& b
+    ) { a.swap(b); }
+    /*!
+        provides a global swap function
+    !*/
+
+// ----------------------------------------------------------------------------------------
+
+    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_
+
+

dlibs/dlib/any/any_decision_function.h

@@ -0,0 +1,209 @@
+// Copyright (C) 2010  Davis E. King ([email protected])
+// 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.h"
+
+#include "any_decision_function_abstract.h"
+
+namespace dlib
+{
+
+// ----------------------------------------------------------------------------------------
+
+    template <
+        typename sample_type_,
+        typename result_type_ = double
+        >
+    class any_decision_function
+    {
+
+    public:
+
+        typedef sample_type_ sample_type;
+        typedef result_type_ result_type;
+        typedef default_memory_manager mem_manager_type;
+
+        any_decision_function()
+        {
+        }
+
+        any_decision_function (
+            const any_decision_function& item
+        )
+        {
+            if (item.data)
+            {
+                item.data->copy_to(data);
+            }
+        }
+
+        template <typename T>
+        any_decision_function (
+            const T& item
+        )
+        {
+            typedef typename basic_type<T>::type U;
+            data.reset(new derived<U>(item));
+        }
+
+        void clear (
+        )
+        {
+            data.reset();
+        }
+
+        template <typename T>
+        bool contains (
+        ) const
+        {
+            typedef typename basic_type<T>::type U;
+            return dynamic_cast<derived<U>*>(data.get()) != 0;
+        }
+
+        bool is_empty(
+        ) const
+        {
+            return data.get() == 0;
+        }
+
+        result_type operator() (
+            const sample_type& item
+        ) const
+        {
+            // make sure requires clause is not broken
+            DLIB_ASSERT(is_empty() == false,
+                "\t result_type any_decision_function::operator()"
+                << "\n\t You can't call operator() on an empty any_decision_function"
+                << "\n\t this: " << this
+                );
+
+            return data->evaluate(item);
+        }
+
+        template <typename T>
+        T& cast_to(
+        ) 
+        {
+            typedef typename basic_type<T>::type U;
+            derived<U>* d = dynamic_cast<derived<U>*>(data.get());
+            if (d == 0)
+            {
+                throw bad_any_cast();
+            }
+
+            return d->item;
+        }
+
+        template <typename T>
+        const T& cast_to(
+        ) const
+        {
+            typedef typename basic_type<T>::type U;
+            derived<U>* d = dynamic_cast<derived<U>*>(data.get());
+            if (d == 0)
+            {
+                throw bad_any_cast();
+            }
+
+            return d->item;
+        }
+
+        template <typename T>
+        T& get(
+        ) 
+        {
+            typedef typename basic_type<T>::type U;
+            derived<U>* d = dynamic_cast<derived<U>*>(data.get());
+            if (d == 0)
+            {
+                d = new derived<U>();
+                data.reset(d);
+            }
+
+            return d->item;
+        }
+
+        any_decision_function& operator= (
+            const any_decision_function& item
+        )
+        {
+            any_decision_function(item).swap(*this);
+            return *this;
+        }
+
+        void swap (
+            any_decision_function& item
+        )
+        {
+            data.swap(item.data);
+        }
+
+    private:
+
+        struct base
+        {
+            virtual ~base() {}
+
+            virtual void copy_to (
+                std::unique_ptr<base>& dest
+            ) const = 0;
+
+            virtual result_type evaluate (
+                const sample_type& samp
+            ) const = 0;
+        };
+
+        template <typename T>
+        struct derived : public base
+        {
+            T item;
+            derived() {}
+            derived(const T& val) : item(val) {}
+
+            virtual void copy_to (
+                std::unique_ptr<base>& dest
+            ) const
+            {
+                dest.reset(new derived<T>(item));
+            }
+
+            virtual result_type evaluate (
+                const sample_type& samp
+            ) const 
+            {
+                return item(samp);
+            }
+        };
+
+        std::unique_ptr<base> data;
+    };
+
+// ----------------------------------------------------------------------------------------
+
+    template <
+        typename sample_type,
+        typename result_type
+        >
+    inline void swap (
+        any_decision_function<sample_type, result_type>& a,
+        any_decision_function<sample_type, result_type>& b
+    ) { a.swap(b); }
+
+// ----------------------------------------------------------------------------------------
+
+    template <typename T, typename U, typename V> 
+    T& any_cast(any_decision_function<U,V>& a) { return a.template cast_to<T>(); }
+
+    template <typename T, typename U, typename V> 
+    const T& any_cast(const any_decision_function<U,V>& a) { return a.template cast_to<T>(); }
+
+// ----------------------------------------------------------------------------------------
+
+}
+
+
+#endif // DLIB_AnY_DECISION_FUNCTION_Hh_
+
+

dlibs/dlib/any/any_decision_function_abstract.h

@@ -0,0 +1,224 @@
+// Copyright (C) 2010  Davis E. King ([email protected])
+// 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_abstract.h"
+#include "../algs.h"
+
+namespace dlib
+{
+
+// ----------------------------------------------------------------------------------------
+
+    template <
+        typename sample_type_,
+        typename result_type_ = double
+        >
+    class any_decision_function
+    {
+        /*!
+            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() with 
+                the following signature: 
+                    result_type operator()(const sample_type&) const
+
+                It is intended to be used to contain dlib::decision_function objects and
+                other types which represent learned decision functions.  It allows you
+                to write code which contains and processes these decision functions
+                without needing to know the specific types of decision functions used.
+        !*/
+
+    public:
+
+        typedef sample_type_ sample_type;
+        typedef result_type_ result_type;
+        typedef default_memory_manager mem_manager_type;
+
+        any_decision_function(
+        );
+        /*!
+            ensures
+                - this object is properly initialized
+        !*/
+
+        any_decision_function (
+            const any_decision_function& 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.
+        !*/
+
+        template < typename T >
+        any_decision_function (
+            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
+        !*/
+
+        result_type operator() (
+            const sample_type& item
+        ) const;
+        /*!
+            requires
+                - is_empty() == false
+            ensures
+                - Let F denote the function object contained within *this.  Then
+                  this function performs:
+                    return F(item)
+        !*/
+
+        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_decision_function object is destructed and its
+                      state is lost.
+                    - returns a non-const reference to the newly created T object.
+        !*/
+
+        any_decision_function& operator= (
+            const any_decision_function& 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_decision_function& item
+        );
+        /*!
+            ensures
+                - swaps *this and item
+        !*/
+
+    };
+
+// ----------------------------------------------------------------------------------------
+
+    template <
+        typename sample_type,
+        typename result_type
+        >
+    inline void swap (
+        any_decision_function<sample_type,result_type>& a,
+        any_decision_function<sample_type,result_type>& b
+    ) { a.swap(b); }
+    /*!
+        provides a global swap function
+    !*/
+
+// ----------------------------------------------------------------------------------------
+
+    template <
+        typename T,
+        typename sample_type,
+        typename result_type
+        > 
+    T& any_cast(
+        any_decision_function<sample_type,result_type>& a
+    ) { return a.cast_to<T>(); }
+    /*!
+        ensures
+            - returns a.cast_to<T>()
+    !*/
+
+// ----------------------------------------------------------------------------------------
+
+    template <
+        typename T,
+        typename sample_type,
+        typename result_type
+        > 
+    const T& any_cast(
+        const any_decision_function<sample_type,result_type>& a
+    ) { return a.cast_to<T>(); }
+    /*!
+        ensures
+            - returns a.cast_to<T>()
+    !*/
+
+// ----------------------------------------------------------------------------------------
+
+}
+
+#endif // DLIB_AnY_DECISION_FUNCTION_ABSTRACT_H_
+
+
+

dlibs/dlib/any/any_function.h

@@ -0,0 +1,885 @@
+// Copyright (C) 2011  Davis E. King ([email protected])
+// License: Boost Software License   See LICENSE.txt for the full license.
+#ifndef DLIB_AnY_FUNCTION_Hh_
+#define DLIB_AnY_FUNCTION_Hh_
+
+#include "any.h"
+
+#include "any_function_abstract.h"
+
+namespace dlib
+{
+
+// ----------------------------------------------------------------------------------------
+
+    template <typename T>
+    struct sig_traits {};
+
+    template <
+        typename T
+        >
+    struct sig_traits<T ()> 
+    { 
+        typedef T result_type; 
+        typedef void arg1_type; 
+        typedef void arg2_type; 
+        typedef void arg3_type; 
+        typedef void arg4_type; 
+        typedef void arg5_type; 
+        typedef void arg6_type; 
+        typedef void arg7_type; 
+        typedef void arg8_type; 
+        typedef void arg9_type; 
+        typedef void arg10_type; 
+        typedef void arg11_type; 
+        typedef void arg12_type; 
+        typedef void arg13_type; 
+        typedef void arg14_type; 
+        typedef void arg15_type; 
+        typedef void arg16_type; 
+        typedef void arg17_type; 
+        typedef void arg18_type; 
+        typedef void arg19_type; 
+        typedef void arg20_type; 
+
+        const static unsigned long num_args = 0;
+    };
+
+    template <
+        typename T,
+        typename A1
+        >
+    struct sig_traits<T (A1)> 
+    { 
+        typedef T result_type; 
+        typedef A1 arg1_type; 
+        typedef void arg2_type; 
+        typedef void arg3_type; 
+        typedef void arg4_type; 
+        typedef void arg5_type; 
+        typedef void arg6_type; 
+        typedef void arg7_type; 
+        typedef void arg8_type; 
+        typedef void arg9_type; 
+        typedef void arg10_type; 
+        typedef void arg11_type; 
+        typedef void arg12_type; 
+        typedef void arg13_type; 
+        typedef void arg14_type; 
+        typedef void arg15_type; 
+        typedef void arg16_type; 
+        typedef void arg17_type; 
+        typedef void arg18_type; 
+        typedef void arg19_type; 
+        typedef void arg20_type; 
+
+        const static unsigned long num_args = 1;
+    };
+
+    template <
+        typename T,
+        typename A1, typename A2
+        >
+    struct sig_traits<T (A1,A2)> 
+    { 
+        typedef T result_type; 
+        typedef A1 arg1_type; 
+        typedef A2 arg2_type; 
+        typedef void arg3_type; 
+        typedef void arg4_type; 
+        typedef void arg5_type; 
+        typedef void arg6_type; 
+        typedef void arg7_type; 
+        typedef void arg8_type; 
+        typedef void arg9_type; 
+        typedef void arg10_type; 
+        typedef void arg11_type; 
+        typedef void arg12_type; 
+        typedef void arg13_type; 
+        typedef void arg14_type; 
+        typedef void arg15_type; 
+        typedef void arg16_type; 
+        typedef void arg17_type; 
+        typedef void arg18_type; 
+        typedef void arg19_type; 
+        typedef void arg20_type; 
+
+        const static unsigned long num_args = 2;
+    };
+
+    template <
+        typename T,
+        typename A1, typename A2, typename A3
+        >
+    struct sig_traits<T (A1,A2,A3)> 
+    { 
+        typedef T result_type; 
+        typedef A1 arg1_type; 
+        typedef A2 arg2_type; 
+        typedef A3 arg3_type; 
+        typedef void arg4_type; 
+        typedef void arg5_type; 
+        typedef void arg6_type; 
+        typedef void arg7_type; 
+        typedef void arg8_type; 
+        typedef void arg9_type; 
+        typedef void arg10_type; 
+        typedef void arg11_type; 
+        typedef void arg12_type; 
+        typedef void arg13_type; 
+        typedef void arg14_type; 
+        typedef void arg15_type; 
+        typedef void arg16_type; 
+        typedef void arg17_type; 
+        typedef void arg18_type; 
+        typedef void arg19_type; 
+        typedef void arg20_type; 
+
+        const static unsigned long num_args = 3;
+    };
+
+    template <
+        typename T,
+        typename A1, typename A2, typename A3,
+        typename A4
+        >
+    struct sig_traits<T (A1,A2,A3,A4)> 
+    { 
+        typedef T result_type; 
+        typedef A1 arg1_type; 
+        typedef A2 arg2_type; 
+        typedef A3 arg3_type; 
+        typedef A4 arg4_type; 
+        typedef void arg5_type; 
+        typedef void arg6_type; 
+        typedef void arg7_type; 
+        typedef void arg8_type; 
+        typedef void arg9_type; 
+        typedef void arg10_type; 
+        typedef void arg11_type; 
+        typedef void arg12_type; 
+        typedef void arg13_type; 
+        typedef void arg14_type; 
+        typedef void arg15_type; 
+        typedef void arg16_type; 
+        typedef void arg17_type; 
+        typedef void arg18_type; 
+        typedef void arg19_type; 
+        typedef void arg20_type; 
+
+        const static unsigned long num_args = 4;
+    };
+
+    template <
+        typename T,
+        typename A1, typename A2, typename A3,
+        typename A4, typename A5
+        >
+    struct sig_traits<T (A1,A2,A3,A4,A5)> 
+    { 
+        typedef T result_type; 
+        typedef A1 arg1_type; 
+        typedef A2 arg2_type; 
+        typedef A3 arg3_type; 
+        typedef A4 arg4_type; 
+        typedef A5 arg5_type; 
+        typedef void arg6_type; 
+        typedef void arg7_type; 
+        typedef void arg8_type; 
+        typedef void arg9_type; 
+        typedef void arg10_type; 
+        typedef void arg11_type; 
+        typedef void arg12_type; 
+        typedef void arg13_type; 
+        typedef void arg14_type; 
+        typedef void arg15_type; 
+        typedef void arg16_type; 
+        typedef void arg17_type; 
+        typedef void arg18_type; 
+        typedef void arg19_type; 
+        typedef void arg20_type; 
+
+        const static unsigned long num_args = 5;
+    };
+
+    template <
+        typename T,
+        typename A1, typename A2, typename A3,
+        typename A4, typename A5, typename A6
+        >
+    struct sig_traits<T (A1,A2,A3,A4,A5,A6)> 
+    { 
+        typedef T result_type; 
+        typedef A1 arg1_type; 
+        typedef A2 arg2_type; 
+        typedef A3 arg3_type; 
+        typedef A4 arg4_type; 
+        typedef A5 arg5_type; 
+        typedef A6 arg6_type; 
+        typedef void arg7_type; 
+        typedef void arg8_type; 
+        typedef void arg9_type; 
+        typedef void arg10_type; 
+        typedef void arg11_type; 
+        typedef void arg12_type; 
+        typedef void arg13_type; 
+        typedef void arg14_type; 
+        typedef void arg15_type; 
+        typedef void arg16_type; 
+        typedef void arg17_type; 
+        typedef void arg18_type; 
+        typedef void arg19_type; 
+        typedef void arg20_type; 
+
+        const static unsigned long num_args = 6;
+    };
+
+    template <
+        typename T,
+        typename A1, typename A2, typename A3,
+        typename A4, typename A5, typename A6,
+        typename A7
+        >
+    struct sig_traits<T (A1,A2,A3,A4,A5,A6,A7)> 
+    { 
+        typedef T result_type; 
+        typedef A1 arg1_type; 
+        typedef A2 arg2_type; 
+        typedef A3 arg3_type; 
+        typedef A4 arg4_type; 
+        typedef A5 arg5_type; 
+        typedef A6 arg6_type; 
+        typedef A7 arg7_type; 
+        typedef void arg8_type; 
+        typedef void arg9_type; 
+        typedef void arg10_type; 
+        typedef void arg11_type; 
+        typedef void arg12_type; 
+        typedef void arg13_type; 
+        typedef void arg14_type; 
+        typedef void arg15_type; 
+        typedef void arg16_type; 
+        typedef void arg17_type; 
+        typedef void arg18_type; 
+        typedef void arg19_type; 
+        typedef void arg20_type; 
+
+        const static unsigned long num_args = 7;
+    };
+
+    template <
+        typename T,
+        typename A1, typename A2, typename A3,
+        typename A4, typename A5, typename A6,
+        typename A7, typename A8
+        >
+    struct sig_traits<T (A1,A2,A3,A4,A5,A6,A7,A8)> 
+    { 
+        typedef T result_type; 
+        typedef A1 arg1_type; 
+        typedef A2 arg2_type; 
+        typedef A3 arg3_type; 
+        typedef A4 arg4_type; 
+        typedef A5 arg5_type; 
+        typedef A6 arg6_type; 
+        typedef A7 arg7_type; 
+        typedef A8 arg8_type; 
+        typedef void arg9_type; 
+        typedef void arg10_type; 
+        typedef void arg11_type; 
+        typedef void arg12_type; 
+        typedef void arg13_type; 
+        typedef void arg14_type; 
+        typedef void arg15_type; 
+        typedef void arg16_type; 
+        typedef void arg17_type; 
+        typedef void arg18_type; 
+        typedef void arg19_type; 
+        typedef void arg20_type; 
+
+        const static unsigned long num_args = 8;
+    };
+
+    template <
+        typename T,
+        typename A1, typename A2, typename A3,
+        typename A4, typename A5, typename A6,
+        typename A7, typename A8, typename A9
+        >
+    struct sig_traits<T (A1,A2,A3,A4,A5,A6,A7,A8,A9)> 
+    { 
+        typedef T result_type; 
+        typedef A1 arg1_type; 
+        typedef A2 arg2_type; 
+        typedef A3 arg3_type; 
+        typedef A4 arg4_type; 
+        typedef A5 arg5_type; 
+        typedef A6 arg6_type; 
+        typedef A7 arg7_type; 
+        typedef A8 arg8_type; 
+        typedef A9 arg9_type; 
+        typedef void arg10_type; 
+        typedef void arg11_type; 
+        typedef void arg12_type; 
+        typedef void arg13_type; 
+        typedef void arg14_type; 
+        typedef void arg15_type; 
+        typedef void arg16_type; 
+        typedef void arg17_type; 
+        typedef void arg18_type; 
+        typedef void arg19_type; 
+        typedef void arg20_type; 
+
+        const static unsigned long num_args = 9;
+    };
+
+    template <
+        typename T,
+        typename A1, typename A2, typename A3,
+        typename A4, typename A5, typename A6,
+        typename A7, typename A8, typename A9,
+        typename A10
+        >
+    struct sig_traits<T (A1,A2,A3,A4,A5,A6,A7,A8,A9,A10)> 
+    { 
+        typedef T result_type; 
+        typedef A1 arg1_type; 
+        typedef A2 arg2_type; 
+        typedef A3 arg3_type; 
+        typedef A4 arg4_type; 
+        typedef A5 arg5_type; 
+        typedef A6 arg6_type; 
+        typedef A7 arg7_type; 
+        typedef A8 arg8_type; 
+        typedef A9 arg9_type; 
+        typedef A10 arg10_type; 
+        typedef void arg11_type; 
+        typedef void arg12_type; 
+        typedef void arg13_type; 
+        typedef void arg14_type; 
+        typedef void arg15_type; 
+        typedef void arg16_type; 
+        typedef void arg17_type; 
+        typedef void arg18_type; 
+        typedef void arg19_type; 
+        typedef void arg20_type; 
+
+        const static unsigned long num_args = 10;
+    };
+
+    template <
+        typename T,
+        typename A1, typename A2, typename A3,
+        typename A4, typename A5, typename A6,
+        typename A7, typename A8, typename A9,
+        typename A10,
+        typename A11
+        >
+    struct sig_traits<T (A1,A2,A3,A4,A5,A6,A7,A8,A9,A10,A11)> 
+    { 
+        typedef T result_type; 
+        typedef A1 arg1_type; 
+        typedef A2 arg2_type; 
+        typedef A3 arg3_type; 
+        typedef A4 arg4_type; 
+        typedef A5 arg5_type; 
+        typedef A6 arg6_type; 
+        typedef A7 arg7_type; 
+        typedef A8 arg8_type; 
+        typedef A9 arg9_type; 
+        typedef A10 arg10_type; 
+        typedef A11 arg11_type; 
+        typedef void arg12_type; 
+        typedef void arg13_type; 
+        typedef void arg14_type; 
+        typedef void arg15_type; 
+        typedef void arg16_type; 
+        typedef void arg17_type; 
+        typedef void arg18_type; 
+        typedef void arg19_type; 
+        typedef void arg20_type; 
+
+        const static unsigned long num_args = 11;
+    };
+
+    template <
+        typename T,
+        typename A1, typename A2, typename A3,
+        typename A4, typename A5, typename A6,
+        typename A7, typename A8, typename A9,
+        typename A10,
+        typename A11,
+        typename A12
+        >
+    struct sig_traits<T (A1,A2,A3,A4,A5,A6,A7,A8,A9,A10,A11,A12)> 
+    { 
+        typedef T result_type; 
+        typedef A1 arg1_type; 
+        typedef A2 arg2_type; 
+        typedef A3 arg3_type; 
+        typedef A4 arg4_type; 
+        typedef A5 arg5_type; 
+        typedef A6 arg6_type; 
+        typedef A7 arg7_type; 
+        typedef A8 arg8_type; 
+        typedef A9 arg9_type; 
+        typedef A10 arg10_type; 
+        typedef A11 arg11_type; 
+        typedef A12 arg12_type; 
+        typedef void arg13_type; 
+        typedef void arg14_type; 
+        typedef void arg15_type; 
+        typedef void arg16_type; 
+        typedef void arg17_type; 
+        typedef void arg18_type; 
+        typedef void arg19_type; 
+        typedef void arg20_type; 
+
+        const static unsigned long num_args = 12;
+    };
+
+    template <
+        typename T,
+        typename A1, typename A2, typename A3,
+        typename A4, typename A5, typename A6,
+        typename A7, typename A8, typename A9,
+        typename A10,
+        typename A11,
+        typename A12,
+        typename A13
+        >
+    struct sig_traits<T (A1,A2,A3,A4,A5,A6,A7,A8,A9,A10,A11,A12,A13)> 
+    { 
+        typedef T result_type; 
+        typedef A1 arg1_type; 
+        typedef A2 arg2_type; 
+        typedef A3 arg3_type; 
+        typedef A4 arg4_type; 
+        typedef A5 arg5_type; 
+        typedef A6 arg6_type; 
+        typedef A7 arg7_type; 
+        typedef A8 arg8_type; 
+        typedef A9 arg9_type; 
+        typedef A10 arg10_type; 
+        typedef A11 arg11_type; 
+        typedef A12 arg12_type; 
+        typedef A13 arg13_type; 
+        typedef void arg14_type; 
+        typedef void arg15_type; 
+        typedef void arg16_type; 
+        typedef void arg17_type; 
+        typedef void arg18_type; 
+        typedef void arg19_type; 
+        typedef void arg20_type; 
+
+        const static unsigned long num_args = 13;
+    };
+
+    template <
+        typename T,
+        typename A1, typename A2, typename A3,
+        typename A4, typename A5, typename A6,
+        typename A7, typename A8, typename A9,
+        typename A10,
+        typename A11,
+        typename A12,
+        typename A13,
+        typename A14
+        >
+    struct sig_traits<T (A1,A2,A3,A4,A5,A6,A7,A8,A9,A10,A11,A12,A13,A14)> 
+    { 
+        typedef T result_type; 
+        typedef A1 arg1_type; 
+        typedef A2 arg2_type; 
+        typedef A3 arg3_type; 
+        typedef A4 arg4_type; 
+        typedef A5 arg5_type; 
+        typedef A6 arg6_type; 
+        typedef A7 arg7_type; 
+        typedef A8 arg8_type; 
+        typedef A9 arg9_type; 
+        typedef A10 arg10_type; 
+        typedef A11 arg11_type; 
+        typedef A12 arg12_type; 
+        typedef A13 arg13_type; 
+        typedef A14 arg14_type; 
+        typedef void arg15_type; 
+        typedef void arg16_type; 
+        typedef void arg17_type; 
+        typedef void arg18_type; 
+        typedef void arg19_type; 
+        typedef void arg20_type; 
+
+        const static unsigned long num_args = 14;
+    };
+
+    template <
+        typename T,
+        typename A1, typename A2, typename A3,
+        typename A4, typename A5, typename A6,
+        typename A7, typename A8, typename A9,
+        typename A10,
+        typename A11,
+        typename A12,
+        typename A13,
+        typename A14,
+        typename A15
+        >
+    struct sig_traits<T (A1,A2,A3,A4,A5,A6,A7,A8,A9,A10,A11,A12,A13,A14,A15)> 
+    { 
+        typedef T result_type; 
+        typedef A1 arg1_type; 
+        typedef A2 arg2_type; 
+        typedef A3 arg3_type; 
+        typedef A4 arg4_type; 
+        typedef A5 arg5_type; 
+        typedef A6 arg6_type; 
+        typedef A7 arg7_type; 
+        typedef A8 arg8_type; 
+        typedef A9 arg9_type; 
+        typedef A10 arg10_type; 
+        typedef A11 arg11_type; 
+        typedef A12 arg12_type; 
+        typedef A13 arg13_type; 
+        typedef A14 arg14_type; 
+        typedef A15 arg15_type; 
+        typedef void arg16_type; 
+        typedef void arg17_type; 
+        typedef void arg18_type; 
+        typedef void arg19_type; 
+        typedef void arg20_type; 
+
+        const static unsigned long num_args = 15;
+    };
+
+    template <
+        typename T,
+        typename A1, typename A2, typename A3,
+        typename A4, typename A5, typename A6,
+        typename A7, typename A8, typename A9,
+        typename A10,
+        typename A11,
+        typename A12,
+        typename A13,
+        typename A14,
+        typename A15,
+        typename A16
+        >
+    struct sig_traits<T (A1,A2,A3,A4,A5,A6,A7,A8,A9,A10,A11,A12,A13,A14,A15,A16)> 
+    { 
+        typedef T result_type; 
+        typedef A1 arg1_type; 
+        typedef A2 arg2_type; 
+        typedef A3 arg3_type; 
+        typedef A4 arg4_type; 
+        typedef A5 arg5_type; 
+        typedef A6 arg6_type; 
+        typedef A7 arg7_type; 
+        typedef A8 arg8_type; 
+        typedef A9 arg9_type; 
+        typedef A10 arg10_type; 
+        typedef A11 arg11_type; 
+        typedef A12 arg12_type; 
+        typedef A13 arg13_type; 
+        typedef A14 arg14_type; 
+        typedef A15 arg15_type; 
+        typedef A16 arg16_type; 
+        typedef void arg17_type; 
+        typedef void arg18_type; 
+        typedef void arg19_type; 
+        typedef void arg20_type; 
+
+        const static unsigned long num_args = 16;
+    };
+
+    template <
+        typename T,
+        typename A1, typename A2, typename A3,
+        typename A4, typename A5, typename A6,
+        typename A7, typename A8, typename A9,
+        typename A10,
+        typename A11,
+        typename A12,
+        typename A13,
+        typename A14,
+        typename A15,
+        typename A16,
+        typename A17
+        >
+    struct sig_traits<T (A1,A2,A3,A4,A5,A6,A7,A8,A9,A10,A11,A12,A13,A14,A15,A16,A17)> 
+    { 
+        typedef T result_type; 
+        typedef A1 arg1_type; 
+        typedef A2 arg2_type; 
+        typedef A3 arg3_type; 
+        typedef A4 arg4_type; 
+        typedef A5 arg5_type; 
+        typedef A6 arg6_type; 
+        typedef A7 arg7_type; 
+        typedef A8 arg8_type; 
+        typedef A9 arg9_type; 
+        typedef A10 arg10_type; 
+        typedef A11 arg11_type; 
+        typedef A12 arg12_type; 
+        typedef A13 arg13_type; 
+        typedef A14 arg14_type; 
+        typedef A15 arg15_type; 
+        typedef A16 arg16_type; 
+        typedef A17 arg17_type; 
+        typedef void arg18_type; 
+        typedef void arg19_type; 
+        typedef void arg20_type; 
+
+        const static unsigned long num_args = 17;
+    };
+
+    template <
+        typename T,
+        typename A1, typename A2, typename A3,
+        typename A4, typename A5, typename A6,
+        typename A7, typename A8, typename A9,
+        typename A10,
+        typename A11,
+        typename A12,
+        typename A13,
+        typename A14,
+        typename A15,
+        typename A16,
+        typename A17,
+        typename A18
+        >
+    struct sig_traits<T (A1,A2,A3,A4,A5,A6,A7,A8,A9,A10,A11,A12,A13,A14,A15,A16,A17,A18)> 
+    { 
+        typedef T result_type; 
+        typedef A1 arg1_type; 
+        typedef A2 arg2_type; 
+        typedef A3 arg3_type; 
+        typedef A4 arg4_type; 
+        typedef A5 arg5_type; 
+        typedef A6 arg6_type; 
+        typedef A7 arg7_type; 
+        typedef A8 arg8_type; 
+        typedef A9 arg9_type; 
+        typedef A10 arg10_type; 
+        typedef A11 arg11_type; 
+        typedef A12 arg12_type; 
+        typedef A13 arg13_type; 
+        typedef A14 arg14_type; 
+        typedef A15 arg15_type; 
+        typedef A16 arg16_type; 
+        typedef A17 arg17_type; 
+        typedef A18 arg18_type; 
+        typedef void arg19_type; 
+        typedef void arg20_type; 
+
+        const static unsigned long num_args = 18;
+    };
+
+    template <
+        typename T,
+        typename A1, typename A2, typename A3,
+        typename A4, typename A5, typename A6,
+        typename A7, typename A8, typename A9,
+        typename A10,
+        typename A11,
+        typename A12,
+        typename A13,
+        typename A14,
+        typename A15,
+        typename A16,
+        typename A17,
+        typename A18,
+        typename A19
+        >
+    struct sig_traits<T (A1,A2,A3,A4,A5,A6,A7,A8,A9,A10,A11,A12,A13,A14,A15,A16,A17,A18,A19)> 
+    { 
+        typedef T result_type; 
+        typedef A1 arg1_type; 
+        typedef A2 arg2_type; 
+        typedef A3 arg3_type; 
+        typedef A4 arg4_type; 
+        typedef A5 arg5_type; 
+        typedef A6 arg6_type; 
+        typedef A7 arg7_type; 
+        typedef A8 arg8_type; 
+        typedef A9 arg9_type; 
+        typedef A10 arg10_type; 
+        typedef A11 arg11_type; 
+        typedef A12 arg12_type; 
+        typedef A13 arg13_type; 
+        typedef A14 arg14_type; 
+        typedef A15 arg15_type; 
+        typedef A16 arg16_type; 
+        typedef A17 arg17_type; 
+        typedef A18 arg18_type; 
+        typedef A19 arg19_type; 
+        typedef void arg20_type; 
+
+        const static unsigned long num_args = 19;
+    };
+
+    template <
+        typename T,
+        typename A1, typename A2, typename A3,
+        typename A4, typename A5, typename A6,
+        typename A7, typename A8, typename A9,
+        typename A10,
+        typename A11,
+        typename A12,
+        typename A13,
+        typename A14,
+        typename A15,
+        typename A16,
+        typename A17,
+        typename A18,
+        typename A19,
+        typename A20
+        >
+    struct sig_traits<T (A1,A2,A3,A4,A5,A6,A7,A8,A9,A10,A11,A12,A13,A14,A15,A16,A17,A18,A19,A20)> 
+    { 
+        typedef T result_type; 
+        typedef A1 arg1_type; 
+        typedef A2 arg2_type; 
+        typedef A3 arg3_type; 
+        typedef A4 arg4_type; 
+        typedef A5 arg5_type; 
+        typedef A6 arg6_type; 
+        typedef A7 arg7_type; 
+        typedef A8 arg8_type; 
+        typedef A9 arg9_type; 
+        typedef A10 arg10_type; 
+        typedef A11 arg11_type; 
+        typedef A12 arg12_type; 
+        typedef A13 arg13_type; 
+        typedef A14 arg14_type; 
+        typedef A15 arg15_type; 
+        typedef A16 arg16_type; 
+        typedef A17 arg17_type; 
+        typedef A18 arg18_type; 
+        typedef A19 arg19_type; 
+        typedef A20 arg20_type; 
+
+        const static unsigned long num_args = 20;
+    };
+
+// ----------------------------------------------------------------------------------------
+
+    template <
+        typename function_type, 
+        // These arguments are used to control the overloading.  A user should
+        // not mess with them.  
+        typename Enabled = void,
+        unsigned long Num_args = sig_traits<function_type>::num_args
+        >
+    class any_function
+    {
+    private:
+        any_function() {}
+    /* !!!!!!!!    ERRORS ON THE ABOVE LINE    !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+        An error on this line means you are trying to use a function signature
+        with more than the supported number of arguments.  The current version
+        of dlib only supports up to 10 arguments.
+    !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!*/
+    };
+
+
+    // The following preprocessor commands build the various overloaded versions
+    // of any_function for different numbers of commands and void vs. non-void return
+    // types.
+
+//  0 arguments
+#define DLIB_ANY_FUNCTION_ARG_LIST
+#define DLIB_ANY_FUNCTION_ARGS 
+#define DLIB_ANY_FUNCTION_NUM_ARGS 0
+#include "any_function_impl2.h"
+
+//  1 argument
+#define DLIB_ANY_FUNCTION_ARG_LIST arg1_type a1
+#define DLIB_ANY_FUNCTION_ARGS a1
+#define DLIB_ANY_FUNCTION_NUM_ARGS 1
+#include "any_function_impl2.h"
+
+//  2 arguments
+#define DLIB_ANY_FUNCTION_ARG_LIST arg1_type a1, arg2_type a2
+#define DLIB_ANY_FUNCTION_ARGS a1,a2
+#define DLIB_ANY_FUNCTION_NUM_ARGS 2
+#include "any_function_impl2.h"
+
+//  3 arguments
+#define DLIB_ANY_FUNCTION_ARG_LIST arg1_type a1, arg2_type a2, arg3_type a3
+#define DLIB_ANY_FUNCTION_ARGS a1,a2,a3
+#define DLIB_ANY_FUNCTION_NUM_ARGS 3
+#include "any_function_impl2.h"
+
+//  4 arguments
+#define DLIB_ANY_FUNCTION_ARG_LIST arg1_type a1, arg2_type a2, arg3_type a3, arg4_type a4
+#define DLIB_ANY_FUNCTION_ARGS a1,a2,a3,a4
+#define DLIB_ANY_FUNCTION_NUM_ARGS 4
+#include "any_function_impl2.h"
+
+//  5 arguments
+#define DLIB_ANY_FUNCTION_ARG_LIST arg1_type a1, arg2_type a2, arg3_type a3, arg4_type a4, \
+                                   arg5_type a5
+#define DLIB_ANY_FUNCTION_ARGS a1,a2,a3,a4,a5
+#define DLIB_ANY_FUNCTION_NUM_ARGS 5
+#include "any_function_impl2.h"
+
+//  6 arguments
+#define DLIB_ANY_FUNCTION_ARG_LIST arg1_type a1, arg2_type a2, arg3_type a3, arg4_type a4, \
+                                   arg5_type a5, arg6_type a6
+#define DLIB_ANY_FUNCTION_ARGS a1,a2,a3,a4,a5,a6
+#define DLIB_ANY_FUNCTION_NUM_ARGS 6
+#include "any_function_impl2.h"
+
+//  7 arguments
+#define DLIB_ANY_FUNCTION_ARG_LIST arg1_type a1, arg2_type a2, arg3_type a3, arg4_type a4, \
+                                   arg5_type a5, arg6_type a6, arg7_type a7
+#define DLIB_ANY_FUNCTION_ARGS a1,a2,a3,a4,a5,a6,a7
+#define DLIB_ANY_FUNCTION_NUM_ARGS 7
+#include "any_function_impl2.h"
+
+//  8 arguments
+#define DLIB_ANY_FUNCTION_ARG_LIST arg1_type a1, arg2_type a2, arg3_type a3, arg4_type a4, \
+                                   arg5_type a5, arg6_type a6, arg7_type a7, arg8_type a8
+#define DLIB_ANY_FUNCTION_ARGS a1,a2,a3,a4,a5,a6,a7,a8
+#define DLIB_ANY_FUNCTION_NUM_ARGS 8
+#include "any_function_impl2.h"
+
+//  9 arguments
+#define DLIB_ANY_FUNCTION_ARG_LIST arg1_type a1, arg2_type a2, arg3_type a3, arg4_type a4, \
+                                   arg5_type a5, arg6_type a6, arg7_type a7, arg8_type a8, \
+                                   arg9_type a9
+#define DLIB_ANY_FUNCTION_ARGS a1,a2,a3,a4,a5,a6,a7,a8,a9
+#define DLIB_ANY_FUNCTION_NUM_ARGS 9
+#include "any_function_impl2.h"
+
+//  10 arguments
+#define DLIB_ANY_FUNCTION_ARG_LIST arg1_type a1, arg2_type a2, arg3_type a3, arg4_type a4, \
+                                   arg5_type a5, arg6_type a6, arg7_type a7, arg8_type a8, \
+                                   arg9_type a9, arg10_type a10
+#define DLIB_ANY_FUNCTION_ARGS a1,a2,a3,a4,a5,a6,a7,a8,a9,a10
+#define DLIB_ANY_FUNCTION_NUM_ARGS 10 
+#include "any_function_impl2.h"
+
+// ----------------------------------------------------------------------------------------
+
+    template <typename function_type>
+    inline void swap (
+        any_function<function_type>& a,
+        any_function<function_type>& b
+    ) { a.swap(b); }
+
+// ----------------------------------------------------------------------------------------
+
+    template <typename T, typename function_type> 
+    T& any_cast(any_function<function_type>& a) { return a.template cast_to<T>(); }
+
+    template <typename T, typename function_type> 
+    const T& any_cast(const any_function<function_type>& a) { return a.template cast_to<T>(); }
+
+// ----------------------------------------------------------------------------------------
+
+}
+
+#endif // DLIB_AnY_FUNCTION_Hh_
+

dlibs/dlib/any/any_function_abstract.h

@@ -0,0 +1,292 @@
+// Copyright (C) 2011  Davis E. King ([email protected])
+// 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 <
+        typename function_type
+        >
+    class any_function
+    {
+        /*!
+            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 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;
+        // Typedefs defining the argument types.  If an argument does not exist
+        // then it is set to void.
+        typedef type_of_first_argument_in_funct_type  arg1_type;
+        typedef type_of_second_argument_in_funct_type arg2_type;
+        ...
+        typedef type_of_last_argument_in_funct_type   arg10_type;
+        const static unsigned long num_args = total_number_of_non_void_arguments;
+
+        any_function(
+        );
+        /*!
+            ensures
+                - this object is properly initialized
+        !*/
+
+        any_function (
+            const any_function& 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.
+        !*/
+
+        template < typename T >
+        any_function (
+            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 
+        !*/
+
+        bool is_set (
+        ) const;
+        /*!
+            ensures
+                - returns !is_empty()
+        !*/
+
+        result_type operator() (
+        ) 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()
+                  or if result_type is void then this function performs:
+                    F()
+        !*/
+
+        result_type operator() (
+            const arg1_type& a1
+        ) const;
+        /*!
+            requires
+                - is_empty() == false
+                - the signature defined by function_type takes one argument
+            ensures
+                - Let F denote the function object contained within *this.  Then
+                  this function performs:
+                    return F(a1)
+                  or if result_type is void then this function performs:
+                    F(a1)
+        !*/
+
+        result_type operator() (
+            const arg1_type& a1,
+            const arg2_type& a2
+        ) const;
+        /*!
+            requires
+                - is_empty() == false
+                - the signature defined by function_type takes two arguments
+            ensures
+                - Let F denote the function object contained within *this.  Then
+                  this function performs:
+                    return F(a1,a2)
+                  or if result_type is void then this function performs:
+                    F(a1,a2)
+        !*/
+
+        /* !!!!!!!!!  NOTE  !!!!!!!!!
+
+           In addition to the above, operator() is defined for up to 10 arguments.
+           They are not listed here because it would clutter the documentation. 
+
+           !!!!!!!!!  NOTE  !!!!!!!!!  */
+
+        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 object is destructed and its
+                      state is lost.
+                    - returns a non-const reference to the newly created T object.
+        !*/
+
+        any_function& operator= (
+            const any_function& 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_function& item
+        );
+        /*!
+            ensures
+                - swaps *this and item
+        !*/
+
+    };
+
+// ----------------------------------------------------------------------------------------
+
+    template <
+        typename function_type
+        >
+    inline void swap (
+        any_function<function_type>& a,
+        any_function<function_type>& b
+    ) { a.swap(b); }
+    /*!
+        provides a global swap function
+    !*/
+
+// ----------------------------------------------------------------------------------------
+
+    template <
+        typename T,
+        typename function_type
+        > 
+    T& any_cast(
+        any_function<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<function_type>& a
+    ) { return a.cast_to<T>(); }
+    /*!
+        ensures
+            - returns a.cast_to<T>()
+    !*/
+
+// ----------------------------------------------------------------------------------------
+
+}
+
+#endif // DLIB_AnY_FUNCTION_ABSTRACT_H_
+

dlibs/dlib/any/any_function_impl.h

@@ -0,0 +1,516 @@
+// Copyright (C) 2011  Davis E. King ([email protected])
+// License: Boost Software License   See LICENSE.txt for the full license.
+#ifndef DLIB_ANY_FUNCTION_RETURN
+#error "You aren't supposed to directly #include this file.  #include <dlib/any.h> instead."  
+#endif
+
+#ifdef _MSC_VER
+// When using visual studio 2012, disable the warning "warning C4180: qualifier applied to function type has no meaning; ignored"
+// that you get about some template expansions applying & to function types. 
+#pragma warning(disable : 4180)
+#endif
+
+#ifdef DLIB_ANY_FUNCTION_RETURN
+
+// This file contains the body of the any_function class.  We use the
+// preprocessor to generate many different versions.  There are 
+// versions which return a value and those which return void.  For
+// each of these types there are versions with differing numbers
+// of arguments. 
+
+public:
+typedef typename sig_traits<function_type>::result_type result_type;
+typedef typename sig_traits<function_type>::arg1_type arg1_type;
+typedef typename sig_traits<function_type>::arg2_type arg2_type;
+typedef typename sig_traits<function_type>::arg3_type arg3_type;
+typedef typename sig_traits<function_type>::arg4_type arg4_type;
+typedef typename sig_traits<function_type>::arg5_type arg5_type;
+typedef typename sig_traits<function_type>::arg6_type arg6_type;
+typedef typename sig_traits<function_type>::arg7_type arg7_type;
+typedef typename sig_traits<function_type>::arg8_type arg8_type;
+typedef typename sig_traits<function_type>::arg9_type arg9_type;
+typedef typename sig_traits<function_type>::arg10_type arg10_type;
+const static unsigned long num_args = sig_traits<function_type>::num_args;
+
+any_function()
+{
+}
+
+any_function (
+    const any_function& item
+)
+{
+    if (item.data)
+    {
+        item.data->copy_to(data);
+    }
+}
+
+template <typename T>
+any_function (
+    const T& item
+)
+{
+    typedef typename basic_type<T>::type U;
+    data.reset(new derived<U,function_type>(item));
+}
+
+void clear (
+)
+{
+    data.reset();
+}
+
+template <typename T>
+bool contains (
+) const
+{
+    typedef typename basic_type<T>::type U;
+    return dynamic_cast<derived<U,function_type>*>(data.get()) != 0;
+}
+
+bool is_empty(
+) const
+{
+    return data.get() == 0;
+}
+
+bool is_set(
+) const
+{
+    return !is_empty();
+}
+
+template <typename T>
+T& cast_to(
+) 
+{
+    typedef typename basic_type<T>::type U;
+    derived<U,function_type>* d = dynamic_cast<derived<U,function_type>*>(data.get());
+    if (d == 0)
+    {
+        throw bad_any_cast();
+    }
+
+    return d->item;
+}
+
+template <typename T>
+const T& cast_to(
+) const
+{
+    typedef typename basic_type<T>::type U;
+    derived<U,function_type>* d = dynamic_cast<derived<U,function_type>*>(data.get());
+    if (d == 0)
+    {
+        throw bad_any_cast();
+    }
+
+    return d->item;
+}
+
+template <typename T>
+T& get(
+) 
+{
+    typedef typename basic_type<T>::type U;
+    derived<U,function_type>* d = dynamic_cast<derived<U,function_type>*>(data.get());
+    if (d == 0)
+    {
+        d = new derived<U,function_type>();
+        data.reset(d);
+    }
+
+    return d->item;
+}
+
+any_function& operator= (
+    const any_function& item
+)
+{
+    any_function(item).swap(*this);
+    return *this;
+}
+
+void swap (
+    any_function& item
+)
+{
+    data.swap(item.data);
+}
+
+result_type operator()(DLIB_ANY_FUNCTION_ARG_LIST) const 
+{ validate(); DLIB_ANY_FUNCTION_RETURN data->evaluate(DLIB_ANY_FUNCTION_ARGS); }
+/* !!!!!!!!    ERRORS ON THE ABOVE LINE    !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+    If you are getting an error on the above line then it means you
+    have attempted to call a dlib::any_function but you have supplied 
+    arguments which don't match the function signature used by the
+    dlib::any_function. 
+!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!*/
+
+private:
+
+void validate () const
+{
+    // make sure requires clause is not broken
+    DLIB_ASSERT(is_empty() == false,
+        "\t result_type any_function::operator()"
+        << "\n\t You can't call operator() on an empty any_function"
+        << "\n\t this: " << this
+        );
+}
+
+
+template <typename FT>
+struct Tbase
+{
+    virtual ~Tbase() {}
+    virtual result_type evaluate () const = 0;
+    virtual void copy_to ( std::unique_ptr<Tbase>& dest) const = 0;
+};
+
+template <
+    typename T, 
+    typename A1
+    >
+struct Tbase<T (A1)>
+{
+    virtual ~Tbase() {}
+    virtual T evaluate ( A1) const = 0;
+    virtual void copy_to ( std::unique_ptr<Tbase>& dest) const = 0;
+};
+
+template <
+    typename T, 
+    typename A1, typename A2
+    >
+struct Tbase<T (A1,A2)>
+{
+    virtual ~Tbase() {}
+    virtual T evaluate (A1,A2) const = 0;
+    virtual void copy_to ( std::unique_ptr<Tbase>& dest) const = 0;
+};
+
+template <
+    typename T, 
+    typename A1, typename A2, typename A3
+    >
+struct Tbase<T (A1,A2,A3)>
+{
+    virtual ~Tbase() {}
+    virtual T evaluate (A1,A2,A3) const = 0;
+    virtual void copy_to ( std::unique_ptr<Tbase>& dest) const = 0;
+};
+
+template <
+    typename T, 
+    typename A1, typename A2, typename A3,
+    typename A4
+    >
+struct Tbase<T (A1,A2,A3,A4)>
+{
+    virtual ~Tbase() {}
+    virtual T evaluate (A1,A2,A3,A4) const = 0;
+    virtual void copy_to ( std::unique_ptr<Tbase>& dest) const = 0;
+};
+
+template <
+    typename T, 
+    typename A1, typename A2, typename A3,
+    typename A4, typename A5
+    >
+struct Tbase<T (A1,A2,A3,A4,A5)>
+{
+    virtual ~Tbase() {}
+    virtual T evaluate (A1,A2,A3,A4,A5) const = 0;
+    virtual void copy_to ( std::unique_ptr<Tbase>& dest) const = 0;
+};
+
+template <
+    typename T, 
+    typename A1, typename A2, typename A3,
+    typename A4, typename A5, typename A6
+    >
+struct Tbase<T (A1,A2,A3,A4,A5,A6)>
+{
+    virtual ~Tbase() {}
+    virtual T evaluate (A1,A2,A3,A4,A5,A6) const = 0;
+    virtual void copy_to ( std::unique_ptr<Tbase>& dest) const = 0;
+};
+
+template <
+    typename T, 
+    typename A1, typename A2, typename A3,
+    typename A4, typename A5, typename A6,
+    typename A7
+    >
+struct Tbase<T (A1,A2,A3,A4,A5,A6,A7)>
+{
+    virtual ~Tbase() {}
+    virtual T evaluate (A1,A2,A3,A4,A5,A6,A7) const = 0;
+    virtual void copy_to ( std::unique_ptr<Tbase>& dest) const = 0;
+};
+
+template <
+    typename T, 
+    typename A1, typename A2, typename A3,
+    typename A4, typename A5, typename A6,
+    typename A7, typename A8
+    >
+struct Tbase<T (A1,A2,A3,A4,A5,A6,A7,A8)>
+{
+    virtual ~Tbase() {}
+    virtual T evaluate (A1,A2,A3,A4,A5,A6,A7,A8) const = 0;
+    virtual void copy_to ( std::unique_ptr<Tbase>& dest) const = 0;
+};
+
+template <
+    typename T, 
+    typename A1, typename A2, typename A3,
+    typename A4, typename A5, typename A6,
+    typename A7, typename A8, typename A9
+    >
+struct Tbase<T (A1,A2,A3,A4,A5,A6,A7,A8,A9)>
+{
+    virtual ~Tbase() {}
+    virtual T evaluate (A1,A2,A3,A4,A5,A6,A7,A8,A9) const = 0;
+    virtual void copy_to ( std::unique_ptr<Tbase>& dest) const = 0;
+};
+
+template <
+    typename T, 
+    typename A1, typename A2, typename A3,
+    typename A4, typename A5, typename A6,
+    typename A7, typename A8, typename A9,
+    typename A10
+    >
+struct Tbase<T (A1,A2,A3,A4,A5,A6,A7,A8,A9,A10)>
+{
+    virtual ~Tbase() {}
+    virtual T evaluate (A1,A2,A3,A4,A5,A6,A7,A8,A9,A10) const = 0;
+    virtual void copy_to ( std::unique_ptr<Tbase>& dest) const = 0;
+};
+
+typedef Tbase<function_type> base;
+
+// -----------------------------------------------
+
+// Some templates to help deal with the weirdness of storing C function types (rather than pointer to functions).
+// Basically, we make sure things always get turned into function pointers even if the user gives a function reference.
+template <typename T, typename enabled = void>
+struct funct_type { typedef T type; };
+template <typename T>
+struct funct_type<T, typename enable_if<is_function<T> >::type> { typedef T* type; };
+
+template <typename T>
+static typename enable_if<is_function<T>,const T*>::type copy (const T& item) { return &item; }
+template <typename T>
+static typename disable_if<is_function<T>,const T&>::type copy (const T& item) { return item; }
+
+template <typename T, typename U>
+static typename enable_if<is_function<T>,const T&>::type deref (const U& item) { return *item; }
+template <typename T, typename U>
+static typename disable_if<is_function<T>,const T&>::type deref (const U& item) { return item; }
+
+// -----------------------------------------------
+
+#define DLIB_ANY_FUNCTION_DERIVED_BOILERPLATE               \
+    typename funct_type<T>::type item;                      \
+    derived() {}                                            \
+    derived(const T& val) : item(copy(val)) {}              \
+    virtual void copy_to ( std::unique_ptr<base>& dest) const    \
+    { dest.reset(new derived(deref<T>(item))); }
+
+template <typename T, typename FT>
+struct derived : public base
+{
+    DLIB_ANY_FUNCTION_DERIVED_BOILERPLATE
+
+    virtual result_type evaluate (
+    ) const { DLIB_ANY_FUNCTION_RETURN item(); }
+    /* !!!!!!!!    ERRORS ON THE ABOVE LINE    !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+        If you are getting an error on the above line then it means you
+        have attempted to assign a function or function object to a
+        dlib::any_function but the signatures of the source and
+        destination functions don't match.
+    !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!*/
+};
+
+template <typename T, typename A1>
+struct derived<T,result_type (A1)> : public base
+{
+    DLIB_ANY_FUNCTION_DERIVED_BOILERPLATE
+
+    virtual result_type evaluate (
+        A1 a1
+    ) const { DLIB_ANY_FUNCTION_RETURN item(a1); }
+    /* !!!!!!!!    ERRORS ON THE ABOVE LINE    !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+        If you are getting an error on the above line then it means you
+        have attempted to assign a function or function object to a
+        dlib::any_function but the signatures of the source and
+        destination functions don't match.
+    !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!*/
+};
+
+template <typename T, typename A1, typename A2>
+struct derived<T,result_type (A1,A2)> : public base
+{
+    DLIB_ANY_FUNCTION_DERIVED_BOILERPLATE
+
+    virtual result_type evaluate (
+        A1 a1, A2 a2
+    ) const { DLIB_ANY_FUNCTION_RETURN item(a1,a2); }
+    /* !!!!!!!!    ERRORS ON THE ABOVE LINE    !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+        If you are getting an error on the above line then it means you
+        have attempted to assign a function or function object to a
+        dlib::any_function but the signatures of the source and
+        destination functions don't match.
+    !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!*/
+};
+
+template <typename T, typename A1, typename A2, typename A3>
+struct derived<T,result_type (A1,A2,A3)> : public base
+{
+    DLIB_ANY_FUNCTION_DERIVED_BOILERPLATE
+
+    virtual result_type evaluate (
+        A1 a1, A2 a2, A3 a3
+    ) const { DLIB_ANY_FUNCTION_RETURN item(a1,a2,a3); }
+    /* !!!!!!!!    ERRORS ON THE ABOVE LINE    !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+        If you are getting an error on the above line then it means you
+        have attempted to assign a function or function object to a
+        dlib::any_function but the signatures of the source and
+        destination functions don't match.
+    !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!*/
+};
+
+template <typename T, typename A1, typename A2, typename A3,
+                      typename A4>
+struct derived<T,result_type (A1,A2,A3,A4)> : public base
+{
+    DLIB_ANY_FUNCTION_DERIVED_BOILERPLATE
+
+    virtual result_type evaluate (
+        A1 a1, A2 a2, A3 a3, A4 a4
+    ) const { DLIB_ANY_FUNCTION_RETURN item(a1,a2,a3,a4); }
+    /* !!!!!!!!    ERRORS ON THE ABOVE LINE    !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+        If you are getting an error on the above line then it means you
+        have attempted to assign a function or function object to a
+        dlib::any_function but the signatures of the source and
+        destination functions don't match.
+    !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!*/
+};
+
+template <typename T, typename A1, typename A2, typename A3,
+                      typename A4, typename A5>
+struct derived<T,result_type (A1,A2,A3,A4,A5)> : public base
+{
+    DLIB_ANY_FUNCTION_DERIVED_BOILERPLATE
+
+    virtual result_type evaluate (
+        A1 a1, A2 a2, A3 a3, A4 a4, A5 a5
+    ) const { DLIB_ANY_FUNCTION_RETURN item(a1,a2,a3,a4,a5); }
+    /* !!!!!!!!    ERRORS ON THE ABOVE LINE    !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+        If you are getting an error on the above line then it means you
+        have attempted to assign a function or function object to a
+        dlib::any_function but the signatures of the source and
+        destination functions don't match.
+    !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!*/
+};
+
+template <typename T, typename A1, typename A2, typename A3,
+                      typename A4, typename A5, typename A6>
+struct derived<T,result_type (A1,A2,A3,A4,A5,A6)> : public base
+{
+    DLIB_ANY_FUNCTION_DERIVED_BOILERPLATE
+
+    virtual result_type evaluate (
+        A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6
+    ) const { DLIB_ANY_FUNCTION_RETURN item(a1,a2,a3,a4,a5,a6); }
+    /* !!!!!!!!    ERRORS ON THE ABOVE LINE    !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+        If you are getting an error on the above line then it means you
+        have attempted to assign a function or function object to a
+        dlib::any_function but the signatures of the source and
+        destination functions don't match.
+    !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!*/
+};
+
+template <typename T, typename A1, typename A2, typename A3,
+                      typename A4, typename A5, typename A6,
+                      typename A7>
+struct derived<T,result_type (A1,A2,A3,A4,A5,A6,A7)> : public base
+{
+    DLIB_ANY_FUNCTION_DERIVED_BOILERPLATE
+
+    virtual result_type evaluate (
+        A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7
+    ) const { DLIB_ANY_FUNCTION_RETURN item(a1,a2,a3,a4,a5,a6,a7); }
+    /* !!!!!!!!    ERRORS ON THE ABOVE LINE    !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+        If you are getting an error on the above line then it means you
+        have attempted to assign a function or function object to a
+        dlib::any_function but the signatures of the source and
+        destination functions don't match.
+    !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!*/
+};
+
+template <typename T, typename A1, typename A2, typename A3,
+                      typename A4, typename A5, typename A6,
+                      typename A7, typename A8>
+struct derived<T,result_type (A1,A2,A3,A4,A5,A6,A7,A8)> : public base
+{
+    DLIB_ANY_FUNCTION_DERIVED_BOILERPLATE
+
+    virtual result_type evaluate (
+        A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8
+    ) const { DLIB_ANY_FUNCTION_RETURN item(a1,a2,a3,a4,a5,a6,a7,a8); }
+    /* !!!!!!!!    ERRORS ON THE ABOVE LINE    !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+        If you are getting an error on the above line then it means you
+        have attempted to assign a function or function object to a
+        dlib::any_function but the signatures of the source and
+        destination functions don't match.
+    !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!*/
+};
+
+template <typename T, typename A1, typename A2, typename A3,
+                      typename A4, typename A5, typename A6,
+                      typename A7, typename A8, typename A9>
+struct derived<T,result_type (A1,A2,A3,A4,A5,A6,A7,A8,A9)> : public base
+{
+    DLIB_ANY_FUNCTION_DERIVED_BOILERPLATE
+
+    virtual result_type evaluate (
+        A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9
+    ) const { DLIB_ANY_FUNCTION_RETURN item(a1,a2,a3,a4,a5,a6,a7,a8,a9); }
+    /* !!!!!!!!    ERRORS ON THE ABOVE LINE    !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+        If you are getting an error on the above line then it means you
+        have attempted to assign a function or function object to a
+        dlib::any_function but the signatures of the source and
+        destination functions don't match.
+    !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!*/
+};
+
+template <typename T, typename A1, typename A2, typename A3,
+                      typename A4, typename A5, typename A6,
+                      typename A7, typename A8, typename A9,
+                      typename A10>
+struct derived<T,result_type (A1,A2,A3,A4,A5,A6,A7,A8,A9,A10)> : public base
+{
+    DLIB_ANY_FUNCTION_DERIVED_BOILERPLATE
+
+    virtual result_type evaluate (
+        A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9, A10 a10
+    ) const { DLIB_ANY_FUNCTION_RETURN item(a1,a2,a3,a4,a5,a6,a7,a8,a9,a10); }
+    /* !!!!!!!!    ERRORS ON THE ABOVE LINE    !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+        If you are getting an error on the above line then it means you
+        have attempted to assign a function or function object to a
+        dlib::any_function but the signatures of the source and
+        destination functions don't match.
+    !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!*/
+};
+
+std::unique_ptr<base> data;
+
+#undef DLIB_ANY_FUNCTION_DERIVED_BOILERPLATE
+
+#endif // DLIB_ANY_FUNCTION_RETURN
+

dlibs/dlib/any/any_function_impl2.h

@@ -0,0 +1,44 @@
+// Copyright (C) 2011  Davis E. King ([email protected])
+// License: Boost Software License   See LICENSE.txt for the full license.
+#ifndef DLIB_ANY_FUNCTION_ARG_LIST
+#error "You aren't supposed to directly #include this file.  #include <dlib/any.h> instead."  
+#endif
+
+#ifdef DLIB_ANY_FUNCTION_ARG_LIST 
+
+// The case where function_type has a non-void return type
+    template <typename function_type, typename Enabled>
+    class any_function<function_type, Enabled, DLIB_ANY_FUNCTION_NUM_ARGS>
+    {
+#define DLIB_ANY_FUNCTION_RETURN return
+#include "any_function_impl.h"
+#undef DLIB_ANY_FUNCTION_RETURN
+
+    private:
+        // You get a compiler error about this function being private if you try to assign
+        // or copy between any_functions with different types.  You must only copy between
+        // any_functions that represent functions with the same signature.
+        template <typename T, typename U> any_function(const any_function<T,U>&);
+    };
+
+// The case where function_type has a void return type
+    template <typename function_type>
+    class any_function<function_type, typename sig_traits<function_type>::type, DLIB_ANY_FUNCTION_NUM_ARGS>
+    {
+#define DLIB_ANY_FUNCTION_RETURN 
+#include "any_function_impl.h"
+#undef DLIB_ANY_FUNCTION_RETURN
+
+    private:
+        // You get a compiler error about this function being private if you try to assign
+        // or copy between any_functions with different types.  You must only copy between
+        // any_functions that represent functions with the same signature.
+        template <typename T> any_function(const any_function<T>&);
+    };
+
+#undef DLIB_ANY_FUNCTION_ARG_LIST
+#undef DLIB_ANY_FUNCTION_ARGS
+#undef DLIB_ANY_FUNCTION_NUM_ARGS
+
+#endif // DLIB_ANY_FUNCTION_ARG_LIST
+

dlibs/dlib/any/any_trainer.h

@@ -0,0 +1,217 @@
+// Copyright (C) 2010  Davis E. King ([email protected])
+// 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:
+        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()
+        {
+        }
+
+        any_trainer (
+            const any_trainer& item
+        )
+        {
+            if (item.data)
+            {
+                item.data->copy_to(data);
+            }
+        }
+
+        template <typename T>
+        any_trainer (
+            const T& item
+        )
+        {
+            typedef typename basic_type<T>::type U;
+            data.reset(new derived<U>(item));
+        }
+
+        void clear (
+        )
+        {
+            data.reset();
+        }
+
+        template <typename T>
+        bool contains (
+        ) const
+        {
+            typedef typename basic_type<T>::type U;
+            return dynamic_cast<derived<U>*>(data.get()) != 0;
+        }
+
+        bool is_empty(
+        ) const
+        {
+            return data.get() == 0;
+        }
+
+        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 data->train(samples, labels);
+        }
+
+        template <typename T>
+        T& cast_to(
+        ) 
+        {
+            typedef typename basic_type<T>::type U;
+            derived<U>* d = dynamic_cast<derived<U>*>(data.get());
+            if (d == 0)
+            {
+                throw bad_any_cast();
+            }
+
+            return d->item;
+        }
+
+        template <typename T>
+        const T& cast_to(
+        ) const
+        {
+            typedef typename basic_type<T>::type U;
+            derived<U>* d = dynamic_cast<derived<U>*>(data.get());
+            if (d == 0)
+            {
+                throw bad_any_cast();
+            }
+
+            return d->item;
+        }
+
+        template <typename T>
+        T& get(
+        ) 
+        {
+            typedef typename basic_type<T>::type U;
+            derived<U>* d = dynamic_cast<derived<U>*>(data.get());
+            if (d == 0)
+            {
+                d = new derived<U>();
+                data.reset(d);
+            }
+
+            return d->item;
+        }
+
+        any_trainer& operator= (
+            const any_trainer& item
+        )
+        {
+            any_trainer(item).swap(*this);
+            return *this;
+        }
+
+        void swap (
+            any_trainer& item
+        )
+        {
+            data.swap(item.data);
+        }
+
+    private:
+
+        struct base
+        {
+            virtual ~base() {}
+
+            virtual trained_function_type train (
+                const std::vector<sample_type>& samples,
+                const std::vector<scalar_type>& labels
+            ) const = 0;
+
+            virtual void copy_to (
+                std::unique_ptr<base>& dest
+            ) const = 0;
+        };
+
+        template <typename T>
+        struct derived : public base
+        {
+            T item;
+            derived() {}
+            derived(const T& val) : item(val) {}
+
+            virtual void copy_to (
+                std::unique_ptr<base>& dest
+            ) const
+            {
+                dest.reset(new derived<T>(item));
+            }
+
+            virtual trained_function_type train (
+                const std::vector<sample_type>& samples,
+                const std::vector<scalar_type>& labels
+            ) const
+            {
+                return item.train(samples, labels);
+            }
+        };
+
+        std::unique_ptr<base> data;
+    };
+
+// ----------------------------------------------------------------------------------------
+
+    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); }
+
+// ----------------------------------------------------------------------------------------
+
+    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_
+
+
+
+

dlibs/dlib/any/any_trainer_abstract.h

@@ -0,0 +1,234 @@
+// Copyright (C) 2010  Davis E. King ([email protected])
+// 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.
+        !*/
+
+        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_
+
+

dlibs/dlib/appveyor/dtest.yml

@@ -0,0 +1,19 @@
+version: "{build}"
+
+configuration: Release
+
+build_script:
+  # build test
+  - mkdir %APPVEYOR_BUILD_FOLDER%\build_test
+  - cd %APPVEYOR_BUILD_FOLDER%\build_test
+  - cmake -G "Visual Studio 14 2015 Win64" -T host=x64 ../dlib/test
+  - cmake --build . --config %CONFIGURATION% --target dlib_all_source_cpp 
+  - cmake --build . --config %CONFIGURATION% --target imglab 
+  - cmake --build . --config %CONFIGURATION% --target htmlify 
+  - cmake --build . --config %CONFIGURATION% --target gui 
+  - cmake --build . --config %CONFIGURATION% --target dtest
+
+test_script:
+  # run test
+  - cd %APPVEYOR_BUILD_FOLDER%\build_test\%CONFIGURATION%
+  - dtest --runall

dlibs/dlib/appveyor/dtest_vc2017.yml

@@ -0,0 +1,21 @@
+version: "{build}"
+
+configuration: Release
+
+image: Visual Studio 2017
+
+build_script:
+  # build test
+  - mkdir %APPVEYOR_BUILD_FOLDER%\build_test
+  - cd %APPVEYOR_BUILD_FOLDER%\build_test
+  - cmake -G "Visual Studio 15 2017 Win64" -T host=x64 ../dlib/test
+  - cmake --build . --config %CONFIGURATION% --target dlib_all_source_cpp 
+  - cmake --build . --config %CONFIGURATION% --target imglab 
+  - cmake --build . --config %CONFIGURATION% --target htmlify 
+  - cmake --build . --config %CONFIGURATION% --target gui 
+  - cmake --build . --config %CONFIGURATION% --target dtest
+
+test_script:
+  # run test
+  - cd %APPVEYOR_BUILD_FOLDER%\build_test\%CONFIGURATION%
+  - dtest --runall

dlibs/dlib/appveyor/examples.yml

@@ -0,0 +1,16 @@
+version: "{build}"
+
+configuration: Release
+
+image: Visual Studio 2017
+
+build_script:
+  # build test
+  - mkdir %APPVEYOR_BUILD_FOLDER%\build_examples
+  - cd %APPVEYOR_BUILD_FOLDER%\build_examples
+  #- cmake -G "Visual Studio 14 2015 Win64" -T host=x64 ../examples
+  - cmake -G "Visual Studio 15 2017 Win64" -T host=x64 ../examples
+  - cmake --build . --config %CONFIGURATION% 
+
+test_script:
+  # run test

dlibs/dlib/appveyor/python.yml

@@ -0,0 +1,14 @@
+
+environment:
+  matrix:
+    - PATH: C:\Python36;%PATH%
+    - PATH: C:\Python36-x64;%PATH%
+    - PATH: C:\Python37;%PATH%
+    - PATH: C:\Python37-x64;%PATH%
+
+
+build_script:
+  - python setup.py build --clean
+
+test_script:
+  - python setup.py test

dlibs/dlib/array.h

@@ -0,0 +1,10 @@
+// Copyright (C) 2003  Davis E. King ([email protected])
+// 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_
+

dlibs/dlib/array/array_kernel.h

@@ -0,0 +1,809 @@
+// Copyright (C) 2003  Davis E. King ([email protected])
+// License: Boost Software License   See LICENSE.txt for the full license.
+#ifndef DLIB_ARRAY_KERNEl_2_
+#define DLIB_ARRAY_KERNEl_2_
+
+#include "array_kernel_abstract.h"
+#include "../interfaces/enumerable.h"
+#include "../algs.h"
+#include "../serialize.h"
+#include "../sort.h"
+#include "../is_kind.h"
+
+namespace dlib
+{
+
+    template <
+        typename T,
+        typename mem_manager = default_memory_manager 
+        >
+    class array : public enumerable<T>
+    {
+
+        /*!
+            INITIAL VALUE
+                - array_size == 0    
+                - max_array_size == 0
+                - array_elements == 0
+                - pos == 0
+                - last_pos == 0
+                - _at_start == true
+
+            CONVENTION
+                - array_size == size() 
+                - max_array_size == max_size() 
+                - if (max_array_size > 0)
+                    - array_elements == pointer to max_array_size elements of type T
+                - else
+                    - array_elements == 0
+
+                - if (array_size > 0) 
+                    - last_pos == array_elements + array_size - 1
+                - else
+                    - last_pos == 0
+
+
+                - at_start() == _at_start 
+                - current_element_valid() == pos != 0
+                - if (current_element_valid()) then
+                    - *pos == element()
+        !*/
+
+    public:
+
+        // These typedefs are here for backwards compatibility with old versions of dlib.
+        typedef array kernel_1a;
+        typedef array kernel_1a_c;
+        typedef array kernel_2a;
+        typedef array kernel_2a_c;
+        typedef array sort_1a;
+        typedef array sort_1a_c;
+        typedef array sort_1b;
+        typedef array sort_1b_c;
+        typedef array sort_2a;
+        typedef array sort_2a_c;
+        typedef array sort_2b;
+        typedef array sort_2b_c;
+        typedef array expand_1a;
+        typedef array expand_1a_c;
+        typedef array expand_1b;
+        typedef array expand_1b_c;
+        typedef array expand_1c;
+        typedef array expand_1c_c;
+        typedef array expand_1d;
+        typedef array expand_1d_c;
+
+
+
+
+        typedef T type;
+        typedef T value_type;
+        typedef mem_manager mem_manager_type;
+
+        array (
+        ) :
+            array_size(0),
+            max_array_size(0),
+            array_elements(0),
+            pos(0),
+            last_pos(0),
+            _at_start(true)
+        {}
+
+        array(const array&) = delete;
+        array& operator=(array&) = delete; 
+
+        array(
+            array&& item
+        ) : array()
+        {
+            swap(item);
+        }
+
+        array& operator=(
+            array&& item
+        )
+        {
+            swap(item);
+            return *this;
+        }
+
+        explicit array (
+            size_t new_size
+        ) :
+            array_size(0),
+            max_array_size(0),
+            array_elements(0),
+            pos(0),
+            last_pos(0),
+            _at_start(true)
+        {
+            resize(new_size);
+        }
+
+        ~array (
+        ); 
+
+        void clear (
+        );
+
+        inline const T& operator[] (
+            size_t pos
+        ) const;
+
+        inline T& operator[] (
+            size_t pos
+        );
+
+        void set_size (
+            size_t size
+        );
+
+        inline size_t max_size(
+        ) const;
+
+        void set_max_size(
+            size_t max
+        );
+
+        void swap (
+            array& item
+        );
+
+        // functions from the enumerable interface
+        inline size_t size (
+        ) const;
+
+        inline bool at_start (
+        ) const;
+
+        inline void reset (
+        ) const;
+
+        bool current_element_valid (
+        ) const;
+
+        inline const T& element (
+        ) const;
+
+        inline T& element (
+        );
+
+        bool move_next (
+        ) const;
+
+        void sort (
+        );
+
+        void resize (
+            size_t new_size
+        );
+
+        const T& back (
+        ) const;
+
+        T& back (
+        );
+
+        void pop_back (
+        );
+
+        void pop_back (
+            T& item
+        );
+
+        void push_back (
+            T& item
+        );
+
+        void push_back (
+            T&& item
+        );
+
+        typedef T* iterator;
+        typedef const T* const_iterator;
+        iterator                begin()                         { return array_elements; }
+        const_iterator          begin() const                   { return array_elements; }
+        iterator                end()                           { return array_elements+array_size; }
+        const_iterator          end() const                     { return array_elements+array_size; }
+
+    private:
+
+        typename mem_manager::template rebind<T>::other pool;
+
+        // data members
+        size_t array_size;
+        size_t max_array_size;
+        T* array_elements;
+
+        mutable T* pos;
+        T* last_pos;
+        mutable bool _at_start;
+
+    };
+
+    template <
+        typename T,
+        typename mem_manager 
+        >
+    inline void swap (
+        array<T,mem_manager>& a, 
+        array<T,mem_manager>& b 
+    ) { a.swap(b); }
+
+// ----------------------------------------------------------------------------------------
+
+    template <
+        typename T,
+        typename mem_manager
+        >
+    void serialize (
+        const array<T,mem_manager>& item,  
+        std::ostream& out
+    )
+    {
+        try
+        {
+            serialize(item.max_size(),out);
+            serialize(item.size(),out);
+
+            for (size_t i = 0; i < item.size(); ++i)
+                serialize(item[i],out);
+        }
+        catch (serialization_error& e)
+        { 
+            throw serialization_error(e.info + "\n   while serializing object of type array"); 
+        }
+    }
+
+    template <
+        typename T,
+        typename mem_manager
+        >
+    void deserialize (
+        array<T,mem_manager>& item,  
+        std::istream& in
+    )
+    {
+        try
+        {
+            size_t max_size, size;
+            deserialize(max_size,in);
+            deserialize(size,in);
+            item.set_max_size(max_size);
+            item.set_size(size);
+            for (size_t i = 0; i < size; ++i)
+                deserialize(item[i],in);
+        }
+        catch (serialization_error& e)
+        { 
+            item.clear();
+            throw serialization_error(e.info + "\n   while deserializing object of type array"); 
+        }
+    }
+
+// ----------------------------------------------------------------------------------------
+// ----------------------------------------------------------------------------------------
+// member function definitions
+// ----------------------------------------------------------------------------------------
+// ----------------------------------------------------------------------------------------
+
+    template <
+        typename T,
+        typename mem_manager
+        >
+    array<T,mem_manager>::
+    ~array (
+    )
+    {
+        if (array_elements)
+        {
+            pool.deallocate_array(array_elements);
+        }
+    }
+
+// ----------------------------------------------------------------------------------------
+
+    template <
+        typename T,
+        typename mem_manager
+        >
+    void array<T,mem_manager>::
+    clear (
+    )
+    {
+        reset();
+        last_pos = 0;
+        array_size = 0;
+        if (array_elements)
+        {
+            pool.deallocate_array(array_elements);
+        }
+        array_elements = 0;
+        max_array_size = 0;
+
+    }
+
+// ----------------------------------------------------------------------------------------
+
+    template <
+        typename T,
+        typename mem_manager
+        >
+    const T& array<T,mem_manager>::
+    operator[] (
+        size_t pos
+    ) const
+    {
+        // make sure requires clause is not broken
+        DLIB_ASSERT( pos < this->size() , 
+            "\tconst T& array::operator[]"
+            << "\n\tpos must < size()" 
+            << "\n\tpos: " << pos 
+            << "\n\tsize(): " << this->size()
+            << "\n\tthis: " << this
+            );
+
+        return array_elements[pos];
+    }
+
+// ----------------------------------------------------------------------------------------
+
+    template <
+        typename T,
+        typename mem_manager
+        >
+    T& array<T,mem_manager>::
+    operator[] (
+        size_t pos
+    ) 
+    {
+        // make sure requires clause is not broken
+        DLIB_ASSERT( pos < this->size() , 
+            "\tT& array::operator[]"
+            << "\n\tpos must be < size()" 
+            << "\n\tpos: " << pos 
+            << "\n\tsize(): " << this->size()
+            << "\n\tthis: " << this
+            );
+
+        return array_elements[pos];
+    }
+
+// ----------------------------------------------------------------------------------------
+
+    template <
+        typename T,
+        typename mem_manager
+        >
+    void array<T,mem_manager>::
+    set_size (
+        size_t size
+    )
+    {
+        // make sure requires clause is not broken
+        DLIB_CASSERT(( size <= this->max_size() ),
+            "\tvoid array::set_size"
+            << "\n\tsize must be <= max_size()"
+            << "\n\tsize: " << size 
+            << "\n\tmax size: " << this->max_size()
+            << "\n\tthis: " << this
+            );
+
+        reset();
+        array_size = size;
+        if (size > 0)
+            last_pos = array_elements + size - 1;
+        else
+            last_pos = 0;
+    }
+
+// ----------------------------------------------------------------------------------------
+
+    template <
+        typename T,
+        typename mem_manager
+        >
+    size_t array<T,mem_manager>::
+    size (
+    ) const
+    {
+        return array_size;
+    }
+
+// ----------------------------------------------------------------------------------------
+
+    template <
+        typename T,
+        typename mem_manager
+        >
+    void array<T,mem_manager>::
+    set_max_size(
+        size_t max
+    )
+    {
+        reset();
+        array_size = 0;
+        last_pos = 0;
+        if (max != 0)
+        {
+            // if new max size is different
+            if (max != max_array_size)
+            {
+                if (array_elements)
+                {
+                    pool.deallocate_array(array_elements);
+                }
+                // try to get more memroy
+                try { array_elements = pool.allocate_array(max); }
+                catch (...) { array_elements = 0;  max_array_size = 0; throw; }
+                max_array_size = max;
+            }
+
+        }
+        // if the array is being made to be zero
+        else
+        {
+            if (array_elements)
+                pool.deallocate_array(array_elements);
+            max_array_size = 0;
+            array_elements = 0;
+        }
+    }
+
+// ----------------------------------------------------------------------------------------
+
+    template <
+        typename T,
+        typename mem_manager
+        >
+    size_t array<T,mem_manager>::
+    max_size (
+    ) const
+    {
+        return max_array_size;
+    }
+
+// ----------------------------------------------------------------------------------------
+
+    template <
+        typename T,
+        typename mem_manager
+        >
+    void array<T,mem_manager>::
+    swap (
+        array<T,mem_manager>& item
+    )
+    {
+        auto             array_size_temp        = item.array_size;
+        auto             max_array_size_temp    = item.max_array_size;
+        T*               array_elements_temp    = item.array_elements;
+
+        item.array_size         = array_size;
+        item.max_array_size     = max_array_size;
+        item.array_elements     = array_elements;
+
+        array_size        = array_size_temp;
+        max_array_size    = max_array_size_temp;
+        array_elements    = array_elements_temp;
+
+        exchange(_at_start,item._at_start);
+        exchange(pos,item.pos);
+        exchange(last_pos,item.last_pos);
+        pool.swap(item.pool);
+    }
+
+// ----------------------------------------------------------------------------------------
+// ----------------------------------------------------------------------------------------
+//           enumerable function definitions
+// ----------------------------------------------------------------------------------------
+// ----------------------------------------------------------------------------------------
+
+    template <
+        typename T,
+        typename mem_manager
+        >
+    bool array<T,mem_manager>::
+    at_start (
+    ) const
+    {
+        return _at_start;
+    }
+
+// ----------------------------------------------------------------------------------------
+
+    template <
+        typename T,
+        typename mem_manager
+        >
+    void array<T,mem_manager>::
+    reset (
+    ) const
+    {
+        _at_start = true;
+        pos = 0;
+    }
+
+// ----------------------------------------------------------------------------------------
+
+    template <
+        typename T,
+        typename mem_manager
+        >
+    bool array<T,mem_manager>::
+    current_element_valid (
+    ) const
+    {
+        return pos != 0;
+    }
+
+// ----------------------------------------------------------------------------------------
+
+    template <
+        typename T,
+        typename mem_manager
+        >
+    const T& array<T,mem_manager>::
+    element (
+    ) const
+    {
+        // make sure requires clause is not broken
+        DLIB_ASSERT(this->current_element_valid(),
+            "\tconst T& array::element()"
+            << "\n\tThe current element must be valid if you are to access it."
+            << "\n\tthis: " << this
+            );
+
+        return *pos;
+    }
+
+// ----------------------------------------------------------------------------------------
+
+    template <
+        typename T,
+        typename mem_manager
+        >
+    T& array<T,mem_manager>::
+    element (
+    )
+    {
+        // make sure requires clause is not broken
+        DLIB_ASSERT(this->current_element_valid(),
+            "\tT& array::element()"
+            << "\n\tThe current element must be valid if you are to access it."
+            << "\n\tthis: " << this
+            );
+
+        return *pos;
+    }
+
+// ----------------------------------------------------------------------------------------
+
+    template <
+        typename T,
+        typename mem_manager
+        >
+    bool array<T,mem_manager>::
+    move_next (
+    ) const
+    {
+        if (!_at_start)
+        {
+            if (pos < last_pos)
+            {
+                ++pos;
+                return true;
+            }
+            else
+            {
+                pos = 0;
+                return false;
+            }
+        }
+        else
+        {
+            _at_start = false;
+            if (array_size > 0)
+            {
+                pos = array_elements;
+                return true;
+            }
+            else
+            {
+                return false;
+            }
+        }
+    }
+
+// ----------------------------------------------------------------------------------------
+// ----------------------------------------------------------------------------------------
+//                              Yet more functions
+// ----------------------------------------------------------------------------------------
+// ----------------------------------------------------------------------------------------
+
+    template <
+        typename T,
+        typename mem_manager
+        >
+    void array<T,mem_manager>::
+    sort (
+    )
+    {
+        if (this->size() > 1)
+        {
+            // call the quick sort function for arrays that is in algs.h
+            dlib::qsort_array(*this,0,this->size()-1);
+        }
+        this->reset();
+    }
+
+// ----------------------------------------------------------------------------------------
+
+    template <
+        typename T,
+        typename mem_manager
+        >
+    void array<T,mem_manager>::
+    resize (
+        size_t new_size
+    )
+    {
+        if (this->max_size() < new_size)
+        {
+            array temp;
+            temp.set_max_size(new_size);
+            temp.set_size(new_size);
+            for (size_t i = 0; i < this->size(); ++i)
+            {
+                exchange((*this)[i],temp[i]);
+            }
+            temp.swap(*this);
+        }
+        else
+        {
+            this->set_size(new_size);
+        }
+    }
+
+// ----------------------------------------------------------------------------------------
+
+    template <
+        typename T,
+        typename mem_manager
+        >
+    T& array<T,mem_manager>::
+    back (
+    ) 
+    {
+        // make sure requires clause is not broken
+        DLIB_ASSERT( this->size() > 0 , 
+                      "\tT& array::back()"
+                      << "\n\tsize() must be bigger than 0" 
+                      << "\n\tsize(): " << this->size()
+                      << "\n\tthis:   " << this
+        );
+
+        return (*this)[this->size()-1];
+    }
+
+// ----------------------------------------------------------------------------------------
+
+    template <
+        typename T,
+        typename mem_manager
+        >
+    const T& array<T,mem_manager>::
+    back (
+    ) const
+    {
+        // make sure requires clause is not broken
+        DLIB_ASSERT( this->size() > 0 , 
+                      "\tconst T& array::back()"
+                      << "\n\tsize() must be bigger than 0" 
+                      << "\n\tsize(): " << this->size()
+                      << "\n\tthis:   " << this
+        );
+
+        return (*this)[this->size()-1];
+    }
+
+// ----------------------------------------------------------------------------------------
+
+    template <
+        typename T,
+        typename mem_manager
+        >
+    void array<T,mem_manager>::
+    pop_back (
+        T& item
+    ) 
+    {
+        // make sure requires clause is not broken
+        DLIB_ASSERT( this->size() > 0 , 
+                      "\tvoid array::pop_back()"
+                      << "\n\tsize() must be bigger than 0" 
+                      << "\n\tsize(): " << this->size()
+                      << "\n\tthis:   " << this
+        );
+
+        exchange(item,(*this)[this->size()-1]);
+        this->set_size(this->size()-1);
+    }
+
+// ----------------------------------------------------------------------------------------
+
+    template <
+        typename T,
+        typename mem_manager
+        >
+    void array<T,mem_manager>::
+    pop_back (
+    ) 
+    {
+        // make sure requires clause is not broken
+        DLIB_ASSERT( this->size() > 0 , 
+                      "\tvoid array::pop_back()"
+                      << "\n\tsize() must be bigger than 0" 
+                      << "\n\tsize(): " << this->size()
+                      << "\n\tthis:   " << this
+        );
+
+        this->set_size(this->size()-1);
+    }
+
+// ----------------------------------------------------------------------------------------
+
+    template <
+        typename T,
+        typename mem_manager
+        >
+    void array<T,mem_manager>::
+    push_back (
+        T& item
+    ) 
+    {
+        if (this->max_size() == this->size())
+        {
+            // double the size of the array
+            array temp;
+            temp.set_max_size(this->size()*2 + 1);
+            temp.set_size(this->size()+1);
+            for (size_t i = 0; i < this->size(); ++i)
+            {
+                exchange((*this)[i],temp[i]);
+            }
+            exchange(item,temp[temp.size()-1]);
+            temp.swap(*this);
+        }
+        else
+        {
+            this->set_size(this->size()+1);
+            exchange(item,(*this)[this->size()-1]);
+        }
+    }
+
+// ----------------------------------------------------------------------------------------
+
+    template <
+        typename T,
+        typename mem_manager
+        >
+    void array<T,mem_manager>::
+    push_back (
+        T&& item
+    ) { push_back(item); }
+
+// ----------------------------------------------------------------------------------------
+
+    template <typename T, typename MM>
+    struct is_array <array<T,MM> >  
+    {
+        const static bool value = true;
+    };
+
+// ----------------------------------------------------------------------------------------
+
+}
+
+#endif // DLIB_ARRAY_KERNEl_2_
+

dlibs/dlib/array/array_kernel_abstract.h

@@ -0,0 +1,360 @@
+// Copyright (C) 2003  Davis E. King ([email protected])
+// License: Boost Software License   See LICENSE.txt for the full license.
+#undef DLIB_ARRAY_KERNEl_ABSTRACT_
+#ifdef DLIB_ARRAY_KERNEl_ABSTRACT_
+
+#include "../interfaces/enumerable.h"
+#include "../serialize.h"
+#include "../algs.h"
+
+namespace dlib
+{
+
+    template <
+        typename T,
+        typename mem_manager = default_memory_manager 
+        >
+    class array : public enumerable<T>
+    {
+
+        /*!
+            REQUIREMENTS ON T
+                T must have a default constructor.
+
+            REQUIREMENTS ON mem_manager
+                must be an implementation of memory_manager/memory_manager_kernel_abstract.h or
+                must be an implementation of memory_manager_global/memory_manager_global_kernel_abstract.h or
+                must be an implementation of memory_manager_stateless/memory_manager_stateless_kernel_abstract.h 
+                mem_manager::type can be set to anything.
+
+            POINTERS AND REFERENCES TO INTERNAL DATA
+                front(), back(), swap(), max_size(), set_size(), and operator[] 
+                functions do not invalidate pointers or references to internal data.
+                All other functions have no such guarantee.
+
+            INITIAL VALUE
+                size() == 0    
+                max_size() == 0
+
+            ENUMERATION ORDER
+                The enumerator will iterate over the elements of the array in the
+                order (*this)[0], (*this)[1], (*this)[2], ...
+
+            WHAT THIS OBJECT REPRESENTS
+                This object represents an ordered 1-dimensional array of items, 
+                each item is associated with an integer value.  The items are 
+                numbered from 0 though size() - 1 and the operator[] functions 
+                run in constant time.  
+
+                Also note that unless specified otherwise, no member functions
+                of this object throw exceptions.
+        !*/
+        
+        public:
+
+            typedef T type;
+            typedef T value_type;
+            typedef mem_manager mem_manager_type;
+
+            array (
+            );
+            /*!
+                ensures 
+                    - #*this is properly initialized
+                throws
+                    - std::bad_alloc or any exception thrown by T's constructor
+            !*/
+
+            explicit array (
+                size_t new_size
+            );
+            /*!
+                ensures 
+                    - #*this is properly initialized
+                    - #size() == new_size
+                    - #max_size() == new_size
+                    - All elements of the array will have initial values for their type.
+                throws
+                    - std::bad_alloc or any exception thrown by T's constructor
+            !*/
+
+            ~array (
+            ); 
+            /*!
+                ensures
+                    - all memory associated with *this has been released
+            !*/
+
+            array(
+                array&& item
+            );
+            /*!
+                ensures
+                    - move constructs *this from item.  Therefore, the state of item is
+                      moved into *this and #item has a valid but unspecified state.
+            !*/
+
+            array& operator=(
+                array&& item
+            );
+            /*!
+                ensures
+                    - move assigns *this from item.  Therefore, the state of item is
+                      moved into *this and #item has a valid but unspecified state.
+                    - returns a reference to #*this
+            !*/
+
+            void clear (
+            );
+            /*!
+                ensures
+                    - #*this has its initial value
+                throws
+                    - std::bad_alloc or any exception thrown by T's constructor
+                        if this exception is thrown then the array object is unusable 
+                        until clear() is called and succeeds
+            !*/
+
+            const T& operator[] (
+                size_t pos
+            ) const;
+            /*!
+                requires
+                    - pos < size()
+                ensures
+                    - returns a const reference to the element at position pos
+            !*/
+            
+            T& operator[] (
+                size_t pos
+            );
+            /*!
+                requires
+                    - pos < size()
+                ensures
+                    - returns a non-const reference to the element at position pos
+            !*/
+
+            void set_size (
+                size_t size
+            );
+            /*!
+                requires
+                    - size <= max_size()
+                ensures
+                    - #size() == size
+                    - any element with index between 0 and size - 1 which was in the 
+                      array before the call to set_size() retains its value and index.
+                      All other elements have undetermined (but valid for their type) 
+                      values.  (e.g. this object might buffer old T objects and reuse 
+                      them without reinitializing them between calls to set_size())
+                    - #at_start() == true
+                throws
+                    - std::bad_alloc or any exception thrown by T's constructor
+                        may throw this exception if there is not enough memory and 
+                        if it does throw then the call to set_size() has no effect    
+            !*/
+
+            size_t max_size(
+            ) const;
+            /*!
+                ensures
+                    - returns the maximum size of *this
+            !*/
+
+            void set_max_size(
+                size_t max
+            );
+            /*!
+                ensures
+                    - #max_size() == max
+                    - #size() == 0
+                    - #at_start() == true
+                throws
+                    - std::bad_alloc or any exception thrown by T's constructor
+                        may throw this exception if there is not enough 
+                        memory and if it does throw then max_size() == 0    
+            !*/
+
+            void swap (
+                array<T>& item
+            );
+            /*!
+                ensures
+                    - swaps *this and item
+            !*/ 
+            
+            void sort (
+            );
+            /*!
+                requires
+                    - T must be a type with that is comparable via operator<
+                ensures
+                    - for all elements in #*this the ith element is <= the i+1 element
+                    - #at_start() == true
+                throws
+                    - std::bad_alloc or any exception thrown by T's constructor
+                        data may be lost if sort() throws
+            !*/
+
+            void resize (
+                size_t new_size
+            );
+            /*!
+                ensures
+                    - #size() == new_size
+                    - #max_size() == max(new_size,max_size())
+                    - for all i < size() && i < new_size:
+                        - #(*this)[i] == (*this)[i]
+                          (i.e. All the original elements of *this which were at index
+                          values less than new_size are unmodified.)
+                    - for all valid i >= size():
+                        - #(*this)[i] has an undefined value
+                          (i.e. any new elements of the array have an undefined value)
+                throws
+                    - std::bad_alloc or any exception thrown by T's constructor.
+                       If an exception is thrown then it has no effect on *this.
+            !*/
+
+            
+            const T& back (
+            ) const;
+            /*!
+                requires
+                    - size() != 0
+                ensures
+                    - returns a const reference to (*this)[size()-1]
+            !*/
+
+            T& back (
+            );
+            /*!
+                requires
+                    - size() != 0
+                ensures
+                    - returns a non-const reference to (*this)[size()-1]
+            !*/
+
+            void pop_back (
+                T& item
+            );
+            /*!
+                requires
+                    - size() != 0
+                ensures
+                    - #size() == size() - 1
+                    - swaps (*this)[size()-1] into item
+                    - All elements with an index less than size()-1 are 
+                      unmodified by this operation.
+            !*/
+
+            void pop_back (
+            );
+            /*!
+                requires
+                    - size() != 0
+                ensures
+                    - #size() == size() - 1
+                    - All elements with an index less than size()-1 are 
+                      unmodified by this operation.
+            !*/
+
+            void push_back (
+                T& item
+            );
+            /*!
+                ensures
+                    - #size() == size()+1
+                    - swaps item into (*this)[#size()-1] 
+                    - #back() == item
+                    - #item has some undefined value (whatever happens to 
+                      get swapped out of the array)
+                throws
+                    - std::bad_alloc or any exception thrown by T's constructor.
+                       If an exception is thrown then it has no effect on *this.
+            !*/
+
+            void push_back (T&& item) { push_back(item); }
+            /*!
+                enable push_back from rvalues 
+            !*/
+
+            typedef T* iterator;
+            typedef const T* const_iterator;
+
+            iterator begin(
+            );
+            /*!
+                ensures
+                    - returns an iterator that points to the first element in this array or
+                      end() if the array is empty.
+            !*/
+
+            const_iterator begin(
+            ) const;
+            /*!
+                ensures
+                    - returns a const iterator that points to the first element in this
+                      array or end() if the array is empty.
+            !*/
+
+            iterator end(
+            );
+            /*!
+                ensures
+                    - returns an iterator that points to one past the end of the array.
+            !*/
+
+            const_iterator end(
+            ) const;
+            /*!
+                ensures
+                    - returns a const iterator that points to one past the end of the
+                      array.
+            !*/
+
+        private:
+
+            // restricted functions
+            array(array<T>&);        // copy constructor
+            array<T>& operator=(array<T>&);    // assignment operator        
+
+    };
+
+    template <
+        typename T
+        >
+    inline void swap (
+        array<T>& a, 
+        array<T>& b 
+    ) { a.swap(b); }
+    /*!
+        provides a global swap function
+    !*/
+
+    template <
+        typename T
+        >
+    void serialize (
+        const array<T>& item, 
+        std::ostream& out 
+    );   
+    /*!
+        provides serialization support 
+    !*/
+
+    template <
+        typename T 
+        >
+    void deserialize (
+        array<T>& item, 
+        std::istream& in
+    );   
+    /*!
+        provides deserialization support 
+    !*/
+
+}
+
+#endif // DLIB_ARRAY_KERNEl_ABSTRACT_
+

dlibs/dlib/array/array_tools.h

@@ -0,0 +1,38 @@
+// Copyright (C) 2013  Davis E. King ([email protected])
+// License: Boost Software License   See LICENSE.txt for the full license.
+#ifndef DLIB_ARRAY_tOOLS_H_
+#define DLIB_ARRAY_tOOLS_H_
+
+#include "../assert.h"
+#include "array_tools_abstract.h"
+
+namespace dlib
+{
+    template <typename T>
+    void split_array (
+        T& a,
+        T& b,
+        double frac
+    )
+    {
+        // make sure requires clause is not broken
+        DLIB_ASSERT(0 <= frac && frac <= 1,
+            "\t void split_array()"
+            << "\n\t frac must be between 0 and 1."
+            << "\n\t frac: " << frac
+            );
+
+        const unsigned long asize = static_cast<unsigned long>(a.size()*frac);
+        const unsigned long bsize = a.size()-asize;
+
+        b.resize(bsize);
+        for (unsigned long i = 0; i < b.size(); ++i)
+        {
+            swap(b[i], a[i+asize]);
+        }
+        a.resize(asize);
+    }
+}
+
+#endif // DLIB_ARRAY_tOOLS_H_
+

dlibs/dlib/array/array_tools_abstract.h

@@ -0,0 +1,33 @@
+// Copyright (C) 2013  Davis E. King ([email protected])
+// License: Boost Software License   See LICENSE.txt for the full license.
+#undef DLIB_ARRAY_tOOLS_ABSTRACT_H_
+#ifdef DLIB_ARRAY_tOOLS_ABSTRACT_H_
+
+#include "array_kernel_abstract.h"
+
+namespace dlib
+{
+    template <typename T>
+    void split_array (
+        T& a,
+        T& b,
+        double frac
+    );
+    /*!
+        requires
+            - 0 <= frac <= 1
+            - T must be an array type such as dlib::array or std::vector
+        ensures
+            - This function takes the elements of a and splits them into two groups.  The
+              first group remains in a and the second group is put into b.  The ordering of
+              elements in a is preserved.  In particular, concatenating #a with #b will
+              reproduce the original contents of a.
+            - The elements in a are moved around using global swap().  So they must be
+              swappable, but do not need to be copyable.
+            - #a.size() == floor(a.size()*frac)
+            - #b.size() == a.size()-#a.size()
+    !*/
+}
+
+#endif // DLIB_ARRAY_tOOLS_ABSTRACT_H_
+

dlibs/dlib/array2d.h

@@ -0,0 +1,12 @@
+// Copyright (C) 2006  Davis E. King ([email protected])
+// License: Boost Software License   See LICENSE.txt for the full license.
+#ifndef DLIB_ARRAY2d_ 
+#define DLIB_ARRAY2d_
+
+
+#include "array2d/array2d_kernel.h"
+#include "array2d/serialize_pixel_overloads.h"
+#include "array2d/array2d_generic_image.h"
+
+#endif // DLIB_ARRAY2d_
+

dlibs/dlib/array2d/array2d_generic_image.h

@@ -0,0 +1,67 @@
+// Copyright (C) 2014  Davis E. King ([email protected])
+// License: Boost Software License   See LICENSE.txt for the full license.
+#ifndef DLIB_ARRAY2D_GENERIC_iMAGE_Hh_
+#define DLIB_ARRAY2D_GENERIC_iMAGE_Hh_
+
+#include "array2d_kernel.h"
+#include "../image_processing/generic_image.h"
+
+namespace dlib
+{
+    template <typename T, typename mm>
+    struct image_traits<array2d<T,mm> >
+    {
+        typedef T pixel_type;
+    };
+    template <typename T, typename mm>
+    struct image_traits<const array2d<T,mm> >
+    {
+        typedef T pixel_type;
+    };
+
+    template <typename T, typename mm>
+    inline long num_rows( const array2d<T,mm>& img) { return img.nr(); }
+    template <typename T, typename mm>
+    inline long num_columns( const array2d<T,mm>& img) { return img.nc(); }
+
+    template <typename T, typename mm>
+    inline void set_image_size(
+        array2d<T,mm>& img,
+        long rows,
+        long cols 
+    ) { img.set_size(rows,cols); }
+
+    template <typename T, typename mm>
+    inline void* image_data(
+        array2d<T,mm>& img
+    )
+    {
+        if (img.size() != 0)
+            return &img[0][0];
+        else
+            return 0;
+    }
+
+    template <typename T, typename mm>
+    inline const void* image_data(
+        const array2d<T,mm>& img
+    )
+    {
+        if (img.size() != 0)
+            return &img[0][0];
+        else
+            return 0;
+    }
+
+    template <typename T, typename mm>
+    inline long width_step(
+        const array2d<T,mm>& img
+    ) 
+    { 
+        return img.width_step(); 
+    }
+
+}
+
+#endif // DLIB_ARRAY2D_GENERIC_iMAGE_Hh_
+

dlibs/dlib/array2d/array2d_kernel.h

@@ -0,0 +1,522 @@
+// Copyright (C) 2006  Davis E. King ([email protected])
+// License: Boost Software License   See LICENSE.txt for the full license.
+#ifndef DLIB_ARRAY2D_KERNEl_1_
+#define DLIB_ARRAY2D_KERNEl_1_
+
+#include "array2d_kernel_abstract.h"
+#include "../algs.h"
+#include "../interfaces/enumerable.h"
+#include "../serialize.h"
+#include "../geometry/rectangle.h"
+
+namespace dlib
+{
+    template <
+        typename T,
+        typename mem_manager = default_memory_manager
+        >
+    class array2d : public enumerable<T>
+    {
+
+        /*!
+            INITIAL VALUE
+                - nc_ == 0 
+                - nr_ == 0 
+                - data == 0 
+                - at_start_ == true
+                - cur == 0
+                - last == 0
+
+            CONVENTION
+                - nc_ == nc() 
+                - nr_ == nc() 
+                - if (data != 0) then
+                    - last == a pointer to the last element in the data array
+                    - data == pointer to an array of nc_*nr_ T objects 
+                - else
+                    - nc_ == 0
+                    - nr_ == 0
+                    - data == 0
+                    - last == 0
+
+
+                - nr_ * nc_ == size()
+                - if (cur == 0) then
+                    - current_element_valid() == false
+                - else 
+                    - current_element_valid() == true
+                    - *cur == element()
+
+                - at_start_ == at_start()      
+        !*/
+
+
+        class row_helper;
+    public:
+
+        // These typedefs are here for backwards compatibility with older versions of dlib.
+        typedef array2d kernel_1a;
+        typedef array2d kernel_1a_c;
+         
+        typedef T type;
+        typedef mem_manager mem_manager_type;
+        typedef T*          iterator;       
+        typedef const T*    const_iterator; 
+
+
+        // -----------------------------------
+
+        class row 
+        {
+            /*!
+                CONVENTION
+                    - nc_ == nc()
+                    - for all x < nc_:
+                        - (*this)[x] == data[x]
+            !*/
+
+            friend class array2d<T,mem_manager>;
+            friend class row_helper;
+
+        public:
+            long nc (
+            ) const { return nc_; }
+
+            const T& operator[] (
+                long column
+            ) const 
+            { 
+                // make sure requires clause is not broken
+                DLIB_ASSERT(column < nc() && column >= 0,
+                    "\tconst T& array2d::operator[](long column) const"
+                    << "\n\tThe column index given must be less than the number of columns."
+                    << "\n\tthis:    " << this
+                    << "\n\tcolumn:  " << column 
+                    << "\n\tnc(): " << nc()
+                );
+
+                return data[column]; 
+            }
+
+            T& operator[] (
+                long column
+            ) 
+            { 
+                // make sure requires clause is not broken
+                DLIB_ASSERT(column < nc() && column >= 0,
+                    "\tT& array2d::operator[](long column)"
+                    << "\n\tThe column index given must be less than the number of columns."
+                    << "\n\tthis:    " << this
+                    << "\n\tcolumn:  " << column 
+                    << "\n\tnc(): " << nc()
+                );
+
+                return data[column]; 
+            }
+
+        private:
+
+            row(T* data_, long cols) : data(data_), nc_(cols) {}
+
+            T* data; 
+            long nc_;
+
+
+            // restricted functions
+            row(){}
+            row& operator=(row&);
+        };
+
+        // -----------------------------------
+
+        array2d (
+        ) : 
+            data(0),
+            nc_(0),
+            nr_(0),
+            cur(0),
+            last(0),
+            at_start_(true)
+        {
+        }
+
+        array2d(
+            long rows,
+            long cols
+        ) : 
+            data(0),
+            nc_(0),
+            nr_(0),
+            cur(0),
+            last(0),
+            at_start_(true)
+        {
+            // make sure requires clause is not broken
+            DLIB_ASSERT((cols >= 0 && rows >= 0),
+                        "\t array2d::array2d(long rows, long cols)"
+                        << "\n\t The array2d can't have negative rows or columns."
+                        << "\n\t this: " << this
+                        << "\n\t cols: " << cols 
+                        << "\n\t rows: " << rows 
+            );
+
+            set_size(rows,cols);
+        }
+
+        array2d(const array2d&) = delete;        // copy constructor
+        array2d& operator=(const array2d&) = delete;    // assignment operator
+
+#ifdef DLIB_HAS_RVALUE_REFERENCES
+        array2d(array2d&& item) : array2d()
+        {
+            swap(item);
+        }
+
+        array2d& operator= (
+            array2d&& rhs
+        )
+        {
+            swap(rhs);
+            return *this;
+        }
+#endif
+
+        virtual ~array2d (
+        ) { clear(); }
+
+        long nc (
+        ) const { return nc_; }
+
+        long nr (
+        ) const { return nr_; }
+
+        row operator[] (
+            long row_
+        ) 
+        { 
+            // make sure requires clause is not broken
+            DLIB_ASSERT(row_ < nr() && row_ >= 0,
+                "\trow array2d::operator[](long row_)"
+                << "\n\tThe row index given must be less than the number of rows."
+                << "\n\tthis:     " << this
+                << "\n\trow_:      " << row_ 
+                << "\n\tnr(): " << nr()
+                );
+
+            return row(data+row_*nc_, nc_);
+        }
+
+        const row operator[] (
+            long row_
+        ) const 
+        { 
+            // make sure requires clause is not broken
+            DLIB_ASSERT(row_ < nr() && row_ >= 0,
+                "\tconst row array2d::operator[](long row_) const"
+                << "\n\tThe row index given must be less than the number of rows."
+                << "\n\tthis:     " << this
+                << "\n\trow_:      " << row_ 
+                << "\n\tnr(): " << nr()
+            );
+
+            return row(data+row_*nc_, nc_);
+        }
+
+        void swap (
+            array2d& item
+        )
+        {
+            exchange(data,item.data);
+            exchange(nr_,item.nr_);
+            exchange(nc_,item.nc_);
+            exchange(at_start_,item.at_start_);
+            exchange(cur,item.cur);
+            exchange(last,item.last);
+            pool.swap(item.pool);
+        }
+
+        void clear (
+        )
+        {
+            if (data != 0)
+            {
+                pool.deallocate_array(data);
+                nc_ = 0;
+                nr_ = 0;
+                data = 0;
+                at_start_ = true;
+                cur = 0;
+                last = 0;
+            }
+        }
+
+        void set_size (
+            long rows,
+            long cols
+        );
+
+        bool at_start (
+        ) const { return at_start_; }
+
+        void reset (
+        ) const { at_start_ = true; cur = 0; }
+
+        bool current_element_valid (
+        ) const { return (cur != 0); }
+
+        const T& element (
+        ) const 
+        { 
+            // make sure requires clause is not broken
+            DLIB_ASSERT(current_element_valid() == true,
+                "\tconst T& array2d::element()()"
+                << "\n\tYou can only call element() when you are at a valid one."
+                << "\n\tthis:    " << this
+            );
+
+            return *cur; 
+        }
+
+        T& element (
+        ) 
+        { 
+            // make sure requires clause is not broken
+            DLIB_ASSERT(current_element_valid() == true,
+                         "\tT& array2d::element()()"
+                         << "\n\tYou can only call element() when you are at a valid one."
+                         << "\n\tthis:    " << this
+            );
+
+            return *cur; 
+        }
+
+        bool move_next (
+        ) const
+        {
+            if (cur != 0)
+            {
+                if (cur != last)
+                {
+                    ++cur;
+                    return true;
+                }
+                cur = 0;
+                return false;
+            }
+            else if (at_start_)
+            {
+                cur = data;
+                at_start_ = false;
+                return (data != 0);
+            }
+            else
+            {
+                return false;
+            }
+        }
+
+        size_t size (
+        ) const { return static_cast<size_t>(nc_) * static_cast<size_t>(nr_); }
+
+        long width_step (
+        ) const
+        {
+            return nc_*sizeof(T);
+        }
+
+        iterator begin() 
+        {
+            return data;
+        }
+
+        iterator end()
+        {
+            return data+size();
+        }
+
+        const_iterator begin()  const
+        {
+            return data;
+        }
+
+        const_iterator end() const
+        {
+            return data+size();
+        }
+
+
+    private:
+
+
+        T* data;
+        long nc_;
+        long nr_;
+
+        typename mem_manager::template rebind<T>::other pool;
+        mutable T* cur;
+        T* last;
+        mutable bool at_start_;
+
+    };
+
+// ----------------------------------------------------------------------------------------
+
+    template <
+        typename T,
+        typename mem_manager
+        >
+    inline void swap (
+        array2d<T,mem_manager>& a, 
+        array2d<T,mem_manager>& b 
+    ) { a.swap(b); }   
+
+
+    template <
+        typename T,
+        typename mem_manager
+        >
+    void serialize (
+        const array2d<T,mem_manager>& item, 
+        std::ostream& out 
+    )   
+    {
+        try
+        {
+            // The reason the serialization is a little funny is because we are trying to
+            // maintain backwards compatibility with an older serialization format used by
+            // dlib while also encoding things in a way that lets the array2d and matrix
+            // objects have compatible serialization formats.
+            serialize(-item.nr(),out);
+            serialize(-item.nc(),out);
+
+            item.reset();
+            while (item.move_next())
+                serialize(item.element(),out);
+            item.reset();
+        }
+        catch (serialization_error& e)
+        { 
+            throw serialization_error(e.info + "\n   while serializing object of type array2d"); 
+        }
+    }
+
+    template <
+        typename T,
+        typename mem_manager
+        >
+    void deserialize (
+        array2d<T,mem_manager>& item, 
+        std::istream& in
+    )   
+    {
+        try
+        {
+            long nr, nc;
+            deserialize(nr,in);
+            deserialize(nc,in);
+
+            // this is the newer serialization format
+            if (nr < 0 || nc < 0)
+            {
+                nr *= -1;
+                nc *= -1;
+            }
+            else
+            {
+                std::swap(nr,nc);
+            }
+
+            item.set_size(nr,nc);
+
+            while (item.move_next())
+                deserialize(item.element(),in); 
+            item.reset();
+        }
+        catch (serialization_error& e)
+        { 
+            item.clear();
+            throw serialization_error(e.info + "\n   while deserializing object of type array2d"); 
+        }
+    }
+
+// ----------------------------------------------------------------------------------------
+// ----------------------------------------------------------------------------------------
+    // member function definitions
+// ----------------------------------------------------------------------------------------
+// ----------------------------------------------------------------------------------------
+
+    template <
+        typename T,
+        typename mem_manager
+        >
+    void array2d<T,mem_manager>::
+    set_size (
+        long rows,
+        long cols
+    )
+    {
+        // make sure requires clause is not broken
+        DLIB_ASSERT((cols >= 0 && rows >= 0) ,
+               "\tvoid array2d::set_size(long rows, long cols)"
+               << "\n\tThe array2d can't have negative rows or columns."
+               << "\n\tthis: " << this
+               << "\n\tcols: " << cols 
+               << "\n\trows: " << rows 
+        );
+
+        // set the enumerator back at the start
+        at_start_ = true;
+        cur = 0;
+
+        // don't do anything if we are already the right size.
+        if (nc_ == cols && nr_ == rows)
+        {
+            return;
+        }
+
+        nc_ = cols;
+        nr_ = rows;
+
+        // free any existing memory
+        if (data != 0)
+        {
+            pool.deallocate_array(data);
+            data = 0;
+        }
+
+        // now setup this object to have the new size
+        try
+        {
+            if (nr_ > 0)
+            {
+                data = pool.allocate_array(nr_*nc_);
+                last = data + nr_*nc_ - 1;
+            }
+        }
+        catch (...)
+        {
+            if (data)
+                pool.deallocate_array(data);
+
+            data = 0;
+            nc_ = 0;
+            nr_ = 0;
+            last = 0;
+            throw;
+        }
+    }
+
+// ----------------------------------------------------------------------------------------
+
+    template <typename T, typename MM>
+    struct is_array2d <array2d<T,MM> >  
+    {
+        const static bool value = true;
+    };
+
+// ----------------------------------------------------------------------------------------
+
+}
+
+#endif // DLIB_ARRAY2D_KERNEl_1_ 
+

dlibs/dlib/array2d/array2d_kernel_abstract.h

@@ -0,0 +1,339 @@
+// Copyright (C) 2006  Davis E. King ([email protected])
+// License: Boost Software License   See LICENSE.txt for the full license.
+#undef DLIB_ARRAY2D_KERNEl_ABSTRACT_
+#ifdef DLIB_ARRAY2D_KERNEl_ABSTRACT_
+
+#include "../interfaces/enumerable.h"
+#include "../serialize.h"
+#include "../algs.h"
+#include "../geometry/rectangle_abstract.h"
+
+namespace dlib
+{
+
+    template <
+        typename T,
+        typename mem_manager = default_memory_manager 
+        >
+    class array2d : public enumerable<T>
+    {
+
+        /*!
+            REQUIREMENTS ON T
+                T must have a default constructor.
+
+            REQUIREMENTS ON mem_manager
+                must be an implementation of memory_manager/memory_manager_kernel_abstract.h or
+                must be an implementation of memory_manager_global/memory_manager_global_kernel_abstract.h or
+                must be an implementation of memory_manager_stateless/memory_manager_stateless_kernel_abstract.h 
+                mem_manager::type can be set to anything.
+
+            POINTERS AND REFERENCES TO INTERNAL DATA
+                No member functions in this object will invalidate pointers
+                or references to internal data except for the set_size()
+                and clear() member functions.
+
+            INITIAL VALUE
+                nr() == 0
+                nc() == 0
+                
+            ENUMERATION ORDER
+                The enumerator will iterate over the elements of the array starting
+                with row 0 and then proceeding to row 1 and so on.  Each row will be
+                fully enumerated before proceeding on to the next row and the elements
+                in a row will be enumerated beginning with the 0th column, then the 1st 
+                column and so on.
+
+            WHAT THIS OBJECT REPRESENTS
+                This object represents a 2-Dimensional array of objects of 
+                type T. 
+
+                Also note that unless specified otherwise, no member functions
+                of this object throw exceptions.
+
+
+                Finally, note that this object stores its data contiguously and in 
+                row major order.  Moreover, there is no padding at the end of each row.
+                This means that its width_step() value is always equal to sizeof(type)*nc().  
+        !*/
+
+
+    public:
+
+        // ----------------------------------------
+
+        typedef T type;
+        typedef mem_manager mem_manager_type;
+        typedef T*          iterator;       
+        typedef const T*    const_iterator; 
+         
+        // ----------------------------------------
+
+        class row 
+        {
+            /*!
+                POINTERS AND REFERENCES TO INTERNAL DATA
+                    No member functions in this object will invalidate pointers
+                    or references to internal data.
+
+                WHAT THIS OBJECT REPRESENTS
+                    This object represents a row of Ts in an array2d object.
+            !*/
+        public:
+            long nc (
+            ) const;
+            /*!
+                ensures
+                    - returns the number of columns in this row
+            !*/
+
+            const T& operator[] (
+                long column
+            ) const;
+            /*!
+                requires
+                    - 0 <= column < nc()
+                ensures
+                    - returns a const reference to the T in the given column 
+            !*/
+
+            T& operator[] (
+                long column
+            );
+            /*!
+                requires
+                    - 0 <= column < nc()
+                ensures
+                    - returns a non-const reference to the T in the given column 
+            !*/
+
+        private:
+            // restricted functions
+            row();
+            row& operator=(row&);
+        };
+
+        // ----------------------------------------
+
+        array2d (
+        );
+        /*!
+            ensures 
+                - #*this is properly initialized
+            throws
+                - std::bad_alloc 
+        !*/
+
+        array2d(const array2d&) = delete;        // copy constructor
+        array2d& operator=(const array2d&) = delete;    // assignment operator
+
+        array2d(
+            array2d&& item
+        );
+        /*!
+            ensures
+                - Moves the state of item into *this.
+                - #item is in a valid but unspecified state.
+        !*/
+
+        array2d (
+            long rows,
+            long cols 
+        );
+        /*!
+            requires
+                - rows >= 0 && cols >= 0
+            ensures
+                - #nc() == cols
+                - #nr() == rows
+                - #at_start() == true
+                - all elements in this array have initial values for their type
+            throws
+                - std::bad_alloc 
+        !*/
+
+        virtual ~array2d (
+        ); 
+        /*!
+            ensures
+                - all resources associated with *this has been released
+        !*/
+        
+        void clear (
+        );
+        /*!
+            ensures
+                - #*this has an initial value for its type
+        !*/
+
+        long nc (
+        ) const;
+        /*!
+            ensures
+                - returns the number of elements there are in a row.  i.e. returns
+                  the number of columns in *this
+        !*/
+
+        long nr (
+        ) const;
+        /*!
+            ensures
+                - returns the number of rows in *this
+        !*/
+
+        void set_size (
+            long rows,
+            long cols
+        );
+        /*!
+            requires
+                - rows >= 0 && cols >= 0
+            ensures
+                - #nc() == cols
+                - #nr() == rows
+                - #at_start() == true
+                - if (the call to set_size() doesn't change the dimensions of this array) then
+                    - all elements in this array retain their values from before this function was called
+                - else
+                    - all elements in this array have initial values for their type
+            throws
+                - std::bad_alloc 
+                    If this exception is thrown then #*this will have an initial
+                    value for its type.
+        !*/
+
+        row operator[] (
+            long row_index
+        );
+        /*!
+            requires
+                - 0 <= row_index < nr()
+            ensures
+                - returns a non-const row of nc() elements that represents the 
+                  given row_index'th row in *this.
+        !*/
+
+        const row operator[] (
+            long row_index
+        ) const;
+        /*!
+            requires
+                - 0 <= row_index < nr()
+            ensures
+                - returns a const row of nc() elements that represents the 
+                  given row_index'th row in *this.
+        !*/
+
+        void swap (
+            array2d& item
+        );
+        /*!
+            ensures
+                - swaps *this and item
+        !*/ 
+
+        array2d& operator= (
+            array2d&& rhs
+        );
+        /*!
+            ensures
+                - Moves the state of item into *this.
+                - #item is in a valid but unspecified state.
+                - returns #*this
+        !*/
+
+        long width_step (
+        ) const;
+        /*!
+            ensures
+                - returns the size of one row of the image, in bytes.  
+                  More precisely, return a number N such that:
+                  (char*)&item[0][0] + N == (char*)&item[1][0].
+                - for dlib::array2d objects, the returned value
+                  is always equal to sizeof(type)*nc().  However,
+                  other objects which implement dlib::array2d style
+                  interfaces might have padding at the ends of their
+                  rows and therefore might return larger numbers.
+                  An example of such an object is the dlib::cv_image.
+        !*/
+
+        iterator begin(
+        );
+        /*!
+            ensures
+                - returns a random access iterator pointing to the first element in this
+                  object.
+                - The iterator will iterate over the elements of the object in row major
+                  order.
+        !*/
+
+        iterator end(
+        );
+        /*!
+            ensures
+                - returns a random access iterator pointing to one past the end of the last
+                  element in this object.
+        !*/
+
+        const_iterator begin(
+        ) const;
+        /*!
+            ensures
+                - returns a random access iterator pointing to the first element in this
+                  object.
+                - The iterator will iterate over the elements of the object in row major
+                  order.
+        !*/
+
+        const_iterator end(
+        ) const;
+        /*!
+            ensures
+                - returns a random access iterator pointing to one past the end of the last
+                  element in this object.
+        !*/
+
+    };
+
+    template <
+        typename T,
+        typename mem_manager
+        >
+    inline void swap (
+        array2d<T,mem_manager>& a, 
+        array2d<T,mem_manager>& b 
+    ) { a.swap(b); }   
+    /*!
+        provides a global swap function
+    !*/
+
+    template <
+        typename T,
+        typename mem_manager
+        >
+    void serialize (
+        const array2d<T,mem_manager>& item, 
+        std::ostream& out 
+    );   
+    /*!
+        Provides serialization support.  Note that the serialization formats used by the
+        dlib::matrix and dlib::array2d objects are compatible.  That means you can load the
+        serialized data from one into another and it will work properly.
+    !*/
+
+    template <
+        typename T,
+        typename mem_manager
+        >
+    void deserialize (
+        array2d<T,mem_manager>& item, 
+        std::istream& in
+    );   
+    /*!
+        provides deserialization support 
+    !*/
+
+}
+
+#endif // DLIB_ARRAY2D_KERNEl_ABSTRACT_ 
+

dlibs/dlib/array2d/serialize_pixel_overloads.h

@@ -0,0 +1,371 @@
+// Copyright (C) 2006  Davis E. King ([email protected])
+// License: Boost Software License   See LICENSE.txt for the full license.
+#ifndef DLIB_ARRAY2D_SERIALIZE_PIXEL_OvERLOADS_Hh_
+#define DLIB_ARRAY2D_SERIALIZE_PIXEL_OvERLOADS_Hh_
+
+#include "array2d_kernel.h"
+#include "../pixel.h"
+
+namespace dlib
+{
+
+// ----------------------------------------------------------------------------------------
+
+    /*
+        This file contains overloads of the serialize functions for array2d object
+        for the case where they contain simple 8bit POD pixel types.  In these
+        cases we can perform a much faster serialization by writing data in chunks
+        instead of one pixel at a time (this avoids a lot of function call overhead
+        inside the iostreams).
+    */
+
+// ----------------------------------------------------------------------------------------
+
+    template <
+        typename mem_manager
+        >
+    void serialize (
+        const array2d<rgb_pixel,mem_manager>& item, 
+        std::ostream& out 
+    )   
+    {
+        try
+        {
+            // The reason the serialization is a little funny is because we are trying to
+            // maintain backwards compatibility with an older serialization format used by
+            // dlib while also encoding things in a way that lets the array2d and matrix
+            // objects have compatible serialization formats.
+            serialize(-item.nr(),out);
+            serialize(-item.nc(),out);
+
+            COMPILE_TIME_ASSERT(sizeof(rgb_pixel) == 3);
+            
+            if (item.size() != 0)
+                out.write((char*)&item[0][0], sizeof(rgb_pixel)*item.size());
+        }
+        catch (serialization_error& e)
+        { 
+            throw serialization_error(e.info + "\n   while serializing object of type array2d"); 
+        }
+    }
+
+    template <
+        typename mem_manager
+        >
+    void deserialize (
+        array2d<rgb_pixel,mem_manager>& item, 
+        std::istream& in
+    )   
+    {
+        try
+        {
+            COMPILE_TIME_ASSERT(sizeof(rgb_pixel) == 3);
+
+            long nr, nc;
+            deserialize(nr,in);
+            deserialize(nc,in);
+
+            // this is the newer serialization format
+            if (nr < 0 || nc < 0)
+            {
+                nr *= -1;
+                nc *= -1;
+            }
+            else
+            {
+                std::swap(nr,nc);
+            }
+
+            item.set_size(nr,nc);
+
+            if (item.size() != 0)
+                in.read((char*)&item[0][0], sizeof(rgb_pixel)*item.size());
+        }
+        catch (serialization_error& e)
+        { 
+            item.clear();
+            throw serialization_error(e.info + "\n   while deserializing object of type array2d"); 
+        }
+    }
+
+// ----------------------------------------------------------------------------------------
+
+    template <
+        typename mem_manager
+        >
+    void serialize (
+        const array2d<bgr_pixel,mem_manager>& item, 
+        std::ostream& out 
+    )   
+    {
+        try
+        {
+            // The reason the serialization is a little funny is because we are trying to
+            // maintain backwards compatibility with an older serialization format used by
+            // dlib while also encoding things in a way that lets the array2d and matrix
+            // objects have compatible serialization formats.
+            serialize(-item.nr(),out);
+            serialize(-item.nc(),out);
+
+            COMPILE_TIME_ASSERT(sizeof(bgr_pixel) == 3);
+
+            if (item.size() != 0)
+                out.write((char*)&item[0][0], sizeof(bgr_pixel)*item.size());
+        }
+        catch (serialization_error& e)
+        { 
+            throw serialization_error(e.info + "\n   while serializing object of type array2d"); 
+        }
+    }
+
+    template <
+        typename mem_manager
+        >
+    void deserialize (
+        array2d<bgr_pixel,mem_manager>& item, 
+        std::istream& in
+    )   
+    {
+        try
+        {
+            COMPILE_TIME_ASSERT(sizeof(bgr_pixel) == 3);
+
+            long nr, nc;
+            deserialize(nr,in);
+            deserialize(nc,in);
+
+            // this is the newer serialization format
+            if (nr < 0 || nc < 0)
+            {
+                nr *= -1;
+                nc *= -1;
+            }
+            else
+            {
+                std::swap(nr,nc);
+            }
+
+
+            item.set_size(nr,nc);
+
+            if (item.size() != 0)
+                in.read((char*)&item[0][0], sizeof(bgr_pixel)*item.size());
+        }
+        catch (serialization_error& e)
+        { 
+            item.clear();
+            throw serialization_error(e.info + "\n   while deserializing object of type array2d"); 
+        }
+    }
+
+// ----------------------------------------------------------------------------------------
+
+    template <
+        typename mem_manager
+        >
+    void serialize (
+        const array2d<hsi_pixel,mem_manager>& item, 
+        std::ostream& out 
+    )   
+    {
+        try
+        {
+            // The reason the serialization is a little funny is because we are trying to
+            // maintain backwards compatibility with an older serialization format used by
+            // dlib while also encoding things in a way that lets the array2d and matrix
+            // objects have compatible serialization formats.
+            serialize(-item.nr(),out);
+            serialize(-item.nc(),out);
+
+            COMPILE_TIME_ASSERT(sizeof(hsi_pixel) == 3);
+
+            if (item.size() != 0)
+                out.write((char*)&item[0][0], sizeof(hsi_pixel)*item.size());
+        }
+        catch (serialization_error& e)
+        { 
+            throw serialization_error(e.info + "\n   while serializing object of type array2d"); 
+        }
+    }
+
+    template <
+        typename mem_manager
+        >
+    void deserialize (
+        array2d<hsi_pixel,mem_manager>& item, 
+        std::istream& in
+    )   
+    {
+        try
+        {
+            COMPILE_TIME_ASSERT(sizeof(hsi_pixel) == 3);
+
+            long nr, nc;
+            deserialize(nr,in);
+            deserialize(nc,in);
+
+            // this is the newer serialization format
+            if (nr < 0 || nc < 0)
+            {
+                nr *= -1;
+                nc *= -1;
+            }
+            else
+            {
+                std::swap(nr,nc);
+            }
+
+
+            item.set_size(nr,nc);
+
+            if (item.size() != 0)
+                in.read((char*)&item[0][0], sizeof(hsi_pixel)*item.size());
+        }
+        catch (serialization_error& e)
+        { 
+            item.clear();
+            throw serialization_error(e.info + "\n   while deserializing object of type array2d"); 
+        }
+    }
+
+// ----------------------------------------------------------------------------------------
+
+    template <
+        typename mem_manager
+        >
+    void serialize (
+        const array2d<rgb_alpha_pixel,mem_manager>& item, 
+        std::ostream& out 
+    )   
+    {
+        try
+        {
+            // The reason the serialization is a little funny is because we are trying to
+            // maintain backwards compatibility with an older serialization format used by
+            // dlib while also encoding things in a way that lets the array2d and matrix
+            // objects have compatible serialization formats.
+            serialize(-item.nr(),out);
+            serialize(-item.nc(),out);
+
+            COMPILE_TIME_ASSERT(sizeof(rgb_alpha_pixel) == 4);
+
+            if (item.size() != 0)
+                out.write((char*)&item[0][0], sizeof(rgb_alpha_pixel)*item.size());
+        }
+        catch (serialization_error& e)
+        { 
+            throw serialization_error(e.info + "\n   while serializing object of type array2d"); 
+        }
+    }
+
+    template <
+        typename mem_manager
+        >
+    void deserialize (
+        array2d<rgb_alpha_pixel,mem_manager>& item, 
+        std::istream& in
+    )   
+    {
+        try
+        {
+            COMPILE_TIME_ASSERT(sizeof(rgb_alpha_pixel) == 4);
+
+            long nr, nc;
+            deserialize(nr,in);
+            deserialize(nc,in);
+
+            // this is the newer serialization format
+            if (nr < 0 || nc < 0)
+            {
+                nr *= -1;
+                nc *= -1;
+            }
+            else
+            {
+                std::swap(nr,nc);
+            }
+
+
+            item.set_size(nr,nc);
+
+            if (item.size() != 0)
+                in.read((char*)&item[0][0], sizeof(rgb_alpha_pixel)*item.size());
+        }
+        catch (serialization_error& e)
+        { 
+            item.clear();
+            throw serialization_error(e.info + "\n   while deserializing object of type array2d"); 
+        }
+    }
+
+// ----------------------------------------------------------------------------------------
+
+    template <
+        typename mem_manager
+        >
+    void serialize (
+        const array2d<unsigned char,mem_manager>& item, 
+        std::ostream& out 
+    )   
+    {
+        try
+        {
+            // The reason the serialization is a little funny is because we are trying to
+            // maintain backwards compatibility with an older serialization format used by
+            // dlib while also encoding things in a way that lets the array2d and matrix
+            // objects have compatible serialization formats.
+            serialize(-item.nr(),out);
+            serialize(-item.nc(),out);
+
+            if (item.size() != 0)
+                out.write((char*)&item[0][0], sizeof(unsigned char)*item.size());
+        }
+        catch (serialization_error& e)
+        { 
+            throw serialization_error(e.info + "\n   while serializing object of type array2d"); 
+        }
+    }
+
+    template <
+        typename mem_manager
+        >
+    void deserialize (
+        array2d<unsigned char,mem_manager>& item, 
+        std::istream& in
+    )   
+    {
+        try
+        {
+            long nr, nc;
+            deserialize(nr,in);
+            deserialize(nc,in);
+            // this is the newer serialization format
+            if (nr < 0 || nc < 0)
+            {
+                nr *= -1;
+                nc *= -1;
+            }
+            else
+            {
+                std::swap(nr,nc);
+            }
+
+
+            item.set_size(nr,nc);
+
+            if (item.size() != 0)
+                in.read((char*)&item[0][0], sizeof(unsigned char)*item.size());
+        }
+        catch (serialization_error& e)
+        { 
+            item.clear();
+            throw serialization_error(e.info + "\n   while deserializing object of type array2d"); 
+        }
+    }
+
+// ----------------------------------------------------------------------------------------
+
+}
+
+#endif // DLIB_ARRAY2D_SERIALIZE_PIXEL_OvERLOADS_Hh_
+

dlibs/dlib/assert.h

@@ -0,0 +1,217 @@
+// Copyright (C) 2003  Davis E. King ([email protected])
+// License: Boost Software License   See LICENSE.txt for the full license.
+#ifndef DLIB_ASSERt_
+#define DLIB_ASSERt_
+
+#include "config.h"
+#include <sstream>
+#include <iosfwd>
+#include "error.h"
+
+// -----------------------------
+
+// Use some stuff from boost here
+//  (C) Copyright John Maddock 2001 - 2003.
+//  (C) Copyright Darin Adler 2001.
+//  (C) Copyright Peter Dimov 2001.
+//  (C) Copyright Bill Kempf 2002.
+//  (C) Copyright Jens Maurer 2002.
+//  (C) Copyright David Abrahams 2002 - 2003.
+//  (C) Copyright Gennaro Prota 2003.
+//  (C) Copyright Eric Friedman 2003.
+// License: Boost Software License   See LICENSE.txt for the full license.
+// 
+#ifndef DLIB_BOOST_JOIN
+#define DLIB_BOOST_JOIN( X, Y ) DLIB_BOOST_DO_JOIN( X, Y )
+#define DLIB_BOOST_DO_JOIN( X, Y ) DLIB_BOOST_DO_JOIN2(X,Y)
+#define DLIB_BOOST_DO_JOIN2( X, Y ) X##Y
+#endif
+
+// figure out if the compiler has rvalue references. 
+#if defined(__clang__) 
+#   if __has_feature(cxx_rvalue_references)
+#       define DLIB_HAS_RVALUE_REFERENCES
+#   endif
+#   if __has_feature(cxx_generalized_initializers)
+#       define DLIB_HAS_INITIALIZER_LISTS
+#   endif
+#elif defined(__GNUC__) && (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ > 2)) && defined(__GXX_EXPERIMENTAL_CXX0X__) 
+#   define DLIB_HAS_RVALUE_REFERENCES
+#   define DLIB_HAS_INITIALIZER_LISTS
+#elif defined(_MSC_VER) && _MSC_VER >= 1800
+#   define DLIB_HAS_INITIALIZER_LISTS
+#   define DLIB_HAS_RVALUE_REFERENCES
+#elif defined(_MSC_VER) && _MSC_VER >= 1600
+#   define DLIB_HAS_RVALUE_REFERENCES
+#elif defined(__INTEL_COMPILER) && defined(BOOST_INTEL_STDCXX0X)
+#   define DLIB_HAS_RVALUE_REFERENCES
+#   define DLIB_HAS_INITIALIZER_LISTS
+#endif
+
+#if defined(__APPLE__) && defined(__GNUC_LIBSTD__) && ((__GNUC_LIBSTD__-0) * 100 + __GNUC_LIBSTD_MINOR__-0 <= 402)
+ // Apple has not updated libstdc++ in some time and anything under 4.02 does not have <initializer_list> for sure.
+#   undef DLIB_HAS_INITIALIZER_LISTS
+#endif
+
+// figure out if the compiler has static_assert. 
+#if defined(__clang__) 
+#   if __has_feature(cxx_static_assert)
+#       define DLIB_HAS_STATIC_ASSERT
+#   endif
+#elif defined(__GNUC__) && (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ > 2)) && defined(__GXX_EXPERIMENTAL_CXX0X__) 
+#   define DLIB_HAS_STATIC_ASSERT
+#elif defined(_MSC_VER) && _MSC_VER >= 1600
+#   define DLIB_HAS_STATIC_ASSERT
+#elif defined(__INTEL_COMPILER) && defined(BOOST_INTEL_STDCXX0X)
+#   define DLIB_HAS_STATIC_ASSERT
+#endif
+
+
+// -----------------------------
+
+namespace dlib
+{
+    template <bool value> struct compile_time_assert;
+    template <> struct compile_time_assert<true> { enum {value=1};  };
+
+    template <typename T, typename U> struct assert_are_same_type;
+    template <typename T> struct assert_are_same_type<T,T> {enum{value=1};};
+    template <typename T, typename U> struct assert_are_not_same_type {enum{value=1}; };
+    template <typename T> struct assert_are_not_same_type<T,T> {};
+
+    template <typename T, typename U> struct assert_types_match {enum{value=0};};
+    template <typename T> struct assert_types_match<T,T> {enum{value=1};};
+}
+
+
+// gcc 4.8 will warn about unused typedefs.  But we use typedefs in some of the compile
+// time assert macros so we need to make it not complain about them "not being used".
+#ifdef __GNUC__
+#define DLIB_NO_WARN_UNUSED __attribute__ ((unused))
+#else
+#define DLIB_NO_WARN_UNUSED 
+#endif
+
+// Use the newer static_assert if it's available since it produces much more readable error
+// messages.
+#ifdef DLIB_HAS_STATIC_ASSERT
+    #define COMPILE_TIME_ASSERT(expression) static_assert(expression, "Failed assertion")
+    #define ASSERT_ARE_SAME_TYPE(type1, type2) static_assert(::dlib::assert_types_match<type1,type2>::value, "These types should be the same but aren't.")
+    #define ASSERT_ARE_NOT_SAME_TYPE(type1, type2) static_assert(!::dlib::assert_types_match<type1,type2>::value, "These types should NOT be the same.")
+#else
+    #define COMPILE_TIME_ASSERT(expression) \
+        DLIB_NO_WARN_UNUSED typedef char DLIB_BOOST_JOIN(DLIB_CTA, __LINE__)[::dlib::compile_time_assert<(bool)(expression)>::value] 
+
+    #define ASSERT_ARE_SAME_TYPE(type1, type2) \
+        DLIB_NO_WARN_UNUSED typedef char DLIB_BOOST_JOIN(DLIB_AAST, __LINE__)[::dlib::assert_are_same_type<type1,type2>::value] 
+
+    #define ASSERT_ARE_NOT_SAME_TYPE(type1, type2) \
+        DLIB_NO_WARN_UNUSED typedef char DLIB_BOOST_JOIN(DLIB_AANST, __LINE__)[::dlib::assert_are_not_same_type<type1,type2>::value] 
+#endif
+
+// -----------------------------
+
+#if defined DLIB_DISABLE_ASSERTS
+    // if DLIB_DISABLE_ASSERTS is on then never enable DLIB_ASSERT no matter what.
+    #undef ENABLE_ASSERTS
+#endif
+
+#if !defined(DLIB_DISABLE_ASSERTS) && ( defined DEBUG || defined _DEBUG)
+    // make sure ENABLE_ASSERTS is defined if we are indeed using them.
+    #ifndef ENABLE_ASSERTS
+        #define ENABLE_ASSERTS
+    #endif
+#endif
+
+// -----------------------------
+
+#ifdef __GNUC__
+// There is a bug in version 4.4.5 of GCC on Ubuntu which causes GCC to segfault
+// when __PRETTY_FUNCTION__ is used within certain templated functions.  So just
+// don't use it with this version of GCC.
+#  if !(__GNUC__ == 4 && __GNUC_MINOR__ == 4 && __GNUC_PATCHLEVEL__ == 5)
+#    define DLIB_FUNCTION_NAME __PRETTY_FUNCTION__
+#  else
+#    define DLIB_FUNCTION_NAME "unknown function" 
+#  endif
+#elif defined(_MSC_VER)
+#define DLIB_FUNCTION_NAME __FUNCSIG__
+#else
+#define DLIB_FUNCTION_NAME "unknown function" 
+#endif
+
+#define DLIBM_CASSERT(_exp,_message)                                              \
+    {if ( !(_exp) )                                                         \
+    {                                                                       \
+        dlib_assert_breakpoint();                                           \
+        std::ostringstream dlib_o_out;                                       \
+        dlib_o_out << "\n\nError detected at line " << __LINE__ << ".\n";    \
+        dlib_o_out << "Error detected in file " << __FILE__ << ".\n";      \
+        dlib_o_out << "Error detected in function " << DLIB_FUNCTION_NAME << ".\n\n";      \
+        dlib_o_out << "Failing expression was " << #_exp << ".\n";           \
+        dlib_o_out << std::boolalpha << _message << "\n";                    \
+        throw dlib::fatal_error(dlib::EBROKEN_ASSERT,dlib_o_out.str());      \
+    }}                                                                      
+
+// This macro is not needed if you have a real C++ compiler.  It's here to work around bugs in Visual Studio's preprocessor.  
+#define DLIB_WORKAROUND_VISUAL_STUDIO_BUGS(x) x
+// Make it so the 2nd argument of DLIB_CASSERT is optional.  That is, you can call it like
+// DLIB_CASSERT(exp) or DLIB_CASSERT(exp,message).
+#define DLIBM_CASSERT_1_ARGS(exp)              DLIBM_CASSERT(exp,"")
+#define DLIBM_CASSERT_2_ARGS(exp,message)      DLIBM_CASSERT(exp,message)
+#define DLIBM_GET_3TH_ARG(arg1, arg2, arg3, ...) arg3
+#define DLIBM_CASSERT_CHOOSER(...) DLIB_WORKAROUND_VISUAL_STUDIO_BUGS(DLIBM_GET_3TH_ARG(__VA_ARGS__,  DLIBM_CASSERT_2_ARGS, DLIBM_CASSERT_1_ARGS, DLIB_CASSERT_NEVER_USED))
+#define DLIB_CASSERT(...) DLIB_WORKAROUND_VISUAL_STUDIO_BUGS(DLIBM_CASSERT_CHOOSER(__VA_ARGS__)(__VA_ARGS__))
+
+
+#ifdef ENABLE_ASSERTS 
+    #define DLIB_ASSERT(...) DLIB_CASSERT(__VA_ARGS__)
+    #define DLIB_IF_ASSERT(exp) exp
+#else
+    #define DLIB_ASSERT(...) {}
+    #define DLIB_IF_ASSERT(exp) 
+#endif
+
+// ----------------------------------------------------------------------------------------
+
+    /*!A DLIB_ASSERT_HAS_STANDARD_LAYOUT 
+    
+        This macro is meant to cause a compiler error if a type doesn't have a simple
+        memory layout (like a C struct). In particular, types with simple layouts are
+        ones which can be copied via memcpy().
+        
+        
+        This was called a POD type in C++03 and in C++0x we are looking to check if 
+        it is a "standard layout type".  Once we can use C++0x we can change this macro 
+        to something that uses the std::is_standard_layout type_traits class.  
+        See: http://www2.research.att.com/~bs/C++0xFAQ.html#PODs
+    !*/
+    // Use the fact that in C++03 you can't put non-PODs into a union.
+#define DLIB_ASSERT_HAS_STANDARD_LAYOUT(type)   \
+    union  DLIB_BOOST_JOIN(DAHSL_,__LINE__) { type TYPE_NOT_STANDARD_LAYOUT; };  \
+    DLIB_NO_WARN_UNUSED typedef char DLIB_BOOST_JOIN(DAHSL2_,__LINE__)[sizeof(DLIB_BOOST_JOIN(DAHSL_,__LINE__))]; 
+
+// ----------------------------------------------------------------------------------------
+// ----------------------------------------------------------------------------------------
+// ----------------------------------------------------------------------------------------
+
+// breakpoints
+extern "C"
+{
+    inline void dlib_assert_breakpoint(
+    ) {}
+    /*!
+        ensures
+            - this function does nothing 
+              It exists just so you can put breakpoints on it in a debugging tool.
+              It is called only when an DLIB_ASSERT or DLIB_CASSERT fails and is about to
+              throw an exception.
+    !*/
+}
+
+// -----------------------------
+
+#include "stack_trace.h"
+
+#endif // DLIB_ASSERt_
+

dlibs/dlib/base64.h

@@ -0,0 +1,9 @@
+// Copyright (C) 2006  Davis E. King ([email protected])
+// License: Boost Software License   See LICENSE.txt for the full license.
+#ifndef DLIB_BASe64_
+#define DLIB_BASe64_
+
+#include "base64/base64_kernel_1.h"
+
+#endif // DLIB_BASe64_
+

dlibs/dlib/base64/base64_kernel_1.cpp

@@ -0,0 +1,403 @@
+// Copyright (C) 2006  Davis E. King ([email protected])
+// License: Boost Software License   See LICENSE.txt for the full license.
+#ifndef DLIB_BASE64_KERNEL_1_CPp_
+#define DLIB_BASE64_KERNEL_1_CPp_
+
+#include "base64_kernel_1.h"
+#include <iostream>
+#include <sstream>
+#include <climits>
+
+namespace dlib
+{
+
+// ----------------------------------------------------------------------------------------
+
+    base64::line_ending_type base64::
+    line_ending (
+    ) const
+    {
+        return eol_style;
+    }
+
+// ----------------------------------------------------------------------------------------
+
+    void base64::
+    set_line_ending (
+        line_ending_type eol_style_
+    )
+    {
+        eol_style = eol_style_;
+    }
+
+// ----------------------------------------------------------------------------------------
+
+    base64::
+    base64 (
+    ) : 
+        encode_table(0),
+        decode_table(0),
+        bad_value(100),
+        eol_style(LF)
+    {
+        try
+        {
+            encode_table = new char[64];
+            decode_table = new unsigned char[UCHAR_MAX];
+        }
+        catch (...)
+        {
+            if (encode_table) delete [] encode_table;
+            if (decode_table) delete [] decode_table;
+            throw;
+        }
+
+        // now set up the tables with the right stuff
+        encode_table[0] = 'A';
+        encode_table[17] = 'R';
+        encode_table[34] = 'i';
+        encode_table[51] = 'z';
+
+        encode_table[1] = 'B';
+        encode_table[18] = 'S';
+        encode_table[35] = 'j';
+        encode_table[52] = '0';
+
+        encode_table[2] = 'C';
+        encode_table[19] = 'T';
+        encode_table[36] = 'k';
+        encode_table[53] = '1';
+
+        encode_table[3] = 'D';
+        encode_table[20] = 'U';
+        encode_table[37] = 'l';
+        encode_table[54] = '2';
+
+        encode_table[4] = 'E';
+        encode_table[21] = 'V';
+        encode_table[38] = 'm';
+        encode_table[55] = '3';
+
+        encode_table[5] = 'F';
+        encode_table[22] = 'W';
+        encode_table[39] = 'n';
+        encode_table[56] = '4';
+
+        encode_table[6] = 'G';
+        encode_table[23] = 'X';
+        encode_table[40] = 'o';
+        encode_table[57] = '5';
+
+        encode_table[7] = 'H';
+        encode_table[24] = 'Y';
+        encode_table[41] = 'p';
+        encode_table[58] = '6';
+
+        encode_table[8] = 'I';
+        encode_table[25] = 'Z';
+        encode_table[42] = 'q';
+        encode_table[59] = '7';
+
+        encode_table[9] = 'J';
+        encode_table[26] = 'a';
+        encode_table[43] = 'r';
+        encode_table[60] = '8';
+
+        encode_table[10] = 'K';
+        encode_table[27] = 'b';
+        encode_table[44] = 's';
+        encode_table[61] = '9';
+
+        encode_table[11] = 'L';
+        encode_table[28] = 'c';
+        encode_table[45] = 't';
+        encode_table[62] = '+';
+
+        encode_table[12] = 'M';
+        encode_table[29] = 'd';
+        encode_table[46] = 'u';
+        encode_table[63] = '/';
+
+        encode_table[13] = 'N';
+        encode_table[30] = 'e';
+        encode_table[47] = 'v';
+
+        encode_table[14] = 'O';
+        encode_table[31] = 'f';
+        encode_table[48] = 'w';
+
+        encode_table[15] = 'P';
+        encode_table[32] = 'g';
+        encode_table[49] = 'x';
+
+        encode_table[16] = 'Q';
+        encode_table[33] = 'h';
+        encode_table[50] = 'y';
+
+
+
+        // we can now fill out the decode_table by using the encode_table
+        for (int i = 0; i < UCHAR_MAX; ++i)
+        {
+            decode_table[i] = bad_value;
+        }
+        for (unsigned char i = 0; i < 64; ++i)
+        {
+            decode_table[(unsigned char)encode_table[i]] = i;
+        }
+    }
+
+// ----------------------------------------------------------------------------------------
+
+    base64::
+    ~base64 (
+    )
+    {
+        delete [] encode_table;
+        delete [] decode_table;
+    }
+
+// ----------------------------------------------------------------------------------------
+
+    void base64::
+    encode (
+        std::istream& in_,
+        std::ostream& out_
+    ) const
+    {
+        using namespace std;
+        streambuf& in = *in_.rdbuf();
+        streambuf& out = *out_.rdbuf();
+
+        unsigned char inbuf[3];
+        unsigned char outbuf[4];
+        streamsize status = in.sgetn(reinterpret_cast<char*>(&inbuf),3);
+
+        unsigned char c1, c2, c3, c4, c5, c6;
+
+        int counter = 19;
+
+        // while we haven't hit the end of the input stream
+        while (status != 0)
+        {
+            if (counter == 0)
+            {
+                counter = 19;
+                // write a newline
+                char ch;
+                switch (eol_style)
+                {
+                    case CR:
+                        ch = '\r';
+                        if (out.sputn(&ch,1)!=1)
+                            throw std::ios_base::failure("error occurred in the base64 object");
+                        break;
+                    case LF:
+                        ch = '\n';
+                        if (out.sputn(&ch,1)!=1)
+                            throw std::ios_base::failure("error occurred in the base64 object");
+                        break;
+                    case CRLF:
+                        ch = '\r';
+                        if (out.sputn(&ch,1)!=1)
+                            throw std::ios_base::failure("error occurred in the base64 object");
+                        ch = '\n';
+                        if (out.sputn(&ch,1)!=1)
+                            throw std::ios_base::failure("error occurred in the base64 object");
+                        break;
+                    default:
+                        DLIB_CASSERT(false,"this should never happen");
+                }
+            }
+            --counter;
+
+            if (status == 3)
+            {
+                // encode the bytes in inbuf to base64 and write them to the output stream
+                c1 = inbuf[0]&0xfc;
+                c2 = inbuf[0]&0x03;
+                c3 = inbuf[1]&0xf0;
+                c4 = inbuf[1]&0x0f;
+                c5 = inbuf[2]&0xc0;
+                c6 = inbuf[2]&0x3f;
+
+                outbuf[0] = c1>>2;
+                outbuf[1] = (c2<<4)|(c3>>4);
+                outbuf[2] = (c4<<2)|(c5>>6);
+                outbuf[3] = c6;
+
+
+                outbuf[0] = encode_table[outbuf[0]];
+                outbuf[1] = encode_table[outbuf[1]];
+                outbuf[2] = encode_table[outbuf[2]];
+                outbuf[3] = encode_table[outbuf[3]];
+
+                // write the encoded bytes to the output stream
+                if (out.sputn(reinterpret_cast<char*>(&outbuf),4)!=4)
+                {
+                    throw std::ios_base::failure("error occurred in the base64 object");
+                }
+
+                // get 3 more input bytes
+                status = in.sgetn(reinterpret_cast<char*>(&inbuf),3);
+                continue;
+            }
+            else if (status == 2)
+            {
+                // we are at the end of the input stream and need to add some padding
+
+                // encode the bytes in inbuf to base64 and write them to the output stream
+                c1 = inbuf[0]&0xfc;
+                c2 = inbuf[0]&0x03;
+                c3 = inbuf[1]&0xf0;
+                c4 = inbuf[1]&0x0f;
+                c5 = 0;
+
+                outbuf[0] = c1>>2;
+                outbuf[1] = (c2<<4)|(c3>>4);
+                outbuf[2] = (c4<<2)|(c5>>6);
+                outbuf[3] = '=';
+
+                outbuf[0] = encode_table[outbuf[0]];
+                outbuf[1] = encode_table[outbuf[1]];
+                outbuf[2] = encode_table[outbuf[2]];
+
+                // write the encoded bytes to the output stream
+                if (out.sputn(reinterpret_cast<char*>(&outbuf),4)!=4)
+                {
+                    throw std::ios_base::failure("error occurred in the base64 object");
+                }
+
+
+                break;
+            }
+            else // in this case status must be 1 
+            {
+                // we are at the end of the input stream and need to add some padding
+
+                // encode the bytes in inbuf to base64 and write them to the output stream
+                c1 = inbuf[0]&0xfc;
+                c2 = inbuf[0]&0x03;
+                c3 = 0;
+
+                outbuf[0] = c1>>2;
+                outbuf[1] = (c2<<4)|(c3>>4);
+                outbuf[2] = '=';
+                outbuf[3] = '=';
+
+                outbuf[0] = encode_table[outbuf[0]];
+                outbuf[1] = encode_table[outbuf[1]];
+
+
+                // write the encoded bytes to the output stream
+                if (out.sputn(reinterpret_cast<char*>(&outbuf),4)!=4)
+                {
+                    throw std::ios_base::failure("error occurred in the base64 object");
+                }
+
+                break;
+            }
+        } // while (status != 0)
+        
+
+        // make sure the stream buffer flushes to its I/O channel
+        out.pubsync();
+    }
+
+// ----------------------------------------------------------------------------------------
+
+    void base64::
+    decode (
+        std::istream& in_,
+        std::ostream& out_
+    ) const
+    {
+        using namespace std;
+        streambuf& in = *in_.rdbuf();
+        streambuf& out = *out_.rdbuf();
+
+        unsigned char inbuf[4];
+        unsigned char outbuf[3];
+        int inbuf_pos = 0;
+        streamsize status = in.sgetn(reinterpret_cast<char*>(inbuf),1);
+
+        // only count this character if it isn't some kind of filler
+        if (status == 1 && decode_table[inbuf[0]] != bad_value )
+            ++inbuf_pos;
+
+        unsigned char c1, c2, c3, c4, c5, c6;
+        streamsize outsize;
+
+        // while we haven't hit the end of the input stream
+        while (status != 0)
+        {
+            // if we have 4 valid characters
+            if (inbuf_pos == 4)
+            {
+                inbuf_pos = 0;
+
+                // this might be the end of the encoded data so we need to figure out if 
+                // there was any padding applied.
+                outsize = 3;
+                if (inbuf[3] == '=')
+                {
+                    if (inbuf[2] == '=')
+                        outsize = 1;
+                    else
+                        outsize = 2;
+                }
+
+                // decode the incoming characters
+                inbuf[0] = decode_table[inbuf[0]];
+                inbuf[1] = decode_table[inbuf[1]];
+                inbuf[2] = decode_table[inbuf[2]];
+                inbuf[3] = decode_table[inbuf[3]];
+
+
+                // now pack these guys into bytes rather than 6 bit chunks
+                c1 = inbuf[0]<<2;
+                c2 = inbuf[1]>>4;
+                c3 = inbuf[1]<<4;
+                c4 = inbuf[2]>>2;
+                c5 = inbuf[2]<<6;
+                c6 = inbuf[3];
+
+                outbuf[0] = c1|c2;
+                outbuf[1] = c3|c4;
+                outbuf[2] = c5|c6;
+
+
+                // write the encoded bytes to the output stream
+                if (out.sputn(reinterpret_cast<char*>(&outbuf),outsize)!=outsize)
+                {
+                    throw std::ios_base::failure("error occurred in the base64 object");
+                }
+            }
+
+            // get more input characters 
+            status = in.sgetn(reinterpret_cast<char*>(inbuf + inbuf_pos),1);
+            // only count this character if it isn't some kind of filler 
+            if ((decode_table[inbuf[inbuf_pos]] != bad_value || inbuf[inbuf_pos] == '=') && 
+                status != 0)
+                ++inbuf_pos;
+        } // while (status != 0)
+        
+        if (inbuf_pos != 0)
+        {
+            ostringstream sout;
+            sout << inbuf_pos << " extra characters were found at the end of the encoded data."
+                << "  This may indicate that the data stream has been truncated.";
+            // this happens if we hit EOF in the middle of decoding a 24bit block.
+            throw decode_error(sout.str());
+        }
+
+        // make sure the stream buffer flushes to its I/O channel
+        out.pubsync();
+    }
+
+// ----------------------------------------------------------------------------------------
+
+}
+
+#endif // DLIB_BASE64_KERNEL_1_CPp_
+

dlibs/dlib/base64/base64_kernel_1.h

@@ -0,0 +1,92 @@
+// Copyright (C) 2006  Davis E. King ([email protected])
+// License: Boost Software License   See LICENSE.txt for the full license.
+#ifndef DLIB_BASE64_KERNEl_1_
+#define DLIB_BASE64_KERNEl_1_
+
+#include "../algs.h"
+#include "base64_kernel_abstract.h"
+#include <iosfwd>
+
+namespace dlib
+{
+
+    class base64 
+    {
+        /*!
+            INITIAL VALUE
+                - bad_value == 100
+                - encode_table == a pointer to an array of 64 chars
+                - where x is a 6 bit value the following is true:
+                    - encode_table[x] == the base64 encoding of x
+                - decode_table == a pointer to an array of UCHAR_MAX chars
+                - where x is any char value:
+                    - if (x is a valid character in the base64 coding scheme) then
+                        - decode_table[x] == the 6 bit value that x encodes
+                    - else
+                        - decode_table[x] == bad_value 
+
+            CONVENTION
+                - The state of this object never changes so just refer to its
+                  initial value.
+                  
+
+        !*/
+
+    public:
+        // this is here for backwards compatibility with older versions of dlib.
+        typedef base64 kernel_1a;
+
+        class decode_error : public dlib::error { public:
+        decode_error( const std::string& e) : error(e) {}};
+
+        base64 (
+        );
+
+        virtual ~base64 (
+        );
+
+        enum line_ending_type
+        {
+            CR,  // i.e. "\r"
+            LF,  // i.e. "\n"
+            CRLF // i.e. "\r\n"
+        };
+
+        line_ending_type line_ending (
+        ) const;
+
+        void set_line_ending (
+            line_ending_type eol_style_
+        );
+
+        void encode (
+            std::istream& in,
+            std::ostream& out
+        ) const;
+
+        void decode (
+            std::istream& in,
+            std::ostream& out
+        ) const;
+
+    private:
+
+        char* encode_table;
+        unsigned char* decode_table;
+        const unsigned char bad_value;
+        line_ending_type eol_style;
+
+        // restricted functions
+        base64(base64&);        // copy constructor
+        base64& operator=(base64&);    // assignment operator
+
+    };   
+   
+}
+
+#ifdef NO_MAKEFILE
+#include "base64_kernel_1.cpp"
+#endif
+
+#endif // DLIB_BASE64_KERNEl_1_
+

dlibs/dlib/base64/base64_kernel_abstract.h

@@ -0,0 +1,121 @@
+// Copyright (C) 2006  Davis E. King ([email protected])
+// License: Boost Software License   See LICENSE.txt for the full license.
+#undef DLIB_BASE64_KERNEl_ABSTRACT_
+#ifdef DLIB_BASE64_KERNEl_ABSTRACT_
+
+#include "../algs.h"
+#include <iosfwd>
+
+namespace dlib
+{
+
+    class base64 
+    {
+        /*!
+            INITIAL VALUE
+                - line_ending() == LF
+
+            WHAT THIS OBJECT REPRESENTS
+                This object consists of the two functions encode and decode.
+                These functions allow you to encode and decode data to and from
+                the Base64 Content-Transfer-Encoding defined in section 6.8 of
+                rfc2045.
+        !*/
+
+    public:
+
+        class decode_error : public dlib::error {};
+
+        base64 (
+        );
+        /*!
+            ensures
+                - #*this is properly initialized
+            throws
+                - std::bad_alloc
+        !*/
+
+        virtual ~base64 (
+        );
+        /*!
+            ensures
+                - all memory associated with *this has been released
+        !*/
+
+        enum line_ending_type
+        {
+            CR,  // i.e. "\r"
+            LF,  // i.e. "\n"
+            CRLF // i.e. "\r\n"
+        };
+
+        line_ending_type line_ending (
+        ) const;
+        /*!
+            ensures
+                - returns the type of end of line bytes the encoder
+                  will use when encoding data to base64 blocks.  Note that
+                  the ostream object you use might apply some sort of transform
+                  to line endings as well.  For example, C++ ofstream objects
+                  usually convert '\n' into whatever a normal newline is for
+                  your platform unless you open a file in binary mode.  But
+                  aside from file streams the ostream objects usually don't
+                  modify the data you pass to them.
+        !*/
+
+        void set_line_ending (
+            line_ending_type eol_style
+        );
+        /*!
+            ensures
+                - #line_ending() == eol_style
+        !*/
+
+        void encode (
+            std::istream& in,
+            std::ostream& out
+        ) const;
+        /*!
+            ensures
+                - reads all data from in (until EOF is reached) and encodes it
+                  and writes it to out
+            throws
+                - std::ios_base::failure
+                    if there was a problem writing to out then this exception will 
+                    be thrown.                      
+                - any other exception
+                    this exception may be thrown if there is any other problem                    
+        !*/
+
+        void decode (
+            std::istream& in,
+            std::ostream& out
+        ) const;
+        /*!
+            ensures
+                - reads data from in (until EOF is reached), decodes it,
+                  and writes it to out. 
+            throws
+                - std::ios_base::failure
+                    if there was a problem writing to out then this exception will 
+                    be thrown.           
+                - decode_error
+                    if an error was detected in the encoded data that prevented
+                    it from being correctly decoded then this exception is 
+                    thrown.  
+                - any other exception
+                    this exception may be thrown if there is any other problem                    
+        !*/
+
+    private:
+
+        // restricted functions
+        base64(base64&);        // copy constructor
+        base64& operator=(base64&);    // assignment operator
+
+    };   
+   
+}
+
+#endif // DLIB_BASE64_KERNEl_ABSTRACT_
+

dlibs/dlib/bayes_utils.h

@@ -0,0 +1,11 @@
+// Copyright (C) 2007  Davis E. King ([email protected])
+// License: Boost Software License   See LICENSE.txt for the full license.
+#ifndef DLIB_BAYES_UTILs_H_
+#define DLIB_BAYES_UTILs_H_ 
+
+#include "bayes_utils/bayes_utils.h"
+
+#endif // DLIB_BAYES_UTILs_H_ 
+
+
+

dlibs/dlib/bayes_utils/bayes_utils.h

@@ -0,0 +1,1678 @@
+// Copyright (C) 2007  Davis E. King ([email protected])
+// License: Boost Software License   See LICENSE.txt for the full license.
+#ifndef DLIB_BAYES_UTILs_
+#define DLIB_BAYES_UTILs_
+
+#include "bayes_utils_abstract.h"
+
+#include <algorithm>
+#include <ctime>
+#include <memory>
+#include <vector>
+
+#include "../string.h"
+#include "../map.h"
+#include "../matrix.h"
+#include "../rand.h"
+#include "../array.h"
+#include "../set.h"
+#include "../algs.h"
+#include "../noncopyable.h"
+#include "../graph.h"
+
+namespace dlib
+{
+
+// ----------------------------------------------------------------------------------------
+
+    class assignment 
+    {
+    public:
+
+        assignment()
+        {
+        }
+
+        assignment(
+            const assignment& a
+        )
+        {
+            a.reset();
+            while (a.move_next())
+            {
+                unsigned long idx = a.element().key();
+                unsigned long value = a.element().value();
+                vals.add(idx,value);
+            }
+        }
+
+        assignment& operator = (
+            const assignment& rhs
+        )
+        {
+            if (this == &rhs)
+                return *this;
+
+            assignment(rhs).swap(*this);
+            return *this;
+        }
+
+        void clear()
+        {
+            vals.clear();
+        }
+
+        bool operator < (
+            const assignment& item
+        ) const 
+        {  
+            if (size() < item.size())
+                return true;
+            else if (size() > item.size())
+                return false;
+
+            reset();
+            item.reset();
+            while (move_next())
+            {
+                item.move_next();
+                if (element().key() < item.element().key())
+                    return true;
+                else if (element().key() > item.element().key())
+                    return false;
+                else if (element().value() < item.element().value())
+                    return true;
+                else if (element().value() > item.element().value())
+                    return false;
+            }
+
+            return false;
+        }
+
+        bool has_index (
+            unsigned long idx
+        ) const
+        {
+            return vals.is_in_domain(idx);
+        }
+
+        void add (
+            unsigned long idx,
+            unsigned long value = 0
+        )
+        {
+            // make sure requires clause is not broken
+            DLIB_ASSERT( has_index(idx) == false ,
+                         "\tvoid assignment::add(idx)"
+                         << "\n\tYou can't add the same index to an assignment object more than once"
+                         << "\n\tidx:  " << idx 
+                         << "\n\tthis: " << this
+            );
+
+            vals.add(idx, value);
+        }
+
+        unsigned long& operator[] (
+            const long idx
+        )
+        {
+            // make sure requires clause is not broken
+            DLIB_ASSERT( has_index(idx) == true ,
+                         "\tunsigned long assignment::operator[](idx)"
+                         << "\n\tYou can't access an index value if it isn't already in the object"
+                         << "\n\tidx:  " << idx 
+                         << "\n\tthis: " << this
+            );
+
+            return vals[idx];
+        }
+
+        const unsigned long& operator[] (
+            const long idx
+        ) const
+        { 
+            // make sure requires clause is not broken
+            DLIB_ASSERT( has_index(idx) == true ,
+                         "\tunsigned long assignment::operator[](idx)"
+                         << "\n\tYou can't access an index value if it isn't already in the object"
+                         << "\n\tidx:  " << idx 
+                         << "\n\tthis: " << this
+            );
+
+            return vals[idx];
+        }
+
+        void swap (
+            assignment& item
+        )
+        {
+            vals.swap(item.vals);
+        }
+
+        void remove (
+            unsigned long idx
+        )
+        {
+            // make sure requires clause is not broken
+            DLIB_ASSERT( has_index(idx) == true ,
+                         "\tunsigned long assignment::remove(idx)"
+                         << "\n\tYou can't remove an index value if it isn't already in the object"
+                         << "\n\tidx:  " << idx 
+                         << "\n\tthis: " << this
+            );
+
+            vals.destroy(idx);
+        }
+
+        unsigned long size() const { return vals.size(); }
+
+        void reset() const { vals.reset(); }
+
+        bool move_next() const { return vals.move_next(); }
+
+        map_pair<unsigned long, unsigned long>& element() 
+        { 
+            // make sure requires clause is not broken
+            DLIB_ASSERT(current_element_valid() == true,
+                        "\tmap_pair<unsigned long,unsigned long>& assignment::element()"
+                        << "\n\tyou can't access the current element if it doesn't exist"
+                        << "\n\tthis: " << this
+            );
+            return vals.element(); 
+        }
+
+        const map_pair<unsigned long, unsigned long>& element() const 
+        { 
+            // make sure requires clause is not broken
+            DLIB_ASSERT(current_element_valid() == true,
+                        "\tconst map_pair<unsigned long,unsigned long>& assignment::element() const"
+                        << "\n\tyou can't access the current element if it doesn't exist"
+                        << "\n\tthis: " << this
+            );
+
+            return vals.element(); 
+        }
+
+        bool at_start() const { return vals.at_start(); }
+
+        bool current_element_valid() const { return vals.current_element_valid(); }
+
+        friend inline void serialize (
+            const assignment& item,
+            std::ostream& out 
+        )   
+        {
+            serialize(item.vals, out);
+        }
+
+        friend inline void deserialize (
+            assignment& item,
+            std::istream& in
+        )
+        {
+            deserialize(item.vals, in);
+        }
+
+    private:
+        mutable dlib::map<unsigned long, unsigned long>::kernel_1b_c vals;
+    };
+
+    inline std::ostream& operator << (
+        std::ostream& out,
+        const assignment& a
+    )
+    {
+        a.reset();
+        out << "(";
+        if (a.move_next())
+            out << a.element().key() << ":" << a.element().value();
+
+        while (a.move_next())
+        {
+            out << ", " << a.element().key() << ":" << a.element().value();
+        }
+
+        out << ")";
+        return out;
+    }
+
+
+    inline void swap (
+        assignment& a,
+        assignment& b
+    )
+    {
+        a.swap(b);
+    }
+
+
+// ------------------------------------------------------------------------
+
+    class joint_probability_table 
+    {
+        /*!
+            INITIAL VALUE
+                - table.size() == 0
+
+            CONVENTION
+                - size() == table.size()
+                - probability(a) == table[a]
+        !*/
+    public:
+
+        joint_probability_table (
+            const joint_probability_table& t
+        )
+        {
+            t.reset();
+            while (t.move_next())
+            {
+                assignment a = t.element().key();
+                double p = t.element().value();
+                set_probability(a,p);
+            }
+        }
+
+        joint_probability_table() {}
+
+        joint_probability_table& operator= (
+            const joint_probability_table& rhs
+        )
+        {
+            if (this == &rhs)
+                return *this;
+            joint_probability_table(rhs).swap(*this);
+            return *this;
+        }
+
+        void set_probability (
+            const assignment& a,
+            double p
+        )
+        {
+            // make sure requires clause is not broken
+            DLIB_ASSERT(0.0 <= p && p <= 1.0,
+                        "\tvoid& joint_probability_table::set_probability(a,p)"
+                        << "\n\tyou have given an invalid probability value"
+                        << "\n\tp:    " << p 
+                        << "\n\ta:    " << a 
+                        << "\n\tthis: " << this
+            );
+
+            if (table.is_in_domain(a))
+            {
+                table[a] = p;
+            }
+            else
+            {
+                assignment temp(a);
+                table.add(temp,p);
+            }
+        }
+
+        bool has_entry_for (
+            const assignment& a
+        ) const
+        {
+            return table.is_in_domain(a);
+        }
+
+        void add_probability (
+            const assignment& a,
+            double p
+        )
+        {
+            // make sure requires clause is not broken
+            DLIB_ASSERT(0.0 <= p && p <= 1.0,
+                        "\tvoid& joint_probability_table::add_probability(a,p)"
+                        << "\n\tyou have given an invalid probability value"
+                        << "\n\tp:    " << p 
+                        << "\n\ta:    " << a 
+                        << "\n\tthis: " << this
+            );
+
+            if (table.is_in_domain(a))
+            {
+                table[a] += p;
+                if (table[a] > 1.0)
+                    table[a] = 1.0;
+            }
+            else
+            {
+                assignment temp(a);
+                table.add(temp,p);
+            }
+        }
+
+        double probability (
+            const assignment& a
+        ) const
+        {
+            return table[a];
+        }
+
+        void clear()
+        {
+            table.clear();
+        }
+
+        size_t size () const { return table.size(); }
+        bool move_next() const { return table.move_next(); }
+        void reset() const { table.reset(); }
+        map_pair<assignment,double>& element() 
+        { 
+            // make sure requires clause is not broken
+            DLIB_ASSERT(current_element_valid() == true,
+                        "\tmap_pair<assignment,double>& joint_probability_table::element()"
+                        << "\n\tyou can't access the current element if it doesn't exist"
+                        << "\n\tthis: " << this
+            );
+
+            return table.element(); 
+        }
+
+        const map_pair<assignment,double>& element() const 
+        { 
+            // make sure requires clause is not broken
+            DLIB_ASSERT(current_element_valid() == true,
+                        "\tconst map_pair<assignment,double>& joint_probability_table::element() const"
+                        << "\n\tyou can't access the current element if it doesn't exist"
+                        << "\n\tthis: " << this
+            );
+
+            return table.element(); 
+        }
+
+        bool at_start() const { return table.at_start(); }
+
+        bool current_element_valid() const { return table.current_element_valid(); }
+
+
+        template <typename T>
+        void marginalize (
+            const T& vars,
+            joint_probability_table& out
+        ) const
+        {
+            out.clear();
+            double p;
+            reset();
+            while (move_next())
+            {
+                assignment a;
+                const assignment& asrc = element().key();
+                p = element().value();
+
+                asrc.reset();
+                while (asrc.move_next())
+                {
+                    if (vars.is_member(asrc.element().key()))
+                        a.add(asrc.element().key(), asrc.element().value());
+                }
+
+                out.add_probability(a,p);
+            }
+        }
+
+        void marginalize (
+            const unsigned long var,
+            joint_probability_table& out
+        ) const
+        {
+            out.clear();
+            double p;
+            reset();
+            while (move_next())
+            {
+                assignment a;
+                const assignment& asrc = element().key();
+                p = element().value();
+
+                asrc.reset();
+                while (asrc.move_next())
+                {
+                    if (var == asrc.element().key())
+                        a.add(asrc.element().key(), asrc.element().value());
+                }
+
+                out.add_probability(a,p);
+            }
+        }
+
+        void normalize (
+        )
+        {
+            double sum = 0;
+
+            reset();
+            while (move_next())
+                sum += element().value();
+
+            reset();
+            while (move_next())
+                element().value() /= sum;
+        }
+
+        void swap (
+            joint_probability_table& item
+        )
+        {
+            table.swap(item.table);
+        }
+
+        friend inline void serialize (
+            const joint_probability_table& item,
+            std::ostream& out 
+        )   
+        {
+            serialize(item.table, out);
+        }
+
+        friend inline void deserialize (
+            joint_probability_table& item,
+            std::istream& in
+        )
+        {
+            deserialize(item.table, in);
+        }
+
+    private:
+
+        dlib::map<assignment, double >::kernel_1b_c table;
+    };
+
+    inline void swap (
+        joint_probability_table& a,
+        joint_probability_table& b
+    ) { a.swap(b); }
+
+// ----------------------------------------------------------------------------------------
+
+    class conditional_probability_table : noncopyable
+    {
+        /*!
+            INITIAL VALUE
+                - table.size() == 0
+
+            CONVENTION
+                - if (table.is_in_domain(ps) && value < num_vals && table[ps](value) >= 0) then
+                    - has_entry_for(value,ps) == true
+                    - probability(value,ps) == table[ps](value)
+                - else
+                    - has_entry_for(value,ps) == false 
+
+                - num_values() == num_vals
+        !*/
+    public:
+
+        conditional_probability_table()
+        {
+            clear();
+        }
+
+        void set_num_values (
+            unsigned long num
+        )
+        {
+            num_vals = num;
+            table.clear();
+        }
+
+        bool has_entry_for (
+            unsigned long value,
+            const assignment& ps
+        ) const
+        {
+            if (table.is_in_domain(ps) && value < num_vals && table[ps](value) >= 0)
+                return true;
+            else
+                return false;
+        }
+
+        unsigned long num_values (
+        ) const { return num_vals; }
+
+        void set_probability (
+            unsigned long value,
+            const assignment& ps,
+            double p
+        )
+        {
+            // make sure requires clause is not broken
+            DLIB_ASSERT( value < num_values() && 0.0 <= p && p <= 1.0 ,
+                         "\tvoid conditional_probability_table::set_probability()"
+                         << "\n\tinvalid arguments to set_probability"
+                         << "\n\tvalue: " << value 
+                         << "\n\tnum_values(): " << num_values()
+                         << "\n\tp:     " << p 
+                         << "\n\tps:    " << ps 
+                         << "\n\tthis:  " << this
+            );
+
+            if (table.is_in_domain(ps))
+            {
+                table[ps](value) = p;
+            }
+            else
+            {
+                matrix<double,1> dist(num_vals);
+                set_all_elements(dist,-1);
+                dist(value) = p;
+                assignment temp(ps);
+                table.add(temp,dist);
+            }
+        }
+
+        double probability(
+            unsigned long value,
+            const assignment& ps 
+        ) const
+        {
+            // make sure requires clause is not broken
+            DLIB_ASSERT( value < num_values() && has_entry_for(value,ps) ,
+                         "\tvoid conditional_probability_table::probability()"
+                         << "\n\tinvalid arguments to probability"
+                         << "\n\tvalue:        " << value 
+                         << "\n\tnum_values(): " << num_values() 
+                         << "\n\tps:           " << ps 
+                         << "\n\tthis:         " << this
+            );
+
+            return table[ps](value);
+        }
+
+        void clear()
+        {
+            table.clear();
+            num_vals = 0;
+        }
+
+        void empty_table ()
+        {
+            table.clear();
+        }
+
+        void swap (
+            conditional_probability_table& item 
+        ) 
+        { 
+            exchange(num_vals, item.num_vals);
+            table.swap(item.table);
+        }
+
+        friend inline void serialize (
+            const conditional_probability_table& item,
+            std::ostream& out 
+        )   
+        {
+            serialize(item.table, out);
+            serialize(item.num_vals, out);
+        }
+
+        friend inline void deserialize (
+            conditional_probability_table& item,
+            std::istream& in
+        )
+        {
+            deserialize(item.table, in);
+            deserialize(item.num_vals, in);
+        }
+
+    private:
+        dlib::map<assignment, matrix<double,1> >::kernel_1b_c table;
+        unsigned long num_vals;
+    };
+
+    inline void swap (
+        conditional_probability_table& a,
+        conditional_probability_table& b
+    ) { a.swap(b); }
+
+// ------------------------------------------------------------------------
+
+    class bayes_node : noncopyable
+    {
+    public:
+        bayes_node ()
+        {
+            is_instantiated = false;
+            value_ = 0;
+        }
+
+        unsigned long value (
+        ) const { return value_;}
+
+        void set_value (
+            unsigned long new_value
+        )
+        {
+            // make sure requires clause is not broken
+            DLIB_ASSERT( new_value < table().num_values(),
+                         "\tvoid bayes_node::set_value(new_value)"
+                         << "\n\tnew_value must be less than the number of possible values for this node"
+                         << "\n\tnew_value:            " << new_value 
+                         << "\n\ttable().num_values(): " << table().num_values() 
+                         << "\n\tthis:                 " << this
+            );
+
+            value_ = new_value;
+        }
+
+        conditional_probability_table& table (
+        ) { return table_; }
+
+        const conditional_probability_table& table (
+        ) const { return table_; }
+
+        bool is_evidence (
+        ) const { return is_instantiated; }
+
+        void set_as_nonevidence (
+        ) { is_instantiated = false; }
+
+        void set_as_evidence (
+        ) { is_instantiated = true; }
+
+        void swap (
+            bayes_node& item 
+        ) 
+        { 
+            exchange(value_, item.value_);
+            exchange(is_instantiated, item.is_instantiated);
+            table_.swap(item.table_);
+        }
+
+        friend inline void serialize (
+            const bayes_node& item,
+            std::ostream& out 
+        )   
+        {
+            serialize(item.value_, out);
+            serialize(item.is_instantiated, out);
+            serialize(item.table_, out);
+        }
+
+        friend inline void deserialize (
+            bayes_node& item,
+            std::istream& in
+        )
+        {
+            deserialize(item.value_, in);
+            deserialize(item.is_instantiated, in);
+            deserialize(item.table_, in);
+        }
+
+    private:
+
+        unsigned long value_; 
+        bool is_instantiated;
+        conditional_probability_table table_;
+    };
+
+    inline void swap (
+        bayes_node& a,
+        bayes_node& b
+    ) { a.swap(b); }
+
+// ------------------------------------------------------------------------
+
+    namespace bayes_node_utils
+    {
+
+        template <typename T>
+        unsigned long node_num_values (
+            const T& bn,
+            unsigned long n
+        )  
+        { 
+            // make sure requires clause is not broken
+            DLIB_ASSERT( n < bn.number_of_nodes(),
+                         "\tvoid bayes_node_utils::node_num_values(bn, n)"
+                         << "\n\tInvalid arguments to this function"
+                         << "\n\tn:                     " << n 
+                         << "\n\tbn.number_of_nodes():  " << bn.number_of_nodes() 
+            );
+
+            return bn.node(n).data.table().num_values(); 
+        }
+
+    // ----------------------------------------------------------------------------------------
+
+        template <typename T>
+        void set_node_value (
+            T& bn,
+            unsigned long n,
+            unsigned long val
+        ) 
+        { 
+            // make sure requires clause is not broken
+            DLIB_ASSERT( n < bn.number_of_nodes() && val < node_num_values(bn,n),
+                         "\tvoid bayes_node_utils::set_node_value(bn, n, val)"
+                         << "\n\tInvalid arguments to this function"
+                         << "\n\tn:                     " << n 
+                         << "\n\tval:                   " << val 
+                         << "\n\tbn.number_of_nodes():  " << bn.number_of_nodes() 
+                         << "\n\tnode_num_values(bn,n): " << node_num_values(bn,n) 
+            );
+
+            bn.node(n).data.set_value(val); 
+        }
+
+    // ----------------------------------------------------------------------------------------
+        template <typename T>
+        unsigned long node_value (
+            const T& bn,
+            unsigned long n
+        ) 
+        { 
+            // make sure requires clause is not broken
+            DLIB_ASSERT( n < bn.number_of_nodes(),
+                         "\tunsigned long bayes_node_utils::node_value(bn, n)"
+                         << "\n\tInvalid arguments to this function"
+                         << "\n\tn:                     " << n 
+                         << "\n\tbn.number_of_nodes():  " << bn.number_of_nodes() 
+            );
+
+            return bn.node(n).data.value();
+        }
+    // ----------------------------------------------------------------------------------------
+
+        template <typename T>
+        bool node_is_evidence (
+            const T& bn,
+            unsigned long n
+        ) 
+        { 
+            // make sure requires clause is not broken
+            DLIB_ASSERT( n < bn.number_of_nodes(),
+                         "\tbool bayes_node_utils::node_is_evidence(bn, n)"
+                         << "\n\tInvalid arguments to this function"
+                         << "\n\tn:                     " << n 
+                         << "\n\tbn.number_of_nodes():  " << bn.number_of_nodes() 
+            );
+
+            return bn.node(n).data.is_evidence();
+        }
+
+    // ----------------------------------------------------------------------------------------
+
+        template <typename T>
+        void set_node_as_evidence (
+            T& bn,
+            unsigned long n
+        ) 
+        { 
+            // make sure requires clause is not broken
+            DLIB_ASSERT( n < bn.number_of_nodes(),
+                         "\tvoid bayes_node_utils::set_node_as_evidence(bn, n)"
+                         << "\n\tInvalid arguments to this function"
+                         << "\n\tn:                     " << n 
+                         << "\n\tbn.number_of_nodes():  " << bn.number_of_nodes() 
+            );
+
+            bn.node(n).data.set_as_evidence(); 
+        }
+
+    // ----------------------------------------------------------------------------------------
+        template <typename T>
+        void set_node_as_nonevidence (
+            T& bn,
+            unsigned long n
+        ) 
+        { 
+            // make sure requires clause is not broken
+            DLIB_ASSERT( n < bn.number_of_nodes(),
+                         "\tvoid bayes_node_utils::set_node_as_nonevidence(bn, n)"
+                         << "\n\tInvalid arguments to this function"
+                         << "\n\tn:                     " << n 
+                         << "\n\tbn.number_of_nodes():  " << bn.number_of_nodes() 
+            );
+
+            bn.node(n).data.set_as_nonevidence(); 
+        }
+
+    // ----------------------------------------------------------------------------------------
+
+        template <typename T>
+        void set_node_num_values (
+            T& bn,
+            unsigned long n,
+            unsigned long num
+        ) 
+        { 
+            // make sure requires clause is not broken
+            DLIB_ASSERT( n < bn.number_of_nodes(),
+                         "\tvoid bayes_node_utils::set_node_num_values(bn, n, num)"
+                         << "\n\tInvalid arguments to this function"
+                         << "\n\tn:                     " << n 
+                         << "\n\tbn.number_of_nodes():  " << bn.number_of_nodes() 
+            );
+
+            bn.node(n).data.table().set_num_values(num); 
+        }
+
+    // ----------------------------------------------------------------------------------------
+
+        template <typename T>
+        double node_probability (
+            const T& bn,
+            unsigned long n,
+            unsigned long value,
+            const assignment& parents 
+        ) 
+        {
+            // make sure requires clause is not broken
+            DLIB_ASSERT( n < bn.number_of_nodes() && value < node_num_values(bn,n),
+                         "\tdouble bayes_node_utils::node_probability(bn, n, value, parents)"
+                         << "\n\tInvalid arguments to this function"
+                         << "\n\tn:                     " << n 
+                         << "\n\tvalue:                 " << value 
+                         << "\n\tbn.number_of_nodes():  " << bn.number_of_nodes() 
+                         << "\n\tnode_num_values(bn,n): " << node_num_values(bn,n) 
+            );
+
+            DLIB_ASSERT( parents.size() == bn.node(n).number_of_parents(),
+                         "\tdouble bayes_node_utils::node_probability(bn, n, value, parents)"
+                         << "\n\tInvalid arguments to this function"
+                         << "\n\tn:                             " << n 
+                         << "\n\tparents.size():                " << parents.size()
+                         << "\n\tb.node(n).number_of_parents(): " << bn.node(n).number_of_parents()
+            );
+
+#ifdef ENABLE_ASSERTS
+            parents.reset();
+            while (parents.move_next())
+            {
+                const unsigned long x = parents.element().key();
+                DLIB_ASSERT( bn.has_edge(x, n),
+                             "\tdouble bayes_node_utils::node_probability(bn, n, value, parents)"
+                             << "\n\tInvalid arguments to this function"
+                             << "\n\tn: " << n 
+                             << "\n\tx: " << x 
+                );
+                DLIB_ASSERT( parents[x] < node_num_values(bn,x),
+                             "\tdouble bayes_node_utils::node_probability(bn, n, value, parents)"
+                             << "\n\tInvalid arguments to this function"
+                             << "\n\tn:                     " << n 
+                             << "\n\tx:                     " << x 
+                             << "\n\tparents[x]:            " << parents[x] 
+                             << "\n\tnode_num_values(bn,x): " << node_num_values(bn,x) 
+                );
+            }
+#endif
+
+            return bn.node(n).data.table().probability(value, parents);
+        }
+
+    // ----------------------------------------------------------------------------------------
+
+        template <typename T>
+        void set_node_probability (
+            T& bn,
+            unsigned long n,
+            unsigned long value,
+            const assignment& parents,
+            double p
+        )
+        {
+            // make sure requires clause is not broken
+            DLIB_ASSERT( n < bn.number_of_nodes() && value < node_num_values(bn,n),
+                         "\tvoid bayes_node_utils::set_node_probability(bn, n, value, parents, p)"
+                         << "\n\tInvalid arguments to this function"
+                         << "\n\tn:                     " << n 
+                         << "\n\tp:                     " << p 
+                         << "\n\tvalue:                 " << value 
+                         << "\n\tbn.number_of_nodes():  " << bn.number_of_nodes() 
+                         << "\n\tnode_num_values(bn,n): " << node_num_values(bn,n) 
+            );
+
+            DLIB_ASSERT( parents.size() == bn.node(n).number_of_parents(),
+                         "\tvoid bayes_node_utils::set_node_probability(bn, n, value, parents, p)"
+                         << "\n\tInvalid arguments to this function"
+                         << "\n\tn:                             " << n 
+                         << "\n\tp:                             " << p 
+                         << "\n\tparents.size():                " << parents.size()
+                         << "\n\tbn.node(n).number_of_parents(): " << bn.node(n).number_of_parents()
+            );
+
+            DLIB_ASSERT( 0.0 <= p && p <= 1.0,
+                         "\tvoid bayes_node_utils::set_node_probability(bn, n, value, parents, p)"
+                         << "\n\tInvalid arguments to this function"
+                         << "\n\tn: " << n 
+                         << "\n\tp: " << p 
+            );
+
+#ifdef ENABLE_ASSERTS
+            parents.reset();
+            while (parents.move_next())
+            {
+                const unsigned long x = parents.element().key();
+                DLIB_ASSERT( bn.has_edge(x, n),
+                             "\tvoid bayes_node_utils::set_node_probability(bn, n, value, parents, p)"
+                             << "\n\tInvalid arguments to this function"
+                             << "\n\tn: " << n 
+                             << "\n\tx: " << x 
+                );
+                DLIB_ASSERT( parents[x] < node_num_values(bn,x),
+                             "\tvoid bayes_node_utils::set_node_probability(bn, n, value, parents, p)"
+                             << "\n\tInvalid arguments to this function"
+                             << "\n\tn:                     " << n 
+                             << "\n\tx:                     " << x 
+                             << "\n\tparents[x]:            " << parents[x] 
+                             << "\n\tnode_num_values(bn,x): " << node_num_values(bn,x) 
+                );
+            }
+#endif
+
+            bn.node(n).data.table().set_probability(value,parents,p);
+        }
+
+// ----------------------------------------------------------------------------------------
+
+        template <typename T>
+        const assignment node_first_parent_assignment (
+            const T& bn,
+            unsigned long n
+        ) 
+        { 
+            // make sure requires clause is not broken
+            DLIB_ASSERT( n < bn.number_of_nodes(),
+                         "\tconst assignment bayes_node_utils::node_first_parent_assignment(bn, n)"
+                         << "\n\tInvalid arguments to this function"
+                         << "\n\tn:                     " << n 
+            );
+
+            assignment a;
+            const unsigned long num_parents = bn.node(n).number_of_parents();
+            for (unsigned long i = 0; i < num_parents; ++i)
+            {
+                a.add(bn.node(n).parent(i).index(), 0);
+            }
+            return a;
+        }
+
+// ----------------------------------------------------------------------------------------
+
+        template <typename T>
+        bool node_next_parent_assignment (
+            const T& bn,
+            unsigned long n,
+            assignment& a
+        ) 
+        { 
+            // make sure requires clause is not broken
+            DLIB_ASSERT( n < bn.number_of_nodes(),
+                         "\tbool bayes_node_utils::node_next_parent_assignment(bn, n, a)"
+                         << "\n\tInvalid arguments to this function"
+                         << "\n\tn:                     " << n 
+            );
+
+            DLIB_ASSERT( a.size() == bn.node(n).number_of_parents(),
+                         "\tbool bayes_node_utils::node_next_parent_assignment(bn, n, a)"
+                         << "\n\tInvalid arguments to this function"
+                         << "\n\tn:                             " << n 
+                         << "\n\ta.size():                      " << a.size()
+                         << "\n\tbn.node(n).number_of_parents(): " << bn.node(n).number_of_parents()
+            );
+
+#ifdef ENABLE_ASSERTS
+            a.reset();
+            while (a.move_next())
+            {
+                const unsigned long x = a.element().key();
+                DLIB_ASSERT( bn.has_edge(x, n),
+                             "\tbool bayes_node_utils::node_next_parent_assignment(bn, n, a)"
+                             << "\n\tInvalid arguments to this function"
+                             << "\n\tn: " << n 
+                             << "\n\tx: " << x 
+                );
+                DLIB_ASSERT( a[x] < node_num_values(bn,x),
+                             "\tbool bayes_node_utils::node_next_parent_assignment(bn, n, a)"
+                             << "\n\tInvalid arguments to this function"
+                             << "\n\tn:                     " << n 
+                             << "\n\tx:                     " << x 
+                             << "\n\ta[x]:                  " << a[x] 
+                             << "\n\tnode_num_values(bn,x): " << node_num_values(bn,x) 
+                );
+            }
+#endif
+
+            // basically this loop just adds 1 to the assignment but performs
+            // carries if necessary
+            for (unsigned long p = 0; p < a.size(); ++p)
+            {
+                const unsigned long pindex = bn.node(n).parent(p).index();
+                a[pindex] += 1;
+
+                // if we need to perform a carry
+                if (a[pindex] >= node_num_values(bn,pindex))
+                {
+                    a[pindex] = 0;
+                }
+                else
+                {
+                    // no carry necessary so we are done
+                    return true;
+                }
+            }
+
+            // we got through the entire loop which means a carry propagated all the way out
+            // so there must not be any more valid assignments left
+            return false;
+        }
+
+// ----------------------------------------------------------------------------------------
+
+        template <typename T>
+        bool node_cpt_filled_out (
+            const T& bn,
+            unsigned long n
+        ) 
+        { 
+            // make sure requires clause is not broken
+            DLIB_ASSERT( n < bn.number_of_nodes(),
+                         "\tbool bayes_node_utils::node_cpt_filled_out(bn, n)"
+                         << "\n\tInvalid arguments to this function"
+                         << "\n\tn:                     " << n 
+                         << "\n\tbn.number_of_nodes():  " << bn.number_of_nodes() 
+            );
+
+            const unsigned long num_values = node_num_values(bn,n);
+
+
+            const conditional_probability_table& table = bn.node(n).data.table();
+
+            // now loop over all the possible parent assignments for this node
+            assignment a(node_first_parent_assignment(bn,n));
+            do
+            {
+                double sum = 0;
+                // make sure that this assignment has an entry for all the values this node can take one
+                for (unsigned long value = 0; value < num_values; ++value)
+                {
+                    if (table.has_entry_for(value,a) == false)
+                        return false;
+                    else
+                        sum += table.probability(value,a);
+                }
+
+                // check if the sum of probabilities equals 1 as it should
+                if (std::abs(sum-1.0) > 1e-5)
+                    return false;
+            } while (node_next_parent_assignment(bn,n,a));
+
+            return true;
+        }
+
+    }
+
+// ----------------------------------------------------------------------------------------
+
+    class bayesian_network_gibbs_sampler : noncopyable
+    {
+    public:
+
+        bayesian_network_gibbs_sampler ()
+        {
+            rnd.set_seed(cast_to_string(std::time(0)));
+        }
+
+
+        template <
+            typename T
+            >
+        void sample_graph (
+            T& bn
+        )
+        {
+            using namespace bayes_node_utils;
+            for (unsigned long n = 0; n < bn.number_of_nodes(); ++n)
+            {
+                if (node_is_evidence(bn, n))
+                    continue;
+
+                samples.set_size(node_num_values(bn,n)); 
+                // obtain the probability distribution for this node
+                for (long i = 0; i < samples.nc(); ++i)
+                {
+                    set_node_value(bn, n, i);
+                    samples(i) = node_probability(bn, n);
+
+                    for (unsigned long j = 0; j < bn.node(n).number_of_children(); ++j)
+                        samples(i) *= node_probability(bn, bn.node(n).child(j).index());
+                }
+
+                //normalize samples
+                samples /= sum(samples);
+
+
+                // select a random point in the probability distribution
+                double prob = rnd.get_random_double();
+
+                // now find the point in the distribution this probability corresponds to
+                long j;
+                for (j = 0; j < samples.nc()-1; ++j)
+                {
+                    if (prob <= samples(j))
+                        break;
+                    else
+                        prob -= samples(j);
+                }
+
+                set_node_value(bn, n, j);
+            }
+        }
+
+
+    private:
+
+        template <
+            typename T
+            >
+        double node_probability (
+            const T& bn,
+            unsigned long n 
+        ) 
+        /*!
+            requires
+                - n < bn.number_of_nodes()
+            ensures
+                - computes the probability of node n having its current value given
+                  the current values of its parents in the network bn
+        !*/
+        {
+            v.clear();
+            for (unsigned long i = 0; i < bn.node(n).number_of_parents(); ++i)
+            {
+                v.add(bn.node(n).parent(i).index(), bn.node(n).parent(i).data.value());
+            }
+            return bn.node(n).data.table().probability(bn.node(n).data.value(), v);
+        }
+
+        assignment v;
+
+        dlib::rand rnd;
+        matrix<double,1> samples; 
+    };
+
+// ----------------------------------------------------------------------------------------
+
+    namespace bayesian_network_join_tree_helpers
+    {
+        class bnjt
+        {
+            /*!
+                this object is the base class used in this pimpl idiom
+            !*/
+        public:
+            virtual ~bnjt() {}
+
+            virtual const matrix<double,1> probability(
+                unsigned long idx
+            )  const = 0;
+        };
+
+        template <typename T, typename U>
+        class bnjt_impl : public bnjt
+        {
+            /*!
+                This object is the implementation in the pimpl idiom
+            !*/
+
+        public:
+
+            bnjt_impl (
+                const T& bn,
+                const U& join_tree
+            )
+            {
+                create_bayesian_network_join_tree(bn, join_tree, join_tree_values);
+
+                cliques.resize(bn.number_of_nodes());
+
+                // figure out which cliques contain each node
+                for (unsigned long i = 0; i < cliques.size(); ++i)
+                {
+                    // find the smallest clique that contains node with index i
+                    unsigned long smallest_clique = 0;
+                    unsigned long size = std::numeric_limits<unsigned long>::max();
+
+                    for (unsigned long n = 0; n < join_tree.number_of_nodes(); ++n)
+                    {
+                        if (join_tree.node(n).data.is_member(i) && join_tree.node(n).data.size() < size)
+                        {
+                            size = join_tree.node(n).data.size();
+                            smallest_clique = n;
+                        }
+                    }
+
+                    cliques[i] = smallest_clique;
+                }
+            }
+
+            virtual const matrix<double,1> probability(
+                unsigned long idx
+            ) const 
+            {
+                join_tree_values.node(cliques[idx]).data.marginalize(idx, table);
+                table.normalize();
+                var.clear();
+                var.add(idx);
+                dist.set_size(table.size());
+
+                // read the probabilities out of the table and into the row matrix
+                for (unsigned long i = 0; i < table.size(); ++i)
+                {
+                    var[idx] = i;
+                    dist(i) = table.probability(var); 
+                }
+
+                return dist;
+            }
+
+        private:
+
+            graph< joint_probability_table, joint_probability_table >::kernel_1a_c join_tree_values;
+            array<unsigned long> cliques;
+            mutable joint_probability_table table;
+            mutable assignment var;
+            mutable matrix<double,1> dist;
+           
+
+        // ----------------------------------------------------------------------------------------
+
+            template <typename set_type, typename node_type>
+            bool set_contains_all_parents_of_node (
+                const set_type& set,
+                const node_type& node
+            )
+            {
+                for (unsigned long i = 0; i < node.number_of_parents(); ++i)
+                {
+                    if (set.is_member(node.parent(i).index()) == false)
+                        return false;
+                }
+                return true;
+            }
+
+        // ----------------------------------------------------------------------------------------
+
+            template <
+                typename V
+                >
+            void pass_join_tree_message (
+                const U& join_tree,
+                V& bn_join_tree ,
+                unsigned long from,
+                unsigned long to
+            )
+            {
+                using namespace bayes_node_utils;
+                const typename U::edge_type& e = edge(join_tree, from, to);
+                typename V::edge_type& old_s = edge(bn_join_tree, from, to);
+
+                typedef typename V::edge_type joint_prob_table;
+
+                joint_prob_table new_s;
+                bn_join_tree.node(from).data.marginalize(e, new_s);
+
+                joint_probability_table temp(new_s);
+                // divide new_s by old_s and store the result in temp.
+                // if old_s is empty then that is the same as if it was all 1s
+                // so we don't have to do this if that is the case.
+                if (old_s.size() > 0)
+                {
+                    temp.reset();
+                    old_s.reset();
+                    while (temp.move_next())
+                    {
+                        old_s.move_next();
+                        if (old_s.element().value() != 0)
+                            temp.element().value()  /= old_s.element().value();
+                    }
+                }
+
+                // now multiply temp by d and store the results in d
+                joint_probability_table& d = bn_join_tree.node(to).data;
+                d.reset();
+                while (d.move_next())
+                {
+                    assignment a; 
+                    const assignment& asrc = d.element().key();
+                    asrc.reset();
+                    while (asrc.move_next())
+                    {
+                        if (e.is_member(asrc.element().key()))
+                            a.add(asrc.element().key(), asrc.element().value());
+                    }
+
+                    d.element().value() *= temp.probability(a);
+
+                }
+
+                // store new_s in old_s
+                new_s.swap(old_s);
+
+            }
+
+        // ----------------------------------------------------------------------------------------
+
+            template <
+                typename V
+                >
+            void create_bayesian_network_join_tree (
+                const T& bn,
+                const U& join_tree,
+                V& bn_join_tree 
+            )
+            /*!
+                requires
+                    - bn is a proper bayesian network
+                    - join_tree is the join tree for that bayesian network
+                ensures
+                    - bn_join_tree == the output of the join tree algorithm for bayesian network inference.  
+                      So each node in this graph contains a joint_probability_table for the clique
+                      in the corresponding node in the join_tree graph.
+            !*/
+            {
+                using namespace bayes_node_utils;
+                bn_join_tree.clear();
+                copy_graph_structure(join_tree, bn_join_tree);
+
+                // we need to keep track of which node is "in" each clique for the purposes of 
+                // initializing the tables in each clique.  So this vector will be used to do that
+                // and a value of join_tree.number_of_nodes() means that the node with 
+                // that index is unassigned.
+                std::vector<unsigned long> node_assigned_to(bn.number_of_nodes(),join_tree.number_of_nodes());
+
+                // populate evidence with all the evidence node indices and their values
+                dlib::map<unsigned long, unsigned long>::kernel_1b_c evidence;
+                for (unsigned long i = 0; i < bn.number_of_nodes(); ++i)
+                {
+                    if (node_is_evidence(bn, i))
+                    {
+                        unsigned long idx = i;
+                        unsigned long value = node_value(bn, i);
+                        evidence.add(idx,value);
+                    }
+                }
+
+
+                // initialize the bn join tree
+                for (unsigned long i = 0; i < join_tree.number_of_nodes(); ++i)
+                {
+                    bool contains_evidence = false;
+                    std::vector<unsigned long> indices;
+                    assignment value;
+
+                    // loop over all the nodes in this clique in the join tree.  In this loop 
+                    // we are making an assignment with all the values of the nodes it represents set to 0
+                    join_tree.node(i).data.reset();
+                    while (join_tree.node(i).data.move_next())
+                    {
+                        const unsigned long idx = join_tree.node(i).data.element();
+                        indices.push_back(idx);
+                        value.add(idx);
+
+                        if (evidence.is_in_domain(join_tree.node(i).data.element()))
+                            contains_evidence = true;
+                    }
+
+                    // now loop over all possible combinations of values that the nodes this 
+                    // clique in the join tree can take on.  We do this by counting by one through all
+                    // legal values
+                    bool more_assignments = true;
+                    while (more_assignments)
+                    {
+                        bn_join_tree.node(i).data.set_probability(value,1);
+
+                        // account for any evidence
+                        if (contains_evidence)
+                        {
+                            // loop over all the nodes in this cluster
+                            for (unsigned long j = 0; j < indices.size(); ++j)
+                            {
+                                // if the current node is an evidence node
+                                if (evidence.is_in_domain(indices[j]))
+                                {
+                                    const unsigned long idx = indices[j];
+                                    const unsigned long evidence_value = evidence[idx];
+                                    if (value[idx] != evidence_value)
+                                        bn_join_tree.node(i).data.set_probability(value , 0);
+                                }
+                            }
+                        }
+
+
+                        // now check if any of the nodes in this cluster also have their parents in this cluster
+                        join_tree.node(i).data.reset();
+                        while (join_tree.node(i).data.move_next())
+                        {
+                            const unsigned long idx = join_tree.node(i).data.element();
+                            // if this clique contains all the parents of this node and also hasn't
+                            // been assigned to another clique
+                            if (set_contains_all_parents_of_node(join_tree.node(i).data,  bn.node(idx)) && 
+                                (i == node_assigned_to[idx] || node_assigned_to[idx] == join_tree.number_of_nodes()) )
+                            {
+                                // note that this node is now assigned to this clique 
+                                node_assigned_to[idx] = i;
+                                // node idx has all its parents in the cluster
+                                assignment parent_values;
+                                for (unsigned long j = 0; j < bn.node(idx).number_of_parents(); ++j)
+                                {
+                                    const unsigned long pidx = bn.node(idx).parent(j).index();
+                                    parent_values.add(pidx, value[pidx]);
+                                }
+
+                                double temp = bn_join_tree.node(i).data.probability(value);
+                                bn_join_tree.node(i).data.set_probability(value, temp * node_probability(bn, idx, value[idx], parent_values));
+
+                            }
+                        }
+
+
+                        // now advance the value variable to its next possible state if there is one
+                        more_assignments = false;
+                        value.reset();
+                        while (value.move_next())
+                        {
+                            value.element().value() += 1;
+                            // if overflow
+                            if (value.element().value() == node_num_values(bn, value.element().key()))
+                            {
+                                value.element().value() = 0;
+                            }
+                            else
+                            {
+                                more_assignments = true;
+                                break;
+                            }
+                        }
+
+                    } // end while (more_assignments) 
+                } 
+
+
+
+
+                // the tree is now initialized.  Now all we need to do is perform the propagation and
+                // we are done
+                dlib::array<dlib::set<unsigned long>::compare_1b_c> remaining_msg_to_send;
+                dlib::array<dlib::set<unsigned long>::compare_1b_c> remaining_msg_to_receive;
+                remaining_msg_to_receive.resize(join_tree.number_of_nodes());
+                remaining_msg_to_send.resize(join_tree.number_of_nodes());
+                for (unsigned long i = 0; i < remaining_msg_to_receive.size(); ++i)
+                {
+                    for (unsigned long j = 0; j < join_tree.node(i).number_of_neighbors(); ++j)
+                    {
+                        const unsigned long idx = join_tree.node(i).neighbor(j).index();
+                        unsigned long temp;
+                        temp = idx; remaining_msg_to_receive[i].add(temp);
+                        temp = idx; remaining_msg_to_send[i].add(temp);
+                    }
+                }
+
+                // now remaining_msg_to_receive[i] contains all the nodes that node i hasn't yet received
+                // a message from.
+                // we will consider node 0 to be the root node.
+
+
+                bool message_sent = true;
+                std::vector<unsigned long>::iterator iter;
+                while (message_sent)
+                {
+                    message_sent = false;
+                    for (unsigned long i = 1; i < remaining_msg_to_send.size(); ++i)
+                    {
+                        // if node i hasn't sent any messages but has received all but one then send a message to the one
+                        // node who hasn't sent i a message
+                        if (remaining_msg_to_send[i].size() == join_tree.node(i).number_of_neighbors() && remaining_msg_to_receive[i].size() == 1)
+                        {
+                            unsigned long to;
+                            // get the last remaining thing from this set
+                            remaining_msg_to_receive[i].remove_any(to);
+
+                            // send the message
+                            pass_join_tree_message(join_tree, bn_join_tree, i, to);
+
+                            // record that we sent this message
+                            remaining_msg_to_send[i].destroy(to);
+                            remaining_msg_to_receive[to].destroy(i);
+
+                            // put to back in since we still need to receive it
+                            remaining_msg_to_receive[i].add(to);
+                            message_sent = true;
+                        }
+                        else if (remaining_msg_to_receive[i].size() == 0 && remaining_msg_to_send[i].size() > 0)
+                        {
+                            unsigned long to;
+                            remaining_msg_to_send[i].remove_any(to);
+                            remaining_msg_to_receive[to].destroy(i);
+                            pass_join_tree_message(join_tree, bn_join_tree, i, to);
+                            message_sent = true;
+                        }
+                    }
+
+                    if (remaining_msg_to_receive[0].size() == 0)
+                    {
+                        // send a message to all of the root nodes neighbors unless we have already sent out he messages
+                        while (remaining_msg_to_send[0].size() > 0)
+                        {
+                            unsigned long to;
+                            remaining_msg_to_send[0].remove_any(to);
+                            remaining_msg_to_receive[to].destroy(0);
+                            pass_join_tree_message(join_tree, bn_join_tree, 0, to);
+                            message_sent = true;
+                        }
+                    }
+
+
+                }
+
+            }
+
+        };
+    }
+
+    class bayesian_network_join_tree : noncopyable
+    {
+        /*!
+            use the pimpl idiom to push the template arguments from the class level to the
+            constructor level
+        !*/
+
+    public:
+
+        template <
+            typename T,
+            typename U
+            >
+        bayesian_network_join_tree (
+            const T& bn,
+            const U& join_tree
+        )
+        {
+            // make sure requires clause is not broken
+            DLIB_ASSERT( bn.number_of_nodes() > 0 ,
+                        "\tbayesian_network_join_tree::bayesian_network_join_tree(bn,join_tree)"
+                        << "\n\tYou have given an invalid bayesian network"
+                        << "\n\tthis:              " << this
+                    );
+
+            DLIB_ASSERT( is_join_tree(bn, join_tree) == true ,
+                        "\tbayesian_network_join_tree::bayesian_network_join_tree(bn,join_tree)"
+                        << "\n\tYou have given an invalid join tree for the supplied bayesian network"
+                        << "\n\tthis:              " << this
+                    );
+            DLIB_ASSERT( graph_contains_length_one_cycle(bn) == false,
+                        "\tbayesian_network_join_tree::bayesian_network_join_tree(bn,join_tree)"
+                        << "\n\tYou have given an invalid bayesian network"
+                        << "\n\tthis:              " << this
+                    );
+            DLIB_ASSERT( graph_is_connected(bn) == true,
+                        "\tbayesian_network_join_tree::bayesian_network_join_tree(bn,join_tree)"
+                        << "\n\tYou have given an invalid bayesian network"
+                        << "\n\tthis:              " << this
+                    );
+
+#ifdef ENABLE_ASSERTS
+            for (unsigned long i = 0; i < bn.number_of_nodes(); ++i)
+            {
+                DLIB_ASSERT(bayes_node_utils::node_cpt_filled_out(bn,i) == true,
+                        "\tbayesian_network_join_tree::bayesian_network_join_tree(bn,join_tree)"
+                        << "\n\tYou have given an invalid bayesian network. "
+                        << "\n\tYou must finish filling out the conditional_probability_table of node " << i
+                        << "\n\tthis:              " << this
+                    );
+            }
+#endif
+
+            impl.reset(new bayesian_network_join_tree_helpers::bnjt_impl<T,U>(bn, join_tree));
+            num_nodes = bn.number_of_nodes();
+        }
+
+        const matrix<double,1> probability(
+            unsigned long idx
+        ) const
+        {
+            // make sure requires clause is not broken
+            DLIB_ASSERT( idx < number_of_nodes() ,
+                        "\tconst matrix<double,1> bayesian_network_join_tree::probability(idx)"
+                        << "\n\tYou have specified an invalid node index"
+                        << "\n\tidx:               " << idx 
+                        << "\n\tnumber_of_nodes(): " << number_of_nodes() 
+                        << "\n\tthis:              " << this
+                    );
+
+            return impl->probability(idx);
+        }
+
+        unsigned long number_of_nodes (
+        ) const { return num_nodes; }
+
+        void swap (
+            bayesian_network_join_tree& item
+        )
+        {
+            exchange(num_nodes, item.num_nodes);
+            impl.swap(item.impl);
+        }
+
+    private:
+
+        std::unique_ptr<bayesian_network_join_tree_helpers::bnjt> impl;
+        unsigned long num_nodes;
+
+    };
+
+    inline void swap (
+        bayesian_network_join_tree& a,
+        bayesian_network_join_tree& b
+    ) { a.swap(b); }
+
+}
+
+// ----------------------------------------------------------------------------------------
+
+#endif // DLIB_BAYES_UTILs_
+

dlibs/dlib/bayes_utils/bayes_utils_abstract.h

@@ -0,0 +1,1042 @@
+// Copyright (C) 2007  Davis E. King ([email protected])
+// License: Boost Software License   See LICENSE.txt for the full license.
+#undef DLIB_BAYES_UTILs_ABSTRACT_
+#ifdef DLIB_BAYES_UTILs_ABSTRACT_
+
+#include "../algs.h"
+#include "../noncopyable.h"
+#include "../interfaces/enumerable.h"
+#include "../interfaces/map_pair.h"
+#include "../serialize.h"
+#include <iostream>
+
+namespace dlib
+{
+
+// ----------------------------------------------------------------------------------------
+
+    class assignment : public enumerable<map_pair<unsigned long, unsigned long> >
+    {
+        /*!
+            INITIAL VALUE
+                - size() == 0
+
+            ENUMERATION ORDER
+                The enumerator will iterate over the entries in the assignment in 
+                ascending order according to index values.  (i.e. the elements are 
+                enumerated in sorted order according to the value of their keys)
+
+            WHAT THIS OBJECT REPRESENTS
+                This object models an assignment of random variables to particular values.
+                It is used with the joint_probability_table and conditional_probability_table
+                objects to represent assignments of various random variables to actual values.
+
+                So for example, if you had a joint_probability_table that represented the
+                following table:
+                    P(A = 0, B = 0) = 0.2
+                    P(A = 0, B = 1) = 0.3
+                    P(A = 1, B = 0) = 0.1
+                    P(A = 1, B = 1) = 0.4
+
+                    Also lets define an enum so we have concrete index numbers for A and B
+                    enum { A = 0, B = 1};
+
+                Then you could query the value of P(A=1, B=0) as follows:
+                    assignment a;
+                    a.set(A, 1);
+                    a.set(B, 0);
+                    // and now it is the case that:
+                    table.probability(a) == 0.1 
+                    a[A] == 1
+                    a[B] == 0
+
+
+                Also note that when enumerating the elements of an assignment object
+                the key() refers to the index and the value() refers to the value at that
+                index. For example: 
+
+                // assume a is an assignment object
+                a.reset();
+                while (a.move_next())
+                {
+                    // in this loop it is always the case that:
+                    // a[a.element().key()] == a.element().value()
+                }
+        !*/
+
+    public:
+
+        assignment(
+        );
+        /*!
+            ensures
+                - this object is properly initialized
+        !*/
+
+        assignment(
+            const assignment& a
+        );
+        /*!
+            ensures
+                - #*this is a copy of a
+        !*/
+
+        assignment& operator = (
+            const assignment& rhs
+        );
+        /*!
+            ensures
+                - #*this is a copy of rhs
+                - returns *this
+        !*/
+
+        void clear(
+        );
+        /*!
+            ensures
+                - this object has been returned to its initial value
+        !*/
+
+        bool operator < (
+            const assignment& item
+        ) const;
+        /*!
+            ensures
+                - The exact functioning of this operator is undefined.  The only guarantee
+                  is that it establishes a total ordering on all possible assignment objects.
+                  In other words, this operator makes it so that you can use assignment
+                  objects in the associative containers but otherwise isn't of any 
+                  particular use.
+        !*/
+
+        bool has_index (
+            unsigned long idx
+        ) const;
+        /*!
+            ensures
+                - if (this assignment object has an entry for index idx) then
+                    - returns true
+                - else
+                    - returns false
+        !*/
+
+        void add (
+            unsigned long idx,
+            unsigned long value = 0
+        );
+        /*!
+            requires
+                - has_index(idx) == false
+            ensures
+                - #has_index(idx) == true 
+                - #(*this)[idx] == value 
+        !*/
+
+        void remove (
+            unsigned long idx
+        );
+        /*!
+            requires
+                - has_index(idx) == true 
+            ensures
+                - #has_index(idx) == false 
+        !*/
+
+        unsigned long& operator[] (
+            const long idx
+        );
+        /*!
+            requires
+                - has_index(idx) == true
+            ensures
+                - returns a reference to the value associated with index idx
+        !*/
+
+        const unsigned long& operator[] (
+            const long idx
+        ) const;
+        /*!
+            requires
+                - has_index(idx) == true
+            ensures
+                - returns a const reference to the value associated with index idx
+        !*/
+
+        void swap (
+            assignment& item
+        );
+        /*!
+            ensures
+                - swaps *this and item
+        !*/
+
+    };
+
+    inline void swap (
+        assignment& a,
+        assignment& b
+    ) { a.swap(b); }
+    /*!
+        provides a global swap
+    !*/
+
+    std::ostream& operator << (
+        std::ostream& out,
+        const assignment& a
+    );
+    /*!
+        ensures
+            - writes a to the given output stream in the following format:
+              (index1:value1, index2:value2, ..., indexN:valueN)
+    !*/
+
+    void serialize (
+        const assignment& item,
+        std::ostream& out 
+    );   
+    /*!
+        provides serialization support 
+    !*/
+
+    void deserialize (
+        assignment& item,
+        std::istream& in
+    );   
+    /*!
+        provides deserialization support 
+    !*/
+
+// ------------------------------------------------------------------------
+
+    class joint_probability_table : public enumerable<map_pair<assignment, double> >
+    {
+        /*!
+            INITIAL VALUE
+                - size() == 0
+
+            ENUMERATION ORDER
+                The enumerator will iterate over the entries in the probability table 
+                in no particular order but they will all be visited.
+
+            WHAT THIS OBJECT REPRESENTS
+                This object models a joint probability table.  That is, it models
+                the function p(X).  So this object models the probability of a particular
+                set of variables (referred to as X).
+        !*/
+
+    public:
+
+        joint_probability_table(
+        );
+        /*!
+            ensures
+                - this object is properly initialized
+        !*/
+
+        joint_probability_table (
+            const joint_probability_table& t
+        );
+        /*!
+            ensures
+                - this object is a copy of t
+        !*/
+
+        void clear(
+        );
+        /*!
+            ensures
+                - this object has its initial value
+        !*/
+
+        joint_probability_table& operator= (
+            const joint_probability_table& rhs
+        );
+        /*!
+            ensures
+                - this object is a copy of rhs
+                - returns a reference to *this
+        !*/
+
+        bool has_entry_for (
+            const assignment& a
+        ) const;
+        /*!
+            ensures
+                - if (this joint_probability_table has an entry for p(X = a)) then
+                    - returns true
+                - else
+                    - returns false
+        !*/
+
+        void set_probability (
+            const assignment& a,
+            double p
+        );
+        /*!
+            requires
+                - 0 <= p <= 1
+            ensures
+                - if (has_entry_for(a) == false) then
+                    - #size() == size() + 1
+                - #probability(a) == p
+                - #has_entry_for(a) == true
+        !*/
+
+        void add_probability (
+            const assignment& a,
+            double p
+        );
+        /*!
+            requires
+                - 0 <= p <= 1
+            ensures
+                - if (has_entry_for(a) == false) then
+                    - #size() == size() + 1
+                    - #probability(a) == p
+                - else
+                    - #probability(a) == min(probability(a) + p, 1.0)
+                      (i.e. does a saturating add)
+                - #has_entry_for(a) == true
+        !*/
+
+        const double probability (
+            const assignment& a
+        ) const;
+        /*!
+            ensures
+                - returns the probability p(X == a)
+        !*/
+
+        template <
+            typename T
+            >
+        void marginalize (
+            const T& vars,
+            joint_probability_table& output_table
+        ) const;
+        /*!
+            requires
+                - T is an implementation of set/set_kernel_abstract.h
+            ensures
+                - marginalizes *this by summing over all variables not in vars.  The
+                  result is stored in output_table.  
+        !*/
+
+        void marginalize (
+            const unsigned long var,
+            joint_probability_table& output_table
+        ) const;
+        /*!
+            ensures
+                - is identical to calling the above marginalize() function with a set
+                  that contains only var.  Or in other words, performs a marginalization
+                  with just one variable var.  So that output_table will contain a table giving
+                  the marginal probability of var all by itself.
+        !*/
+
+        void normalize (
+        );
+        /*!
+            ensures
+                - let sum == the sum of all the probabilities in this table
+                - after normalize() has finished it will be the case that the sum of all
+                  the entries in this table is 1.0.  This is accomplished by dividing all
+                  the entries by the sum described above.
+        !*/
+
+        void swap (
+            joint_probability_table& item
+        );
+        /*!
+            ensures
+                - swaps *this and item
+        !*/
+
+    };
+
+    inline void swap (
+        joint_probability_table& a,
+        joint_probability_table& b
+    ) { a.swap(b); }
+    /*!
+        provides a global swap
+    !*/
+
+    void serialize (
+        const joint_probability_table& item,
+        std::ostream& out 
+    );   
+    /*!
+        provides serialization support
+    !*/
+
+    void deserialize (
+        joint_probability_table& item,
+        std::istream& in
+    );   
+    /*!
+        provides deserialization support 
+    !*/
+
+// ----------------------------------------------------------------------------------------
+
+    class conditional_probability_table : noncopyable
+    {
+        /*!
+            INITIAL VALUE
+                - num_values() == 0
+                - has_value_for(x, y) == false for all values of x and y
+
+            WHAT THIS OBJECT REPRESENTS
+                This object models a conditional probability table.  That is, it models
+                the function p( X | parents).  So this object models the conditional 
+                probability of a particular variable (referred to as X) given another set 
+                of variables (referred to as parents).  
+        !*/
+
+    public:
+
+        conditional_probability_table(
+        );
+        /*!
+            ensures
+                - this object is properly initialized
+        !*/
+
+        void clear(
+        );
+        /*!
+            ensures
+                - this object has its initial value
+        !*/
+
+        void empty_table (
+        );
+        /*!
+            ensures
+                - for all possible v and p:
+                    - #has_entry_for(v,p) == false
+                  (i.e. this function clears out the table when you call it but doesn't 
+                  change the value of num_values())
+        !*/
+
+        void set_num_values (
+            unsigned long num
+        );
+        /*!
+            ensures
+                - #num_values() == num
+                - for all possible v and p:
+                    - #has_entry_for(v,p) == false
+                  (i.e. this function clears out the table when you call it)
+        !*/
+
+        unsigned long num_values (
+        ) const; 
+        /*!
+            ensures
+                - This object models the probability table p(X | parents).  This
+                  function returns the number of values X can take on.
+        !*/
+
+        bool has_entry_for (
+            unsigned long value,
+            const assignment& ps
+        ) const;
+        /*!
+            ensures
+                - if (this conditional_probability_table has an entry for p(X = value, parents = ps)) then
+                    - returns true
+                - else
+                    - returns false
+        !*/
+
+        void set_probability (
+            unsigned long value,
+            const assignment& ps,
+            double p
+        );
+        /*!
+            requires
+                - value < num_values()
+                - 0 <= p <= 1
+            ensures
+                - #probability(ps, value) == p
+                - #has_entry_for(value, ps) == true
+        !*/
+
+        double probability(
+            unsigned long value,
+            const assignment& ps
+        ) const;
+        /*!
+            requires
+                - value < num_values()
+                - has_entry_for(value, ps) == true
+            ensures
+                - returns the probability p( X = value | parents = ps). 
+        !*/
+
+        void swap (
+            conditional_probability_table& item
+        );
+        /*!
+            ensures
+                - swaps *this and item
+        !*/
+    };
+
+    inline void swap (
+        conditional_probability_table& a,
+        conditional_probability_table& b
+    ) { a.swap(b); }
+    /*!
+        provides a global swap
+    !*/
+
+    void serialize (
+        const conditional_probability_table& item,
+        std::ostream& out 
+    );   
+    /*!
+        provides serialization support
+    !*/
+
+    void deserialize (
+        conditional_probability_table& item,
+        std::istream& in
+    );   
+    /*!
+        provides deserialization support 
+    !*/
+
+// ------------------------------------------------------------------------
+// ------------------------------------------------------------------------
+// ------------------------------------------------------------------------
+
+    class bayes_node : noncopyable
+    {
+        /*!
+            INITIAL VALUE
+                - is_evidence() == false
+                - value() == 0
+                - table().num_values() == 0
+
+            WHAT THIS OBJECT REPRESENTS
+                This object represents a node in a bayesian network.  It is
+                intended to be used inside the dlib::directed_graph object to
+                represent bayesian networks.
+        !*/
+
+    public:
+        bayes_node (
+        );
+        /*!
+            ensures
+                - this object is properly initialized
+        !*/
+
+        unsigned long value (
+        ) const;
+        /*!
+            ensures
+                - returns the current value of this node
+        !*/
+
+        void set_value (
+            unsigned long new_value
+        );
+        /*!
+            requires
+                - new_value < table().num_values()
+            ensures
+                - #value() == new_value
+        !*/
+
+        conditional_probability_table& table (
+        );
+        /*!
+            ensures
+                - returns a reference to the conditional_probability_table associated with this node
+        !*/
+
+        const conditional_probability_table& table (
+        ) const;
+        /*!
+            ensures
+                - returns a const reference to the conditional_probability_table associated with this 
+                  node.
+        !*/
+
+        bool is_evidence (
+        ) const;
+        /*!
+            ensures
+                - if (this is an evidence node) then
+                    - returns true
+                - else
+                    - returns false
+        !*/
+
+        void set_as_nonevidence (
+        );
+        /*!
+            ensures
+                - #is_evidence() == false
+        !*/
+
+        void set_as_evidence (
+        );
+        /*!
+            ensures
+                - #is_evidence() == true 
+        !*/
+
+        void swap (
+            bayes_node& item
+        );
+        /*!
+            ensures
+                - swaps *this and item
+        !*/
+
+    };
+
+    inline void swap (
+        bayes_node& a,
+        bayes_node& b
+    ) { a.swap(b); }
+    /*!
+        provides a global swap
+    !*/
+
+    void serialize (
+        const bayes_node& item,
+        std::ostream& out 
+    );   
+    /*!
+        provides serialization support
+    !*/
+
+    void deserialize (
+        bayes_node& item,
+        std::istream& in
+    );   
+    /*!
+        provides deserialization support 
+    !*/
+
+// ----------------------------------------------------------------------------------------
+// ----------------------------------------------------------------------------------------
+// ----------------------------------------------------------------------------------------
+
+    /*
+        The following group of functions are convenience functions for manipulating 
+        bayes_node objects while they are inside a directed_graph.   These functions
+        also have additional requires clauses that, in debug mode, will protect you
+        from attempts to manipulate a bayesian network in an inappropriate way.
+    */
+
+    namespace bayes_node_utils
+    {
+
+        template <
+            typename T
+            >
+        void set_node_value (
+            T& bn,
+            unsigned long n,
+            unsigned long val
+        );
+        /*!
+            requires
+                - T is an implementation of directed_graph/directed_graph_kernel_abstract.h
+                - T::type == bayes_node
+                - n < bn.number_of_nodes()
+                - val < node_num_values(bn, n)
+            ensures
+                - #bn.node(n).data.value() = val
+        !*/
+
+    // ------------------------------------------------------------------------------------
+
+        template <
+            typename T
+            >
+        unsigned long node_value (
+            const T& bn,
+            unsigned long n
+        );
+        /*!
+            requires
+                - T is an implementation of directed_graph/directed_graph_kernel_abstract.h
+                - T::type == bayes_node
+                - n < bn.number_of_nodes()
+            ensures
+                - returns bn.node(n).data.value()
+        !*/
+
+    // ------------------------------------------------------------------------------------
+
+        template <
+            typename T
+            >
+        bool node_is_evidence (
+            const T& bn,
+            unsigned long n
+        ); 
+        /*!
+            requires
+                - T is an implementation of directed_graph/directed_graph_kernel_abstract.h
+                - T::type == bayes_node
+                - n < bn.number_of_nodes()
+            ensures
+                - returns bn.node(n).data.is_evidence()
+        !*/
+
+    // ------------------------------------------------------------------------------------
+
+        template <
+            typename T
+            >
+        void set_node_as_evidence (
+            T& bn,
+            unsigned long n
+        );
+        /*!
+            requires
+                - T is an implementation of directed_graph/directed_graph_kernel_abstract.h
+                - T::type == bayes_node
+                - n < bn.number_of_nodes()
+            ensures
+                - executes: bn.node(n).data.set_as_evidence()
+        !*/
+
+    // ------------------------------------------------------------------------------------
+
+        template <
+            typename T
+            >
+        void set_node_as_nonevidence (
+            T& bn,
+            unsigned long n
+        );
+        /*!
+            requires
+                - T is an implementation of directed_graph/directed_graph_kernel_abstract.h
+                - T::type == bayes_node
+                - n < bn.number_of_nodes()
+            ensures
+                - executes: bn.node(n).data.set_as_nonevidence()
+        !*/
+
+    // ------------------------------------------------------------------------------------
+
+        template <
+            typename T
+            >
+        void set_node_num_values (
+            T& bn,
+            unsigned long n,
+            unsigned long num
+        ); 
+        /*!
+            requires
+                - T is an implementation of directed_graph/directed_graph_kernel_abstract.h
+                - T::type == bayes_node
+                - n < bn.number_of_nodes()
+            ensures
+                - #bn.node(n).data.table().num_values() == num
+                  (i.e. sets the number of different values this node can take)
+        !*/
+
+    // ------------------------------------------------------------------------------------
+
+        template <
+            typename T
+            >
+        unsigned long node_num_values (
+            const T& bn,
+            unsigned long n
+        );
+        /*!
+            requires
+                - T is an implementation of directed_graph/directed_graph_kernel_abstract.h
+                - T::type == bayes_node
+                - n < bn.number_of_nodes()
+            ensures
+                - returns bn.node(n).data.table().num_values() 
+                  (i.e. returns the number of different values this node can take)
+        !*/
+
+    // ------------------------------------------------------------------------------------
+
+        template <
+            typename T
+            >
+        const double node_probability (
+            const T& bn,
+            unsigned long n,
+            unsigned long value,
+            const assignment& parents 
+        );
+        /*!
+            requires
+                - T is an implementation of directed_graph/directed_graph_kernel_abstract.h
+                - T::type == bayes_node
+                - n < bn.number_of_nodes()
+                - value < node_num_values(bn,n)
+                - parents.size() == bn.node(n).number_of_parents()
+                - if (parents.has_index(x)) then
+                    - bn.has_edge(x, n)
+                    - parents[x] < node_num_values(bn,x)
+            ensures
+                - returns bn.node(n).data.table().probability(value, parents)
+                  (i.e. returns the probability of node n having the given value when
+                  its parents have the given assignment)
+        !*/
+
+    // ------------------------------------------------------------------------------------
+
+        template <
+            typename T
+            >
+        const double set_node_probability (
+            const T& bn,
+            unsigned long n,
+            unsigned long value,
+            const assignment& parents,
+            double p
+        );
+        /*!
+            requires
+                - T is an implementation of directed_graph/directed_graph_kernel_abstract.h
+                - T::type == bayes_node
+                - n < bn.number_of_nodes()
+                - value < node_num_values(bn,n)
+                - 0 <= p <= 1
+                - parents.size() == bn.node(n).number_of_parents()
+                - if (parents.has_index(x)) then
+                    - bn.has_edge(x, n)
+                    - parents[x] < node_num_values(bn,x)
+            ensures
+                - #bn.node(n).data.table().probability(value, parents) == p
+                  (i.e. sets the probability of node n having the given value when
+                  its parents have the given assignment to the probability p)
+        !*/
+
+    // ------------------------------------------------------------------------------------
+
+        template <typename T>
+        const assignment node_first_parent_assignment (
+            const T& bn,
+            unsigned long n
+        );
+        /*!
+            requires
+                - T is an implementation of directed_graph/directed_graph_kernel_abstract.h
+                - T::type == bayes_node
+                - n < bn.number_of_nodes()
+            ensures
+                - returns an assignment A such that:
+                    - A.size() == bn.node(n).number_of_parents()
+                    - if (P is a parent of bn.node(n)) then
+                        - A.has_index(P)
+                        - A[P] == 0
+                    - I.e. this function returns an assignment that contains all
+                      the parents of the given node.  Also, all the values of each
+                      parent in the assignment is set to zero.
+        !*/
+
+    // ------------------------------------------------------------------------------------
+
+        template <typename T>
+        bool node_next_parent_assignment (
+            const T& bn,
+            unsigned long n,
+            assignment& A
+        );
+        /*!
+            requires
+                - T is an implementation of directed_graph/directed_graph_kernel_abstract.h
+                - T::type == bayes_node
+                - n < bn.number_of_nodes()
+                - A.size() == bn.node(n).number_of_parents()
+                - if (A.has_index(x)) then
+                    - bn.has_edge(x, n)
+                    - A[x] < node_num_values(bn,x)
+            ensures
+                - The behavior of this function is defined by the following code:
+                  assignment a(node_first_parent_assignment(bn,n);
+                  do {
+                    // this loop loops over all possible parent assignments
+                    // of the node bn.node(n).  Each time through the loop variable a
+                    // will be the next assignment.
+                  } while (node_next_parent_assignment(bn,n,a))
+        !*/
+
+    // ------------------------------------------------------------------------------------
+
+        template <typename T>
+        bool node_cpt_filled_out (
+            const T& bn,
+            unsigned long n
+        );
+        /*!
+            requires
+                - T is an implementation of directed_graph/directed_graph_kernel_abstract.h
+                - T::type == bayes_node
+                - n < bn.number_of_nodes()
+            ensures
+                - if (the conditional_probability_table bn.node(n).data.table() is
+                  fully filled out for this node) then
+                    - returns true
+                    - This means that each parent assignment for the given node
+                      along with all possible values of this node shows up in the
+                      table.
+                    - It also means that all the probabilities conditioned on the
+                      same parent assignment sum to 1.0
+                - else
+                    - returns false
+        !*/
+
+    }
+
+// ----------------------------------------------------------------------------------------
+// ----------------------------------------------------------------------------------------
+// ----------------------------------------------------------------------------------------
+
+    class bayesian_network_gibbs_sampler : noncopyable
+    {
+        /*!
+            INITIAL VALUE
+                This object has no state
+
+            WHAT THIS OBJECT REPRESENTS
+                This object performs Markov Chain Monte Carlo sampling of a bayesian
+                network using the Gibbs sampling technique. 
+
+                Note that this object is limited to only bayesian networks that 
+                don't contain deterministic nodes.  That is, incorrect results may
+                be computed if this object is used when the bayesian network contains 
+                any nodes that have a probability of 1 in their conditional probability
+                tables for any event.  So don't use this object for networks with 
+                deterministic nodes.
+        !*/
+    public:
+
+        bayesian_network_gibbs_sampler (
+        );
+        /*!
+            ensures
+                - this object is properly initialized
+        !*/
+
+        template <
+            typename T
+            >
+        void sample_graph (
+            T& bn
+        )
+        /*!
+            requires
+                - T is an implementation of directed_graph/directed_graph_kernel_abstract.h
+                - T::type == bayes_node
+            ensures
+                - modifies randomly (via the Gibbs sampling technique) samples all the nodes
+                  in the network and updates their values with the newly sampled values
+        !*/
+    };
+
+// ----------------------------------------------------------------------------------------
+
+    class bayesian_network_join_tree : noncopyable
+    {
+        /*!
+            WHAT THIS OBJECT REPRESENTS
+                This object represents an implementation of the join tree algorithm
+                for inference in bayesian networks.  It doesn't have any mutable state.
+                To you use you just give it a directed_graph that contains a bayesian 
+                network and a graph object that contains that networks corresponding
+                join tree.  Then you may query this object to determine the probabilities
+                of any variables in the original bayesian network.
+        !*/
+
+    public:
+
+        template <
+            typename bn_type,
+            typename join_tree_type 
+            >
+        bayesian_network_join_tree (
+            const bn_type& bn,
+            const join_tree_type& join_tree
+        );
+        /*!
+            requires
+                - bn_type is an implementation of directed_graph/directed_graph_kernel_abstract.h
+                - bn_type::type == bayes_node
+                - join_tree_type is an implementation of graph/graph_kernel_abstract.h
+                - join_tree_type::type is an implementation of set/set_compare_abstract.h and
+                  this set type contains unsigned long objects. 
+                - join_tree_type::edge_type is an implementation of set/set_compare_abstract.h and
+                  this set type contains unsigned long objects. 
+                - is_join_tree(bn, join_tree) == true
+                - bn == a valid bayesian network with all its conditional probability tables
+                  filled out
+                - for all valid n:
+                    - node_cpt_filled_out(bn,n) == true
+                - graph_contains_length_one_cycle(bn) == false
+                - graph_is_connected(bn) == true
+                - bn.number_of_nodes() > 0
+            ensures
+                - this object is properly initialized
+        !*/
+
+        unsigned long number_of_nodes (
+        ) const;
+        /*!
+            ensures
+                - returns the number of nodes in the bayesian network that this
+                  object was instantiated from.
+        !*/
+
+        const matrix<double,1> probability(
+            unsigned long idx
+        ) const;
+        /*!
+            requires
+                - idx < number_of_nodes()
+            ensures
+                - returns the probability distribution for the node with index idx that was in the bayesian 
+                  network that *this was instantiated from.  Let D represent this distribution, then:
+                    - D.nc() == the number of values the node idx ranges over
+                    - D.nr() == 1 
+                    - D(i) == the probability of node idx taking on the value i 
+        !*/
+
+        void swap (
+            bayesian_network_join_tree& item
+        );
+        /*!
+            ensures
+                - swaps *this with item
+        !*/
+
+    };
+
+    inline void swap (
+        bayesian_network_join_tree& a,
+        bayesian_network_join_tree& b
+    ) { a.swap(b); }
+    /*!
+        provides a global swap
+    !*/
+
+// ----------------------------------------------------------------------------------------
+
+}
+
+#endif // DLIB_BAYES_UTILs_ABSTRACT_
+
+

dlibs/dlib/bigint.h

@@ -0,0 +1,43 @@
+// Copyright (C) 2003  Davis E. King ([email protected])
+// License: Boost Software License   See LICENSE.txt for the full license.
+#ifndef DLIB_BIGINt_
+#define DLIB_BIGINt_
+
+#include "bigint/bigint_kernel_1.h"
+#include "bigint/bigint_kernel_2.h"
+#include "bigint/bigint_kernel_c.h"
+
+
+
+
+namespace dlib
+{
+
+
+    class bigint
+    {
+        bigint() {}
+
+
+    public:
+        
+        //----------- kernels ---------------
+
+        // kernel_1a        
+        typedef     bigint_kernel_1
+                    kernel_1a;
+        typedef     bigint_kernel_c<kernel_1a>
+                    kernel_1a_c;
+          
+        // kernel_2a        
+        typedef     bigint_kernel_2
+                    kernel_2a;
+        typedef     bigint_kernel_c<kernel_2a>
+                    kernel_2a_c;
+          
+
+    };
+}
+
+#endif // DLIB_BIGINt_
+

dlibs/dlib/bigint/bigint_kernel_1.cpp

@@ -0,0 +1,1720 @@
+// Copyright (C) 2003  Davis E. King ([email protected])
+// License: Boost Software License   See LICENSE.txt for the full license.
+#ifndef DLIB_BIGINT_KERNEL_1_CPp_
+#define DLIB_BIGINT_KERNEL_1_CPp_
+#include "bigint_kernel_1.h"
+
+#include <iostream>
+
+namespace dlib
+{
+
+// ----------------------------------------------------------------------------------------
+// ----------------------------------------------------------------------------------------
+    // member/friend function definitions
+// ----------------------------------------------------------------------------------------
+// ----------------------------------------------------------------------------------------
+
+    bigint_kernel_1::
+    bigint_kernel_1 (
+    ) :
+        slack(25),
+        data(new data_record(slack))
+    {}
+
+// ----------------------------------------------------------------------------------------
+
+    bigint_kernel_1::
+    bigint_kernel_1 (
+        uint32 value
+    ) :
+        slack(25),
+        data(new data_record(slack))
+    {
+        *(data->number) = static_cast<uint16>(value&0xFFFF);
+        *(data->number+1) = static_cast<uint16>((value>>16)&0xFFFF);
+        if (*(data->number+1) != 0)
+            data->digits_used = 2;
+    }
+
+// ----------------------------------------------------------------------------------------
+
+    bigint_kernel_1::
+    bigint_kernel_1 (
+        const bigint_kernel_1& item
+    ) :
+        slack(25),
+        data(item.data)
+    {
+        data->references += 1;
+    }
+
+// ----------------------------------------------------------------------------------------
+
+    bigint_kernel_1::
+    ~bigint_kernel_1 (
+    )
+    {
+        if (data->references == 1)
+        {
+            delete data;
+        }
+        else
+        {
+            data->references -= 1;
+        }
+    }
+
+// ----------------------------------------------------------------------------------------
+
+    const bigint_kernel_1 bigint_kernel_1::
+    operator+ (
+        const bigint_kernel_1& rhs
+    ) const
+    {
+        data_record* temp = new data_record (
+                    std::max(rhs.data->digits_used,data->digits_used) + slack
+                    );
+        long_add(data,rhs.data,temp);
+        return bigint_kernel_1(temp,0);
+    }
+
+// ----------------------------------------------------------------------------------------
+
+    bigint_kernel_1& bigint_kernel_1::
+    operator+= (
+        const bigint_kernel_1& rhs
+    )
+    {
+        // if there are other references to our data
+        if (data->references != 1)
+        {
+            data_record* temp = new data_record(std::max(data->digits_used,rhs.data->digits_used)+slack);
+            data->references -= 1;   
+            long_add(data,rhs.data,temp);
+            data = temp;
+        }
+        // if data is not big enough for the result
+        else if (data->size <= std::max(data->digits_used,rhs.data->digits_used))
+        {
+            data_record* temp = new data_record(std::max(data->digits_used,rhs.data->digits_used)+slack);
+            long_add(data,rhs.data,temp);
+            delete data;
+            data = temp;
+        }
+        // there is enough size and no references
+        else
+        {
+            long_add(data,rhs.data,data);
+        }
+        return *this;
+    }
+
+// ----------------------------------------------------------------------------------------
+
+    const bigint_kernel_1 bigint_kernel_1::
+    operator- (
+        const bigint_kernel_1& rhs
+    ) const
+    {
+        data_record* temp = new data_record (
+                    data->digits_used + slack
+                    );
+        long_sub(data,rhs.data,temp);
+        return bigint_kernel_1(temp,0);
+    }
+
+// ----------------------------------------------------------------------------------------
+
+    bigint_kernel_1& bigint_kernel_1::
+    operator-= (
+        const bigint_kernel_1& rhs
+    )
+    {
+        // if there are other references to this data 
+        if (data->references != 1)
+        {
+            data_record* temp = new data_record(data->digits_used+slack);
+            data->references -= 1;
+            long_sub(data,rhs.data,temp);
+            data = temp;
+        }
+        else
+        {
+            long_sub(data,rhs.data,data);
+        }
+        return *this;
+    }
+
+// ----------------------------------------------------------------------------------------
+
+    const bigint_kernel_1 bigint_kernel_1::
+    operator* (
+        const bigint_kernel_1& rhs
+    ) const
+    {
+        data_record* temp = new data_record (
+                    data->digits_used + rhs.data->digits_used + slack
+                    );
+        long_mul(data,rhs.data,temp);
+        return bigint_kernel_1(temp,0);
+    }
+
+// ----------------------------------------------------------------------------------------
+
+    bigint_kernel_1& bigint_kernel_1::
+    operator*= (
+        const bigint_kernel_1& rhs
+    )
+    {
+        // create a data_record to store the result of the multiplication in
+        data_record* temp = new data_record(rhs.data->digits_used+data->digits_used+slack);        
+        long_mul(data,rhs.data,temp);
+
+        // if there are other references to data
+        if (data->references != 1)
+        {
+            data->references -= 1;
+        }
+        else
+        {
+            delete data;
+        }
+        data = temp;
+        return *this;
+    }
+
+// ----------------------------------------------------------------------------------------
+
+    const bigint_kernel_1 bigint_kernel_1::
+    operator/ (
+        const bigint_kernel_1& rhs
+    ) const
+    {
+        data_record* temp = new data_record(data->digits_used+slack);
+        data_record* remainder;
+        try {
+            remainder = new data_record(data->digits_used+slack);           
+        } catch (...) { delete temp; throw; }
+
+        long_div(data,rhs.data,temp,remainder);
+        delete remainder;
+    
+
+        return bigint_kernel_1(temp,0);
+    }
+
+// ----------------------------------------------------------------------------------------
+
+    bigint_kernel_1& bigint_kernel_1::
+    operator/= (
+        const bigint_kernel_1& rhs
+    )
+    {
+
+        data_record* temp = new data_record(data->digits_used+slack);
+        data_record* remainder;
+        try {
+            remainder = new data_record(data->digits_used+slack);
+        } catch (...) { delete temp; throw; }    
+
+        long_div(data,rhs.data,temp,remainder);
+
+        // check if there are other references to data
+        if (data->references != 1)
+        {
+            data->references -= 1;
+        }
+        // if there are no references to data then it must be deleted
+        else
+        {
+            delete data;
+        }
+        data = temp;
+        delete remainder;
+
+        
+        return *this;
+    }
+
+// ----------------------------------------------------------------------------------------
+
+    const bigint_kernel_1 bigint_kernel_1::
+    operator% (
+        const bigint_kernel_1& rhs
+    ) const
+    {
+        data_record* temp = new data_record(data->digits_used+slack);
+        data_record* remainder;
+        try {
+            remainder = new data_record(data->digits_used+slack);
+        } catch (...) { delete temp; throw; }
+
+        long_div(data,rhs.data,temp,remainder);
+        delete temp;
+        return bigint_kernel_1(remainder,0);
+    }
+
+// ----------------------------------------------------------------------------------------
+
+    bigint_kernel_1& bigint_kernel_1::
+    operator%= (
+        const bigint_kernel_1& rhs
+    )
+    {
+        data_record* temp = new data_record(data->digits_used+slack);
+        data_record* remainder;
+        try {
+            remainder = new data_record(data->digits_used+slack);
+        } catch (...) { delete temp; throw; }
+
+        long_div(data,rhs.data,temp,remainder);
+
+        // check if there are other references to data
+        if (data->references != 1)
+        {
+            data->references -= 1;
+        }
+        // if there are no references to data then it must be deleted
+        else
+        {
+            delete data;
+        }
+        data = remainder;
+        delete temp;
+        return *this;
+    }
+
+// ----------------------------------------------------------------------------------------
+
+    bool bigint_kernel_1::
+    operator < (
+        const bigint_kernel_1& rhs
+    ) const
+    {
+        return is_less_than(data,rhs.data);
+    }
+
+// ----------------------------------------------------------------------------------------
+
+    bool bigint_kernel_1::
+    operator == (
+        const bigint_kernel_1& rhs
+    ) const
+    {
+        return is_equal_to(data,rhs.data);
+    }
+
+// ----------------------------------------------------------------------------------------
+
+    bigint_kernel_1& bigint_kernel_1::
+    operator= (
+        const bigint_kernel_1& rhs
+    )
+    {
+        if (this == &rhs)
+            return *this;
+
+        // if we have the only reference to our data then delete it
+        if (data->references == 1)
+        {
+            delete data;
+            data = rhs.data;
+            data->references += 1;
+        }
+        else
+        {
+            data->references -= 1;
+            data = rhs.data;
+            data->references += 1;
+        }
+
+        return *this;
+    }
+
+// ----------------------------------------------------------------------------------------
+
+    std::ostream& operator<< (
+        std::ostream& out_,
+        const bigint_kernel_1& rhs
+    )
+    {
+        std::ostream out(out_.rdbuf());
+
+        typedef bigint_kernel_1 bigint;
+        
+        bigint::data_record* temp = new bigint::data_record(*rhs.data,0);
+
+
+
+        // get a char array big enough to hold the number in ascii format
+        char* str;
+        try {
+            str = new char[(rhs.data->digits_used)*5+10];
+        } catch (...) { delete temp; throw; }
+
+        char* str_start = str;
+        str += (rhs.data->digits_used)*5+9;
+        *str = 0; --str;
+
+
+        uint16 remainder;
+        rhs.short_div(temp,10000,temp,remainder);
+
+        // pull the digits out of remainder
+        char a = remainder % 10 + '0';
+        remainder /= 10;
+        char b = remainder % 10 + '0';
+        remainder /= 10;
+        char c = remainder % 10 + '0';
+        remainder /= 10;
+        char d = remainder % 10 + '0';
+        remainder /= 10;
+
+
+        *str = a; --str;
+        *str = b; --str;
+        *str = c; --str;
+        *str = d; --str;
+
+
+        // keep looping until temp represents zero
+        while (temp->digits_used != 1 || *(temp->number) != 0)
+        {            
+            rhs.short_div(temp,10000,temp,remainder);
+
+            // pull the digits out of remainder
+            char a = remainder % 10 + '0';
+            remainder /= 10;
+            char b = remainder % 10 + '0';
+            remainder /= 10;
+            char c = remainder % 10 + '0';
+            remainder /= 10;
+            char d = remainder % 10 + '0';
+            remainder /= 10;
+
+            *str = a; --str;
+            *str = b; --str;
+            *str = c; --str;
+            *str = d; --str;              
+        }
+
+        // throw away and extra leading zeros
+        ++str;
+        if (*str == '0')
+            ++str;
+        if (*str == '0')
+            ++str;
+        if (*str == '0')
+            ++str;
+
+
+        
+
+        out << str;
+        delete [] str_start;
+        delete temp;
+        return out_;
+
+    }
+
+// ----------------------------------------------------------------------------------------
+
+    std::istream& operator>> (
+        std::istream& in_,
+        bigint_kernel_1& rhs
+    )
+    {
+        std::istream in(in_.rdbuf());
+
+        // ignore any leading whitespaces
+        while (in.peek() == ' ' || in.peek() == '\t' || in.peek() == '\n')
+        {
+            in.get();
+        }
+
+        // if the first digit is not an integer then this is an error
+        if ( !(in.peek() >= '0' && in.peek() <= '9'))
+        {
+            in_.clear(std::ios::failbit);
+            return in_;
+        }
+
+        int num_read;
+        bigint_kernel_1 temp;
+        do
+        {
+
+            // try to get 4 chars from in
+            num_read = 1;
+            char a = 0;
+            char b = 0; 
+            char c = 0;
+            char d = 0;
+
+            if (in.peek() >= '0' && in.peek() <= '9')
+            {
+                num_read *= 10;
+                a = in.get();
+            }
+            if (in.peek() >= '0' && in.peek() <= '9')
+            {
+                num_read *= 10;
+                b = in.get();
+            }
+            if (in.peek() >= '0' && in.peek() <= '9')
+            {
+                num_read *= 10;
+                c = in.get();
+            }
+            if (in.peek() >= '0' && in.peek() <= '9')
+            {
+                num_read *= 10;
+                d = in.get();
+            }
+            
+            // merge the for digits into an uint16
+            uint16 num = 0;
+            if (a != 0)
+            {
+                num = a - '0';
+            }
+            if (b != 0)
+            {
+                num *= 10;
+                num += b - '0';
+            }
+            if (c != 0)
+            {
+                num *= 10;
+                num += c - '0';
+            }
+            if (d != 0)
+            {
+                num *= 10;
+                num += d - '0';
+            }
+
+
+            if (num_read != 1)
+            {
+                // shift the digits in temp left by the number of new digits we just read
+                temp *= num_read;
+                // add in new digits
+                temp += num;
+            }
+
+        } while (num_read == 10000);
+
+
+        rhs = temp;
+        return in_;
+    }
+
+// ----------------------------------------------------------------------------------------
+
+    const bigint_kernel_1 operator+ (
+        uint16 lhs,
+        const bigint_kernel_1& rhs
+    )
+    {
+        typedef bigint_kernel_1 bigint;
+        bigint::data_record* temp = new bigint::data_record
+                (rhs.data->digits_used+rhs.slack);
+
+        rhs.short_add(rhs.data,lhs,temp);
+        return bigint_kernel_1(temp,0);
+    }
+
+// ----------------------------------------------------------------------------------------
+
+    const bigint_kernel_1 operator+ (
+        const bigint_kernel_1& lhs,
+        uint16 rhs
+    )
+    {
+        typedef bigint_kernel_1 bigint;
+        bigint::data_record* temp = new bigint::data_record
+                (lhs.data->digits_used+lhs.slack);
+
+        lhs.short_add(lhs.data,rhs,temp);
+        return bigint_kernel_1(temp,0);
+    }
+
+// ----------------------------------------------------------------------------------------
+
+    bigint_kernel_1& bigint_kernel_1::
+    operator+= (
+        uint16 rhs
+    )
+    {
+        // if there are other references to this data 
+        if (data->references != 1)
+        {
+            data_record* temp = new data_record(data->digits_used+slack);
+            data->references -= 1;    
+            short_add(data,rhs,temp);
+            data = temp;
+        }
+        // or if we need to enlarge data then do so
+        else if (data->digits_used == data->size)
+        {
+            data_record* temp = new data_record(data->digits_used+slack);
+            short_add(data,rhs,temp);
+            delete data;
+            data = temp;
+        }
+        // or if there is plenty of space and no references
+        else
+        {
+            short_add(data,rhs,data);
+        }
+        return *this;
+    }
+
+// ----------------------------------------------------------------------------------------
+
+    const bigint_kernel_1 operator- (
+        uint16 lhs,
+        const bigint_kernel_1& rhs
+    )
+    {
+        typedef bigint_kernel_1 bigint;
+        bigint::data_record* temp = new bigint::data_record(rhs.slack);
+
+        *(temp->number) = lhs - *(rhs.data->number);
+
+        return bigint_kernel_1(temp,0);
+    }
+
+// ----------------------------------------------------------------------------------------
+
+    const bigint_kernel_1 operator- (
+        const bigint_kernel_1& lhs,
+        uint16 rhs
+    )
+    {
+        typedef bigint_kernel_1 bigint;
+        bigint::data_record* temp = new bigint::data_record
+                (lhs.data->digits_used+lhs.slack);
+
+        lhs.short_sub(lhs.data,rhs,temp);
+        return bigint_kernel_1(temp,0);
+    }
+
+// ----------------------------------------------------------------------------------------
+
+    bigint_kernel_1& bigint_kernel_1::
+    operator-= (
+        uint16 rhs
+    )
+    {
+        // if there are other references to this data 
+        if (data->references != 1)
+        {
+            data_record* temp = new data_record(data->digits_used+slack);
+            data->references -= 1;
+            short_sub(data,rhs,temp);
+            data = temp;
+        }
+        else
+        {
+            short_sub(data,rhs,data);
+        }
+        return *this;
+    }
+
+// ----------------------------------------------------------------------------------------
+
+    const bigint_kernel_1 operator* (
+        uint16 lhs,
+        const bigint_kernel_1& rhs
+    )
+    {
+        typedef bigint_kernel_1 bigint;
+        bigint::data_record* temp = new bigint::data_record
+                (rhs.data->digits_used+rhs.slack);
+
+        rhs.short_mul(rhs.data,lhs,temp);
+        return bigint_kernel_1(temp,0);        
+    }
+
+// ----------------------------------------------------------------------------------------
+
+    const bigint_kernel_1 operator* (
+        const bigint_kernel_1& lhs,
+        uint16 rhs
+    )
+    {
+        typedef bigint_kernel_1 bigint;
+        bigint::data_record* temp = new bigint::data_record
+                (lhs.data->digits_used+lhs.slack);
+
+        lhs.short_mul(lhs.data,rhs,temp);
+        return bigint_kernel_1(temp,0);  
+    }
+
+// ----------------------------------------------------------------------------------------
+
+    bigint_kernel_1& bigint_kernel_1::
+    operator*= (
+        uint16 rhs
+    )
+    {
+        // if there are other references to this data 
+        if (data->references != 1)
+        {
+            data_record* temp = new data_record(data->digits_used+slack);
+            data->references -= 1;
+            short_mul(data,rhs,temp);
+            data = temp;
+        }
+        // or if we need to enlarge data
+        else if (data->digits_used == data->size)
+        {
+            data_record* temp = new data_record(data->digits_used+slack);
+            short_mul(data,rhs,temp);
+            delete data;
+            data = temp;
+        }
+        else
+        {
+            short_mul(data,rhs,data);
+        }
+        return *this;
+    }
+
+// ----------------------------------------------------------------------------------------
+
+    const bigint_kernel_1 operator/ (
+        uint16 lhs,
+        const bigint_kernel_1& rhs
+    )
+    {
+        typedef bigint_kernel_1 bigint;
+        bigint::data_record* temp = new bigint::data_record(rhs.slack);
+
+        // if rhs might not be bigger than lhs
+        if (rhs.data->digits_used == 1)
+        {
+            *(temp->number) = lhs/ *(rhs.data->number);
+        }
+        
+        return bigint_kernel_1(temp,0);  
+    }
+
+// ----------------------------------------------------------------------------------------
+
+    const bigint_kernel_1 operator/ (
+        const bigint_kernel_1& lhs,
+        uint16 rhs
+    )
+    {
+        typedef bigint_kernel_1 bigint;
+        bigint::data_record* temp = new bigint::data_record
+                (lhs.data->digits_used+lhs.slack);
+
+        uint16 remainder;
+        lhs.short_div(lhs.data,rhs,temp,remainder);
+        return bigint_kernel_1(temp,0);  
+    }
+
+// ----------------------------------------------------------------------------------------
+
+    bigint_kernel_1& bigint_kernel_1::
+    operator/= (
+        uint16 rhs
+    )
+    {
+        uint16 remainder;
+        // if there are other references to this data
+        if (data->references != 1)
+        {
+            data_record* temp = new data_record(data->digits_used+slack);
+            data->references -= 1;
+            short_div(data,rhs,temp,remainder);    
+            data = temp;
+        }
+        else
+        {
+            short_div(data,rhs,data,remainder);
+        }
+        return *this;
+    }
+
+// ----------------------------------------------------------------------------------------
+
+    const bigint_kernel_1 operator% (
+        uint16 lhs,
+        const bigint_kernel_1& rhs
+    )
+    {
+        typedef bigint_kernel_1 bigint;
+        // temp is zero by default
+        bigint::data_record* temp = new bigint::data_record(rhs.slack);
+
+        if (rhs.data->digits_used == 1)
+        {
+            // if rhs is just an uint16 inside then perform the modulus
+            *(temp->number) = lhs % *(rhs.data->number);
+        }
+        else
+        {
+            // if rhs is bigger than lhs then the answer is lhs
+            *(temp->number) = lhs;
+        }
+        
+        return bigint_kernel_1(temp,0);  
+    }
+
+// ----------------------------------------------------------------------------------------
+
+    const bigint_kernel_1 operator% (
+        const bigint_kernel_1& lhs,
+        uint16 rhs
+    )
+    {
+        typedef bigint_kernel_1 bigint;
+        bigint::data_record* temp = new bigint::data_record(lhs.data->digits_used+lhs.slack);
+
+        uint16 remainder;
+
+        lhs.short_div(lhs.data,rhs,temp,remainder);
+        temp->digits_used = 1;
+        *(temp->number) = remainder;
+        return bigint_kernel_1(temp,0);          
+    }
+
+// ----------------------------------------------------------------------------------------
+
+    bigint_kernel_1& bigint_kernel_1::
+    operator%= (
+        uint16 rhs
+    )
+    {
+        uint16 remainder;
+        // if there are other references to this data
+        if (data->references != 1)
+        {
+            data_record* temp = new data_record(data->digits_used+slack);
+            data->references -= 1;
+            short_div(data,rhs,temp,remainder);
+            data = temp;
+        }
+        else
+        {
+            short_div(data,rhs,data,remainder);
+        }
+
+        data->digits_used = 1;
+        *(data->number) = remainder;
+        return *this;
+    }
+
+// ----------------------------------------------------------------------------------------
+
+    bool operator < (
+        uint16 lhs,
+        const bigint_kernel_1& rhs
+    )
+    {
+        return (rhs.data->digits_used > 1 || lhs < *(rhs.data->number) );
+    }
+
+// ----------------------------------------------------------------------------------------
+
+    bool operator < (
+        const bigint_kernel_1& lhs,
+        uint16 rhs
+    )
+    {
+        return (lhs.data->digits_used == 1 && *(lhs.data->number) < rhs);
+    }
+
+// ----------------------------------------------------------------------------------------
+
+    bool operator == (
+        const bigint_kernel_1& lhs,
+        uint16 rhs
+    )
+    {
+        return (lhs.data->digits_used == 1 && *(lhs.data->number) == rhs);
+    }
+
+// ----------------------------------------------------------------------------------------
+
+    bool operator == (
+        uint16 lhs,
+        const bigint_kernel_1& rhs
+    )
+    {
+        return (rhs.data->digits_used == 1 && *(rhs.data->number) == lhs);
+    }
+
+// ----------------------------------------------------------------------------------------
+
+    bigint_kernel_1& bigint_kernel_1::
+    operator= (
+        uint16 rhs
+    )
+    {
+        // check if there are other references to our data
+        if (data->references != 1)
+        {
+            data->references -= 1;
+            try {
+                data = new data_record(slack);
+            } catch (...) { data->references += 1; throw; }
+        }
+        else
+        {
+            data->digits_used = 1;
+        }
+        
+        *(data->number) = rhs;
+
+        return *this;
+    }
+
+// ----------------------------------------------------------------------------------------
+
+    bigint_kernel_1& bigint_kernel_1::
+    operator++ (
+    )
+    {
+        // if there are other references to this data then make a copy of it
+        if (data->references != 1)
+        {
+            data_record* temp = new data_record(data->digits_used+slack);
+            data->references -= 1;
+            increment(data,temp);
+            data = temp;
+        }
+        // or if we need to enlarge data then do so
+        else if (data->digits_used == data->size)
+        {
+            data_record* temp = new data_record(data->digits_used+slack);
+            increment(data,temp);
+            delete data;
+            data = temp;
+        }
+        else
+        {
+            increment(data,data);
+        }
+
+        return *this;
+    }
+
+// ----------------------------------------------------------------------------------------
+
+    const bigint_kernel_1 bigint_kernel_1::
+    operator++ (
+        int
+    )
+    {
+        data_record* temp; // this is the copy of temp we will return in the end
+         
+        data_record* temp2 = new data_record(data->digits_used+slack);
+        increment(data,temp2);
+        
+        temp = data;
+        data = temp2;
+
+        return bigint_kernel_1(temp,0);
+    }
+
+// ----------------------------------------------------------------------------------------
+
+    bigint_kernel_1& bigint_kernel_1::
+    operator-- (
+    )
+    {
+        // if there are other references to this data 
+        if (data->references != 1)
+        {
+            data_record* temp = new data_record(data->digits_used+slack);
+            data->references -= 1;
+            decrement(data,temp);
+            data = temp;
+        }
+        else
+        {
+            decrement(data,data);
+        }
+
+        return *this;
+    }
+
+// ----------------------------------------------------------------------------------------
+
+    const bigint_kernel_1 bigint_kernel_1::
+    operator-- (
+        int
+    )
+    {
+        data_record* temp; // this is the copy of temp we will return in the end
+         
+        data_record* temp2 = new data_record(data->digits_used+slack);
+        decrement(data,temp2);
+        
+        temp = data;
+        data = temp2;
+
+        return bigint_kernel_1(temp,0);
+    }
+
+// ----------------------------------------------------------------------------------------
+// ----------------------------------------------------------------------------------------
+    // private member function definitions
+// ----------------------------------------------------------------------------------------
+// ----------------------------------------------------------------------------------------
+
+    void bigint_kernel_1::
+    short_add (
+        const data_record* data,        
+        uint16 value,
+        data_record* result
+    ) const
+    {
+        // put value into the carry part of temp
+        uint32 temp = value;
+        temp <<= 16;
+
+        
+        const uint16* number = data->number;
+        const uint16* end = number + data->digits_used; // one past the end of number
+        uint16* r = result->number;
+
+        while (number != end)
+        {
+            // add *number and the current carry
+            temp = *number + (temp>>16);
+            // put the low word of temp into *r
+            *r = static_cast<uint16>(temp & 0xFFFF);
+
+            ++number;
+            ++r;
+        }
+
+        // if there is a final carry
+        if ((temp>>16) != 0)
+        {
+            result->digits_used = data->digits_used + 1;
+            // store the carry in the most significant digit of the result
+            *r = static_cast<uint16>(temp>>16); 
+        }
+        else
+        {
+            result->digits_used = data->digits_used;
+        }
+    }
+
+// ----------------------------------------------------------------------------------------
+
+    void bigint_kernel_1::
+    short_sub (
+        const data_record* data,        
+        uint16 value,
+        data_record* result
+    ) const
+    {
+        
+
+        const uint16* number = data->number;
+        const uint16* end = number + data->digits_used - 1;
+        uint16* r = result->number;
+
+        uint32 temp = *number - value;
+
+        // put the low word of temp into *data 
+        *r = static_cast<uint16>(temp & 0xFFFF);
+
+        
+        while (number != end)
+        {
+            ++number;
+            ++r;
+
+            // subtract the carry from *number 
+            temp = *number - (temp>>31);
+
+            // put the low word of temp into *r 
+            *r = static_cast<uint16>(temp & 0xFFFF);
+        }
+
+        // if we lost a digit in the subtraction
+        if (*r == 0)
+        {
+            if (data->digits_used == 1)
+                result->digits_used = 1;
+            else
+                result->digits_used = data->digits_used - 1;
+        }
+        else
+        {
+            result->digits_used = data->digits_used;
+        }
+
+
+    }
+
+// ----------------------------------------------------------------------------------------
+
+    void bigint_kernel_1::
+    short_mul (
+        const data_record* data,        
+        uint16 value,
+        data_record* result
+    ) const
+    {
+        
+        uint32 temp = 0;
+
+
+        const uint16* number = data->number;        
+        uint16* r = result->number;
+        const uint16* end = r + data->digits_used;
+
+
+
+        while ( r != end)
+        {
+
+            // multiply *data and value and add in the carry
+            temp = *number*(uint32)value + (temp>>16);
+
+            // put the low word of temp into *data
+            *r = static_cast<uint16>(temp & 0xFFFF);
+
+            ++number;
+            ++r;
+        }
+
+        // if there is a final carry
+        if ((temp>>16) != 0)
+        {
+            result->digits_used = data->digits_used + 1;
+            // put the final carry into the most significant digit of the result
+            *r = static_cast<uint16>(temp>>16);
+        }
+        else
+        {
+            result->digits_used = data->digits_used;
+        }
+
+
+    }
+
+// ----------------------------------------------------------------------------------------
+
+    void bigint_kernel_1::
+    short_div (
+        const data_record* data,        
+        uint16 value,   
+        data_record* result,
+        uint16& rem
+    ) const
+    {
+        
+        uint16 remainder = 0;
+        uint32 temp;
+
+        
+
+        const uint16* number = data->number + data->digits_used - 1;
+        const uint16* end = number - data->digits_used;
+        uint16* r = result->number + data->digits_used - 1;
+
+
+        // if we are losing a digit in this division
+        if (*number < value)
+        {
+            if (data->digits_used == 1)
+                result->digits_used = 1;
+            else
+                result->digits_used = data->digits_used - 1;
+        }
+        else
+        {
+            result->digits_used = data->digits_used;
+        }
+
+
+        // perform the actual division
+        while (number != end)
+        {
+           
+            temp = *number + (((uint32)remainder)<<16);
+
+            *r = static_cast<uint16>(temp/value);
+            remainder = static_cast<uint16>(temp%value);
+
+            --number;
+            --r;
+        }
+
+        rem = remainder;
+    }
+
+// ----------------------------------------------------------------------------------------
+
+    void bigint_kernel_1::
+    long_add (
+        const data_record* lhs,
+        const data_record* rhs,
+        data_record* result
+    ) const
+    {
+        // put value into the carry part of temp
+        uint32 temp=0;        
+
+        uint16* min_num;  // the number with the least digits used
+        uint16* max_num;  // the number with the most digits used
+        uint16* min_end;  // one past the end of min_num
+        uint16* max_end;  // one past the end of max_num
+        uint16* r = result->number;
+
+        uint32 max_digits_used;
+        if (lhs->digits_used < rhs->digits_used)
+        {
+            max_digits_used = rhs->digits_used;
+            min_num = lhs->number;
+            max_num = rhs->number;
+            min_end = min_num + lhs->digits_used;
+            max_end = max_num + rhs->digits_used;
+        }
+        else
+        {
+            max_digits_used = lhs->digits_used;
+            min_num = rhs->number;
+            max_num = lhs->number;
+            min_end = min_num + rhs->digits_used;
+            max_end = max_num + lhs->digits_used;
+        }
+
+        
+
+
+        while (min_num != min_end)
+        {
+            // add *min_num, *max_num and the current carry
+            temp = *min_num + *max_num + (temp>>16);
+            // put the low word of temp into *r
+            *r = static_cast<uint16>(temp & 0xFFFF);
+
+            ++min_num;
+            ++max_num;
+            ++r;
+        }
+
+
+        while (max_num != max_end)
+        {
+            // add *max_num and the current carry
+            temp = *max_num + (temp>>16);
+            // put the low word of temp into *r
+            *r = static_cast<uint16>(temp & 0xFFFF);
+
+            ++max_num;
+            ++r;
+        }        
+
+        // check if there was a final carry
+        if ((temp>>16) != 0)
+        {
+            result->digits_used = max_digits_used + 1;
+            // put the carry into the most significant digit in the result
+            *r = static_cast<uint16>(temp>>16);
+        }
+        else
+        {
+            result->digits_used = max_digits_used;
+        }
+
+        
+    }
+
+// ----------------------------------------------------------------------------------------
+
+    void bigint_kernel_1::
+    long_sub (
+        const data_record* lhs,
+        const data_record* rhs,
+        data_record* result
+    ) const
+    {
+
+
+        const uint16* number1 = lhs->number;
+        const uint16* number2 = rhs->number;
+        const uint16* end = number2 + rhs->digits_used;
+        uint16* r = result->number;
+
+
+
+        uint32 temp =0;
+
+        
+        while (number2 != end)
+        {
+
+            // subtract *number2 from *number1 and then subtract any carry
+            temp = *number1 - *number2 - (temp>>31);
+
+            // put the low word of temp into *r 
+            *r = static_cast<uint16>(temp & 0xFFFF);
+
+            ++number1;
+            ++number2;
+            ++r;
+        }
+
+        end = lhs->number + lhs->digits_used;
+        while (number1 != end)
+        {
+
+            // subtract the carry from *number1 
+            temp = *number1 - (temp>>31);
+
+            // put the low word of temp into *r 
+            *r = static_cast<uint16>(temp & 0xFFFF);
+
+            ++number1;
+            ++r;
+        }
+
+        result->digits_used = lhs->digits_used;
+        // adjust the number of digits used appropriately 
+        --r;
+        while (*r == 0 && result->digits_used > 1)
+        {
+            --r;
+            --result->digits_used;
+        }
+    }
+
+// ----------------------------------------------------------------------------------------
+
+    void bigint_kernel_1::
+    long_div (
+        const data_record* lhs,
+        const data_record* rhs,
+        data_record* result,
+        data_record* remainder
+    ) const
+    {
+        // zero result
+        result->digits_used = 1;
+        *(result->number) = 0;
+
+        uint16* a;
+        uint16* b;
+        uint16* end;
+
+        // copy lhs into remainder
+        remainder->digits_used = lhs->digits_used;
+        a = remainder->number;
+        end = a + remainder->digits_used;
+        b = lhs->number;
+        while (a != end)
+        {
+            *a = *b;
+            ++a;
+            ++b;
+        }
+
+
+        // if rhs is bigger than lhs then result == 0 and remainder == lhs
+        // so then we can quit right now
+        if (is_less_than(lhs,rhs))
+        {
+            return;            
+        }
+
+
+        // make a temporary number
+        data_record temp(lhs->digits_used + slack);
+
+
+        // shift rhs left until it is one shift away from being larger than lhs and
+        // put the number of left shifts necessary into shifts
+        uint32 shifts; 
+        shifts = (lhs->digits_used - rhs->digits_used) * 16;
+
+        shift_left(rhs,&temp,shifts);
+
+
+        // while (lhs > temp)
+        while (is_less_than(&temp,lhs))
+        {
+            shift_left(&temp,&temp,1);
+            ++shifts;
+        }
+        // make sure lhs isn't smaller than temp
+        while (is_less_than(lhs,&temp))
+        {
+            shift_right(&temp,&temp);
+            --shifts;
+        }
+
+        
+        
+        // we want to execute the loop shifts +1 times
+        ++shifts;
+        while (shifts != 0)
+        {
+            shift_left(result,result,1);
+            // if (temp <= remainder)
+            if (!is_less_than(remainder,&temp))
+            {
+                long_sub(remainder,&temp,remainder);
+                
+                // increment result
+                uint16* r = result->number;
+                uint16* end = r + result->digits_used;
+                while (true)
+                {
+                    ++(*r);
+                    // if there was no carry then we are done
+                    if (*r != 0)
+                        break;
+
+                    ++r;
+
+                    // if we hit the end of r and there is still a carry then
+                    // the next digit of r is 1 and there is one more digit used
+                    if (r == end)
+                    {
+                        *r = 1;
+                        ++(result->digits_used);
+                        break;
+                    }
+                }
+            }
+            shift_right(&temp,&temp);
+            --shifts;
+        }
+        
+        
+    }
+
+// ----------------------------------------------------------------------------------------
+
+    void bigint_kernel_1::
+    long_mul (
+        const data_record* lhs,
+        const data_record* rhs,
+        data_record* result
+    ) const
+    {
+        // make result be zero
+        result->digits_used = 1;
+        *(result->number) = 0;
+        
+
+        const data_record* aa;
+        const data_record* bb;
+
+        if (lhs->digits_used < rhs->digits_used)
+        {
+            // make copies of lhs and rhs and give them an appropriate amount of
+            // extra memory so there won't be any overflows
+            aa = lhs;
+            bb = rhs;
+        }
+        else
+        {
+            // make copies of lhs and rhs and give them an appropriate amount of
+            // extra memory so there won't be any overflows
+            aa = rhs;
+            bb = lhs;
+        }
+        // this is where we actually copy lhs and rhs
+        data_record b(*bb,aa->digits_used+slack); // the larger(approximately) of lhs and rhs
+
+
+        uint32 shift_value = 0;
+        uint16* anum = aa->number;
+        uint16* end = anum + aa->digits_used;
+        while (anum != end )
+        {
+            uint16 bit = 0x0001;
+ 
+            for (int i = 0; i < 16; ++i)
+            {
+                // if the specified bit of a is 1
+                if ((*anum & bit) != 0)
+                {
+                    shift_left(&b,&b,shift_value);
+                    shift_value = 0;
+                    long_add(&b,result,result);
+                }
+                ++shift_value;
+                bit <<= 1;
+            }
+
+            ++anum;                        
+        }
+    }
+
+// ----------------------------------------------------------------------------------------
+
+    void bigint_kernel_1::
+    shift_left (
+        const data_record* data,
+        data_record* result,
+        uint32 shift_amount
+    ) const
+    {
+        uint32 offset = shift_amount/16;
+        shift_amount &= 0xf;  // same as shift_amount %= 16;
+
+        uint16* r = result->number + data->digits_used + offset; // result
+        uint16* end = data->number;
+        uint16* s = end + data->digits_used; // source
+        const uint32 temp = 16 - shift_amount;
+
+        *r = (*(--s) >> temp);
+        // set the number of digits used in the result
+        // if the upper bits from *s were zero then don't count this first word
+        if (*r == 0)
+        {
+            result->digits_used = data->digits_used + offset;
+        }
+        else
+        {
+            result->digits_used = data->digits_used + offset + 1;
+        }
+        --r;
+
+        while (s != end)
+        {
+            *r = ((*s << shift_amount) | ( *(s-1) >> temp));
+            --r;
+            --s;
+        }
+        *r = *s << shift_amount;
+
+        // now zero the rest of the result
+        end = result->number;
+        while (r != end)
+            *(--r) = 0;
+
+    }
+
+// ----------------------------------------------------------------------------------------
+
+    void bigint_kernel_1::
+    shift_right (
+        const data_record* data,
+        data_record* result
+    ) const
+    {
+
+            uint16* r = result->number; // result
+            uint16* s = data->number; // source
+            uint16* end = s + data->digits_used - 1;
+
+            while (s != end)
+            {
+                *r = (*s >> 1) | (*(s+1) << 15);
+                ++r;
+                ++s;
+            }
+            *r = *s >> 1;
+
+
+            // calculate the new number for digits_used
+            if (*r == 0)
+            {
+                if (data->digits_used != 1)
+                    result->digits_used = data->digits_used - 1;
+                else
+                    result->digits_used = 1;
+            }
+            else
+            {
+                result->digits_used = data->digits_used;
+            }
+  
+
+    }
+
+// ----------------------------------------------------------------------------------------
+
+    bool bigint_kernel_1::
+    is_less_than (
+        const data_record* lhs,
+        const data_record* rhs
+    ) const
+    {
+        uint32 lhs_digits_used = lhs->digits_used;
+        uint32 rhs_digits_used = rhs->digits_used;
+
+        // if lhs is definitely less than rhs
+        if (lhs_digits_used < rhs_digits_used )
+            return true;
+        // if lhs is definitely greater than rhs
+        else if (lhs_digits_used > rhs_digits_used)
+            return false;
+        else 
+        {
+            uint16* end = lhs->number;
+            uint16* l = end         + lhs_digits_used;
+            uint16* r = rhs->number + rhs_digits_used;
+            
+            while (l != end)
+            {
+                --l;
+                --r;
+                if (*l < *r)
+                    return true;
+                else if (*l > *r)
+                    return false;
+            }
+
+            // at this point we know that they are equal
+            return false;
+        }
+
+    }
+
+// ----------------------------------------------------------------------------------------
+
+    bool bigint_kernel_1::
+    is_equal_to (
+        const data_record* lhs,
+        const data_record* rhs
+    ) const
+    {
+        // if lhs and rhs are definitely not equal
+        if (lhs->digits_used != rhs->digits_used )
+        {
+            return false;
+        }
+        else 
+        {            
+            uint16* l = lhs->number;
+            uint16* r = rhs->number;
+            uint16* end = l + lhs->digits_used;
+            
+            while (l != end)
+            {
+                if (*l != *r)
+                    return false;
+                ++l;
+                ++r;
+            }
+
+            // at this point we know that they are equal
+            return true;
+        }
+
+    }
+
+// ----------------------------------------------------------------------------------------
+
+    void bigint_kernel_1::
+    increment (
+        const data_record* source,
+        data_record* dest
+    ) const
+    {
+        uint16* s = source->number;
+        uint16* d = dest->number;
+        uint16* end = s + source->digits_used;
+        while (true)
+        {
+            *d = *s + 1;
+
+            // if there was no carry then break out of the loop
+            if (*d != 0)
+            {
+                dest->digits_used = source->digits_used;
+
+                // copy the rest of the digits over to d
+                ++d; ++s;
+                while (s != end)
+                {
+                    *d = *s;
+                    ++d;
+                    ++s;
+                }
+
+                break;
+            }
+            
+
+            ++s;            
+
+            // if we have hit the end of s and there was a carry up to this point
+            // then just make the next digit 1 and add one to the digits used
+            if (s == end)
+            {
+                ++d;
+                dest->digits_used = source->digits_used + 1;
+                *d = 1;
+                break;
+            }
+
+            ++d;
+        }
+    }
+
+// ----------------------------------------------------------------------------------------
+
+    void bigint_kernel_1::
+    decrement (
+        const data_record* source,
+        data_record* dest
+    ) const
+    {
+        uint16* s = source->number;
+        uint16* d = dest->number;
+        uint16* end = s + source->digits_used;
+        while (true)
+        {
+            *d = *s - 1;
+
+            // if there was no carry then break out of the loop
+            if (*d != 0xFFFF)
+            {
+                // if we lost a digit in the subtraction 
+                if (*d == 0 && s+1 == end)
+                {
+                    if (source->digits_used == 1)
+                        dest->digits_used = 1;
+                    else
+                        dest->digits_used = source->digits_used - 1;
+                }
+                else
+                {
+                    dest->digits_used = source->digits_used;
+                }
+                break;
+            }
+            else
+            {
+                ++d;
+                ++s;
+            }
+
+        }
+
+        // copy the rest of the digits over to d
+        ++d;
+        ++s;
+        while (s != end)
+        {
+            *d = *s;
+            ++d;
+            ++s;
+        }
+    }
+
+// ----------------------------------------------------------------------------------------
+
+}
+#endif // DLIB_BIGINT_KERNEL_1_CPp_
+

dlibs/dlib/bigint/bigint_kernel_1.h

@@ -0,0 +1,543 @@
+// Copyright (C) 2003  Davis E. King ([email protected])
+// License: Boost Software License   See LICENSE.txt for the full license.
+#ifndef DLIB_BIGINT_KERNEl_1_
+#define DLIB_BIGINT_KERNEl_1_
+
+#include "bigint_kernel_abstract.h"
+#include "../algs.h"
+#include "../serialize.h"
+#include "../uintn.h"
+#include <iosfwd>
+
+namespace dlib
+{
+    
+
+    class bigint_kernel_1 
+    {
+        /*!
+            INITIAL VALUE
+                slack               == 25
+                data->number[0]     == 0 
+                data->size          == slack 
+                data->references    == 1 
+                data->digits_used   == 1
+                
+
+            CONVENTION
+                slack  == the number of extra digits placed into the number when it is 
+                    created.  the slack value should never be less than 1
+
+                data->number == pointer to an array of data->size uint16s.
+                    data represents a string of base 65535 numbers with data[0] being
+                    the least significant bit and data[data->digits_used-1] being the most 
+                    significant
+
+
+                NOTE: In the comments I will consider a word to be a 16 bit value
+
+
+                data->digits_used == the number of significant digits in the number.
+                    data->digits_used tells us the number of used elements in the 
+                    data->number array so everything beyond data->number[data->digits_used-1] 
+                    is undefined
+
+                data->references == the number of bigint_kernel_1 objects which refer
+                    to this data_record
+
+
+
+        !*/
+
+
+        struct data_record
+        {
+
+
+            explicit data_record(
+                uint32 size_
+            ) : 
+                size(size_),
+                number(new uint16[size_]),
+                references(1),
+                digits_used(1)
+            {*number = 0;}
+            /*!
+                ensures
+                    - initializes *this to represent zero
+            !*/
+
+            data_record(
+                const data_record& item,
+                uint32 additional_size
+            ) :
+                size(item.digits_used + additional_size),
+                number(new uint16[size]),
+                references(1),
+                digits_used(item.digits_used)
+            {
+                uint16* source = item.number;
+                uint16* dest = number;
+                uint16* end = source + digits_used;
+                while (source != end)
+                {
+                    *dest = *source;
+                    ++dest;
+                    ++source;
+                }
+            }
+            /*!
+                ensures
+                    - *this is a copy of item except with 
+                      size == item.digits_used + additional_size
+            !*/
+
+            ~data_record(
+            )
+            {
+                delete [] number;
+            }
+
+
+            const uint32 size;
+            uint16* number;
+            uint32 references;            
+            uint32 digits_used;
+
+        private:
+            // no copy constructor
+            data_record ( data_record&);
+        };
+
+
+
+        // note that the second parameter is just there 
+        // to resolve the ambiguity between this constructor and 
+        // bigint_kernel_1(uint32)
+        explicit bigint_kernel_1 (
+            data_record* data_, int
+        ): slack(25),data(data_) {}
+        /*!
+            ensures
+                - *this is initialized with data_ as its data member
+        !*/
+
+
+    public:
+
+        bigint_kernel_1 (
+        );
+
+        bigint_kernel_1 (
+            uint32 value
+        );
+
+        bigint_kernel_1 (
+            const bigint_kernel_1& item
+        );
+
+        virtual ~bigint_kernel_1 (
+        );
+
+        const bigint_kernel_1 operator+ (
+            const bigint_kernel_1& rhs
+        ) const;
+
+        bigint_kernel_1& operator+= (
+            const bigint_kernel_1& rhs
+        );
+
+        const bigint_kernel_1 operator- (
+            const bigint_kernel_1& rhs
+        ) const;
+
+        bigint_kernel_1& operator-= (
+            const bigint_kernel_1& rhs
+        );
+
+        const bigint_kernel_1 operator* (
+            const bigint_kernel_1& rhs
+        ) const;
+
+        bigint_kernel_1& operator*= (
+            const bigint_kernel_1& rhs
+        );
+
+        const bigint_kernel_1 operator/ (
+            const bigint_kernel_1& rhs
+        ) const;
+
+        bigint_kernel_1& operator/= (
+            const bigint_kernel_1& rhs
+        );
+
+        const bigint_kernel_1 operator% (
+            const bigint_kernel_1& rhs
+        ) const;
+
+        bigint_kernel_1& operator%= (
+            const bigint_kernel_1& rhs
+        );
+
+        bool operator < (
+            const bigint_kernel_1& rhs
+        ) const;
+
+        bool operator == (
+            const bigint_kernel_1& rhs
+        ) const;
+
+        bigint_kernel_1& operator= (
+            const bigint_kernel_1& rhs
+        );
+
+        friend std::ostream& operator<< (
+            std::ostream& out,
+            const bigint_kernel_1& rhs
+        );
+
+        friend std::istream& operator>> (
+            std::istream& in,
+            bigint_kernel_1& rhs
+        );
+
+        bigint_kernel_1& operator++ (
+        );
+
+        const bigint_kernel_1 operator++ (
+            int
+        );
+
+        bigint_kernel_1& operator-- (
+        );
+
+        const bigint_kernel_1 operator-- (
+            int
+        );
+
+        friend const bigint_kernel_1 operator+ (
+            uint16 lhs,
+            const bigint_kernel_1& rhs
+        );
+
+        friend const bigint_kernel_1 operator+ (
+            const bigint_kernel_1& lhs,
+            uint16 rhs
+        );
+
+        bigint_kernel_1& operator+= (
+            uint16 rhs
+        );
+
+        friend const bigint_kernel_1 operator- (
+            uint16 lhs,
+            const bigint_kernel_1& rhs
+        );
+
+        friend const bigint_kernel_1 operator- (
+            const bigint_kernel_1& lhs,
+            uint16 rhs
+        );
+
+        bigint_kernel_1& operator-= (
+            uint16 rhs
+        );
+
+        friend const bigint_kernel_1 operator* (
+            uint16 lhs,
+            const bigint_kernel_1& rhs
+        );
+
+        friend const bigint_kernel_1 operator* (
+            const bigint_kernel_1& lhs,
+            uint16 rhs
+        );
+
+        bigint_kernel_1& operator*= (
+            uint16 rhs
+        );
+
+        friend const bigint_kernel_1 operator/ (
+            uint16 lhs,
+            const bigint_kernel_1& rhs
+        );
+
+        friend const bigint_kernel_1 operator/ (
+            const bigint_kernel_1& lhs,
+            uint16 rhs
+        );
+
+        bigint_kernel_1& operator/= (
+            uint16 rhs
+        );
+
+        friend const bigint_kernel_1 operator% (
+            uint16 lhs,
+            const bigint_kernel_1& rhs
+        );
+
+        friend const bigint_kernel_1 operator% (
+            const bigint_kernel_1& lhs,
+            uint16 rhs
+        );
+
+        bigint_kernel_1& operator%= (
+            uint16 rhs
+        );
+
+        friend bool operator < (
+            uint16 lhs,
+            const bigint_kernel_1& rhs
+        );
+
+        friend bool operator < (
+            const bigint_kernel_1& lhs,
+            uint16 rhs
+        );
+
+        friend bool operator == (
+            const bigint_kernel_1& lhs,
+            uint16 rhs
+        );
+
+        friend bool operator == (
+            uint16 lhs,
+            const bigint_kernel_1& rhs
+        );
+
+        bigint_kernel_1& operator= (
+            uint16 rhs
+        );
+
+
+        void swap (
+            bigint_kernel_1& item
+        ) { data_record* temp = data; data = item.data; item.data = temp; }
+
+
+    private:
+
+        void long_add (
+            const data_record* lhs,
+            const data_record* rhs,
+            data_record* result
+        ) const;
+        /*!
+            requires
+                - result->size >= max(lhs->digits_used,rhs->digits_used) + 1
+            ensures
+                - result == lhs + rhs
+        !*/
+
+        void long_sub (
+            const data_record* lhs,
+            const data_record* rhs,
+            data_record* result
+        ) const;
+        /*!
+            requires
+                - lhs >= rhs 
+                - result->size >= lhs->digits_used
+            ensures
+                - result == lhs - rhs
+        !*/
+
+        void long_div (
+            const data_record* lhs,
+            const data_record* rhs,
+            data_record* result,
+            data_record* remainder
+        ) const;
+        /*!
+            requires 
+                - rhs != 0 
+                - result->size >= lhs->digits_used 
+                - remainder->size >= lhs->digits_used 
+                - each parameter is unique (i.e. lhs != result, lhs != remainder, etc.)
+            ensures
+                - result == lhs / rhs
+                - remainder == lhs % rhs
+        !*/
+
+        void long_mul (
+            const data_record* lhs,
+            const data_record* rhs,
+            data_record* result
+        ) const;
+        /*!
+            requires
+                - result->size >= lhs->digits_used + rhs->digits_used 
+                - result != lhs 
+                - result != rhs
+            ensures
+                - result == lhs * rhs
+        !*/
+
+        void short_add (
+            const data_record* data,
+            uint16 value,
+            data_record* result            
+        ) const;
+        /*!
+            requires
+                - result->size >= data->size + 1
+            ensures
+                - result == data + value
+        !*/
+
+        void short_sub (
+            const data_record* data,
+            uint16 value,
+            data_record* result
+        ) const;
+        /*!
+            requires
+                - data >= value 
+                - result->size >= data->digits_used
+            ensures
+                - result == data - value
+        !*/
+
+        void short_mul (
+            const data_record* data,
+            uint16 value,
+            data_record* result            
+        ) const;
+        /*!
+            requires
+                - result->size >= data->digits_used + 1
+            ensures
+                - result == data * value
+        !*/
+
+        void short_div (
+            const data_record* data,            
+            uint16 value,
+            data_record* result,
+            uint16& remainder
+        ) const;
+        /*!
+            requires
+                - value != 0 
+                - result->size >= data->digits_used
+            ensures
+                - result = data*value 
+                - remainder = data%value
+        !*/
+
+        void shift_left (
+            const data_record* data,
+            data_record* result,
+            uint32 shift_amount
+        ) const;
+        /*!
+            requires
+                - result->size >= data->digits_used + shift_amount/8 + 1
+            ensures
+                - result == data << shift_amount
+        !*/
+
+        void shift_right (
+            const data_record* data,
+            data_record* result
+        ) const;
+        /*!
+            requires
+                - result->size >= data->digits_used 
+            ensures
+                - result == data >> 1
+        !*/
+
+        bool is_less_than (
+            const data_record* lhs,
+            const data_record* rhs
+        ) const;
+        /*! 
+            ensures
+                - returns true if lhs < rhs 
+                - returns false otherwise
+        !*/ 
+
+        bool is_equal_to (
+            const data_record* lhs,
+            const data_record* rhs
+        ) const;
+        /*!
+            ensures
+                - returns true if lhs == rhs 
+                - returns false otherwise
+        !*/
+
+        void increment (
+            const data_record* source,
+            data_record* dest
+        ) const;
+        /*!
+            requires
+                - dest->size >= source->digits_used + 1
+            ensures
+                - dest = source + 1
+        !*/
+
+        void decrement (
+            const data_record* source,
+            data_record* dest
+        ) const;
+        /*!
+            requires
+                source != 0
+            ensuers
+                dest = source - 1
+        !*/
+
+        // member data
+        const uint32 slack;
+        data_record* data;     
+        
+        
+
+    };
+
+    inline void swap (
+        bigint_kernel_1& a,
+        bigint_kernel_1& b
+    ) { a.swap(b); }
+
+    inline void serialize (
+        const bigint_kernel_1& item, 
+        std::ostream& out
+    )
+    { 
+        std::ios::fmtflags oldflags = out.flags();  
+        out << item << ' '; 
+        out.flags(oldflags); 
+        if (!out) throw serialization_error("Error serializing object of type bigint_kernel_c"); 
+    }   
+
+    inline void deserialize (
+        bigint_kernel_1& item, 
+        std::istream& in
+    ) 
+    { 
+        std::ios::fmtflags oldflags = in.flags();  
+        in >> item;
+        in.flags(oldflags); 
+        if (in.get() != ' ')
+        {
+            item = 0;
+            throw serialization_error("Error deserializing object of type bigint_kernel_c"); 
+        }
+    }   
+
+    inline bool operator>  (const bigint_kernel_1& a, const bigint_kernel_1& b) { return b < a; } 
+    inline bool operator!= (const bigint_kernel_1& a, const bigint_kernel_1& b) { return !(a == b); }
+    inline bool operator<= (const bigint_kernel_1& a, const bigint_kernel_1& b) { return !(b < a); }
+    inline bool operator>= (const bigint_kernel_1& a, const bigint_kernel_1& b) { return !(a < b); }
+}
+
+#ifdef NO_MAKEFILE
+#include "bigint_kernel_1.cpp"
+#endif
+
+#endif // DLIB_BIGINT_KERNEl_1_
+

dlibs/dlib/bigint/bigint_kernel_2.cpp

@@ -0,0 +1,1945 @@
+// Copyright (C) 2003  Davis E. King ([email protected])
+// License: Boost Software License   See LICENSE.txt for the full license.
+#ifndef DLIB_BIGINT_KERNEL_2_CPp_
+#define DLIB_BIGINT_KERNEL_2_CPp_
+#include "bigint_kernel_2.h"
+
+#include <iostream>
+#include <cmath>
+
+namespace dlib
+{
+
+// ----------------------------------------------------------------------------------------
+// ----------------------------------------------------------------------------------------
+    // member/friend function definitions
+// ----------------------------------------------------------------------------------------
+// ----------------------------------------------------------------------------------------
+
+    bigint_kernel_2::
+    bigint_kernel_2 (
+    ) :
+        slack(25),
+        data(new data_record(slack))
+    {}
+
+// ----------------------------------------------------------------------------------------
+
+    bigint_kernel_2::
+    bigint_kernel_2 (
+        uint32 value
+    ) :
+        slack(25),
+        data(new data_record(slack))
+    {
+        *(data->number) = static_cast<uint16>(value&0xFFFF);
+        *(data->number+1) = static_cast<uint16>((value>>16)&0xFFFF);
+        if (*(data->number+1) != 0)
+            data->digits_used = 2;
+    }
+
+// ----------------------------------------------------------------------------------------
+
+    bigint_kernel_2::
+    bigint_kernel_2 (
+        const bigint_kernel_2& item
+    ) :
+        slack(25),
+        data(item.data)
+    {
+        data->references += 1;
+    }
+
+// ----------------------------------------------------------------------------------------
+
+    bigint_kernel_2::
+    ~bigint_kernel_2 (
+    )
+    {
+        if (data->references == 1)
+        {
+            delete data;
+        }
+        else
+        {
+            data->references -= 1;
+        }
+    }
+
+// ----------------------------------------------------------------------------------------
+
+    const bigint_kernel_2 bigint_kernel_2::
+    operator+ (
+        const bigint_kernel_2& rhs
+    ) const
+    {
+        data_record* temp = new data_record (
+                    std::max(rhs.data->digits_used,data->digits_used) + slack
+                    );
+        long_add(data,rhs.data,temp);
+        return bigint_kernel_2(temp,0);
+    }
+
+// ----------------------------------------------------------------------------------------
+
+    bigint_kernel_2& bigint_kernel_2::
+    operator+= (
+        const bigint_kernel_2& rhs
+    )
+    {
+        // if there are other references to our data
+        if (data->references != 1)
+        {
+            data_record* temp = new data_record(std::max(data->digits_used,rhs.data->digits_used)+slack);
+            data->references -= 1;   
+            long_add(data,rhs.data,temp);
+            data = temp;
+        }
+        // if data is not big enough for the result
+        else if (data->size <= std::max(data->digits_used,rhs.data->digits_used))
+        {
+            data_record* temp = new data_record(std::max(data->digits_used,rhs.data->digits_used)+slack);
+            long_add(data,rhs.data,temp);
+            delete data;
+            data = temp;
+        }
+        // there is enough size and no references
+        else
+        {
+            long_add(data,rhs.data,data);
+        }
+        return *this;
+    }
+
+// ----------------------------------------------------------------------------------------
+
+    const bigint_kernel_2 bigint_kernel_2::
+    operator- (
+        const bigint_kernel_2& rhs
+    ) const
+    {
+        data_record* temp = new data_record (
+                    data->digits_used + slack
+                    );
+        long_sub(data,rhs.data,temp);
+        return bigint_kernel_2(temp,0);
+    }
+
+// ----------------------------------------------------------------------------------------
+
+    bigint_kernel_2& bigint_kernel_2::
+    operator-= (
+        const bigint_kernel_2& rhs
+    )
+    {
+        // if there are other references to this data 
+        if (data->references != 1)
+        {
+            data_record* temp = new data_record(data->digits_used+slack);
+            data->references -= 1;
+            long_sub(data,rhs.data,temp);
+            data = temp;
+        }
+        else
+        {
+            long_sub(data,rhs.data,data);
+        }
+        return *this;
+    }
+
+// ----------------------------------------------------------------------------------------
+
+    const bigint_kernel_2 bigint_kernel_2::
+    operator* (
+        const bigint_kernel_2& rhs
+    ) const
+    {
+        data_record* temp = new data_record (
+                    data->digits_used + rhs.data->digits_used + slack
+                    );
+        long_mul(data,rhs.data,temp);
+        return bigint_kernel_2(temp,0);
+    }
+
+// ----------------------------------------------------------------------------------------
+
+    bigint_kernel_2& bigint_kernel_2::
+    operator*= (
+        const bigint_kernel_2& rhs
+    )
+    {
+        // create a data_record to store the result of the multiplication in
+        data_record* temp = new data_record(rhs.data->digits_used+data->digits_used+slack);        
+        long_mul(data,rhs.data,temp);
+
+        // if there are other references to data
+        if (data->references != 1)
+        {
+            data->references -= 1;
+        }
+        else
+        {
+            delete data;
+        }
+        data = temp;
+        return *this;
+    }
+
+// ----------------------------------------------------------------------------------------
+
+    const bigint_kernel_2 bigint_kernel_2::
+    operator/ (
+        const bigint_kernel_2& rhs
+    ) const
+    {
+        data_record* temp = new data_record(data->digits_used+slack);
+        data_record* remainder;
+        try {
+            remainder = new data_record(data->digits_used+slack);           
+        } catch (...) { delete temp; throw; }
+
+        long_div(data,rhs.data,temp,remainder);
+        delete remainder;
+    
+
+        return bigint_kernel_2(temp,0);
+    }
+
+// ----------------------------------------------------------------------------------------
+
+    bigint_kernel_2& bigint_kernel_2::
+    operator/= (
+        const bigint_kernel_2& rhs
+    )
+    {
+
+        data_record* temp = new data_record(data->digits_used+slack);
+        data_record* remainder;
+        try {
+            remainder = new data_record(data->digits_used+slack);
+        } catch (...) { delete temp; throw; }    
+
+        long_div(data,rhs.data,temp,remainder);
+
+        // check if there are other references to data
+        if (data->references != 1)
+        {
+            data->references -= 1;
+        }
+        // if there are no references to data then it must be deleted
+        else
+        {
+            delete data;
+        }
+        data = temp;
+        delete remainder;
+
+        
+        return *this;
+    }
+
+// ----------------------------------------------------------------------------------------
+
+    const bigint_kernel_2 bigint_kernel_2::
+    operator% (
+        const bigint_kernel_2& rhs
+    ) const
+    {
+        data_record* temp = new data_record(data->digits_used+slack);
+        data_record* remainder;
+        try {
+            remainder = new data_record(data->digits_used+slack);
+        } catch (...) { delete temp; throw; }
+
+        long_div(data,rhs.data,temp,remainder);
+        delete temp;
+        return bigint_kernel_2(remainder,0);
+    }
+
+// ----------------------------------------------------------------------------------------
+
+    bigint_kernel_2& bigint_kernel_2::
+    operator%= (
+        const bigint_kernel_2& rhs
+    )
+    {
+        data_record* temp = new data_record(data->digits_used+slack);
+        data_record* remainder;
+        try {
+            remainder = new data_record(data->digits_used+slack);
+        } catch (...) { delete temp; throw; }
+
+        long_div(data,rhs.data,temp,remainder);
+
+        // check if there are other references to data
+        if (data->references != 1)
+        {
+            data->references -= 1;
+        }
+        // if there are no references to data then it must be deleted
+        else
+        {
+            delete data;
+        }
+        data = remainder;
+        delete temp;
+        return *this;
+    }
+
+// ----------------------------------------------------------------------------------------
+
+    bool bigint_kernel_2::
+    operator < (
+        const bigint_kernel_2& rhs
+    ) const
+    {
+        return is_less_than(data,rhs.data);
+    }
+
+// ----------------------------------------------------------------------------------------
+
+    bool bigint_kernel_2::
+    operator == (
+        const bigint_kernel_2& rhs
+    ) const
+    {
+        return is_equal_to(data,rhs.data);
+    }
+
+// ----------------------------------------------------------------------------------------
+
+    bigint_kernel_2& bigint_kernel_2::
+    operator= (
+        const bigint_kernel_2& rhs
+    )
+    {
+        if (this == &rhs)
+            return *this;
+
+        // if we have the only reference to our data then delete it
+        if (data->references == 1)
+        {
+            delete data;
+            data = rhs.data;
+            data->references += 1;
+        }
+        else
+        {
+            data->references -= 1;
+            data = rhs.data;
+            data->references += 1;
+        }
+
+        return *this;
+    }
+
+// ----------------------------------------------------------------------------------------
+
+    std::ostream& operator<< (
+        std::ostream& out_,
+        const bigint_kernel_2& rhs
+    )
+    {
+        std::ostream out(out_.rdbuf());
+
+        typedef bigint_kernel_2 bigint;
+        
+        bigint::data_record* temp = new bigint::data_record(*rhs.data,0);
+
+
+
+        // get a char array big enough to hold the number in ascii format
+        char* str;
+        try {
+            str = new char[(rhs.data->digits_used)*5+10];
+        } catch (...) { delete temp; throw; }
+
+        char* str_start = str;
+        str += (rhs.data->digits_used)*5+9;
+        *str = 0; --str;
+
+
+        uint16 remainder;
+        rhs.short_div(temp,10000,temp,remainder);
+
+        // pull the digits out of remainder
+        char a = remainder % 10 + '0';
+        remainder /= 10;
+        char b = remainder % 10 + '0';
+        remainder /= 10;
+        char c = remainder % 10 + '0';
+        remainder /= 10;
+        char d = remainder % 10 + '0';
+        remainder /= 10;
+
+
+        *str = a; --str;
+        *str = b; --str;
+        *str = c; --str;
+        *str = d; --str;
+
+
+        // keep looping until temp represents zero
+        while (temp->digits_used != 1 || *(temp->number) != 0)
+        {            
+            rhs.short_div(temp,10000,temp,remainder);
+
+            // pull the digits out of remainder
+            char a = remainder % 10 + '0';
+            remainder /= 10;
+            char b = remainder % 10 + '0';
+            remainder /= 10;
+            char c = remainder % 10 + '0';
+            remainder /= 10;
+            char d = remainder % 10 + '0';
+            remainder /= 10;
+
+            *str = a; --str;
+            *str = b; --str;
+            *str = c; --str;
+            *str = d; --str;              
+        }
+
+        // throw away and extra leading zeros
+        ++str;
+        if (*str == '0')
+            ++str;
+        if (*str == '0')
+            ++str;
+        if (*str == '0')
+            ++str;
+
+
+        
+
+        out << str;
+        delete [] str_start;
+        delete temp;
+        return out_;
+
+    }
+
+// ----------------------------------------------------------------------------------------
+
+    std::istream& operator>> (
+        std::istream& in_,
+        bigint_kernel_2& rhs
+    )
+    {
+        std::istream in(in_.rdbuf());
+
+        // ignore any leading whitespaces
+        while (in.peek() == ' ' || in.peek() == '\t' || in.peek() == '\n')
+        {
+            in.get();
+        }
+
+        // if the first digit is not an integer then this is an error
+        if ( !(in.peek() >= '0' && in.peek() <= '9'))
+        {
+            in_.clear(std::ios::failbit);
+            return in_;
+        }
+
+        int num_read;
+        bigint_kernel_2 temp;
+        do
+        {
+
+            // try to get 4 chars from in
+            num_read = 1;
+            char a = 0;
+            char b = 0; 
+            char c = 0;
+            char d = 0;
+
+            if (in.peek() >= '0' && in.peek() <= '9')
+            {
+                num_read *= 10;
+                a = in.get();
+            }
+            if (in.peek() >= '0' && in.peek() <= '9')
+            {
+                num_read *= 10;
+                b = in.get();
+            }
+            if (in.peek() >= '0' && in.peek() <= '9')
+            {
+                num_read *= 10;
+                c = in.get();
+            }
+            if (in.peek() >= '0' && in.peek() <= '9')
+            {
+                num_read *= 10;
+                d = in.get();
+            }
+            
+            // merge the for digits into an uint16
+            uint16 num = 0;
+            if (a != 0)
+            {
+                num = a - '0';
+            }
+            if (b != 0)
+            {
+                num *= 10;
+                num += b - '0';
+            }
+            if (c != 0)
+            {
+                num *= 10;
+                num += c - '0';
+            }
+            if (d != 0)
+            {
+                num *= 10;
+                num += d - '0';
+            }
+
+
+            if (num_read != 1)
+            {
+                // shift the digits in temp left by the number of new digits we just read
+                temp *= num_read;
+                // add in new digits
+                temp += num;
+            }
+
+        } while (num_read == 10000);
+
+
+        rhs = temp;
+        return in_;
+    }
+
+// ----------------------------------------------------------------------------------------
+
+    const bigint_kernel_2 operator+ (
+        uint16 lhs,
+        const bigint_kernel_2& rhs
+    )
+    {
+        typedef bigint_kernel_2 bigint;
+        bigint::data_record* temp = new bigint::data_record
+                (rhs.data->digits_used+rhs.slack);
+
+        rhs.short_add(rhs.data,lhs,temp);
+        return bigint_kernel_2(temp,0);
+    }
+
+// ----------------------------------------------------------------------------------------
+
+    const bigint_kernel_2 operator+ (
+        const bigint_kernel_2& lhs,
+        uint16 rhs
+    )
+    {
+        typedef bigint_kernel_2 bigint;
+        bigint::data_record* temp = new bigint::data_record
+                (lhs.data->digits_used+lhs.slack);
+
+        lhs.short_add(lhs.data,rhs,temp);
+        return bigint_kernel_2(temp,0);
+    }
+
+// ----------------------------------------------------------------------------------------
+
+    bigint_kernel_2& bigint_kernel_2::
+    operator+= (
+        uint16 rhs
+    )
+    {
+        // if there are other references to this data 
+        if (data->references != 1)
+        {
+            data_record* temp = new data_record(data->digits_used+slack);
+            data->references -= 1;    
+            short_add(data,rhs,temp);
+            data = temp;
+        }
+        // or if we need to enlarge data then do so
+        else if (data->digits_used == data->size)
+        {
+            data_record* temp = new data_record(data->digits_used+slack);
+            short_add(data,rhs,temp);
+            delete data;
+            data = temp;
+        }
+        // or if there is plenty of space and no references
+        else
+        {
+            short_add(data,rhs,data);
+        }
+        return *this;
+    }
+
+// ----------------------------------------------------------------------------------------
+
+    const bigint_kernel_2 operator- (
+        uint16 lhs,
+        const bigint_kernel_2& rhs
+    )
+    {
+        typedef bigint_kernel_2 bigint;
+        bigint::data_record* temp = new bigint::data_record(rhs.slack);
+
+        *(temp->number) = lhs - *(rhs.data->number);
+
+        return bigint_kernel_2(temp,0);
+    }
+
+// ----------------------------------------------------------------------------------------
+
+    const bigint_kernel_2 operator- (
+        const bigint_kernel_2& lhs,
+        uint16 rhs
+    )
+    {
+        typedef bigint_kernel_2 bigint;
+        bigint::data_record* temp = new bigint::data_record
+                (lhs.data->digits_used+lhs.slack);
+
+        lhs.short_sub(lhs.data,rhs,temp);
+        return bigint_kernel_2(temp,0);
+    }
+
+// ----------------------------------------------------------------------------------------
+
+    bigint_kernel_2& bigint_kernel_2::
+    operator-= (
+        uint16 rhs
+    )
+    {
+        // if there are other references to this data 
+        if (data->references != 1)
+        {
+            data_record* temp = new data_record(data->digits_used+slack);
+            data->references -= 1;
+            short_sub(data,rhs,temp);
+            data = temp;
+        }
+        else
+        {
+            short_sub(data,rhs,data);
+        }
+        return *this;
+    }
+
+// ----------------------------------------------------------------------------------------
+
+    const bigint_kernel_2 operator* (
+        uint16 lhs,
+        const bigint_kernel_2& rhs
+    )
+    {
+        typedef bigint_kernel_2 bigint;
+        bigint::data_record* temp = new bigint::data_record
+                (rhs.data->digits_used+rhs.slack);
+
+        rhs.short_mul(rhs.data,lhs,temp);
+        return bigint_kernel_2(temp,0);        
+    }
+
+// ----------------------------------------------------------------------------------------
+
+    const bigint_kernel_2 operator* (
+        const bigint_kernel_2& lhs,
+        uint16 rhs
+    )
+    {
+        typedef bigint_kernel_2 bigint;
+        bigint::data_record* temp = new bigint::data_record
+                (lhs.data->digits_used+lhs.slack);
+
+        lhs.short_mul(lhs.data,rhs,temp);
+        return bigint_kernel_2(temp,0);  
+    }
+
+// ----------------------------------------------------------------------------------------
+
+    bigint_kernel_2& bigint_kernel_2::
+    operator*= (
+        uint16 rhs
+    )
+    {
+        // if there are other references to this data 
+        if (data->references != 1)
+        {
+            data_record* temp = new data_record(data->digits_used+slack);
+            data->references -= 1;
+            short_mul(data,rhs,temp);
+            data = temp;
+        }
+        // or if we need to enlarge data
+        else if (data->digits_used == data->size)
+        {
+            data_record* temp = new data_record(data->digits_used+slack);
+            short_mul(data,rhs,temp);
+            delete data;
+            data = temp;
+        }
+        else
+        {
+            short_mul(data,rhs,data);
+        }
+        return *this;
+    }
+
+// ----------------------------------------------------------------------------------------
+
+    const bigint_kernel_2 operator/ (
+        uint16 lhs,
+        const bigint_kernel_2& rhs
+    )
+    {
+        typedef bigint_kernel_2 bigint;
+        bigint::data_record* temp = new bigint::data_record(rhs.slack);
+
+        // if rhs might not be bigger than lhs
+        if (rhs.data->digits_used == 1)
+        {
+            *(temp->number) = lhs/ *(rhs.data->number);
+        }
+        
+        return bigint_kernel_2(temp,0);  
+    }
+
+// ----------------------------------------------------------------------------------------
+
+    const bigint_kernel_2 operator/ (
+        const bigint_kernel_2& lhs,
+        uint16 rhs
+    )
+    {
+        typedef bigint_kernel_2 bigint;
+        bigint::data_record* temp = new bigint::data_record
+                (lhs.data->digits_used+lhs.slack);
+
+        uint16 remainder;
+        lhs.short_div(lhs.data,rhs,temp,remainder);
+        return bigint_kernel_2(temp,0);  
+    }
+
+// ----------------------------------------------------------------------------------------
+
+    bigint_kernel_2& bigint_kernel_2::
+    operator/= (
+        uint16 rhs
+    )
+    {
+        uint16 remainder;
+        // if there are other references to this data
+        if (data->references != 1)
+        {
+            data_record* temp = new data_record(data->digits_used+slack);
+            data->references -= 1;
+            short_div(data,rhs,temp,remainder);    
+            data = temp;
+        }
+        else
+        {
+            short_div(data,rhs,data,remainder);
+        }
+        return *this;
+    }
+
+// ----------------------------------------------------------------------------------------
+
+    const bigint_kernel_2 operator% (
+        uint16 lhs,
+        const bigint_kernel_2& rhs
+    )
+    {
+        typedef bigint_kernel_2 bigint;
+        // temp is zero by default
+        bigint::data_record* temp = new bigint::data_record(rhs.slack);
+
+        if (rhs.data->digits_used == 1)
+        {
+            // if rhs is just an uint16 inside then perform the modulus
+            *(temp->number) = lhs % *(rhs.data->number);
+        }
+        else
+        {
+            // if rhs is bigger than lhs then the answer is lhs
+            *(temp->number) = lhs;
+        }
+        
+        return bigint_kernel_2(temp,0);  
+    }
+
+// ----------------------------------------------------------------------------------------
+
+    const bigint_kernel_2 operator% (
+        const bigint_kernel_2& lhs,
+        uint16 rhs
+    )
+    {
+        typedef bigint_kernel_2 bigint;
+        bigint::data_record* temp = new bigint::data_record(lhs.data->digits_used+lhs.slack);
+
+        uint16 remainder;
+
+        lhs.short_div(lhs.data,rhs,temp,remainder);
+        temp->digits_used = 1;
+        *(temp->number) = remainder;
+        return bigint_kernel_2(temp,0);          
+    }
+
+// ----------------------------------------------------------------------------------------
+
+    bigint_kernel_2& bigint_kernel_2::
+    operator%= (
+        uint16 rhs
+    )
+    {
+        uint16 remainder;
+        // if there are other references to this data
+        if (data->references != 1)
+        {
+            data_record* temp = new data_record(data->digits_used+slack);
+            data->references -= 1;
+            short_div(data,rhs,temp,remainder);
+            data = temp;
+        }
+        else
+        {
+            short_div(data,rhs,data,remainder);
+        }
+
+        data->digits_used = 1;
+        *(data->number) = remainder;
+        return *this;
+    }
+
+// ----------------------------------------------------------------------------------------
+
+    bool operator < (
+        uint16 lhs,
+        const bigint_kernel_2& rhs
+    )
+    {
+        return (rhs.data->digits_used > 1 || lhs < *(rhs.data->number) );
+    }
+
+// ----------------------------------------------------------------------------------------
+
+    bool operator < (
+        const bigint_kernel_2& lhs,
+        uint16 rhs
+    )
+    {
+        return (lhs.data->digits_used == 1 && *(lhs.data->number) < rhs);
+    }
+
+// ----------------------------------------------------------------------------------------
+
+    bool operator == (
+        const bigint_kernel_2& lhs,
+        uint16 rhs
+    )
+    {
+        return (lhs.data->digits_used == 1 && *(lhs.data->number) == rhs);
+    }
+
+// ----------------------------------------------------------------------------------------
+
+    bool operator == (
+        uint16 lhs,
+        const bigint_kernel_2& rhs
+    )
+    {
+        return (rhs.data->digits_used == 1 && *(rhs.data->number) == lhs);
+    }
+
+// ----------------------------------------------------------------------------------------
+
+    bigint_kernel_2& bigint_kernel_2::
+    operator= (
+        uint16 rhs
+    )
+    {
+        // check if there are other references to our data
+        if (data->references != 1)
+        {
+            data->references -= 1;
+            try {
+                data = new data_record(slack);
+            } catch (...) { data->references += 1; throw; }
+        }
+        else
+        {
+            data->digits_used = 1;
+        }
+        
+        *(data->number) = rhs;
+
+        return *this;
+    }
+
+// ----------------------------------------------------------------------------------------
+
+    bigint_kernel_2& bigint_kernel_2::
+    operator++ (
+    )
+    {
+        // if there are other references to this data then make a copy of it
+        if (data->references != 1)
+        {
+            data_record* temp = new data_record(data->digits_used+slack);
+            data->references -= 1;
+            increment(data,temp);
+            data = temp;
+        }
+        // or if we need to enlarge data then do so
+        else if (data->digits_used == data->size)
+        {
+            data_record* temp = new data_record(data->digits_used+slack);
+            increment(data,temp);
+            delete data;
+            data = temp;
+        }
+        else
+        {
+            increment(data,data);
+        }
+
+        return *this;
+    }
+
+// ----------------------------------------------------------------------------------------
+
+    const bigint_kernel_2 bigint_kernel_2::
+    operator++ (
+        int
+    )
+    {
+        data_record* temp; // this is the copy of temp we will return in the end
+         
+        data_record* temp2 = new data_record(data->digits_used+slack);
+        increment(data,temp2);
+        
+        temp = data;
+        data = temp2;
+
+        return bigint_kernel_2(temp,0);
+    }
+
+// ----------------------------------------------------------------------------------------
+
+    bigint_kernel_2& bigint_kernel_2::
+    operator-- (
+    )
+    {
+        // if there are other references to this data 
+        if (data->references != 1)
+        {
+            data_record* temp = new data_record(data->digits_used+slack);
+            data->references -= 1;
+            decrement(data,temp);
+            data = temp;
+        }
+        else
+        {
+            decrement(data,data);
+        }
+
+        return *this;
+    }
+
+// ----------------------------------------------------------------------------------------
+
+    const bigint_kernel_2 bigint_kernel_2::
+    operator-- (
+        int
+    )
+    {
+        data_record* temp; // this is the copy of temp we will return in the end
+         
+        data_record* temp2 = new data_record(data->digits_used+slack);
+        decrement(data,temp2);
+        
+        temp = data;
+        data = temp2;
+
+        return bigint_kernel_2(temp,0);
+    }
+
+// ----------------------------------------------------------------------------------------
+// ----------------------------------------------------------------------------------------
+    // private member function definitions
+// ----------------------------------------------------------------------------------------
+// ----------------------------------------------------------------------------------------
+
+    void bigint_kernel_2::
+    short_add (
+        const data_record* data,        
+        uint16 value,
+        data_record* result
+    ) const
+    {
+        // put value into the carry part of temp
+        uint32 temp = value;
+        temp <<= 16;
+
+        
+        const uint16* number = data->number;
+        const uint16* end = number + data->digits_used; // one past the end of number
+        uint16* r = result->number;
+
+        while (number != end)
+        {
+            // add *number and the current carry
+            temp = *number + (temp>>16);
+            // put the low word of temp into *r
+            *r = static_cast<uint16>(temp & 0xFFFF);
+
+            ++number;
+            ++r;
+        }
+
+        // if there is a final carry
+        if ((temp>>16) != 0)
+        {
+            result->digits_used = data->digits_used + 1;
+            // store the carry in the most significant digit of the result
+            *r = static_cast<uint16>(temp>>16); 
+        }
+        else
+        {
+            result->digits_used = data->digits_used;
+        }
+    }
+
+// ----------------------------------------------------------------------------------------
+
+    void bigint_kernel_2::
+    short_sub (
+        const data_record* data,        
+        uint16 value,
+        data_record* result
+    ) const
+    {
+        
+
+        const uint16* number = data->number;
+        const uint16* end = number + data->digits_used - 1;
+        uint16* r = result->number;
+
+        uint32 temp = *number - value;
+
+        // put the low word of temp into *data 
+        *r = static_cast<uint16>(temp & 0xFFFF);
+
+        
+        while (number != end)
+        {
+            ++number;
+            ++r;
+
+            // subtract the carry from *number 
+            temp = *number - (temp>>31);
+
+            // put the low word of temp into *r 
+            *r = static_cast<uint16>(temp & 0xFFFF);
+        }
+
+        // if we lost a digit in the subtraction
+        if (*r == 0)
+        {
+            if (data->digits_used == 1)
+                result->digits_used = 1;
+            else
+                result->digits_used = data->digits_used - 1;
+        }
+        else
+        {
+            result->digits_used = data->digits_used;
+        }
+
+
+    }
+
+// ----------------------------------------------------------------------------------------
+
+    void bigint_kernel_2::
+    short_mul (
+        const data_record* data,        
+        uint16 value,
+        data_record* result
+    ) const
+    {
+        
+        uint32 temp = 0;
+
+
+        const uint16* number = data->number;        
+        uint16* r = result->number;
+        const uint16* end = r + data->digits_used;
+
+
+
+        while ( r != end)
+        {
+
+            // multiply *data and value and add in the carry
+            temp = *number*(uint32)value + (temp>>16);
+
+            // put the low word of temp into *data
+            *r = static_cast<uint16>(temp & 0xFFFF);
+
+            ++number;
+            ++r;
+        }
+
+        // if there is a final carry
+        if ((temp>>16) != 0)
+        {
+            result->digits_used = data->digits_used + 1;
+            // put the final carry into the most significant digit of the result
+            *r = static_cast<uint16>(temp>>16);
+        }
+        else
+        {
+            result->digits_used = data->digits_used;
+        }
+
+
+    }
+
+// ----------------------------------------------------------------------------------------
+
+    void bigint_kernel_2::
+    short_div (
+        const data_record* data,        
+        uint16 value,   
+        data_record* result,
+        uint16& rem
+    ) const
+    {
+        
+        uint16 remainder = 0;
+        uint32 temp;
+
+        
+
+        const uint16* number = data->number + data->digits_used - 1;
+        const uint16* end = number - data->digits_used;
+        uint16* r = result->number + data->digits_used - 1;
+
+
+        // if we are losing a digit in this division
+        if (*number < value)
+        {
+            if (data->digits_used == 1)
+                result->digits_used = 1;
+            else
+                result->digits_used = data->digits_used - 1;
+        }
+        else
+        {
+            result->digits_used = data->digits_used;
+        }
+
+
+        // perform the actual division
+        while (number != end)
+        {
+           
+            temp = *number + (((uint32)remainder)<<16);
+
+            *r = static_cast<uint16>(temp/value);
+            remainder = static_cast<uint16>(temp%value);
+
+            --number;
+            --r;
+        }
+
+        rem = remainder;
+    }
+
+// ----------------------------------------------------------------------------------------
+
+    void bigint_kernel_2::
+    long_add (
+        const data_record* lhs,
+        const data_record* rhs,
+        data_record* result
+    ) const
+    {
+        // put value into the carry part of temp
+        uint32 temp=0;        
+
+        uint16* min_num;  // the number with the least digits used
+        uint16* max_num;  // the number with the most digits used
+        uint16* min_end;  // one past the end of min_num
+        uint16* max_end;  // one past the end of max_num
+        uint16* r = result->number;
+
+        uint32 max_digits_used;
+        if (lhs->digits_used < rhs->digits_used)
+        {
+            max_digits_used = rhs->digits_used;
+            min_num = lhs->number;
+            max_num = rhs->number;
+            min_end = min_num + lhs->digits_used;
+            max_end = max_num + rhs->digits_used;
+        }
+        else
+        {
+            max_digits_used = lhs->digits_used;
+            min_num = rhs->number;
+            max_num = lhs->number;
+            min_end = min_num + rhs->digits_used;
+            max_end = max_num + lhs->digits_used;
+        }
+
+        
+
+
+        while (min_num != min_end)
+        {
+            // add *min_num, *max_num and the current carry
+            temp = *min_num + *max_num + (temp>>16);
+            // put the low word of temp into *r
+            *r = static_cast<uint16>(temp & 0xFFFF);
+
+            ++min_num;
+            ++max_num;
+            ++r;
+        }
+
+
+        while (max_num != max_end)
+        {
+            // add *max_num and the current carry
+            temp = *max_num + (temp>>16);
+            // put the low word of temp into *r
+            *r = static_cast<uint16>(temp & 0xFFFF);
+
+            ++max_num;
+            ++r;
+        }        
+
+        // check if there was a final carry
+        if ((temp>>16) != 0)
+        {
+            result->digits_used = max_digits_used + 1;
+            // put the carry into the most significant digit in the result
+            *r = static_cast<uint16>(temp>>16);
+        }
+        else
+        {
+            result->digits_used = max_digits_used;
+        }
+
+        
+    }
+
+// ----------------------------------------------------------------------------------------
+
+    void bigint_kernel_2::
+    long_sub (
+        const data_record* lhs,
+        const data_record* rhs,
+        data_record* result
+    ) const
+    {
+
+
+        const uint16* number1 = lhs->number;
+        const uint16* number2 = rhs->number;
+        const uint16* end = number2 + rhs->digits_used;
+        uint16* r = result->number;
+
+
+
+        uint32 temp =0;
+
+        
+        while (number2 != end)
+        {
+
+            // subtract *number2 from *number1 and then subtract any carry
+            temp = *number1 - *number2 - (temp>>31);
+
+            // put the low word of temp into *r 
+            *r = static_cast<uint16>(temp & 0xFFFF);
+
+            ++number1;
+            ++number2;
+            ++r;
+        }
+
+        end = lhs->number + lhs->digits_used;
+        while (number1 != end)
+        {
+
+            // subtract the carry from *number1 
+            temp = *number1 - (temp>>31);
+
+            // put the low word of temp into *r 
+            *r = static_cast<uint16>(temp & 0xFFFF);
+
+            ++number1;
+            ++r;
+        }
+
+        result->digits_used = lhs->digits_used;
+        // adjust the number of digits used appropriately 
+        --r;
+        while (*r == 0 && result->digits_used > 1)
+        {
+            --r;
+            --result->digits_used;
+        }
+    }
+
+// ----------------------------------------------------------------------------------------
+
+    void bigint_kernel_2::
+    long_div (
+        const data_record* lhs,
+        const data_record* rhs,
+        data_record* result,
+        data_record* remainder
+    ) const
+    {
+        // zero result
+        result->digits_used = 1;
+        *(result->number) = 0;
+
+        uint16* a;
+        uint16* b;
+        uint16* end;
+
+        // copy lhs into remainder
+        remainder->digits_used = lhs->digits_used;
+        a = remainder->number;
+        end = a + remainder->digits_used;
+        b = lhs->number;
+        while (a != end)
+        {
+            *a = *b;
+            ++a;
+            ++b;
+        }
+
+
+        // if rhs is bigger than lhs then result == 0 and remainder == lhs
+        // so then we can quit right now
+        if (is_less_than(lhs,rhs))
+        {
+            return;            
+        }
+
+
+        // make a temporary number
+        data_record temp(lhs->digits_used + slack);
+
+
+        // shift rhs left until it is one shift away from being larger than lhs and
+        // put the number of left shifts necessary into shifts
+        uint32 shifts; 
+        shifts = (lhs->digits_used - rhs->digits_used) * 16;
+
+        shift_left(rhs,&temp,shifts);
+
+
+        // while (lhs > temp)
+        while (is_less_than(&temp,lhs))
+        {
+            shift_left(&temp,&temp,1);
+            ++shifts;
+        }
+        // make sure lhs isn't smaller than temp
+        while (is_less_than(lhs,&temp))
+        {
+            shift_right(&temp,&temp);
+            --shifts;
+        }
+
+        
+        
+        // we want to execute the loop shifts +1 times
+        ++shifts;
+        while (shifts != 0)
+        {
+            shift_left(result,result,1);
+            // if (temp <= remainder)
+            if (!is_less_than(remainder,&temp))
+            {
+                long_sub(remainder,&temp,remainder);
+                
+                // increment result
+                uint16* r = result->number;
+                uint16* end = r + result->digits_used;
+                while (true)
+                {
+                    ++(*r);
+                    // if there was no carry then we are done
+                    if (*r != 0)
+                        break;
+
+                    ++r;
+
+                    // if we hit the end of r and there is still a carry then
+                    // the next digit of r is 1 and there is one more digit used
+                    if (r == end)
+                    {
+                        *r = 1;
+                        ++(result->digits_used);
+                        break;
+                    }
+                }
+            }
+            shift_right(&temp,&temp);
+            --shifts;
+        }
+        
+        
+    }
+
+// ----------------------------------------------------------------------------------------
+
+    void bigint_kernel_2::
+    long_mul (
+        const data_record* lhs,
+        const data_record* rhs,
+        data_record* result
+    ) const
+    {
+        // if one of the numbers is small then use this simple but O(n^2) algorithm
+        if (std::min(lhs->digits_used, rhs->digits_used) < 10)
+        {
+            // make result be zero
+            result->digits_used = 1;
+            *(result->number) = 0;
+
+
+            const data_record* aa;
+            const data_record* bb;
+
+            if (lhs->digits_used < rhs->digits_used)
+            {
+                // make copies of lhs and rhs and give them an appropriate amount of
+                // extra memory so there won't be any overflows
+                aa = lhs;
+                bb = rhs;
+            }
+            else
+            {
+                // make copies of lhs and rhs and give them an appropriate amount of
+                // extra memory so there won't be any overflows
+                aa = rhs;
+                bb = lhs;
+            }
+
+            // copy the larger(approximately) of lhs and rhs into b
+            data_record b(*bb,aa->digits_used+slack); 
+
+
+            uint32 shift_value = 0;
+            uint16* anum = aa->number;
+            uint16* end = anum + aa->digits_used;
+            while (anum != end )
+            {
+                uint16 bit = 0x0001;
+
+                for (int i = 0; i < 16; ++i)
+                {
+                    // if the specified bit of a is 1
+                    if ((*anum & bit) != 0)
+                    {
+                        shift_left(&b,&b,shift_value);
+                        shift_value = 0;
+                        long_add(&b,result,result);
+                    }
+                    ++shift_value;
+                    bit <<= 1;
+                }
+
+                ++anum;                        
+            }
+        }
+        else  // else if both lhs and rhs are large then use the more complex 
+              // O(n*logn) algorithm
+        {
+            uint32 size = 1;
+            // make size a power of 2
+            while (size < (lhs->digits_used + rhs->digits_used)*2)  
+            {
+                size *= 2;
+            }
+
+            // allocate some temporary space so we can do the FFT
+            ct* a = new ct[size];
+            ct* b; try {b = new ct[size]; } catch (...) { delete [] a; throw; }
+
+            // load lhs into the a array.  We are breaking the input number into 
+            // 8bit chunks for the purpose of using this fft algorithm.  The reason 
+            // for this is so that we have smaller numbers coming out of the final 
+            // ifft.  This helps avoid overflow.
+            for (uint32 i = 0; i < lhs->digits_used; ++i)
+            {
+                a[i*2] = ct((t)(lhs->number[i]&0xFF),0);
+                a[i*2+1] = ct((t)(lhs->number[i]>>8),0);
+            }
+            for (uint32 i = lhs->digits_used*2; i < size; ++i)
+            {
+                a[i] = 0;
+            }
+
+            // load rhs into the b array
+            for (uint32 i = 0; i < rhs->digits_used; ++i)
+            {
+                b[i*2] = ct((t)(rhs->number[i]&0xFF),0);
+                b[i*2+1] = ct((t)(rhs->number[i]>>8),0);
+            }
+            for (uint32 i = rhs->digits_used*2; i < size; ++i)
+            {
+                b[i] = 0;
+            }
+
+            // perform the forward fft of a and b
+            fft(a,size);
+            fft(b,size);
+
+            const double l = 1.0/size;
+
+            // do the pointwise multiply of a and b and also apply the scale
+            // factor in this loop too.
+            for (unsigned long i = 0; i < size; ++i)
+            {
+                a[i] = l*a[i]*b[i];
+            }
+
+            // Now compute the inverse fft of the pointwise multiplication of a and b.  
+            // This is basically the result.  We just have to take care of any carries 
+            // that should happen.
+            ifft(a,size);
+
+            // loop over the result and propagate any carries that need to take place.  
+            // We will also be moving the resulting numbers into result->number at 
+            // the same time.
+            uint64 carry = 0;
+            result->digits_used = 0;
+            int zeros = 0;
+            const uint32 len = lhs->digits_used + rhs->digits_used;
+            for (unsigned long i = 0; i < len; ++i)
+            {
+                uint64 num1 = static_cast<uint64>(std::floor(a[i*2].real()+0.5));
+                num1 += carry;
+                carry = 0;
+                if (num1 > 255)
+                {
+                    carry = num1 >> 8;
+                    num1 = (num1&0xFF);
+                }
+
+                uint64 num2 = static_cast<uint64>(std::floor(a[i*2+1].real()+0.5));
+                num2 += carry;
+                carry = 0;
+                if (num2 > 255)
+                {
+                    carry = num2 >> 8;
+                    num2 = (num2&0xFF);
+                }
+
+                // put the new number into its final place
+                num1 = (num2<<8) | num1;
+                result->number[i] = static_cast<uint16>(num1);
+
+                // keep track of the number of leading zeros
+                if (num1 == 0)
+                    ++zeros;
+                else
+                    zeros = 0;
+                ++(result->digits_used);
+            }
+
+            // adjust digits_used so that it reflects the actual number
+            // of non-zero digits in our representation.
+            result->digits_used -= zeros;
+
+            // if the result was zero then adjust the result accordingly
+            if (result->digits_used == 0)
+            {
+                // make result be zero
+                result->digits_used = 1;
+                *(result->number) = 0;
+            }
+
+            // free all the temporary buffers
+            delete [] a;
+            delete [] b;
+        }
+    }
+
+// ----------------------------------------------------------------------------------------
+
+    void bigint_kernel_2::
+    shift_left (
+        const data_record* data,
+        data_record* result,
+        uint32 shift_amount
+    ) const
+    {
+        uint32 offset = shift_amount/16;
+        shift_amount &= 0xf;  // same as shift_amount %= 16;
+
+        uint16* r = result->number + data->digits_used + offset; // result
+        uint16* end = data->number;
+        uint16* s = end + data->digits_used; // source
+        const uint32 temp = 16 - shift_amount;
+
+        *r = (*(--s) >> temp);
+        // set the number of digits used in the result
+        // if the upper bits from *s were zero then don't count this first word
+        if (*r == 0)
+        {
+            result->digits_used = data->digits_used + offset;
+        }
+        else
+        {
+            result->digits_used = data->digits_used + offset + 1;
+        }
+        --r;
+
+        while (s != end)
+        {
+            *r = ((*s << shift_amount) | ( *(s-1) >> temp));
+            --r;
+            --s;
+        }
+        *r = *s << shift_amount;
+
+        // now zero the rest of the result
+        end = result->number;
+        while (r != end)
+            *(--r) = 0;
+
+    }
+
+// ----------------------------------------------------------------------------------------
+
+    void bigint_kernel_2::
+    shift_right (
+        const data_record* data,
+        data_record* result
+    ) const
+    {
+
+            uint16* r = result->number; // result
+            uint16* s = data->number; // source
+            uint16* end = s + data->digits_used - 1;
+
+            while (s != end)
+            {
+                *r = (*s >> 1) | (*(s+1) << 15);
+                ++r;
+                ++s;
+            }
+            *r = *s >> 1;
+
+
+            // calculate the new number for digits_used
+            if (*r == 0)
+            {
+                if (data->digits_used != 1)
+                    result->digits_used = data->digits_used - 1;
+                else
+                    result->digits_used = 1;
+            }
+            else
+            {
+                result->digits_used = data->digits_used;
+            }
+  
+
+    }
+
+// ----------------------------------------------------------------------------------------
+
+    bool bigint_kernel_2::
+    is_less_than (
+        const data_record* lhs,
+        const data_record* rhs
+    ) const
+    {
+        uint32 lhs_digits_used = lhs->digits_used;
+        uint32 rhs_digits_used = rhs->digits_used;
+
+        // if lhs is definitely less than rhs
+        if (lhs_digits_used < rhs_digits_used )
+            return true;
+        // if lhs is definitely greater than rhs
+        else if (lhs_digits_used > rhs_digits_used)
+            return false;
+        else 
+        {
+            uint16* end = lhs->number;
+            uint16* l = end         + lhs_digits_used;
+            uint16* r = rhs->number + rhs_digits_used;
+            
+            while (l != end)
+            {
+                --l;
+                --r;
+                if (*l < *r)
+                    return true;
+                else if (*l > *r)
+                    return false;
+            }
+
+            // at this point we know that they are equal
+            return false;
+        }
+
+    }
+
+// ----------------------------------------------------------------------------------------
+
+    bool bigint_kernel_2::
+    is_equal_to (
+        const data_record* lhs,
+        const data_record* rhs
+    ) const
+    {
+        // if lhs and rhs are definitely not equal
+        if (lhs->digits_used != rhs->digits_used )
+        {
+            return false;
+        }
+        else 
+        {            
+            uint16* l = lhs->number;
+            uint16* r = rhs->number;
+            uint16* end = l + lhs->digits_used;
+            
+            while (l != end)
+            {
+                if (*l != *r)
+                    return false;
+                ++l;
+                ++r;
+            }
+
+            // at this point we know that they are equal
+            return true;
+        }
+
+    }
+
+// ----------------------------------------------------------------------------------------
+
+    void bigint_kernel_2::
+    increment (
+        const data_record* source,
+        data_record* dest
+    ) const
+    {
+        uint16* s = source->number;
+        uint16* d = dest->number;
+        uint16* end = s + source->digits_used;
+        while (true)
+        {
+            *d = *s + 1;
+
+            // if there was no carry then break out of the loop
+            if (*d != 0)
+            {
+                dest->digits_used = source->digits_used;
+
+                // copy the rest of the digits over to d
+                ++d; ++s;
+                while (s != end)
+                {
+                    *d = *s;
+                    ++d;
+                    ++s;
+                }
+
+                break;
+            }
+            
+
+            ++s;            
+
+            // if we have hit the end of s and there was a carry up to this point
+            // then just make the next digit 1 and add one to the digits used
+            if (s == end)
+            {
+                ++d;
+                dest->digits_used = source->digits_used + 1;
+                *d = 1;
+                break;
+            }
+
+            ++d;
+        }
+    }
+
+// ----------------------------------------------------------------------------------------
+
+    void bigint_kernel_2::
+    decrement (
+        const data_record* source,
+        data_record* dest
+    ) const
+    {
+        uint16* s = source->number;
+        uint16* d = dest->number;
+        uint16* end = s + source->digits_used;
+        while (true)
+        {
+            *d = *s - 1;
+
+            // if there was no carry then break out of the loop
+            if (*d != 0xFFFF)
+            {
+                // if we lost a digit in the subtraction 
+                if (*d == 0 && s+1 == end)
+                {
+                    if (source->digits_used == 1)
+                        dest->digits_used = 1;
+                    else
+                        dest->digits_used = source->digits_used - 1;
+                }
+                else
+                {
+                    dest->digits_used = source->digits_used;
+                }
+                break;
+            }
+            else
+            {
+                ++d;
+                ++s;
+            }
+
+        }
+
+        // copy the rest of the digits over to d
+        ++d;
+        ++s;
+        while (s != end)
+        {
+            *d = *s;
+            ++d;
+            ++s;
+        }
+    }
+
+// ----------------------------------------------------------------------------------------
+
+    void bigint_kernel_2::
+    fft (
+        ct* data, 
+        unsigned long len
+    ) const 
+    {
+        const t pi2 = -2.0*3.1415926535897932384626433832795028841971693993751;
+
+        const unsigned long half = len/2;
+
+        std::vector<ct> twiddle_factors;
+        twiddle_factors.resize(half);
+
+        // compute the complex root of unity w
+        const t temp = pi2/len;
+        ct w = ct(std::cos(temp),std::sin(temp));
+
+        ct w_pow = 1;
+
+        // compute the twiddle factors
+        for (std::vector<ct>::size_type j = 0; j < twiddle_factors.size(); ++j)
+        {
+            twiddle_factors[j] = w_pow; 
+            w_pow *= w;
+        }
+
+        ct a, b;
+
+        // now compute the decimation in frequency.  This first
+        // outer loop loops log2(len) number of times
+        unsigned long skip = 1;
+        for (unsigned long step = half; step != 0; step >>= 1)
+        {
+            // do blocks of butterflies in this loop
+            for (unsigned long j = 0; j < len; j += step*2)
+            {
+                // do step butterflies
+                for (unsigned long k = 0; k < step; ++k)
+                {
+                    const unsigned long a_idx = j+k;
+                    const unsigned long b_idx = j+k+step;
+                    a = data[a_idx] + data[b_idx];
+                    b = (data[a_idx] - data[b_idx])*twiddle_factors[k*skip];
+                    data[a_idx] = a;
+                    data[b_idx] = b;
+                }
+            }
+            skip *= 2;
+        }
+    }
+
+// ----------------------------------------------------------------------------------------
+
+    void bigint_kernel_2::
+    ifft(
+        ct* data, 
+        unsigned long len
+    ) const 
+    {
+        const t pi2 = 2.0*3.1415926535897932384626433832795028841971693993751;
+
+        const unsigned long half = len/2;
+
+        std::vector<ct> twiddle_factors;
+        twiddle_factors.resize(half);
+
+        // compute the complex root of unity w
+        const t temp = pi2/len;
+        ct w = ct(std::cos(temp),std::sin(temp));
+
+        ct w_pow = 1;
+
+        // compute the twiddle factors
+        for (std::vector<ct>::size_type j = 0; j < twiddle_factors.size(); ++j)
+        {
+            twiddle_factors[j] = w_pow; 
+            w_pow *= w;
+        }
+
+        ct a, b;
+
+        // now compute the inverse decimation in frequency.  This first
+        // outer loop loops log2(len) number of times
+        unsigned long skip = half;
+        for (unsigned long step = 1; step <= half; step <<= 1)
+        {
+            // do blocks of butterflies in this loop
+            for (unsigned long j = 0; j < len; j += step*2)
+            {
+                // do step butterflies
+                for (unsigned long k = 0; k < step; ++k)
+                {
+                    const unsigned long a_idx = j+k;
+                    const unsigned long b_idx = j+k+step;
+                    data[b_idx] *= twiddle_factors[k*skip];
+                    a = data[a_idx] + data[b_idx];
+                    b = data[a_idx] - data[b_idx];
+                    data[a_idx] = a;
+                    data[b_idx] = b;
+                }
+            }
+            skip /= 2;
+        }
+    }
+
+// ----------------------------------------------------------------------------------------
+
+}
+#endif // DLIB_BIGINT_KERNEL_2_CPp_
+

dlibs/dlib/bigint/bigint_kernel_2.h

@@ -0,0 +1,569 @@
+// Copyright (C) 2003  Davis E. King ([email protected])
+// License: Boost Software License   See LICENSE.txt for the full license.
+#ifndef DLIB_BIGINT_KERNEl_2_
+#define DLIB_BIGINT_KERNEl_2_
+
+#include "bigint_kernel_abstract.h"
+#include "../algs.h"
+#include "../serialize.h"
+#include "../uintn.h"
+#include <iosfwd>
+#include <cmath>
+#include <complex>
+#include <vector>
+
+namespace dlib
+{
+    
+    class bigint_kernel_2 
+    {
+        /*!
+            INITIAL VALUE
+                slack               == 25
+                data->number[0]     == 0 
+                data->size          == slack 
+                data->references    == 1 
+                data->digits_used   == 1
+                
+
+            CONVENTION
+                slack  == the number of extra digits placed into the number when it is 
+                    created.  the slack value should never be less than 1
+
+                data->number == pointer to an array of data->size uint16s.
+                    data represents a string of base 65535 numbers with data[0] being
+                    the least significant bit and data[data->digits_used-1] being the most 
+                    significant
+
+
+                NOTE: In the comments I will consider a word to be a 16 bit value
+
+
+                data->digits_used == the number of significant digits in the number.
+                    data->digits_used tells us the number of used elements in the 
+                    data->number array so everything beyond data->number[data->digits_used-1] 
+                    is undefined
+
+                data->references == the number of bigint_kernel_2 objects which refer
+                    to this data_record
+        !*/
+
+
+        struct data_record
+        {
+
+
+            explicit data_record(
+                uint32 size_
+            ) : 
+                size(size_),
+                number(new uint16[size_]),
+                references(1),
+                digits_used(1)
+            {*number = 0;}
+            /*!
+                ensures
+                    - initializes *this to represent zero
+            !*/
+
+            data_record(
+                const data_record& item,
+                uint32 additional_size
+            ) :
+                size(item.digits_used + additional_size),
+                number(new uint16[size]),
+                references(1),
+                digits_used(item.digits_used)
+            {
+                uint16* source = item.number;
+                uint16* dest = number;
+                uint16* end = source + digits_used;
+                while (source != end)
+                {
+                    *dest = *source;
+                    ++dest;
+                    ++source;
+                }
+            }
+            /*!
+                ensures
+                    - *this is a copy of item except with 
+                      size == item.digits_used + additional_size
+            !*/
+
+            ~data_record(
+            )
+            {
+                delete [] number;
+            }
+
+
+            const uint32 size;
+            uint16* number;
+            uint32 references;            
+            uint32 digits_used;
+
+        private:
+            // no copy constructor
+            data_record ( data_record&);
+        };
+
+
+        // note that the second parameter is just there 
+        // to resolve the ambiguity between this constructor and 
+        // bigint_kernel_2(uint32)
+        explicit bigint_kernel_2 (
+            data_record* data_, int
+        ): slack(25),data(data_) {}
+        /*!
+            ensures
+                - *this is initialized with data_ as its data member
+        !*/
+
+    public:
+
+        bigint_kernel_2 (
+        );
+
+        bigint_kernel_2 (
+            uint32 value
+        );
+
+        bigint_kernel_2 (
+            const bigint_kernel_2& item
+        );
+
+        virtual ~bigint_kernel_2 (
+        );
+
+        const bigint_kernel_2 operator+ (
+            const bigint_kernel_2& rhs
+        ) const;
+
+        bigint_kernel_2& operator+= (
+            const bigint_kernel_2& rhs
+        );
+
+        const bigint_kernel_2 operator- (
+            const bigint_kernel_2& rhs
+        ) const;
+
+        bigint_kernel_2& operator-= (
+            const bigint_kernel_2& rhs
+        );
+
+        const bigint_kernel_2 operator* (
+            const bigint_kernel_2& rhs
+        ) const;
+
+        bigint_kernel_2& operator*= (
+            const bigint_kernel_2& rhs
+        );
+
+        const bigint_kernel_2 operator/ (
+            const bigint_kernel_2& rhs
+        ) const;
+
+        bigint_kernel_2& operator/= (
+            const bigint_kernel_2& rhs
+        );
+
+        const bigint_kernel_2 operator% (
+            const bigint_kernel_2& rhs
+        ) const;
+
+        bigint_kernel_2& operator%= (
+            const bigint_kernel_2& rhs
+        );
+
+        bool operator < (
+            const bigint_kernel_2& rhs
+        ) const;
+
+        bool operator == (
+            const bigint_kernel_2& rhs
+        ) const;
+
+        bigint_kernel_2& operator= (
+            const bigint_kernel_2& rhs
+        );
+
+        friend std::ostream& operator<< (
+            std::ostream& out,
+            const bigint_kernel_2& rhs
+        );
+
+        friend std::istream& operator>> (
+            std::istream& in,
+            bigint_kernel_2& rhs
+        );
+
+        bigint_kernel_2& operator++ (
+        );
+
+        const bigint_kernel_2 operator++ (
+            int
+        );
+
+        bigint_kernel_2& operator-- (
+        );
+
+        const bigint_kernel_2 operator-- (
+            int
+        );
+
+        friend const bigint_kernel_2 operator+ (
+            uint16 lhs,
+            const bigint_kernel_2& rhs
+        );
+
+        friend const bigint_kernel_2 operator+ (
+            const bigint_kernel_2& lhs,
+            uint16 rhs
+        );
+
+        bigint_kernel_2& operator+= (
+            uint16 rhs
+        );
+
+        friend const bigint_kernel_2 operator- (
+            uint16 lhs,
+            const bigint_kernel_2& rhs
+        );
+
+        friend const bigint_kernel_2 operator- (
+            const bigint_kernel_2& lhs,
+            uint16 rhs
+        );
+
+        bigint_kernel_2& operator-= (
+            uint16 rhs
+        );
+
+        friend const bigint_kernel_2 operator* (
+            uint16 lhs,
+            const bigint_kernel_2& rhs
+        );
+
+        friend const bigint_kernel_2 operator* (
+            const bigint_kernel_2& lhs,
+            uint16 rhs
+        );
+
+        bigint_kernel_2& operator*= (
+            uint16 rhs
+        );
+
+        friend const bigint_kernel_2 operator/ (
+            uint16 lhs,
+            const bigint_kernel_2& rhs
+        );
+
+        friend const bigint_kernel_2 operator/ (
+            const bigint_kernel_2& lhs,
+            uint16 rhs
+        );
+
+        bigint_kernel_2& operator/= (
+            uint16 rhs
+        );
+
+        friend const bigint_kernel_2 operator% (
+            uint16 lhs,
+            const bigint_kernel_2& rhs
+        );
+
+        friend const bigint_kernel_2 operator% (
+            const bigint_kernel_2& lhs,
+            uint16 rhs
+        );
+
+        bigint_kernel_2& operator%= (
+            uint16 rhs
+        );
+
+        friend bool operator < (
+            uint16 lhs,
+            const bigint_kernel_2& rhs
+        );
+
+        friend bool operator < (
+            const bigint_kernel_2& lhs,
+            uint16 rhs
+        );
+
+        friend bool operator == (
+            const bigint_kernel_2& lhs,
+            uint16 rhs
+        );
+
+        friend bool operator == (
+            uint16 lhs,
+            const bigint_kernel_2& rhs
+        );
+
+        bigint_kernel_2& operator= (
+            uint16 rhs
+        );
+
+
+        void swap (
+            bigint_kernel_2& item
+        ) { data_record* temp = data; data = item.data; item.data = temp; }
+
+
+    private:
+
+        typedef double t;
+        typedef std::complex<t> ct;
+
+        void fft(
+            ct* data, 
+            unsigned long len
+        ) const;
+        /*!
+            requires
+                - len == x^n for some integer n (i.e. len is a power of 2)
+                - len > 0
+            ensures
+                - #data == the FT decimation in frequency of data
+        !*/
+
+        void ifft(
+            ct* data, 
+            unsigned long len
+        ) const;
+        /*!
+            requires
+                - len == x^n for some integer n (i.e. len is a power of 2)
+                - len > 0
+            ensures
+                - #data == the inverse decimation in frequency of data. 
+                  (i.e. the inverse of what fft(data,len,-1) does to data)
+        !*/
+
+        void long_add (
+            const data_record* lhs,
+            const data_record* rhs,
+            data_record* result
+        ) const;
+        /*!
+            requires
+                - result->size >= max(lhs->digits_used,rhs->digits_used) + 1
+            ensures
+                - result == lhs + rhs
+        !*/
+
+        void long_sub (
+            const data_record* lhs,
+            const data_record* rhs,
+            data_record* result
+        ) const;
+        /*!
+            requires
+                - lhs >= rhs 
+                - result->size >= lhs->digits_used
+            ensures
+                - result == lhs - rhs
+        !*/
+
+        void long_div (
+            const data_record* lhs,
+            const data_record* rhs,
+            data_record* result,
+            data_record* remainder
+        ) const;
+        /*!
+            requires 
+                - rhs != 0 
+                - result->size >= lhs->digits_used 
+                - remainder->size >= lhs->digits_used 
+                - each parameter is unique (i.e. lhs != result, lhs != remainder, etc.)
+            ensures
+                - result == lhs / rhs
+                - remainder == lhs % rhs
+        !*/
+
+        void long_mul (
+            const data_record* lhs,
+            const data_record* rhs,
+            data_record* result
+        ) const;
+        /*!
+            requires
+                - result->size >= lhs->digits_used + rhs->digits_used 
+                - result != lhs 
+                - result != rhs
+            ensures
+                - result == lhs * rhs
+        !*/
+
+        void short_add (
+            const data_record* data,
+            uint16 value,
+            data_record* result            
+        ) const;
+        /*!
+            requires
+                - result->size >= data->size + 1
+            ensures
+                - result == data + value
+        !*/
+
+        void short_sub (
+            const data_record* data,
+            uint16 value,
+            data_record* result
+        ) const;
+        /*!
+            requires
+                - data >= value 
+                - result->size >= data->digits_used
+            ensures
+                - result == data - value
+        !*/
+
+        void short_mul (
+            const data_record* data,
+            uint16 value,
+            data_record* result            
+        ) const;
+        /*!
+            requires
+                - result->size >= data->digits_used + 1
+            ensures
+                - result == data * value
+        !*/
+
+        void short_div (
+            const data_record* data,            
+            uint16 value,
+            data_record* result,
+            uint16& remainder
+        ) const;
+        /*!
+            requires
+                - value != 0 
+                - result->size >= data->digits_used
+            ensures
+                - result = data*value 
+                - remainder = data%value
+        !*/
+
+        void shift_left (
+            const data_record* data,
+            data_record* result,
+            uint32 shift_amount
+        ) const;
+        /*!
+            requires
+                - result->size >= data->digits_used + shift_amount/8 + 1
+            ensures
+                - result == data << shift_amount
+        !*/
+
+        void shift_right (
+            const data_record* data,
+            data_record* result
+        ) const;
+        /*!
+            requires
+                - result->size >= data->digits_used 
+            ensures
+                - result == data >> 1
+        !*/
+
+        bool is_less_than (
+            const data_record* lhs,
+            const data_record* rhs
+        ) const;
+        /*! 
+            ensures
+                - returns true if lhs < rhs 
+                - returns false otherwise
+        !*/ 
+
+        bool is_equal_to (
+            const data_record* lhs,
+            const data_record* rhs
+        ) const;
+        /*!
+            ensures
+                - returns true if lhs == rhs 
+                - returns false otherwise
+        !*/
+
+        void increment (
+            const data_record* source,
+            data_record* dest
+        ) const;
+        /*!
+            requires
+                - dest->size >= source->digits_used + 1
+            ensures
+                - dest = source + 1
+        !*/
+
+        void decrement (
+            const data_record* source,
+            data_record* dest
+        ) const;
+        /*!
+            requires
+                source != 0
+            ensuers
+                dest = source - 1
+        !*/
+
+        // member data
+        const uint32 slack;
+        data_record* data;     
+        
+        
+
+    };
+
+    inline void swap (
+        bigint_kernel_2& a,
+        bigint_kernel_2& b
+    ) { a.swap(b); }
+
+    inline void serialize (
+        const bigint_kernel_2& item, 
+        std::ostream& out
+    )
+    { 
+        std::ios::fmtflags oldflags = out.flags();  
+        out << item << ' '; 
+        out.flags(oldflags); 
+        if (!out) throw serialization_error("Error serializing object of type bigint_kernel_c"); 
+    }   
+
+    inline void deserialize (
+        bigint_kernel_2& item, 
+        std::istream& in
+    ) 
+    { 
+        std::ios::fmtflags oldflags = in.flags();  
+        in >> item;
+        in.flags(oldflags); 
+        if (in.get() != ' ')
+        {
+            item = 0;
+            throw serialization_error("Error deserializing object of type bigint_kernel_c"); 
+        }
+    }   
+
+    inline bool operator>  (const bigint_kernel_2& a, const bigint_kernel_2& b) { return b < a; } 
+    inline bool operator!= (const bigint_kernel_2& a, const bigint_kernel_2& b) { return !(a == b); }
+    inline bool operator<= (const bigint_kernel_2& a, const bigint_kernel_2& b) { return !(b < a); }
+    inline bool operator>= (const bigint_kernel_2& a, const bigint_kernel_2& b) { return !(a < b); }
+
+}
+
+#ifdef NO_MAKEFILE
+#include "bigint_kernel_2.cpp"
+#endif
+
+#endif // DLIB_BIGINT_KERNEl_2_
+

dlibs/dlib/bigint/bigint_kernel_abstract.h

@@ -0,0 +1,670 @@
+// Copyright (C) 2003  Davis E. King ([email protected])
+// License: Boost Software License   See LICENSE.txt for the full license.
+#undef DLIB_BIGINT_KERNEl_ABSTRACT_
+#ifdef DLIB_BIGINT_KERNEl_ABSTRACT_
+
+#include <iosfwd>
+#include "../algs.h"
+#include "../serialize.h"
+#include "../uintn.h"
+
+namespace dlib
+{
+
+    class bigint 
+    {
+        /*!
+            INITIAL VALUE
+                *this == 0
+
+            WHAT THIS OBJECT REPRESENTS
+                This object represents an arbitrary precision unsigned integer
+
+                the following operators are supported:
+                operator +
+                operator +=
+                operator -
+                operator -=
+                operator *
+                operator *=
+                operator /
+                operator /=
+                operator %
+                operator %=
+                operator ==
+                operator <
+                operator =
+                operator << (for writing to ostreams)
+                operator >> (for reading from istreams)
+                operator++       // pre increment
+                operator++(int)  // post increment
+                operator--       // pre decrement
+                operator--(int)  // post decrement
+
+
+                the other comparison operators(>, !=, <=, and >=) are 
+                available and come from the templates in dlib::relational_operators
+
+            THREAD SAFETY
+                bigint may be reference counted so it is very unthread safe.
+                use with care in a multithreaded program
+
+        !*/
+
+    public:
+
+        bigint (
+        );
+        /*!
+            ensures
+                - #*this is properly initialized
+            throws
+                - std::bad_alloc
+                    if this is thrown the bigint will be unusable but 
+                    will not leak memory
+        !*/
+
+        bigint (
+            uint32 value
+        );
+        /*!
+            requires
+                - value <= (2^32)-1
+            ensures
+                - #*this is properly initialized
+                - #*this == value
+            throws
+                - std::bad_alloc
+                    if this is thrown the bigint will be unusable but 
+                    will not leak memory
+        !*/
+
+        bigint (
+            const bigint& item
+        );
+        /*!
+            ensures
+                - #*this is properly initialized 
+                - #*this == value
+            throws
+                - std::bad_alloc
+                    if this is thrown the bigint will be unusable but 
+                    will not leak memory
+        !*/
+
+        virtual ~bigint (
+        );
+        /*!
+            ensures
+                - all resources associated with #*this have been released
+        !*/
+
+        const bigint operator+ (
+            const bigint& rhs
+        ) const;
+        /*!
+            ensures
+                - returns the result of adding rhs to *this
+            throws
+                - std::bad_alloc
+                    if this function throws then it has no effect
+        !*/
+
+        bigint& operator+= (
+            const bigint& rhs
+        );
+        /*!
+            ensures
+                - #*this == *this + rhs
+                - returns #*this
+            throws
+                - std::bad_alloc
+                    if this function throws then it has no effect                                        
+        !*/
+
+        const bigint operator- (
+            const bigint& rhs
+        ) const;
+        /*!
+            requires
+                - *this >= rhs
+            ensures
+                - returns the result of subtracting rhs from *this
+            throws
+                - std::bad_alloc
+                    if this function throws then it has no effect
+        !*/
+
+        bigint& operator-= (
+            const bigint& rhs
+        );
+        /*!
+            requires
+                - *this >= rhs            
+            ensures
+                - #*this == *this - rhs
+                - returns #*this
+            throws
+                - std::bad_alloc
+                    if this function throws then it has no effect
+        !*/
+
+        const bigint operator* (
+            const bigint& rhs
+        ) const;
+        /*!
+            ensures
+                - returns the result of multiplying *this and rhs
+            throws
+                - std::bad_alloc
+                    if this function throws then it has no effect
+        !*/
+
+        bigint& operator*= (
+            const bigint& rhs
+        );
+        /*!
+            ensures
+                - #*this == *this * rhs
+                - returns #*this
+            throws
+                - std::bad_alloc
+                    if this function throws then it has no effect
+        !*/
+
+        const bigint operator/ (
+            const bigint& rhs
+        ) const;
+        /*!
+            requires
+                - rhs != 0
+            ensures
+                - returns the result of dividing *this by rhs
+            throws
+                - std::bad_alloc
+                    if this function throws then it has no effect
+        !*/
+
+        bigint& operator/= (
+            const bigint& rhs
+        );
+        /*!
+            requires
+                - rhs != 0
+            ensures
+                - #*this == *this / rhs
+                - returns #*this
+            throws
+                - std::bad_alloc
+                    if this function throws then it has no effect
+        !*/
+
+        const bigint operator% (
+            const bigint& rhs
+        ) const;
+        /*!
+            requires
+                - rhs != 0
+            ensures
+                - returns the result of *this mod rhs
+            throws
+                - std::bad_alloc
+                    if this function throws then it has no effect
+        !*/
+
+        bigint& operator%= (
+            const bigint& rhs
+        );
+        /*!
+            requires
+                - rhs != 0
+            ensures
+                - #*this == *this % rhs
+                - returns #*this
+            throws
+                - std::bad_alloc
+                    if this function throws then it has no effect
+        !*/
+
+        bool operator < (
+            const bigint& rhs
+        ) const;
+        /*!
+            ensures
+                - returns true if *this is less than rhs 
+                - returns false otherwise
+        !*/
+
+        bool operator == (
+            const bigint& rhs
+        ) const;
+        /*!
+            ensures
+                - returns true if *this and rhs represent the same number 
+                - returns false otherwise
+        !*/
+
+        bigint& operator= (
+            const bigint& rhs
+        );
+        /*!
+            ensures
+                - #*this == rhs
+            throws
+                - std::bad_alloc
+                    if this function throws then it has no effect
+        !*/
+
+
+        friend std::ostream& operator<< (
+            std::ostream& out,
+            const bigint& rhs
+        );
+        /*!
+            ensures
+                - the number in *this has been written to #out as a base ten number
+            throws
+                - std::bad_alloc
+                    if this function throws then it has no effect (nothing
+                    is written to out)
+        !*/
+
+        friend std::istream& operator>> (
+            std::istream& in,
+            bigint& rhs
+        );
+        /*!
+            ensures
+                - reads a number from in and puts it into #*this 
+                - if (there is no positive base ten number on the input stream ) then 
+                    - #in.fail() == true
+            throws
+                - std::bad_alloc
+                    if this function throws the value in rhs is undefined and some
+                    characters may have been read from in.  rhs is still usable though,
+                    its value is just unknown.
+        !*/
+
+
+        bigint& operator++ (
+        );
+        /*!
+            ensures
+                - #*this == *this + 1 
+                - returns #*this
+            throws
+                - std::bad_alloc
+                    if this function throws then it has no effect
+        !*/
+
+        const bigint operator++ (
+            int
+        );
+        /*!
+            ensures
+                - #*this == *this + 1
+                - returns *this
+            throws
+                - std::bad_alloc
+                    if this function throws then it has no effect
+        !*/
+
+        bigint& operator-- (
+        );
+        /*! 
+            requires
+                - *this != 0
+            ensures
+                - #*this == *this - 1
+                - returns #*this
+            throws
+                - std::bad_alloc
+                    if this function throws then it has no effect
+        !*/
+
+        const bigint operator-- (
+            int
+        );
+        /*!
+            requires
+                - *this != 0
+            ensures
+                - #*this == *this - 1
+                - returns *this
+            throws
+                - std::bad_alloc
+                    if this function throws then it has no effect
+        !*/
+
+        void swap (
+            bigint& item
+        );
+        /*!
+            ensures
+                - swaps *this and item
+        !*/ 
+
+
+        // ------------------------------------------------------------------
+        // ----    The following functions are identical to the above   -----
+        // ----  but take uint16 as one of their arguments. They  ---
+        // ----  exist only to allow for a more efficient implementation  ---
+        // ------------------------------------------------------------------
+
+
+        friend const bigint operator+ (
+            uint16 lhs,
+            const bigint& rhs
+        );
+        /*!
+            requires
+                - lhs <= 65535
+            ensures
+                - returns the result of adding rhs to lhs
+            throws
+                - std::bad_alloc
+                    if this function throws then it has no effect
+        !*/
+
+        friend const bigint operator+ (
+            const bigint& lhs,
+            uint16 rhs
+        );
+        /*!
+            requires
+                - rhs <= 65535
+            ensures
+                - returns the result of adding rhs to lhs
+            throws
+                - std::bad_alloc
+                    if this function throws then it has no effect
+        !*/
+
+        bigint& operator+= (
+            uint16 rhs
+        );
+        /*!
+            requires
+                - rhs <= 65535
+            ensures
+                - #*this == *this + rhs                
+                - returns #this
+            throws
+                - std::bad_alloc
+                    if this function throws then it has no effect
+        !*/
+
+        friend const bigint operator- (
+            uint16 lhs,
+            const bigint& rhs
+        );
+        /*!
+            requires
+                - lhs >= rhs 
+                - lhs <= 65535
+            ensures
+                - returns the result of subtracting rhs from lhs
+            throws
+                - std::bad_alloc
+                    if this function throws then it has no effect
+        !*/
+
+        friend const bigint operator- (
+            const bigint& lhs,
+            uint16 rhs
+        );
+        /*!
+            requires
+                - lhs >= rhs 
+                - rhs <= 65535
+            ensures
+                - returns the result of subtracting rhs from lhs
+            throws
+                - std::bad_alloc
+                    if this function throws then it has no effect
+        !*/
+
+        bigint& operator-= (
+            uint16 rhs
+        );
+        /*!
+            requires
+                - *this >= rhs 
+                - rhs <= 65535
+            ensures
+                - #*this == *this - rhs
+                - returns #*this
+            throws
+                - std::bad_alloc
+                    if this function throws then it has no effect
+        !*/
+
+        friend const bigint operator* (
+            uint16 lhs,
+            const bigint& rhs
+        );
+        /*!
+            requires
+                - lhs <= 65535
+            ensures
+                - returns the result of multiplying lhs and rhs
+            throws
+                - std::bad_alloc
+                    if this function throws then it has no effect
+        !*/
+
+        friend const bigint operator* (
+            const bigint& lhs,
+            uint16 rhs
+        );
+        /*!
+            requires
+                - rhs <= 65535
+            ensures
+                - returns the result of multiplying lhs and rhs
+            throws
+                - std::bad_alloc
+                    if this function throws then it has no effect
+        !*/
+
+        bigint& operator*= (
+            uint16 rhs
+        );
+        /*!
+            requires
+                - rhs <= 65535
+            ensures
+                - #*this == *this * rhs
+                - returns #*this
+            throws
+                - std::bad_alloc
+                    if this function throws then it has no effect
+        !*/
+
+        friend const bigint operator/ (
+            uint16 lhs,
+            const bigint& rhs
+        );
+        /*!
+            requires
+                - rhs != 0 
+                - lhs <= 65535
+            ensures
+                - returns the result of dividing lhs by rhs
+            throws
+                - std::bad_alloc
+                    if this function throws then it has no effect
+        !*/
+
+        friend const bigint operator/ (
+            const bigint& lhs,
+            uint16 rhs
+        );
+        /*!
+            requires
+                - rhs != 0 
+                - rhs <= 65535
+            ensures
+                - returns the result of dividing lhs by rhs
+            throws
+                - std::bad_alloc
+                    if this function throws then it has no effect
+        !*/
+
+        bigint& operator/= (
+            uint16 rhs
+        );
+        /*!
+            requires
+                - rhs != 0 
+                - rhs <= 65535
+            ensures
+                - #*this == *this / rhs
+                - returns #*this
+            throws
+                - std::bad_alloc
+                    if this function throws then it has no effect
+        !*/
+
+        friend const bigint operator% (
+            uint16 lhs,
+            const bigint& rhs
+        );
+        /*!
+            requires
+                - rhs != 0 
+                - lhs <= 65535
+            ensures
+                - returns the result of lhs mod rhs
+            throws
+                - std::bad_alloc
+                    if this function throws then it has no effect
+        !*/
+
+        friend const bigint operator% (
+            const bigint& lhs,
+            uint16 rhs
+        );
+        /*!
+            requires
+                - rhs != 0 
+                - rhs <= 65535
+            ensures
+                - returns the result of lhs mod rhs
+            throws
+                - std::bad_alloc
+                    if this function throws then it has no effect
+        !*/
+
+        bigint& operator%= (
+            uint16 rhs
+        );
+        /*!
+            requires
+                - rhs != 0 
+                - rhs <= 65535
+            ensures
+                - #*this == *this % rhs
+                - returns #*this
+            throws
+                - std::bad_alloc
+                    if this function throws then it has no effect
+        !*/
+
+
+        friend bool operator < (
+            uint16 lhs,
+            const bigint& rhs
+        );
+        /*!
+            requires
+                - lhs <= 65535
+            ensures
+                - returns true if lhs is less than rhs 
+                - returns false otherwise
+        !*/
+
+        friend bool operator < (
+            const bigint& lhs,
+            uint16 rhs
+        );
+        /*!
+            requires
+                - rhs <= 65535
+            ensures
+                - returns true if lhs is less than rhs 
+                - returns false otherwise
+        !*/
+
+        friend bool operator == (
+            const bigint& lhs,
+            uint16 rhs
+        );
+        /*!
+            requires
+                - rhs <= 65535
+            ensures
+                - returns true if lhs and rhs represent the same number 
+                - returns false otherwise
+        !*/
+
+        friend bool operator == (
+            uint16 lhs,
+            const bigint& rhs
+        );
+        /*!
+            requires
+                - lhs <= 65535
+            ensures
+                - returns true if lhs and rhs represent the same number 
+                - returns false otherwise
+        !*/
+
+        bigint& operator= (
+            uint16 rhs
+        );
+        /*!
+            requires
+                - rhs <= 65535
+            ensures
+                - #*this == rhs
+                - returns #*this
+            throws
+                - std::bad_alloc
+                    if this function throws then it has no effect
+        !*/
+
+    };   
+   
+    inline void swap (
+        bigint& a, 
+        bigint& b 
+    ) { a.swap(b); }   
+    /*!
+        provides a global swap function
+    !*/
+
+    void serialize (
+        const bigint& item, 
+        std::istream& in
+    );   
+    /*!
+        provides serialization support 
+    !*/
+
+    void deserialize (
+        bigint& item, 
+        std::istream& in
+    );   
+    /*!
+        provides deserialization support 
+    !*/
+
+    inline bool operator>  (const bigint& a, const bigint& b) { return b < a; } 
+    inline bool operator!= (const bigint& a, const bigint& b) { return !(a == b); }
+    inline bool operator<= (const bigint& a, const bigint& b) { return !(b < a); }
+    inline bool operator>= (const bigint& a, const bigint& b) { return !(a < b); }
+}
+
+#endif // DLIB_BIGINT_KERNEl_ABSTRACT_
+

dlibs/dlib/bigint/bigint_kernel_c.h

@@ -0,0 +1,1140 @@
+// Copyright (C) 2003  Davis E. King ([email protected])
+// License: Boost Software License   See LICENSE.txt for the full license.
+#ifndef DLIB_BIGINT_KERNEl_C_
+#define DLIB_BIGINT_KERNEl_C_
+
+#include "bigint_kernel_abstract.h"
+#include "../algs.h"
+#include "../assert.h"
+#include <iostream>
+
+namespace dlib
+{
+
+// ----------------------------------------------------------------------------------------
+
+    template <
+        typename bigint_base
+        >
+    class bigint_kernel_c 
+    {
+        bigint_base data;
+
+        explicit bigint_kernel_c (
+            const bigint_base& item
+        ) : data(item) {}
+
+    public:
+
+
+        bigint_kernel_c (
+        );
+
+        bigint_kernel_c (
+            uint32 value
+        );
+
+        bigint_kernel_c (
+            const bigint_kernel_c<bigint_base>& item
+        );
+
+        ~bigint_kernel_c (
+        );
+
+        const bigint_kernel_c<bigint_base> operator+ (
+            const bigint_kernel_c<bigint_base>& rhs
+        ) const;
+
+        bigint_kernel_c<bigint_base>& operator+= (
+            const bigint_kernel_c<bigint_base>& rhs
+        );
+
+        const bigint_kernel_c<bigint_base> operator- (
+            const bigint_kernel_c<bigint_base>& rhs
+        ) const;
+        bigint_kernel_c<bigint_base>& operator-= (
+            const bigint_kernel_c<bigint_base>& rhs
+        );
+
+        const bigint_kernel_c<bigint_base> operator* (
+            const bigint_kernel_c<bigint_base>& rhs
+        ) const;
+
+        bigint_kernel_c<bigint_base>& operator*= (
+            const bigint_kernel_c<bigint_base>& rhs
+        );
+
+        const bigint_kernel_c<bigint_base> operator/ (
+            const bigint_kernel_c<bigint_base>& rhs
+        ) const;
+
+        bigint_kernel_c<bigint_base>& operator/= (
+            const bigint_kernel_c<bigint_base>& rhs
+        );
+
+        const bigint_kernel_c<bigint_base> operator% (
+            const bigint_kernel_c<bigint_base>& rhs
+        ) const;
+
+        bigint_kernel_c<bigint_base>& operator%= (
+            const bigint_kernel_c<bigint_base>& rhs
+        );
+
+        bool operator < (
+            const bigint_kernel_c<bigint_base>& rhs
+        ) const;
+
+        bool operator == (
+            const bigint_kernel_c<bigint_base>& rhs
+        ) const;
+
+        bigint_kernel_c<bigint_base>& operator= (
+            const bigint_kernel_c<bigint_base>& rhs
+        );
+
+        template <typename T>
+        friend std::ostream& operator<< (
+            std::ostream& out,
+            const bigint_kernel_c<T>& rhs
+        );
+
+        template <typename T>
+        friend std::istream& operator>>  (
+            std::istream& in,
+            bigint_kernel_c<T>& rhs
+        );
+
+        bigint_kernel_c<bigint_base>& operator++ (
+        );
+
+        const bigint_kernel_c<bigint_base> operator++ (
+            int
+        );
+
+        bigint_kernel_c<bigint_base>& operator-- (
+        );
+
+        const bigint_kernel_c<bigint_base> operator-- (
+            int
+        );
+
+        template <typename T>
+        friend const bigint_kernel_c<T> operator+  (
+            uint16 lhs,
+            const bigint_kernel_c<T>& rhs
+        );
+
+        template <typename T>
+        friend const bigint_kernel_c<T> operator+  (
+            const bigint_kernel_c<T>& lhs,
+            uint16 rhs
+        );
+
+        bigint_kernel_c<bigint_base>& operator+= (
+            uint16 rhs
+        );
+
+        template <typename T>
+        friend const bigint_kernel_c<T> operator-  (
+            uint16 lhs,
+            const bigint_kernel_c<T>& rhs
+        );
+
+        template <typename T>
+        friend const bigint_kernel_c<T> operator-  (
+            const bigint_kernel_c<T>& lhs,
+            uint16 rhs
+        );
+
+        bigint_kernel_c<bigint_base>& operator-= (
+            uint16 rhs
+        );
+
+        template <typename T>
+        friend const bigint_kernel_c<T> operator*  (
+            uint16 lhs,
+            const bigint_kernel_c<T>& rhs
+        );
+
+        template <typename T>
+        friend const bigint_kernel_c<T> operator*  (
+            const bigint_kernel_c<T>& lhs,
+            uint16 rhs
+        );
+
+        bigint_kernel_c<bigint_base>& operator*= (
+            uint16 rhs
+        );
+
+        template <typename T>
+        friend const bigint_kernel_c<T> operator/  (
+            uint16 lhs,
+            const bigint_kernel_c<T>& rhs
+        );
+
+        template <typename T>
+        friend const bigint_kernel_c<T> operator/  (
+            const bigint_kernel_c<T>& lhs,
+            uint16 rhs
+        );
+
+        bigint_kernel_c<bigint_base>& operator/= (
+            uint16 rhs
+        );
+
+        template <typename T>
+        friend const bigint_kernel_c<T> operator%  (
+            uint16 lhs,
+            const bigint_kernel_c<T>& rhs
+        );
+
+        template <typename T>
+        friend const bigint_kernel_c<T> operator%  (
+            const bigint_kernel_c<T>& lhs,
+            uint16 rhs
+        );
+
+        bigint_kernel_c<bigint_base>& operator%= (
+            uint16 rhs
+        );
+
+        template <typename T>
+        friend bool operator <  (
+            uint16 lhs,
+            const bigint_kernel_c<T>& rhs
+        );
+
+        template <typename T>
+        friend bool operator <  (
+            const bigint_kernel_c<T>& lhs,
+            uint16 rhs
+        );
+
+        template <typename T>
+        friend bool operator ==  (
+            const bigint_kernel_c<T>& lhs,
+            uint16 rhs
+        );
+
+        template <typename T>
+        friend bool operator ==  (
+            uint16 lhs,
+            const bigint_kernel_c<T>& rhs
+        );
+
+        bigint_kernel_c<bigint_base>& operator= (
+            uint16 rhs
+        );
+
+
+        void swap (
+            bigint_kernel_c<bigint_base>& item
+        ) { data.swap(item.data); }
+
+    };
+
+    template <
+        typename bigint_base
+        >
+    void swap (
+        bigint_kernel_c<bigint_base>& a,
+        bigint_kernel_c<bigint_base>& b
+    ) { a.swap(b); }
+
+
+// ----------------------------------------------------------------------------------------
+
+    template <
+        typename bigint_base
+        >
+    inline void serialize (
+        const bigint_kernel_c<bigint_base>& item, 
+        std::ostream& out
+    )
+    { 
+        std::ios::fmtflags oldflags = out.flags();  
+        out << item << ' '; 
+        out.flags(oldflags); 
+        if (!out) throw serialization_error("Error serializing object of type bigint_kernel_c"); 
+    }   
+
+    template <
+        typename bigint_base
+        >
+    inline void deserialize (
+        bigint_kernel_c<bigint_base>& item, 
+        std::istream& in
+    ) 
+    { 
+        std::ios::fmtflags oldflags = in.flags();  
+        in >> item;
+        in.flags(oldflags); 
+        if (in.get() != ' ') 
+        {
+            item = 0;
+            throw serialization_error("Error deserializing object of type bigint_kernel_c"); 
+        }
+    }   
+
+// ----------------------------------------------------------------------------------------
+// ----------------------------------------------------------------------------------------
+    // member function definitions
+// ----------------------------------------------------------------------------------------
+// ----------------------------------------------------------------------------------------
+
+    template <
+        typename bigint_base
+        >
+    bigint_kernel_c<bigint_base>::
+    bigint_kernel_c (
+    )
+    {}
+
+// ----------------------------------------------------------------------------------------
+
+    template <
+        typename bigint_base
+        >
+    bigint_kernel_c<bigint_base>::
+    bigint_kernel_c (
+        uint32 value
+    ) : 
+        data(value)
+    {
+        // make sure requires clause is not broken
+        DLIB_CASSERT( value <= 0xFFFFFFFF ,
+            "\tbigint::bigint(uint16)"
+            << "\n\t value must be <= (2^32)-1"
+            << "\n\tthis:  " << this
+            << "\n\tvalue:   " << value
+            );        
+    }
+
+// ----------------------------------------------------------------------------------------
+
+    template <
+        typename bigint_base
+        >
+    bigint_kernel_c<bigint_base>::
+    bigint_kernel_c (
+        const bigint_kernel_c<bigint_base>& item
+    ) :
+        data(item.data)
+    {}
+
+// ----------------------------------------------------------------------------------------
+
+    template <
+        typename bigint_base
+        >
+    bigint_kernel_c<bigint_base>::
+    ~bigint_kernel_c (
+    )
+    {}
+
+// ----------------------------------------------------------------------------------------
+
+    template <
+        typename bigint_base
+        >
+    const bigint_kernel_c<bigint_base> bigint_kernel_c<bigint_base>::
+    operator+ (
+        const bigint_kernel_c<bigint_base>& rhs
+    ) const
+    {
+        return bigint_kernel_c<bigint_base>(data + rhs.data);
+    }
+
+// ----------------------------------------------------------------------------------------
+
+    template <
+        typename bigint_base
+        >
+    bigint_kernel_c<bigint_base>& bigint_kernel_c<bigint_base>::
+    operator+= (
+        const bigint_kernel_c<bigint_base>& rhs
+    )
+    {
+        data += rhs.data;
+        return *this;
+    }
+
+// ----------------------------------------------------------------------------------------
+
+    template <
+        typename bigint_base
+        >
+    const bigint_kernel_c<bigint_base> bigint_kernel_c<bigint_base>::
+    operator- (
+        const bigint_kernel_c<bigint_base>& rhs
+    ) const
+    {
+        // make sure requires clause is not broken
+        DLIB_CASSERT( !(*this < rhs),
+            "\tconst bigint bigint::operator-(const bigint&)"
+            << "\n\t *this should not be less than rhs"
+            << "\n\tthis:  " << this
+            << "\n\t*this: " << *this 
+            << "\n\trhs:   " << rhs
+            );
+
+        // call the real function
+        return bigint_kernel_c<bigint_base>(data-rhs.data);
+    }
+
+// ----------------------------------------------------------------------------------------
+
+    template <
+        typename bigint_base
+        >
+    bigint_kernel_c<bigint_base>& bigint_kernel_c<bigint_base>::
+    operator-= (
+        const bigint_kernel_c<bigint_base>& rhs
+    )
+    {
+        // make sure requires clause is not broken
+        DLIB_CASSERT( !(*this < rhs),
+            "\tbigint& bigint::operator-=(const bigint&)"
+            << "\n\t *this should not be less than rhs"
+            << "\n\tthis:  " << this
+            << "\n\t*this: " << *this 
+            << "\n\trhs:   " << rhs
+            );
+
+        // call the real function
+        data -= rhs.data;
+        return *this;
+    }
+
+// ----------------------------------------------------------------------------------------
+
+    template <
+        typename bigint_base
+        >
+    const bigint_kernel_c<bigint_base> bigint_kernel_c<bigint_base>::
+    operator* (
+        const bigint_kernel_c<bigint_base>& rhs
+    ) const
+    {
+        return bigint_kernel_c<bigint_base>(data * rhs.data );
+    }
+
+// ----------------------------------------------------------------------------------------
+
+    template <
+        typename bigint_base
+        >
+    bigint_kernel_c<bigint_base>& bigint_kernel_c<bigint_base>::
+    operator*= (
+        const bigint_kernel_c<bigint_base>& rhs
+    )
+    {
+        data *= rhs.data;
+        return *this;
+    }
+
+// ----------------------------------------------------------------------------------------
+
+    template <
+        typename bigint_base
+        >
+    const bigint_kernel_c<bigint_base> bigint_kernel_c<bigint_base>::
+    operator/ (
+        const bigint_kernel_c<bigint_base>& rhs
+    ) const
+    {
+        //make sure requires clause is not broken
+        DLIB_CASSERT( !(rhs == 0),
+            "\tconst bigint bigint::operator/(const bigint&)"
+            << "\n\t can't divide by zero"
+            << "\n\tthis:  " << this
+            );
+
+        // call the real function
+        return bigint_kernel_c<bigint_base>(data/rhs.data);
+    }
+
+// ----------------------------------------------------------------------------------------
+
+    template <
+        typename bigint_base
+        >
+    bigint_kernel_c<bigint_base>& bigint_kernel_c<bigint_base>::
+    operator/= (
+        const bigint_kernel_c<bigint_base>& rhs
+    )
+    {
+        // make sure requires clause is not broken
+        DLIB_CASSERT( !(rhs == 0),
+            "\tbigint& bigint::operator/=(const bigint&)"
+            << "\n\t can't divide by zero"
+            << "\n\tthis:  " << this
+            );
+
+        // call the real function
+        data /= rhs.data;
+        return *this;
+    }
+
+// ----------------------------------------------------------------------------------------
+
+    template <
+        typename bigint_base
+        >
+    const bigint_kernel_c<bigint_base> bigint_kernel_c<bigint_base>::
+    operator% (
+        const bigint_kernel_c<bigint_base>& rhs
+    ) const
+    {
+        // make sure requires clause is not broken
+        DLIB_CASSERT( !(rhs == 0),
+            "\tconst bigint bigint::operator%(const bigint&)"
+            << "\n\t can't divide by zero"
+            << "\n\tthis:  " << this
+            );
+
+        // call the real function
+        return bigint_kernel_c<bigint_base>(data%rhs.data);
+    }
+
+// ----------------------------------------------------------------------------------------
+
+    template <
+        typename bigint_base
+        >
+    bigint_kernel_c<bigint_base>& bigint_kernel_c<bigint_base>::
+    operator%= (
+        const bigint_kernel_c<bigint_base>& rhs
+    )
+    {
+        // make sure requires clause is not broken
+        DLIB_CASSERT( !(rhs == 0),
+            "\tbigint& bigint::operator%=(const bigint&)"
+            << "\n\t can't divide by zero"
+            << "\n\tthis:  " << this
+            );
+
+        // call the real function
+        data %= rhs.data;
+        return *this;
+    }
+
+// ----------------------------------------------------------------------------------------
+
+    template <
+        typename bigint_base
+        >
+    bool bigint_kernel_c<bigint_base>::
+    operator < (
+        const bigint_kernel_c<bigint_base>& rhs
+    ) const
+    {
+        return data < rhs.data;
+    }
+
+// ----------------------------------------------------------------------------------------
+
+    template <
+        typename bigint_base
+        >
+    bool bigint_kernel_c<bigint_base>::
+    operator == (
+        const bigint_kernel_c<bigint_base>& rhs
+    ) const
+    {
+        return data == rhs.data;
+    }
+
+// ----------------------------------------------------------------------------------------
+
+    template <
+        typename bigint_base
+        >
+    bigint_kernel_c<bigint_base>& bigint_kernel_c<bigint_base>::
+    operator= (
+        const bigint_kernel_c<bigint_base>& rhs
+    )
+    {
+        data = rhs.data;
+        return *this;
+    }
+
+// ----------------------------------------------------------------------------------------
+
+    template <
+        typename bigint_base
+        >
+    std::ostream& operator<< (
+        std::ostream& out,
+        const bigint_kernel_c<bigint_base>& rhs
+    )
+    {
+        out << rhs.data;
+        return out;
+    }
+
+// ----------------------------------------------------------------------------------------
+
+    template <
+        typename bigint_base
+        >
+    std::istream& operator>> (
+        std::istream& in,
+        bigint_kernel_c<bigint_base>& rhs
+    )
+    {
+        in >> rhs.data;
+        return in;
+    }
+
+// ----------------------------------------------------------------------------------------
+
+    template <
+        typename bigint_base
+        >
+    bigint_kernel_c<bigint_base>& bigint_kernel_c<bigint_base>::
+    operator++ (
+    )
+    {
+        ++data;
+        return *this;
+    }
+
+// ----------------------------------------------------------------------------------------
+
+    template <
+        typename bigint_base
+        >
+    const bigint_kernel_c<bigint_base> bigint_kernel_c<bigint_base>::
+    operator++ (
+        int
+    )
+    {
+        return bigint_kernel_c<bigint_base>(data++);
+    }
+
+// ----------------------------------------------------------------------------------------
+
+    template <
+        typename bigint_base
+        >
+    bigint_kernel_c<bigint_base>& bigint_kernel_c<bigint_base>::
+    operator-- (
+    )
+    {
+        // make sure requires clause is not broken
+        DLIB_CASSERT( !(*this == 0),
+            "\tbigint& bigint::operator--()"
+            << "\n\t *this to subtract from *this it must not be zero to begin with"
+            << "\n\tthis:  " << this
+            );
+
+        // call the real function
+        --data;
+        return *this;
+    }
+
+// ----------------------------------------------------------------------------------------
+
+    template <
+        typename bigint_base
+        >
+    const bigint_kernel_c<bigint_base> bigint_kernel_c<bigint_base>::
+    operator-- (
+        int
+    )
+    {
+        // make sure requires clause is not broken
+        DLIB_CASSERT( !(*this == 0),
+            "\tconst bigint bigint::operator--(int)"
+            << "\n\t *this to subtract from *this it must not be zero to begin with"
+            << "\n\tthis:  " << this
+            );
+
+        // call the real function
+        return bigint_kernel_c<bigint_base>(data--);
+    }
+
+// ----------------------------------------------------------------------------------------
+
+    template <
+        typename bigint_base
+        >
+    const bigint_kernel_c<bigint_base> operator+ (
+        uint16 l,
+        const bigint_kernel_c<bigint_base>& rhs
+    )
+    {
+        uint32 lhs = l;
+        // make sure requires clause is not broken
+        DLIB_CASSERT( lhs <= 65535,
+            "\tconst bigint operator+(uint16, const bigint&)"
+            << "\n\t lhs must be <= 65535"
+            << "\n\trhs:   " << rhs
+            << "\n\tlhs:   " << lhs
+            );
+
+        return bigint_kernel_c<bigint_base>(static_cast<uint16>(lhs)+rhs.data);
+    }
+
+// ----------------------------------------------------------------------------------------
+
+    template <
+        typename bigint_base
+        >
+    const bigint_kernel_c<bigint_base> operator+ (
+        const bigint_kernel_c<bigint_base>& lhs,
+        uint16 r
+    )
+    {
+        uint32 rhs = r;
+        // make sure requires clause is not broken
+        DLIB_CASSERT( rhs <= 65535,
+            "\tconst bigint operator+(const bigint&, uint16)"
+            << "\n\t rhs must be <= 65535"
+            << "\n\trhs:   " << rhs
+            << "\n\tlhs:   " << lhs
+            );
+
+        return bigint_kernel_c<bigint_base>(lhs.data+static_cast<uint16>(rhs));
+    }
+
+// ----------------------------------------------------------------------------------------
+
+    template <
+        typename bigint_base
+        >
+    bigint_kernel_c<bigint_base>& bigint_kernel_c<bigint_base>::
+    operator+= (
+        uint16 r
+    )
+    {
+        uint32 rhs = r;
+        // make sure requires clause is not broken
+        DLIB_CASSERT( rhs <= 65535,
+            "\tbigint& bigint::operator+=(uint16)"
+            << "\n\t rhs must be <= 65535"
+            << "\n\tthis:  " << this
+            << "\n\t*this: " << *this 
+            << "\n\trhs:   " << rhs
+            );
+
+        data += rhs;
+        return *this;
+    }
+
+// ----------------------------------------------------------------------------------------
+
+    template <
+        typename bigint_base
+        >
+    const bigint_kernel_c<bigint_base> operator- (
+        uint16 l,
+        const bigint_kernel_c<bigint_base>& rhs
+    )
+    {
+        uint32 lhs = l;
+        // make sure requires clause is not broken
+        DLIB_CASSERT( !(static_cast<uint16>(lhs) < rhs) && lhs <= 65535,
+            "\tconst bigint operator-(uint16,const bigint&)"
+            << "\n\t lhs must be greater than or equal to rhs and lhs <= 65535"
+            << "\n\tlhs:   " << lhs
+            << "\n\trhs:   " << rhs
+            << "\n\t&lhs:  " << &lhs
+            << "\n\t&rhs:  " << &rhs
+            );
+
+        // call the real function
+        return bigint_kernel_c<bigint_base>(static_cast<uint16>(lhs)-rhs.data);
+    }
+
+// ----------------------------------------------------------------------------------------
+
+    template <
+        typename bigint_base
+        >
+    const bigint_kernel_c<bigint_base> operator- (
+        const bigint_kernel_c<bigint_base>& lhs,
+        uint16 r
+    )
+    {
+        uint32 rhs = r;
+        // make sure requires clause is not broken
+        DLIB_CASSERT( !(lhs < static_cast<uint16>(rhs)) && rhs <= 65535,
+            "\tconst bigint operator-(const bigint&,uint16)"
+            << "\n\t lhs must be greater than or equal to rhs and rhs <= 65535"
+            << "\n\tlhs:   " << lhs
+            << "\n\trhs:   " << rhs
+            << "\n\t&lhs:  " << &lhs
+            << "\n\t&rhs:  " << &rhs
+            );
+
+        // call the real function
+        return bigint_kernel_c<bigint_base>(lhs.data-static_cast<uint16>(rhs));
+    }
+
+// ----------------------------------------------------------------------------------------
+
+    template <
+        typename bigint_base
+        >
+    bigint_kernel_c<bigint_base>& bigint_kernel_c<bigint_base>::
+    operator-= (
+        uint16 r
+    )
+    {
+        uint32 rhs = r;
+        // make sure requires clause is not broken
+        DLIB_CASSERT( !(*this < static_cast<uint16>(rhs)) && rhs <= 65535,
+            "\tbigint& bigint::operator-=(uint16)"
+            << "\n\t *this must not be less than rhs and rhs <= 65535"
+            << "\n\tthis:  " << this
+            << "\n\t*this: " << *this
+            << "\n\trhs:   " << rhs
+            );
+
+        // call the real function
+        data -= static_cast<uint16>(rhs);
+        return *this;
+    }
+
+// ----------------------------------------------------------------------------------------
+
+    template <
+        typename bigint_base
+        >
+    const bigint_kernel_c<bigint_base> operator* (
+        uint16 l,
+        const bigint_kernel_c<bigint_base>& rhs
+    )
+    {
+        uint32 lhs = l;
+        // make sure requires clause is not broken
+        DLIB_CASSERT( lhs <= 65535,
+            "\tconst bigint operator*(uint16, const bigint&)"
+            << "\n\t lhs must be <= 65535"
+            << "\n\trhs:   " << rhs
+            << "\n\tlhs:   " << lhs
+            );
+
+        return bigint_kernel_c<bigint_base>(lhs*rhs.data);
+    }
+
+// ----------------------------------------------------------------------------------------
+
+    template <
+        typename bigint_base
+        >
+    const bigint_kernel_c<bigint_base> operator* (
+        const bigint_kernel_c<bigint_base>& lhs,
+        uint16 r
+    )
+    {
+        uint32 rhs = r;
+        // make sure requires clause is not broken
+        DLIB_CASSERT( rhs <= 65535,
+            "\tconst bigint operator*(const bigint&, uint16)"
+            << "\n\t rhs must be <= 65535"
+            << "\n\trhs:   " << rhs
+            << "\n\tlhs:   " << lhs
+            );
+
+        return bigint_kernel_c<bigint_base>(lhs.data*rhs);
+    }
+
+// ----------------------------------------------------------------------------------------
+
+    template <
+        typename bigint_base
+        >
+    bigint_kernel_c<bigint_base>& bigint_kernel_c<bigint_base>::
+    operator*= (
+        uint16 r
+    )
+    {
+        uint32 rhs = r;
+        // make sure requires clause is not broken
+        DLIB_CASSERT( rhs <= 65535,
+            "\t bigint bigint::operator*=(uint16)"
+            << "\n\t rhs must be <= 65535"
+            << "\n\tthis:  " << this
+            << "\n\t*this: " << *this 
+            << "\n\trhs:   " << rhs
+            );
+
+        data *= static_cast<uint16>(rhs);
+        return *this;
+    }
+
+// ----------------------------------------------------------------------------------------
+
+    template <
+        typename bigint_base
+        >
+    const bigint_kernel_c<bigint_base> operator/ (
+        uint16 l,
+        const bigint_kernel_c<bigint_base>& rhs
+    )
+    {
+        uint32 lhs = l;
+        // make sure requires clause is not broken
+        DLIB_CASSERT( !(rhs == 0) && lhs <= 65535,
+            "\tconst bigint operator/(uint16,const bigint&)"
+            << "\n\t you can't divide by zero and lhs <= 65535"
+            << "\n\t&lhs:  " << &lhs
+            << "\n\t&rhs:  " << &rhs
+            << "\n\tlhs:   " << lhs
+            );
+
+        // call the real function
+        return bigint_kernel_c<bigint_base>(lhs/rhs.data);
+    }
+
+// ----------------------------------------------------------------------------------------
+
+    template <
+        typename bigint_base
+        >
+    const bigint_kernel_c<bigint_base> operator/ (
+        const bigint_kernel_c<bigint_base>& lhs,
+        uint16 r
+    )
+    {
+        uint32 rhs = r;
+        // make sure requires clause is not broken
+        DLIB_CASSERT( !(rhs == 0) && rhs <= 65535,
+            "\tconst bigint operator/(const bigint&,uint16)"
+            << "\n\t you can't divide by zero and rhs <= 65535"
+            << "\n\t&lhs:  " << &lhs
+            << "\n\t&rhs:  " << &rhs
+            << "\n\trhs:   " << rhs
+            );
+
+        // call the real function
+        return bigint_kernel_c<bigint_base>(lhs.data/static_cast<uint16>(rhs));
+    }
+
+// ----------------------------------------------------------------------------------------
+
+    template <
+        typename bigint_base
+        >
+    bigint_kernel_c<bigint_base>& bigint_kernel_c<bigint_base>::
+    operator/= (
+        uint16 rhs
+    )
+    {
+        // make sure requires clause is not broken
+        DLIB_CASSERT( !(rhs == 0) && static_cast<uint32>(rhs) <= 65535,
+            "\tbigint& bigint::operator/=(uint16)"
+            << "\n\t you can't divide by zero and rhs must be <= 65535"
+            << "\n\tthis:  " << this
+            << "\n\trhs:   " << rhs
+            );
+
+        // call the real function
+        data /= rhs;
+        return *this;
+    }
+
+// ----------------------------------------------------------------------------------------
+
+    template <
+        typename bigint_base
+        >
+    const bigint_kernel_c<bigint_base> operator% (
+        uint16 lhs,
+        const bigint_kernel_c<bigint_base>& rhs
+    )
+    {
+        // make sure requires clause is not broken
+        DLIB_CASSERT( !(rhs == 0) && static_cast<uint32>(lhs) <= 65535,
+            "\tconst bigint operator%(uint16,const bigint&)"
+            << "\n\t you can't divide by zero and lhs must be <= 65535"
+            << "\n\t&lhs:  " << &lhs
+            << "\n\t&rhs:  " << &rhs
+            << "\n\tlhs:   " << lhs
+            );
+
+        // call the real function
+        return bigint_kernel_c<bigint_base>(lhs%rhs.data);
+    }
+
+// ----------------------------------------------------------------------------------------
+
+    template <
+        typename bigint_base
+        >
+    const bigint_kernel_c<bigint_base> operator% (
+        const bigint_kernel_c<bigint_base>& lhs,
+        uint16 r
+    )
+    {
+        uint32 rhs = r;
+        // make sure requires clause is not broken
+        DLIB_CASSERT( !(rhs == 0) && rhs <= 65535,
+            "\tconst bigint operator%(const bigint&,uint16)"
+            << "\n\t you can't divide by zero and rhs must be <= 65535"
+            << "\n\t&lhs:  " << &lhs
+            << "\n\t&rhs:  " << &rhs
+            << "\n\trhs:   " << rhs
+            );
+
+        // call the real function
+        return bigint_kernel_c<bigint_base>(lhs.data%static_cast<uint16>(rhs));
+    }
+
+// ----------------------------------------------------------------------------------------
+
+    template <
+        typename bigint_base
+        >
+    bigint_kernel_c<bigint_base>& bigint_kernel_c<bigint_base>::
+    operator%= (
+        uint16 r
+    )
+    {
+
+        uint32 rhs = r;
+        // make sure requires clause is not broken
+        DLIB_CASSERT( !(rhs == 0) && rhs <= 65535,
+            "\tbigint& bigint::operator%=(uint16)"
+            << "\n\t you can't divide by zero and rhs must be <= 65535"
+            << "\n\tthis:  " << this
+            << "\n\trhs:   " << rhs
+            );
+
+        // call the real function
+        data %= rhs;
+        return *this;
+    }
+
+// ----------------------------------------------------------------------------------------
+
+    template <
+        typename bigint_base
+        >
+    bool operator < (
+        uint16 l,
+        const bigint_kernel_c<bigint_base>& rhs
+    )
+    {
+        uint32 lhs = l;
+        // make sure requires clause is not broken
+        DLIB_CASSERT( lhs <= 65535,
+            "\tbool operator<(uint16, const bigint&)"
+            << "\n\t lhs must be <= 65535"
+            << "\n\trhs:   " << rhs
+            << "\n\tlhs:   " << lhs
+            );
+
+        return static_cast<uint16>(lhs) < rhs.data;
+    }
+
+// ----------------------------------------------------------------------------------------
+
+    template <
+        typename bigint_base
+        >
+    bool operator < (
+        const bigint_kernel_c<bigint_base>& lhs,
+        uint16 r
+    )
+    {
+        uint32 rhs = r;
+        // make sure requires clause is not broken
+        DLIB_CASSERT( rhs <= 65535,
+            "\tbool operator<(const bigint&, uint16)"
+            << "\n\t rhs must be <= 65535"
+            << "\n\trhs:   " << rhs
+            << "\n\tlhs:   " << lhs
+            );
+
+        return lhs.data < static_cast<uint16>(rhs);
+    }
+
+// ----------------------------------------------------------------------------------------
+
+    template <
+        typename bigint_base
+        >
+    bool operator == (
+        const bigint_kernel_c<bigint_base>& lhs,
+        uint16 r
+    )
+    {
+        uint32 rhs = r;
+        // make sure requires clause is not broken
+        DLIB_CASSERT( rhs <= 65535,
+            "\tbool operator==(const bigint&, uint16)"
+            << "\n\t rhs must be <= 65535"
+            << "\n\trhs:   " << rhs
+            << "\n\tlhs:   " << lhs
+            );
+
+        return lhs.data == static_cast<uint16>(rhs);
+    }
+
+// ----------------------------------------------------------------------------------------
+
+    template <
+        typename bigint_base
+        >
+    bool operator == (
+        uint16 l,
+        const bigint_kernel_c<bigint_base>& rhs
+    )
+    {
+        uint32 lhs = l;
+        // make sure requires clause is not broken
+        DLIB_CASSERT( lhs <= 65535,
+            "\tbool operator==(uint16, const bigint&)"
+            << "\n\t lhs must be <= 65535"
+            << "\n\trhs:   " << rhs
+            << "\n\tlhs:   " << lhs
+            );
+
+        return static_cast<uint16>(lhs) == rhs.data;
+    }
+
+// ----------------------------------------------------------------------------------------
+
+    template <
+        typename bigint_base
+        >
+    bigint_kernel_c<bigint_base>& bigint_kernel_c<bigint_base>::
+    operator= (
+        uint16 r
+    )
+    {
+        uint32 rhs = r;
+        // make sure requires clause is not broken
+        DLIB_CASSERT( rhs <= 65535,
+            "\tbigint bigint::operator=(uint16)"
+            << "\n\t rhs must be <= 65535"
+            << "\n\t*this:  " << *this
+            << "\n\tthis:   " << this
+            << "\n\tlhs:    " << rhs
+            );
+
+        data = static_cast<uint16>(rhs);
+        return *this;
+    }
+
+// ----------------------------------------------------------------------------------------
+
+    template < typename bigint_base >
+    inline bool operator>  (const bigint_kernel_c<bigint_base>& a, const bigint_kernel_c<bigint_base>& b) { return b < a; } 
+    template < typename bigint_base >
+    inline bool operator!= (const bigint_kernel_c<bigint_base>& a, const bigint_kernel_c<bigint_base>& b) { return !(a == b); }
+    template < typename bigint_base >
+    inline bool operator<= (const bigint_kernel_c<bigint_base>& a, const bigint_kernel_c<bigint_base>& b) { return !(b < a); }
+    template < typename bigint_base >
+    inline bool operator>= (const bigint_kernel_c<bigint_base>& a, const bigint_kernel_c<bigint_base>& b) { return !(a < b); }
+
+// ----------------------------------------------------------------------------------------
+
+}
+
+#endif // DLIB_BIGINT_KERNEl_C_
+

dlibs/dlib/binary_search_tree.h

@@ -0,0 +1,50 @@
+// Copyright (C) 2003  Davis E. King ([email protected])
+// License: Boost Software License   See LICENSE.txt for the full license.
+#ifndef DLIB_BINARY_SEARCH_TREe_
+#define DLIB_BINARY_SEARCH_TREe_
+
+
+#include "binary_search_tree/binary_search_tree_kernel_1.h"
+#include "binary_search_tree/binary_search_tree_kernel_2.h"
+#include "binary_search_tree/binary_search_tree_kernel_c.h"
+
+
+#include "algs.h"
+#include <functional>
+
+
+namespace dlib
+{
+
+    template <
+        typename domain,
+        typename range,
+        typename mem_manager = default_memory_manager,
+        typename compare = std::less<domain>
+        >
+    class binary_search_tree
+    {
+        binary_search_tree() {}
+
+    public:
+        
+        //----------- kernels ---------------
+
+        // kernel_1a        
+        typedef     binary_search_tree_kernel_1<domain,range,mem_manager,compare>    
+                    kernel_1a;
+        typedef     binary_search_tree_kernel_c<kernel_1a>
+                    kernel_1a_c;
+
+
+        // kernel_2a        
+        typedef     binary_search_tree_kernel_2<domain,range,mem_manager,compare>    
+                    kernel_2a;
+        typedef     binary_search_tree_kernel_c<kernel_2a>
+                    kernel_2a_c;
+
+    };
+}
+
+#endif // DLIB_BINARY_SEARCH_TREe_
+