Upload 2271 files

.gitattributes

@@ -48,3 +48,28 @@ difpoint/checkpoints/liveportrait_onnx/stitching_lip.trt filter=lfs diff=lfs mer
 difpoint/checkpoints/liveportrait_onnx/landmark.trt filter=lfs diff=lfs merge=lfs -text
 difpoint/checkpoints/liveportrait_onnx/libgrid_sample_3d_plugin.so filter=lfs diff=lfs merge=lfs -text
 difpoint/dataset_process/ckpts/shape_predictor_68_face_landmarks.dat filter=lfs diff=lfs merge=lfs -text
+difpoint/lib/dlib/dlib/test/ffmpeg_data/116-288045-0000.flac filter=lfs diff=lfs merge=lfs -text
+difpoint/lib/dlib/dlib/test/ffmpeg_data/dog.jpg filter=lfs diff=lfs merge=lfs -text
+difpoint/lib/dlib/dlib/test/ffmpeg_data/eagle.jpg filter=lfs diff=lfs merge=lfs -text
+difpoint/lib/dlib/dlib/test/ffmpeg_data/elon-musk-smoke.gif filter=lfs diff=lfs merge=lfs -text
+difpoint/lib/dlib/dlib/test/ffmpeg_data/giraffe.jpg filter=lfs diff=lfs merge=lfs -text
+difpoint/lib/dlib/dlib/test/ffmpeg_data/horses.jpg filter=lfs diff=lfs merge=lfs -text
+difpoint/lib/dlib/dlib/test/ffmpeg_data/MOT17-13-SDP-raw.h265 filter=lfs diff=lfs merge=lfs -text
+difpoint/lib/dlib/dlib/test/ffmpeg_data/MOT20-05-raw_even_shorter.mp4 filter=lfs diff=lfs merge=lfs -text
+difpoint/lib/dlib/dlib/test/ffmpeg_data/MOT20-08-raw_shorter.h264 filter=lfs diff=lfs merge=lfs -text
+difpoint/lib/dlib/dlib/test/ffmpeg_data/scream.jpg filter=lfs diff=lfs merge=lfs -text
+difpoint/lib/dlib/docs/docs/chm/htmlhelp/hha.dll filter=lfs diff=lfs merge=lfs -text
+difpoint/lib/dlib/docs/docs/chm/htmlhelp/itcc.dll filter=lfs diff=lfs merge=lfs -text
+difpoint/lib/dlib/docs/docs/chm/htmlhelp/itircl.dll filter=lfs diff=lfs merge=lfs -text
+difpoint/lib/dlib/docs/docs/chm/htmlhelp/itss.dll filter=lfs diff=lfs merge=lfs -text
+difpoint/lib/dlib/docs/docs/face_landmarking_example.png filter=lfs diff=lfs merge=lfs -text
+difpoint/lib/dlib/docs/docs/find_max_global_example.mp4 filter=lfs diff=lfs merge=lfs -text
+difpoint/lib/dlib/docs/docs/find_max_global_example.webm filter=lfs diff=lfs merge=lfs -text
+difpoint/lib/dlib/docs/docs/quadratic_image_models_IGARSS2013.pdf filter=lfs diff=lfs merge=lfs -text
+difpoint/lib/dlib/docs/docs/watershed.mp4 filter=lfs diff=lfs merge=lfs -text
+difpoint/lib/dlib/docs/docs/watershed.webm filter=lfs diff=lfs merge=lfs -text
+difpoint/lib/dlib/examples/faces/2008_007676.jpg filter=lfs diff=lfs merge=lfs -text
+difpoint/lib/dlib/examples/faces/bald_guys.jpg filter=lfs diff=lfs merge=lfs -text
+difpoint/lib/dlib/examples/faces/dogs.jpg filter=lfs diff=lfs merge=lfs -text
+difpoint/lib/dlib/examples/mmod_cars_test_image.jpg filter=lfs diff=lfs merge=lfs -text
+difpoint/lib/dlib/examples/mmod_cars_test_image2.jpg filter=lfs diff=lfs merge=lfs -text

difpoint/lib/dlib/.github/ISSUE_TEMPLATE/bug.yml

@@ -0,0 +1,80 @@
+name: Bug Report
+description: Create a bug report.
+title: "[Bug]: "
+assignees: []
+body:
+  - type: markdown
+    attributes:
+      value: |
+        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.
+  - type: dropdown
+    id: platform
+    attributes:
+      label: What Operating System(s) are you seeing this problem on?
+      description: Select all that apply
+      multiple: true
+      options:
+        - Linux (x86-64)
+        - Linux (aarch64)
+        - macOS (Intel)
+        - macOS (Apple Silicon)
+        - Windows
+        - Other (plase, specify in the Steps to Reproduce)
+    validations:
+      required: true
+  - type: input
+    id: version
+    attributes:
+      label: dlib version
+      description: "The commit hash, tag name, or package version"
+      placeholder: "19.24"
+    validations:
+      required: true
+  - type: input
+    id: python
+    attributes:
+      label: Python version
+      description: "The version of Python you are using"
+      placeholder: "3.8"
+    validations:
+      required: false
+  - type: input
+    id: compiler
+    attributes:
+      label: Compiler
+      description: "The compiler and version you used to build dlib from source"
+      placeholder: "e.g.: GCC 9, MSVC 19, clang 10"
+    validations:
+      required: true
+  - type: textarea
+    id: expected
+    attributes:
+      label: Expected Behavior
+      description: |
+        A clear and concise description of what you expected to happen
+  - type: textarea
+    id: current
+    attributes:
+      label: Current Behavior
+      description: A clear and concise description of what the bug is
+      placeholder: |
+        Tell us what happened.  Expain in detail the current behavior.
+    validations:
+      required: true
+  - type: textarea
+    id: reproduce
+    validations:
+      required: true    
+    attributes:
+      label: Steps to Reproduce
+      description: Steps to reproduce the behavior
+      placeholder: |
+        Please include as much information as possible that can help to reproduce and
+        understand the issue.  Including a minimal example that reproduces the bug is very useful.
+
+  - type: textarea
+    id: other
+    attributes:
+      label: Anything else?
+      description: |
+        Add any other context about the problem here.

difpoint/lib/dlib/.github/ISSUE_TEMPLATE/config.yml

@@ -0,0 +1,5 @@
+blank_issues_enabled: false
+contact_links:
+- name: 💬 Discussions
+  url: https://github.com/davisking/dlib/discussions
+  about: Please start usage discussions here

difpoint/lib/dlib/.github/ISSUE_TEMPLATE/feature.yml

@@ -0,0 +1,24 @@
+name: Feature Request
+description: Suggest an idea for dlib
+labels: type:enhancement
+assignees: []
+body:
+  - type: markdown
+    attributes:
+      value: |
+        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**.
+  - type: textarea
+    id: description
+    attributes:
+      label: Main idea
+      description: Describe what you want to add or improve
+    validations:
+      required: true
+  - type: textarea
+    id: other
+    attributes:
+      label: Anything else?
+      description: Add any other context about the suggestion here.

difpoint/lib/dlib/.github/workflows/build_cpp.yml

@@ -0,0 +1,274 @@
+name: C++
+
+on:
+  push:
+    branches:
+    - master
+    paths:
+    - ".github/workflows/build_cpp.yml"
+    - "**.cpp"
+    - "**.h"
+    - "**.c"
+    - "**.cu"
+    - "**.cmake"
+    - "**CMakeLists.txt"
+  pull_request:
+    branches:
+    - master
+    paths:
+    - ".github/workflows/build_cpp.yml"
+    - "**.cpp"
+    - "**.h"
+    - "**.c"
+    - "**.cu"
+    - "**.cmake"
+    - "**CMakeLists.txt"
+
+defaults:
+  run:
+    shell: bash
+    working-directory: dlib/test
+
+jobs:
+  ubuntu-latest-gcc-default-cmake-3-8-ffmpeg5:
+    runs-on: 'ubuntu-latest'
+    steps:
+    - uses: actions/checkout@v2
+
+    - name: Install dependencies
+      run: |
+        sudo apt update
+        sudo apt install libwebp-dev make yasm
+        
+    - name: Cache cmake 3.8.0
+      uses: actions/cache@v3
+      id: cache-cmake-download
+      with:
+        # cache this folder:
+        path: ~/cmake-3.8.0-Linux-x86_64
+        key: cmake-3.8.0_try3
+        
+    - run: |
+        # Get the minimum version of cmake dlib supports
+        wget https://cmake.org/files/v3.8/cmake-3.8.0-Linux-x86_64.tar.gz
+        tar -xf cmake-3.8.0-Linux-x86_64.tar.gz -C ~
+      if: steps.cache-cmake-download.outputs.cache-hit != 'true'
+
+    - name: Cache FFmpeg 5
+      uses: actions/cache@v3
+      id: cache-ffmpeg5
+      with:
+        path: /home/runner/ffmpeg-n5.1.3_installation
+        key: ffmpeg-n5.1.3_try4
+        
+    - name: Build FFmpeg 5
+      if: steps.cache-ffmpeg5.outputs.cache-hit != 'true'
+      run: |
+        wget https://github.com/FFmpeg/FFmpeg/archive/refs/tags/n5.1.3.tar.gz
+        tar -xf n5.1.3.tar.gz
+        cd FFmpeg-n5.1.3
+        ./configure --prefix=/home/runner/ffmpeg-n5.1.3_installation --disable-doc --disable-programs
+        make -j4
+        make install
+        cd ..
+        
+    - name: Configure
+      run: |
+        mkdir build
+        cd build
+        ~/cmake-3.8.0-Linux-x86_64/bin/cmake -DCMAKE_PREFIX_PATH=/home/runner/ffmpeg-n5.1.3_installation .. 
+    
+    - name: Build just tests
+      run: |
+        cd build
+        make -j4 dtest
+        
+    - name: Test
+      run: build/dtest --runall -q
+      
+    - name: Build examples, etc
+      run: |
+        cd build
+        make -j2
+
+  ubuntu-latest-gcc-11-blas:
+    runs-on: 'ubuntu-latest'
+    steps:
+    - uses: actions/checkout@v2
+    - name: Install dependencies
+      run: |
+        sudo apt update
+        sudo apt install libwebp-dev libavformat-dev libavcodec-dev libavdevice-dev libavfilter-dev libswresample-dev libswscale-dev libavutil-dev 
+        sudo apt install libopenblas-dev liblapack-dev
+    - name: Install gcc 11
+      run: |
+        sudo apt install gcc-11 g++-11
+        sudo update-alternatives --install /usr/bin/gcc gcc /usr/bin/gcc-11 110 --slave /usr/bin/g++ g++ /usr/bin/g++-11 --slave /usr/bin/gcov gcov /usr/bin/gcov-11
+    - name: Configure
+      run: cmake ${{ github.workspace }}/dlib/test -B build
+    - name: Build just tests
+      run: cmake --build build --config Release --target dtest --parallel 4
+    - name: Test
+      run: build/dtest --runall -q
+    - name: Build examples, etc
+      run: cmake --build build --config Release --parallel 2
+
+    # Test the BLAS bindings
+    - name: Configure BLAS binding tests
+      run: cmake ${{ github.workspace }}/dlib/test/blas_bindings -B build_blas_bindings
+    - name: Build blas binding tests
+      run: cmake --build build_blas_bindings --config Debug --parallel 4
+    - name: Test BLAS bindings
+      run: build_blas_bindings/dtest --runall -q
+
+  ubuntu-20_04-gcc-7:
+    runs-on: 'ubuntu-20.04'
+    steps:
+    - uses: actions/checkout@v2
+
+    - name: Install dependencies
+      run: |
+        sudo apt update
+        sudo apt install libwebp-dev make yasm 
+
+    - name: Install gcc 7
+      run: |
+        sudo apt install gcc-7 g++-7
+
+    - name: Cache FFmpeg 3.2.18
+      uses: actions/cache@v3
+      id: cache-ffmpeg3
+      with:
+        path: /home/runner/ffmpeg-n3.2.18_installation
+        key: ffmpeg-n3.2.18_try1
+        
+    - name: Build FFmpeg 3.2.18
+      if: steps.cache-ffmpeg3.outputs.cache-hit != 'true'
+      run: |
+        wget https://github.com/FFmpeg/FFmpeg/archive/refs/tags/n3.2.18.tar.gz
+        tar -xf n3.2.18.tar.gz
+        cd FFmpeg-n3.2.18
+        ./configure --prefix=/home/runner/ffmpeg-n3.2.18_installation --disable-doc --disable-programs
+        make -j4
+        make install
+        cd ..
+
+    - name: Configure
+      run: |
+        export CC=/usr/bin/gcc-7
+        export CXX=/usr/bin/g++-7
+        cmake ${{ github.workspace }}/dlib/test -B build -DCMAKE_PREFIX_PATH=/home/runner/ffmpeg-n3.2.18_installation
+
+    - name: Build just tests
+      run: cmake --build build --config Release --target dtest --parallel 4
+
+    - name: Test
+      run: build/dtest --runall -q
+
+    - name: Build examples, etc
+      run: cmake --build build --config Release --parallel 2
+
+    # Test cmake scrips can build standalone dlib as a shared library
+    - name: Configure dlib as shared library  
+      run: cmake ${{ github.workspace }}/dlib -B build_dlib_shared -DBUILD_SHARED_LIBS=1 -DCMAKE_PREFIX_PATH=/home/runner/ffmpeg-n3.2.18_installation
+
+    - name: Build dlib as shared library
+      run: cmake --build build_dlib_shared --parallel 4
+
+  ubuntu-latest-clang-default-avx:
+    runs-on: 'ubuntu-latest'
+    steps:
+    - uses: actions/checkout@v2
+    - name: Install dependencies
+      run: |
+        sudo apt update
+        sudo apt install libwebp-dev libavformat-dev libavcodec-dev libavdevice-dev libavfilter-dev libswresample-dev libswscale-dev libavutil-dev 
+    - name: Configure
+      run: |
+        export CC=/usr/bin/clang
+        export CXX=/usr/bin/clang++
+        cmake ${{ github.workspace }}/dlib/test -B build -DUSE_AVX_INSTRUCTIONS=1
+    - name: Build just tests
+      run: cmake --build build --config Release --target dtest --parallel 4
+    - name: Test
+      run: build/dtest --runall -q
+    - name: Build examples, etc
+      run: cmake --build build --config Release --parallel 2
+
+  ubuntu-latest-ffmpeg7:
+    runs-on: 'ubuntu-latest'
+    steps:
+    - uses: actions/checkout@v2
+
+    - name: Install dependencies
+      run: |
+        sudo apt update
+        sudo apt install make yasm 
+
+    - name: Cache FFmpeg 7
+      uses: actions/cache@v3
+      id: cache-ffmpeg7
+      with:
+        path: /home/runner/ffmpeg-n7.0.1_installation
+        key: ffmpeg-n7.0.1_try2
+        
+    - name: Build FFmpeg 7
+      if: steps.cache-ffmpeg7.outputs.cache-hit != 'true'
+      run: |
+        wget https://github.com/FFmpeg/FFmpeg/archive/refs/tags/n7.0.1.tar.gz
+        tar -xf n7.0.1.tar.gz
+        cd FFmpeg-n7.0.1
+        ./configure --prefix=/home/runner/ffmpeg-n7.0.1_installation --disable-doc --disable-programs
+        make -j4
+        make install
+        cd ..
+        
+    - name: Configure
+      run: cmake . -B build -DCMAKE_PREFIX_PATH=/home/runner/ffmpeg-n7.0.1_installation
+    - name: Build ffmpeg example
+      run: cmake --build build --config Release --target ffmpeg_video_muxing_ex --parallel 4
+
+  windows-latest:
+    runs-on: 'windows-latest'
+    steps:
+    - uses: actions/checkout@v2
+    - name: Configure
+      run: |
+        # don't use CMake 3.25.0 https://gitlab.kitware.com/cmake/cmake/-/issues/23975
+        pip3 install cmake==3.24.0
+        cmake . -B build
+    - name: Build just tests
+      run: cmake --build build --config Release --target dtest --parallel 4
+    - name: Test
+      run: build/Release/dtest.exe --runall -q
+    - name: Build ancillary tools
+      run: cmake --build build --config Release --target imglab htmlify dtoc --parallel 4
+
+  windows-2019:
+    runs-on: 'windows-2019'
+    steps:
+    - uses: actions/checkout@v2
+    - name: Configure
+      run: |
+        # don't use CMake 3.25.0 https://gitlab.kitware.com/cmake/cmake/-/issues/23975
+        pip3 install cmake==3.24.0
+        cmake . -B build
+    - name: Build just tests
+      run: cmake --build build --config Debug --target dtest --parallel 4
+    - name: Build ancillary tools
+      run: cmake --build build --config Release --target imglab htmlify dtoc --parallel 4
+  
+  # Disable this because macos targets aren't working on github actions right now.
+  #macos-latest:
+  #  runs-on: 'macos-latest'
+  #  steps:
+  #  - uses: actions/checkout@v2
+  #  - name: Configure
+  #    # MacOS machines often come with low quality BLAS libraries installed, so don't use those.
+  #    run: cmake ${{ github.workspace }}/dlib/test -B build -DDLIB_USE_BLAS=0 -DDLIB_USE_LAPACK=0
+  #  - name: Build just tests
+  #    run: cmake --build build --config Release --target dtest --parallel 4
+  #  - name: Test
+  #    run: build/dtest --runall --no_test_timer -q
+  #  - name: Build examples, etc
+  #    run: cmake --build build --config Release --parallel 2

difpoint/lib/dlib/.github/workflows/build_matlab.yml

@@ -0,0 +1,52 @@
+name: Matlab
+
+on:
+  push:
+    branches:
+    - master
+    paths:
+    - ".github/workflows/build_matlab.yml"
+    - "**.cpp"
+    - "**.h"
+    - "**.c"
+    - "**.cu"
+    - "**.cmake"
+    - "**CMakeLists.txt"
+  pull_request:
+    branches:
+    - master
+    paths:
+    - ".github/workflows/build_matlab.yml"
+    - "**.cpp"
+    - "**.h"
+    - "**.c"
+    - "**.cu"
+    - "**.cmake"
+    - "**CMakeLists.txt"
+
+defaults:
+  run:
+    shell: bash
+    working-directory: dlib/matlab
+
+
+jobs:
+  mex-wrapper:
+    runs-on: 'ubuntu-latest'
+    steps:
+    - uses: actions/checkout@v2
+    - name: Setup MATLAB
+      uses: matlab-actions/setup-matlab@v1
+    - name: Compile mex wrappers 
+      run: |
+        pwd
+        mkdir build
+        cd build
+        cmake ..
+        cmake --build . --config Release --target install --parallel 4
+    - name: Run example script
+      uses: matlab-actions/run-command@v1
+      with:
+        command: cd dlib/matlab; example
+
+

difpoint/lib/dlib/.github/workflows/build_python.yml

@@ -0,0 +1,80 @@
+name: Python
+
+on:
+  push:
+    branches:
+    - master
+    paths:
+    - ".github/workflows/build_python.yml"
+    - "**.cpp"
+    - "**.h"
+    - "**.c"
+    - "**.cu"
+    - "**.cmake"
+    - "**CMakeLists.txt"
+    - "**py"
+  pull_request:
+    branches:
+    - master
+    paths:
+    - ".github/workflows/build_python.yml"
+    - "**.cpp"
+    - "**.h"
+    - "**.c"
+    - "**.cu"
+    - "**.cmake"
+    - "**CMakeLists.txt"
+    - "**py"
+
+defaults:
+  run:
+    shell: bash
+
+jobs:
+  Windows:
+    runs-on: 'windows-latest'
+    steps:
+    - uses: actions/checkout@v3
+    - uses: actions/setup-python@v4
+    - name: Install python deps
+      run: |
+        pip install pytest numpy
+        # don't use CMake 3.25.0 https://gitlab.kitware.com/cmake/cmake/-/issues/23975
+        pip3 install cmake==3.24.0
+    - name: Build
+      run: |
+        pip3 install cmake==3.24.0
+        python setup.py build
+        python setup.py install --user
+    - name: Test
+      run: python -m pytest --ignore docs --ignore dlib
+
+  Ubuntu:
+    runs-on: 'ubuntu-latest'
+    steps:
+    - uses: actions/checkout@v3
+    - uses: actions/setup-python@v4
+    - name: Install python deps
+      run: pip install pytest numpy
+    - name: Build
+      run: |
+        python setup.py build
+        python setup.py install --user
+    - name: Test
+      run: python -m pytest --ignore docs --ignore dlib
+
+# Disabled for now since something is going sideways with python packages on github actions
+# MacOS:
+#   runs-on: 'macos-latest'
+#   steps:
+#   - uses: actions/checkout@v3
+#   - uses: actions/setup-python@v4
+#   - name: Install python deps
+#     run: pip3 install pytest numpy
+#   - name: Build
+#     run: |
+#       python3 setup.py build
+#       python3 setup.py install --user
+#   - name: Test
+#     run: python3 -m pytest --ignore docs --ignore dlib
+

difpoint/lib/dlib/.gitignore

@@ -0,0 +1,20 @@
+**/.idea
+*~
+*.swp
+*.o
+*.so
+*.pyc
+build
+build2
+dist
+*.egg-info/
+docs/release/
+docs/docs/web/
+docs/docs/chm/
+docs/docs/cache/
+docs/docs/git-logs.xml
+docs/docs/python/classes.txt
+docs/docs/python/functions.txt
+docs/docs/python/constants.txt
+**/.vscode
+**/venv

difpoint/lib/dlib/CMakeLists.txt

@@ -0,0 +1,37 @@
+cmake_minimum_required(VERSION 3.8.0)
+
+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)

difpoint/lib/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.

difpoint/lib/dlib/MANIFEST.in

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

difpoint/lib/dlib/README.md

@@ -0,0 +1,77 @@
+# dlib C++ library  [![GitHub Actions C++ Status](https://github.com/davisking/dlib/actions/workflows/build_cpp.yml/badge.svg)](https://github.com/davisking/dlib/actions/workflows/build_cpp.yml) [![GitHub Actions Python Status](https://github.com/davisking/dlib/actions/workflows/build_python.yml/badge.svg)](https://github.com/davisking/dlib/actions/workflows/build_python.yml)
+
+Dlib is a modern C++ toolkit containing machine learning algorithms and tools for creating complex software in C++ to solve real world problems. See [http://dlib.net](http://dlib.net) for the main project documentation and API reference.
+
+
+
+## Compiling dlib C++ example programs
+
+Go into the examples folder and type:
+
+```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 install the build requirement.
+```bash
+python -m venv venv
+pip install build
+```
+
+Then you must compile dlib and install it in your environment. Type:
+```bash
+python -m build --wheel
+pip install dist/dlib-<version>.whl
+```
+
+Or download dlib using PyPi:
+```bash
+pip install dlib
+```
+
+## 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.
+

difpoint/lib/dlib/dlib/CMakeLists.txt

@@ -0,0 +1,1061 @@
+#
+# This is a CMake makefile.  You can find the cmake utility and
+# information about it at http://www.cmake.org
+#
+
+
+cmake_minimum_required(VERSION 3.8.0)
+
+set(CMAKE_DISABLE_SOURCE_CHANGES ON)
+set(CMAKE_DISABLE_IN_SOURCE_BUILD ON)
+
+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 "24")
+set(CPACK_PACKAGE_VERSION_PATCH "99")
+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 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)
+
+# 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 (CMAKE_C_COMPILER_ID STREQUAL "AppleClang")
+   set(CMAKE_C_ARCHIVE_CREATE   "<CMAKE_AR> Scr <TARGET> <LINK_FLAGS> <OBJECTS>")
+   set(CMAKE_C_ARCHIVE_FINISH   "<CMAKE_RANLIB> -no_warning_for_no_symbols -c <TARGET>")
+endif()
+if (CMAKE_CXX_COMPILER_ID STREQUAL "AppleClang")
+   set(CMAKE_CXX_ARCHIVE_CREATE "<CMAKE_AR> Scr <TARGET> <LINK_FLAGS> <OBJECTS>")
+   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_CUDA_COMPUTE_CAPABILITIES_STR
+      "Set this to a comma-separated list of CUDA compute capabilities" )
+   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_WEBP_SUPPORT_STR
+      "Disable this if you don't want to link against libwebp" )
+   set (DLIB_JXL_SUPPORT_STR
+      "Disable this if you don't want to link against libjxl" )
+   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" )
+   set (DLIB_USE_FFMPEG_STR
+      "Disable this if you don't want to use the FFMPEG library" )
+
+   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_WEBP_SUPPORT ${DLIB_WEBP_SUPPORT_STR} OFF)
+      option(DLIB_JXL_SUPPORT ${DLIB_JXL_SUPPORT_STR} OFF)
+      #option(DLIB_USE_FFTW ${DLIB_USE_FFTW_STR} OFF)
+      option(DLIB_USE_MKL_FFT ${DLIB_USE_MKL_FFT_STR} OFF)
+      option(DLIB_USE_FFMPEG ${DLIB_USE_FFMPEG_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)
+      set(DLIB_USE_CUDA_COMPUTE_CAPABILITIES 50 CACHE STRING ${DLIB_USE_CUDA_COMPUTE_CAPABILITIES_STR})
+      option(DLIB_PNG_SUPPORT ${DLIB_PNG_SUPPORT_STR} ON)
+      option(DLIB_GIF_SUPPORT ${DLIB_GIF_SUPPORT_STR} ON)
+      option(DLIB_WEBP_SUPPORT ${DLIB_WEBP_SUPPORT_STR} ON)
+      option(DLIB_JXL_SUPPORT ${DLIB_JXL_SUPPORT_STR} ON)
+      #option(DLIB_USE_FFTW ${DLIB_USE_FFTW_STR} ON)
+      option(DLIB_USE_MKL_FFT ${DLIB_USE_MKL_FFT_STR} ON)
+      option(DLIB_USE_FFMPEG ${DLIB_USE_FFMPEG_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_WEBP_SUPPORT)
+   toggle_preprocessor_switch(DLIB_JXL_SUPPORT) 
+   #toggle_preprocessor_switch(DLIB_USE_FFTW)
+   toggle_preprocessor_switch(DLIB_USE_MKL_FFT)
+   toggle_preprocessor_switch(DLIB_USE_FFMPEG)
+
+
+   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
+      md5/md5_kernel_1.cpp
+      tokenizer/tokenizer_kernel_1.cpp
+      unicode/unicode.cpp
+      test_for_odr_violations.cpp
+      fft/fft.cpp
+      )
+
+   set(dlib_needed_public_libraries)
+   set(dlib_needed_public_includes)
+   set(dlib_needed_public_cflags)
+   set(dlib_needed_public_ldflags)
+   set(dlib_needed_private_libraries)
+   set(dlib_needed_private_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
+         gui_widgets/fonts.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)
+         list (APPEND dlib_needed_private_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)
+            list (APPEND dlib_needed_private_libraries ws2_32 winmm)
+         else()
+            list (APPEND dlib_needed_private_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)
+               list (APPEND dlib_needed_public_includes ${X11_INCLUDE_DIR})
+               list (APPEND dlib_needed_public_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)
+                  list (APPEND dlib_needed_public_includes ${x11_path})
+                  list (APPEND dlib_needed_public_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)
+            list (APPEND dlib_needed_private_libraries ${socketlib})
+         endif ()
+
+         if (NOT DLIB_NO_GUI_SUPPORT)
+            include(FindX11)
+            if (X11_FOUND)
+               list (APPEND dlib_needed_private_includes ${X11_INCLUDE_DIR})
+               list (APPEND dlib_needed_private_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)
+            list (APPEND dlib_needed_public_includes ${GIF_INCLUDE_DIR})
+            list (APPEND dlib_needed_public_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)
+            list (APPEND dlib_needed_private_includes ${PNG_INCLUDE_DIR})
+            list (APPEND dlib_needed_private_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/arm/palette_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)
+            list (APPEND dlib_needed_private_includes ${JPEG_INCLUDE_DIR})
+            list (APPEND dlib_needed_private_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_WEBP_SUPPORT)
+         include(cmake_utils/find_libwebp.cmake)
+         if (WEBP_FOUND)
+            list (APPEND dlib_needed_private_includes ${WEBP_INCLUDE_DIR})
+            list (APPEND dlib_needed_private_libraries ${WEBP_LIBRARY})
+            set(source_files ${source_files}
+               image_loader/webp_loader.cpp
+               image_saver/save_webp.cpp
+               )
+         else()
+             set(DLIB_WEBP_SUPPORT OFF CACHE BOOL ${DLIB_WEBP_SUPPORT_STR} FORCE )
+             toggle_preprocessor_switch(DLIB_WEBP_SUPPORT)
+         endif()
+      endif()
+      if (DLIB_JXL_SUPPORT)
+         include(cmake_utils/find_libjxl.cmake)
+         if (JXL_FOUND)
+            list (APPEND dlib_needed_private_includes ${JXL_INCLUDE_DIRS})
+            list (APPEND dlib_needed_private_libraries ${JXL_LIBRARIES})
+            list (APPEND dlib_needed_public_cflags ${JXL_CFLAGS})
+            list (APPEND dlib_needed_public_ldflags ${JXL_LDFLAGS})
+            set(source_files ${source_files}
+               image_loader/jxl_loader.cpp
+               image_saver/save_jxl.cpp
+               )
+            enable_preprocessor_switch(DLIB_JXL_SUPPORT)
+         else()
+            set(DLIB_JXL_SUPPORT OFF CACHE BOOL ${DLIB_JXL_SUPPORT_STR} FORCE)
+            disable_preprocessor_switch(DLIB_JXL_SUPPORT)
+         endif()
+      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)
+               list (APPEND dlib_needed_public_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)
+               list (APPEND dlib_needed_public_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)
+               list (APPEND dlib_needed_public_includes ${mkl_include_dir})
+               list (APPEND dlib_needed_public_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)
+
+            # 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)
+            string(REPLACE "," ";" DLIB_CUDA_COMPUTE_CAPABILITIES ${DLIB_USE_CUDA_COMPUTE_CAPABILITIES})
+            foreach(CAP ${DLIB_CUDA_COMPUTE_CAPABILITIES})
+                list(APPEND CUDA_NVCC_FLAGS "-gencode arch=compute_${CAP},code=[sm_${CAP},compute_${CAP}]")
+            endforeach()
+            # 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 "-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++14")
+            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 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
+               )
+            list (APPEND dlib_needed_private_libraries ${CUDA_CUBLAS_LIBRARIES})
+            list (APPEND dlib_needed_private_libraries ${cudnn})
+            list (APPEND dlib_needed_private_libraries ${CUDA_curand_LIBRARY})
+            list (APPEND dlib_needed_private_libraries ${CUDA_cusolver_LIBRARY})
+            list (APPEND dlib_needed_private_libraries ${CUDA_CUDART_LIBRARY})
+            if(openmp_libraries)
+               list (APPEND dlib_needed_private_libraries ${openmp_libraries})
+            endif()
+
+            include_directories(${cudnn_include})
+            message(STATUS "Enabling CUDA support for dlib.  DLIB WILL USE CUDA, compute capabilities: ${DLIB_CUDA_COMPUTE_CAPABILITIES}")
+         else()
+            set(DLIB_USE_CUDA OFF CACHE STRING ${DLIB_USE_BLAS_STR} FORCE )
+            toggle_preprocessor_switch(DLIB_USE_CUDA)
+            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)
+            list (APPEND dlib_needed_public_includes ${sqlite_path})
+            list (APPEND dlib_needed_public_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)
+           list (APPEND dlib_needed_private_includes ${fftw_path})
+           list (APPEND dlib_needed_private_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()
+
+      if (DLIB_USE_FFMPEG)
+         include(cmake_utils/find_ffmpeg.cmake)
+         if (FFMPEG_FOUND)
+            list (APPEND dlib_needed_public_includes ${FFMPEG_INCLUDE_DIRS})
+            list (APPEND dlib_needed_public_libraries ${FFMPEG_LINK_LIBRARIES})
+            list (APPEND dlib_needed_public_cflags ${FFMPEG_CFLAGS})
+            list (APPEND dlib_needed_public_ldflags ${FFMPEG_LDFLAGS})
+            enable_preprocessor_switch(DLIB_USE_FFMPEG)
+         else()
+            set(DLIB_USE_FFMPEG OFF CACHE BOOL ${DLIB_USE_FFMPEG_STR} FORCE )
+            disable_preprocessor_switch(DLIB_USE_FFMPEG)
+         endif()
+      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_public_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_public_includes}
+      PRIVATE ${dlib_needed_private_includes}
+      )
+   target_link_libraries(dlib PUBLIC ${dlib_needed_public_libraries} ${dlib_needed_public_ldflags})
+   target_link_libraries(dlib PRIVATE ${dlib_needed_private_libraries})
+   target_compile_options(dlib PUBLIC ${dlib_needed_public_cflags})
+   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})
+      target_compile_features(dlib_all_source_cpp PUBLIC cxx_std_14)
+   endif()
+
+   target_compile_features(dlib PUBLIC cxx_std_14)
+   if((MSVC AND CMAKE_VERSION VERSION_LESS 3.11))
+      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_public_libraries}")
+      # Make the -I include options for pkg-config
+      foreach (ITR ${dlib_needed_public_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)

difpoint/lib/dlib/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.

difpoint/lib/dlib/dlib/algs.h

@@ -0,0 +1,919 @@
+// Copyright (C) 2003  Davis E. King (davis@dlib.net)
+// 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++14 option a reminder
+#if (defined(__GNUC__) && ((__GNUC__ >= 5 && __GNUC_MINOR__ >= 0) || (__GNUC__ > 5))) || \
+    (defined(__clang__) && ((__clang_major__ >= 3 && __clang_minor__ >= 4) || (__clang_major__ >= 3)))
+    #if __cplusplus < 201402L
+        #error "Dlib requires C++14 support.  Give your compiler the -std=c++14 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.
+    #ifdef __NVCC_DIAG_PRAGMA_SUPPORT__
+    #pragma nv_diag_suppress code_is_unreachable
+    #else
+    #pragma diag_suppress code_is_unreachable
+    #endif
+#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>
+#include <cmath> // for std::isfinite 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
+#include "type_traits.h"
+
+// ----------------------------------------------------------------------------------------
+/*!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 can 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);
+    }
+
+// ----------------------------------------------------------------------------------------
+
+    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 >
+    std::enable_if_t<!std::is_convertible<T*, U*>::value && !std::is_convertible<U*,T*>::value, bool>
+    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 >
+    std::enable_if_t<std::is_convertible<T*, U*>::value || std::is_convertible<U*,T*>::value, bool>
+    is_same_object (
+        const T& a, 
+        const U& b
+    ) 
+    { 
+        return (&a == &b); 
+    }
+
+// ----------------------------------------------------------------------------------------
+
+    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; };
+
+// ----------------------------------------------------------------------------------------
+    
+    template <typename T>
+    std::enable_if_t<std::is_floating_point<T>::value, bool> is_finite(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.
+    !*/
+    {
+        return std::isfinite(value);
+    }
+    
+    template <typename T>
+    std::enable_if_t<std::is_integral<T>::value, bool> is_finite(T value)
+    {
+        return std::isfinite((double)value);
+    }
+
+// ----------------------------------------------------------------------------------------
+
+    /*!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;}
+
+// ----------------------------------------------------------------------------------------
+
+    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().
+    !*/
+
+// ----------------------------------------------------------------------------------------
+
+    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);
+    }
+
+// ----------------------------------------------------------------------------------------
+
+    namespace detail
+    {
+        template <class Tuple, class F, std::size_t... I>
+        constexpr void for_each_impl(Tuple&& t, F&& f, std::index_sequence<I...>)
+        {
+#ifdef __cpp_fold_expressions
+            (std::forward<F>(f)(std::get<I>(std::forward<Tuple>(t))),...);
+#else
+            (void)std::initializer_list<int>{(std::forward<F>(f)(std::get<I>(std::forward<Tuple>(t))),0)...};
+#endif
+        }
+    }
+
+    template <class Tuple, class F>
+    constexpr void for_each_in_tuple(Tuple&& t, F&& f)
+    {
+        detail::for_each_impl(std::forward<Tuple>(t), std::forward<F>(f),
+                              std::make_index_sequence<std::tuple_size<std::remove_reference_t<Tuple>>::value>{});
+    }
+
+// ----------------------------------------------------------------------------------------
+}
+
+#endif // DLIB_ALGs_
+

difpoint/lib/dlib/dlib/all/source.cpp

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

difpoint/lib/dlib/dlib/any.h

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

difpoint/lib/dlib/dlib/any/any.h

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

difpoint/lib/dlib/dlib/any/any_abstract.h

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

difpoint/lib/dlib/dlib/any/any_decision_function.h

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

difpoint/lib/dlib/dlib/any/any_decision_function_abstract.h

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

difpoint/lib/dlib/dlib/any/any_function.h

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

difpoint/lib/dlib/dlib/any/any_function_abstract.h

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

difpoint/lib/dlib/dlib/any/any_trainer.h

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

difpoint/lib/dlib/dlib/any/any_trainer_abstract.h

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

difpoint/lib/dlib/dlib/any/storage.h

@@ -0,0 +1,977 @@
+// Copyright (C) 2022  Davis E. King (davis@dlib.net)
+// License: Boost Software License   See LICENSE.txt for the full license.
+#ifndef DLIB_TYPE_ERASURE_H_
+#define DLIB_TYPE_ERASURE_H_
+
+#include <type_traits>
+#include <utility>
+#include <typeindex>
+#include <new>
+#include <memory>
+#include "../assert.h"
+
+namespace dlib
+{
+
+// -----------------------------------------------------------------------------------------------------
+
+    class bad_any_cast : public std::bad_cast 
+    {
+        /*!
+            WHAT THIS OBJECT REPRESENTS
+                This object is the exception class used by the storage objects.
+                It is used to indicate when someone attempts to cast a storage
+                object into a type which isn't contained in the object.
+        !*/
+        
+    public:
+          virtual const char * what() const throw()
+          {
+              return "bad_any_cast";
+          }
+    };
+    
+// -----------------------------------------------------------------------------------------------------
+
+    namespace te
+    {
+
+        /*!
+            This is used as a SFINAE tool to prevent a function taking a universal reference from
+            binding to some undesired type.  For example:
+                template <
+                    typename T,
+                    T_is_not_this_type<SomeExcludedType, T> = true
+                    >
+                void foo(T&&);
+            prevents foo() from binding to an object of type SomeExcludedType.
+        !*/
+        template<class Storage, class T>
+        using T_is_not_this_type = std::enable_if_t<!std::is_same<std::decay_t<T>, Storage>::value, bool>;
+
+// -----------------------------------------------------------------------------------------------------
+
+        template<class Storage>
+        class storage_base
+        {       
+            /*!
+                WHAT THIS OBJECT REPRESENTS
+                    This class defines functionality common to all type erasure storage objects
+                    (defined below in this file).  These objects are essentially type-safe versions of
+                    a void*.  In particular, they are containers which can contain only one object
+                    but the object may be of any type.  
+
+                    Each storage object implements a different way of storing the underlying object.
+                    E.g. on the heap or stack or some other more specialized method.
+            !*/
+
+        public:
+
+            bool is_empty() const
+            /*!
+                ensures
+                    - if (this object contains any kind of object) then
+                        - returns false 
+                    - else
+                        - returns true
+            !*/
+            {
+                const Storage& me = *static_cast<const Storage*>(this);
+                return me.get_ptr() == nullptr;
+            }
+
+            template<typename T>
+            bool contains() const
+            /*!
+                ensures
+                    - if (this object currently contains an object of type T) then
+                        - returns true
+                    - else
+                        - returns false
+            !*/
+            {
+                const Storage& me = *static_cast<const Storage*>(this);
+                return !is_empty() && me.type_id() == std::type_index{typeid(T)};
+            }
+
+            template<typename T>
+            T& unsafe_get() 
+            /*!
+                requires
+                    - contains<T>() == true
+                ensures
+                    - returns a reference to the object contained within *this.
+            !*/
+            {
+                DLIB_ASSERT(contains<T>());
+                Storage& me = *static_cast<Storage*>(this);
+                return *reinterpret_cast<T*>(me.get_ptr()); 
+            }
+
+            template<typename T>
+            const T& unsafe_get() const 
+            /*!
+                requires
+                    - contains<T>() == true
+                ensures
+                    - returns a const reference to the object contained within *this.
+            !*/
+            {
+                DLIB_ASSERT(contains<T>());
+                const Storage& me = *static_cast<const Storage*>(this);
+                return *reinterpret_cast<const T*>(me.get_ptr()); 
+            }
+            
+            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.
+            !*/
+            {
+                Storage& me = *static_cast<Storage*>(this);
+
+                if (!contains<T>())
+                    me = T{};
+                return unsafe_get<T>();
+            }
+
+            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
+            !*/
+            {
+                if (!contains<T>())
+                    throw bad_any_cast{};
+                return unsafe_get<T>();
+            }
+
+            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
+            !*/
+            {
+                if (!contains<T>())
+                    throw bad_any_cast{};
+                return unsafe_get<T>();
+            }
+        };
+
+// -----------------------------------------------------------------------------------------------------
+
+        class storage_heap : public storage_base<storage_heap>
+        {
+        public:
+            /*!
+                WHAT THIS OBJECT REPRESENTS
+                    This object is a storage type that uses type erasure to erase any type.
+
+                    This particular storage type uses heap allocation only.
+            !*/
+
+            storage_heap() = default;
+            /*!
+                ensures
+                    - #is_empty() == true
+                    - for all T: #contains<T>() == false
+            !*/
+
+            template <
+                class T,
+                class T_ = std::decay_t<T>,
+                T_is_not_this_type<storage_heap, T> = true
+            >
+            storage_heap(T &&t) noexcept(std::is_nothrow_constructible<T_,T&&>::value)
+            /*!
+                ensures
+                    - copies or moves the incoming object (depending on the forwarding reference)
+                    - #is_empty() == false 
+                    - #contains<std::decay_t<T>>() == true
+                    - #unsafe_get<T>() will yield the provided t.
+            !*/
+            :   ptr{new T_{std::forward<T>(t)}},
+                del{[](void *self) { 
+                    delete reinterpret_cast<T_*>(self); 
+                }},
+                copy{[](const void *self) -> void * {
+                    return new T_{*reinterpret_cast<const T_*>(self)};
+                }},
+                type_id_{[] {
+                    return std::type_index{typeid(T_)};
+                }}
+            {
+            }
+
+            storage_heap(const storage_heap& other)
+            /*!
+                ensures
+                    - #is_empty() == other.is_empty()
+                    - if other.is_empty() == false then
+                        - underlying object of other is copied using erased type's copy constructor.
+            !*/
+            :   ptr{other.ptr ? other.copy(other.ptr) : nullptr},
+                del{other.del},
+                copy{other.copy},
+                type_id_{other.type_id_}
+            {
+            }
+
+            storage_heap& operator=(const storage_heap& other)
+            /*!
+                ensures
+                    - if is_empty() == false then
+                       - destructs the object contained in this class.
+                    - #is_empty() == other.is_empty()
+                    - if other.is_empty() == false then
+                        - underlying object of other is copied using erased type's copy constructor.
+            !*/
+            {
+                if (this != &other) 
+                    *this = std::move(storage_heap{other});
+                return *this;
+            }
+
+            storage_heap(storage_heap&& other) noexcept
+            /*!
+                ensures
+                    - The state of other is moved into *this.
+                    - #other.is_empty() == true
+            !*/
+            :   ptr{std::exchange(other.ptr, nullptr)},
+                del{std::exchange(other.del, nullptr)},
+                copy{std::exchange(other.copy, nullptr)},
+                type_id_{std::exchange(other.type_id_, nullptr)}
+            {
+            }
+
+            storage_heap& operator=(storage_heap&& other) noexcept
+            /*!
+                ensures
+                    - The state of other is moved into *this.
+                    - #other.is_empty() == true
+                    - returns *this
+            !*/
+            {
+                if (this != &other) 
+                {
+                    clear();
+                    ptr     = std::exchange(other.ptr, nullptr);
+                    del     = std::exchange(other.del, nullptr);
+                    copy    = std::exchange(other.copy, nullptr);
+                    type_id_ = std::exchange(other.type_id_, nullptr);
+                }
+                return *this;
+            }
+
+            ~storage_heap()
+            /*!
+                ensures
+                    - destructs the object contained in *this if one exists. 
+            !*/
+            {
+                if (ptr)
+                    del(ptr);
+            }
+
+            void clear()
+            /*!
+                ensures
+                    - #is_empty() == true
+            !*/
+            {
+                storage_heap{std::move(*this)};
+            }
+
+            void* get_ptr()       
+            /*!
+                ensures
+                    - returns a pointer to the underlying object or nullptr if is_empty()
+            !*/
+            {
+                return ptr;
+            }
+
+            const void* get_ptr() const 
+            /*!
+                ensures
+                    - returns a const pointer to the underlying object or nullptr if is_empty()
+            !*/
+            {
+                return ptr;
+            }
+
+            std::type_index type_id() const
+            /*!
+                requires
+                    - is_empty() == false
+                ensures
+                    - returns the std::type_index of the type contained within this object.
+                      I.e. if this object contains the type T then this returns std::type_index{typeid(T)}.
+            !*/
+            {
+                DLIB_ASSERT(!this->is_empty());
+                return type_id_();
+            }
+
+        private:
+            void* ptr                     = nullptr;
+            void  (*del)(void*)           = nullptr;
+            void* (*copy)(const void*)    = nullptr;
+            std::type_index (*type_id_)()  = nullptr;
+        };
+
+// -----------------------------------------------------------------------------------------------------
+
+        template <std::size_t Size, std::size_t Alignment = 8>
+        class storage_stack : public storage_base<storage_stack<Size, Alignment>>
+        {
+            /*!
+                WHAT THIS OBJECT REPRESENTS
+                    This object is a storage type that uses type erasure to erase any type.
+
+                    This particular storage type uses stack allocation using a template size and alignment.
+                    Therefore, only objects whose size and alignment fits the template parameters can be
+                    erased and absorbed into this object.  Attempting to store a type not
+                    representable on the stack with those settings will result in a build error.
+
+                    This object will be capable of storing any type with an alignment requirement
+                    that is a divisor of Alignment.
+            !*/
+
+        public:
+            storage_stack() = default;
+            /*!
+                ensures
+                    - #is_empty() == true
+                    - for all T: #contains<T>() == false
+            !*/
+
+            template <
+                class T,
+                class T_ = std::decay_t<T>,
+                T_is_not_this_type<storage_stack, T> = true
+            >
+            storage_stack(T &&t) noexcept(std::is_nothrow_constructible<T_,T&&>::value)
+            /*!
+                ensures
+                    - copies or moves the incoming object (depending on the forwarding reference)
+                    - #is_empty() == false 
+                    - #contains<std::decay_t<T>>() == true
+            !*/
+            :   del{[](storage_stack& self) {
+                    reinterpret_cast<T_*>(&self.data)->~T_();
+                    self.del        = nullptr;
+                    self.copy       = nullptr;
+                    self.move       = nullptr;
+                    self.type_id_   = nullptr;
+                }},
+                copy{[](const storage_stack& src, storage_stack& dst) {
+                    new (&dst.data) T_{*reinterpret_cast<const T_*>(&src.data)};
+                    dst.del     = src.del;
+                    dst.copy    = src.copy;
+                    dst.move    = src.move;
+                    dst.type_id_ = src.type_id_;
+                }},
+                move{[](storage_stack& src, storage_stack& dst) {
+                    new (&dst.data) T_{std::move(*reinterpret_cast<T_*>(&src.data))};
+                    dst.del     = src.del;
+                    dst.copy    = src.copy;
+                    dst.move    = src.move;
+                    dst.type_id_ = src.type_id_;
+                }},
+                type_id_{[] {
+                    return std::type_index{typeid(T_)};
+                }}
+            {
+                static_assert(sizeof(T_) <= Size, "insufficient size");
+                static_assert(Alignment % alignof(T_) == 0, "bad alignment");
+                new (&data) T_{std::forward<T>(t)};
+            }
+
+            storage_stack(const storage_stack& other)
+            /*!
+                ensures
+                    - #is_empty() == other.is_empty()
+                    - if other.is_empty() == false then
+                        - underlying object of other is copied using erased type's copy constructor.
+            !*/
+            {
+                if (other.copy)
+                    other.copy(other, *this);
+            }
+
+            storage_stack& operator=(const storage_stack& other)
+            /*!
+                ensures
+                    - #is_empty() == other.is_empty()
+                    - if is_empty() == false then
+                       - destructs the object contained in this class.
+                    - if other.is_empty() == false then
+                        - underlying object of other is copied using erased type's copy constructor
+            !*/
+            {
+                if (this != &other) 
+                {
+                    clear();
+                    if (other.copy)
+                        other.copy(other, *this);
+                }
+                return *this;
+            }
+
+            storage_stack(storage_stack&& other)
+            /*!
+                ensures
+                    - #is_empty() == other.is_empty()
+                    - if other.is_empty() == false then
+                        - underlying object of other is moved using erased type's moved constructor
+            !*/
+            {
+                if (other.move)
+                    other.move(other, *this);
+            }
+
+            storage_stack& operator=(storage_stack&& other)
+            /*!
+                ensures
+                    - if is_empty() == false then
+                       - destructs the object contained in this class.
+                    - #is_empty() == other.is_empty()
+                    - if other.is_empty() == false then
+                        - underlying object of other is moved using erased type's moved constructor.
+                          This does not make other empty.  It will still contain a moved from object
+                          of the underlying type in whatever that object's moved from state is.
+                        - #other.is_empty() == false
+            !*/
+            {
+                if (this != &other) 
+                {
+                    clear();
+                    if (other.move)
+                        other.move(other, *this);
+                }
+                return *this;
+            }
+
+            ~storage_stack()
+            /*!
+                ensures
+                    - destructs the object contained in *this if one exists. 
+            !*/
+            {
+                clear();
+            }
+
+            void clear()
+            /*!
+                ensures
+                    - #is_empty() == true
+            !*/
+            {
+                if (del)
+                    del(*this);
+            }
+
+            void* get_ptr()       
+            /*!
+                ensures
+                    - returns a pointer to the underlying object or nullptr if is_empty()
+            !*/
+            {
+                return del ? (void*)&data : nullptr;
+            }
+
+            const void* get_ptr() const 
+            /*!
+                ensures
+                    - returns a const pointer to the underlying object or nullptr if is_empty()
+            !*/
+            {
+                return del ? (const void*)&data : nullptr;
+            }
+
+            std::type_index type_id() const
+            /*!
+                requires
+                    - is_empty() == false
+                ensures
+                    - returns the std::type_index of the type contained within this object.
+                      I.e. if this object contains the type T then this returns std::type_index{typeid(T)}.
+            !*/
+            {
+                DLIB_ASSERT(!this->is_empty());
+                return type_id_();
+            }
+
+        private:
+            std::aligned_storage_t<Size, Alignment> data;
+            void (*del)(storage_stack&)                         = nullptr;
+            void (*copy)(const storage_stack&, storage_stack&)  = nullptr;
+            void (*move)(storage_stack&, storage_stack&)        = nullptr;
+            std::type_index (*type_id_)()                        = nullptr;
+        };
+
+// -----------------------------------------------------------------------------------------------------
+
+        template <std::size_t Size, std::size_t Alignment = 8>
+        class storage_sbo : public storage_base<storage_sbo<Size, Alignment>>
+        {
+            /*!
+                WHAT THIS OBJECT REPRESENTS
+                    This object is a storage type that uses type erasure to erase any type.
+
+                    This particular storage type uses small buffer optimization (SBO), i.e. optional
+                    stack allocation if the erased type has sizeof <= Size and alignment
+                    requirements no greater than the given Alignment template value.  If not it
+                    allocates the object on the heap.
+            !*/
+
+        public:
+            // type_fits<T>::value tells us if our SBO can hold T.
+            template<typename T>
+            struct type_fits : std::integral_constant<bool, sizeof(T) <= Size && Alignment % alignof(T) == 0>{};
+
+            storage_sbo() = default;
+            /*!
+                ensures
+                    - #is_empty() == true
+                    - for all T: #contains<T>() == false
+            !*/
+
+            template <
+                class T,
+                class T_ = std::decay_t<T>,
+                T_is_not_this_type<storage_sbo, T> = true,
+                std::enable_if_t<type_fits<T_>::value, bool> = true
+            >
+            storage_sbo(T &&t) noexcept(std::is_nothrow_constructible<T_,T&&>::value)
+            /*!
+                ensures
+                    - copies or moves the incoming object (depending on the forwarding reference)
+                    - #is_empty() == false 
+                    - #contains<std::decay_t<T>>() == true
+                    - stack allocation is used
+            !*/
+            :   ptr{new (&data) T_{std::forward<T>(t)}},
+                del{[](storage_sbo& self) {
+                    reinterpret_cast<T_*>(&self.data)->~T_();
+                    self.ptr        = nullptr;
+                    self.del        = nullptr;
+                    self.copy       = nullptr;
+                    self.move       = nullptr;
+                    self.type_id_    = nullptr;
+                }},
+                copy{[](const storage_sbo& src, storage_sbo& dst) {
+                    dst.ptr     = new (&dst.data) T_{*reinterpret_cast<const T_*>(src.ptr)};
+                    dst.del     = src.del;
+                    dst.copy    = src.copy;
+                    dst.move    = src.move;
+                    dst.type_id_ = src.type_id_;
+                }},
+                move{[](storage_sbo& src, storage_sbo& dst) {
+                    dst.ptr     = new (&dst.data) T_{std::move(*reinterpret_cast<T_*>(src.ptr))};
+                    dst.del     = src.del;
+                    dst.copy    = src.copy;
+                    dst.move    = src.move;
+                    dst.type_id_ = src.type_id_;
+                }},
+                type_id_{[] {
+                    return std::type_index{typeid(T_)};
+                }}
+            {
+            }
+
+            template <
+                class T,
+                class T_ = std::decay_t<T>,
+                T_is_not_this_type<storage_sbo, T> = true,
+                std::enable_if_t<!type_fits<T_>::value, bool> = true
+            >
+            storage_sbo(T &&t) noexcept(std::is_nothrow_constructible<T_,T&&>::value)
+            /*!
+                ensures
+                    - copies or moves the incoming object (depending on the forwarding reference)
+                    - #is_empty() == false
+                    - #contains<std::decay_t<T>>() == true
+                    - heap allocation is used
+            !*/
+            :   ptr{new T_{std::forward<T>(t)}},
+                del{[](storage_sbo& self) {
+                    delete reinterpret_cast<T_*>(self.ptr);
+                    self.ptr        = nullptr;
+                    self.del        = nullptr;
+                    self.copy       = nullptr;
+                    self.move       = nullptr;
+                    self.type_id_    = nullptr;
+                }},
+                copy{[](const storage_sbo& src, storage_sbo& dst) {
+                    dst.ptr     = new T_{*reinterpret_cast<const T_*>(src.ptr)};
+                    dst.del     = src.del;
+                    dst.copy    = src.copy;
+                    dst.move    = src.move;
+                    dst.type_id_ = src.type_id_;
+                }},
+                move{[](storage_sbo& src, storage_sbo& dst) {
+                    dst.ptr     = std::exchange(src.ptr,     nullptr);
+                    dst.del     = std::exchange(src.del,     nullptr);
+                    dst.copy    = std::exchange(src.copy,    nullptr);
+                    dst.move    = std::exchange(src.move,    nullptr);
+                    dst.type_id_ = std::exchange(src.type_id_, nullptr);
+                }},
+                type_id_{[] {
+                    return std::type_index{typeid(T_)};
+                }}
+            {
+            }
+
+            storage_sbo(const storage_sbo& other)
+            /*!
+                ensures
+                    - #is_empty() == other.is_empty()
+                    - if other.is_empty() == false then
+                        - underlying object of other is copied using erased type's copy constructor
+            !*/
+            {
+                if (other.copy)
+                    other.copy(other, *this);
+            }
+
+            storage_sbo& operator=(const storage_sbo& other)
+            /*!
+                ensures
+                    - if is_empty() == false then
+                       - destructs the object contained in this class.
+                    - #is_empty() == other.is_empty()
+                    - if other.is_empty() == false then
+                        - underlying object of other is copied using erased type's copy constructor
+            !*/
+            {
+                if (this != &other) 
+                {
+                    clear();
+                    if (other.copy)
+                        other.copy(other, *this);
+                }
+                return *this;
+            }
+
+            storage_sbo(storage_sbo&& other)
+            /*!
+                ensures
+                    - #is_empty() == other.is_empty()
+                    - if other.is_empty() == false then
+                        - if underlying object of other is allocated on stack then
+                            - underlying object of other is moved using erased type's moved constructor.
+                              This does not make other empty.  It will still contain a moved from
+                              object of the underlying type in whatever that object's moved from
+                              state is.
+                            - #other.is_empty() == false
+                        - else
+                            - storage heap pointer is moved.
+                            - #other.is_empty() == true 
+            !*/
+            {
+                if (other.move)
+                    other.move(other, *this);
+            }
+
+            storage_sbo& operator=(storage_sbo&& other)
+            /*!
+                ensures
+                    - underlying object is destructed if is_empty() == false
+                    - #is_empty() == other.is_empty()
+                    - if other.is_empty() == false then
+                        - if underlying object of other is allocated on stack then
+                            - underlying object of other is moved using erased type's moved constructor.
+                              This does not make other empty.  It will still contain a moved from
+                              object of the underlying type in whatever that object's moved from
+                              state is.
+                            - #other.is_empty() == false
+                        - else
+                            - storage heap pointer is moved.
+                            - #other.is_empty() == true 
+            !*/
+            {
+                if (this != &other) 
+                {
+                    clear();
+                    if (other.move)
+                        other.move(other, *this);
+                }
+                return *this;
+            }
+
+            ~storage_sbo()
+            /*!
+                ensures
+                    - destructs the object contained in *this if one exists. 
+            !*/
+            {
+                clear();
+            }
+
+            void clear()
+            /*!
+                ensures
+                    - #is_empty() == true
+            !*/
+            {
+                if (ptr)
+                    del(*this);
+            }
+
+            void* get_ptr()       
+            /*!
+                ensures
+                    - returns a pointer to the underlying object or nullptr if is_empty()
+            !*/
+            {
+                return ptr;
+            }
+
+            const void* get_ptr() const 
+            /*!
+                ensures
+                    - returns a const pointer to the underlying object or nullptr if is_empty()
+            !*/
+            {
+                return ptr;
+            }
+
+            std::type_index type_id() const
+            /*!
+                requires
+                    - is_empty() == false
+                ensures
+                    - returns the std::type_index of the type contained within this object.
+                      I.e. if this object contains the type T then this returns std::type_index{typeid(T)}.
+            !*/
+            {
+                DLIB_ASSERT(!this->is_empty());
+                return type_id_();
+            }
+
+        private:
+            std::aligned_storage_t<Size, Alignment> data;
+            void* ptr                                       = nullptr;
+            void (*del)(storage_sbo&)                       = nullptr;
+            void (*copy)(const storage_sbo&, storage_sbo&)  = nullptr;
+            void (*move)(storage_sbo&, storage_sbo&)        = nullptr;
+            std::type_index (*type_id_)()                    = nullptr;
+        };
+
+// -----------------------------------------------------------------------------------------------------
+
+        class storage_shared : public storage_base<storage_shared>
+        {
+            /*!
+                WHAT THIS OBJECT REPRESENTS
+                    This object is a storage type that uses type erasure to erase any type.
+
+                    This particular storage type uses std::shared_ptr<void> to store and erase
+                    incoming objects. Therefore, it uses heap allocation and reference counting.
+                    Moreover, it has the same copying and move semantics as std::shared_ptr.  I.e.
+                    it results in the underlying object being held by reference rather than by
+                    value.
+            !*/
+
+        public:
+            storage_shared() = default;
+            /*!
+                ensures
+                    - #is_empty() == true
+                    - for all T: #contains<T>() == false
+            !*/
+
+            template <
+                class T,
+                class T_ = std::decay_t<T>,
+                T_is_not_this_type<storage_shared, T> = true
+            >
+            storage_shared(T &&t) noexcept(std::is_nothrow_constructible<T_,T&&>::value)
+            /*!
+                ensures
+                    - copies or moves the incoming object (depending on the forwarding reference)
+                    - #is_empty() == true
+                    - #contains<std::decay_t<T>>() == true
+            !*/
+            :   ptr{std::make_shared<T_>(std::forward<T>(t))},
+                type_id_{[] {
+                    return std::type_index{typeid(T_)};
+                }}
+            {
+            }
+
+            // This object has the same copy/move semantics as a std::shared_ptr<void>
+            storage_shared(const storage_shared& other)             = default;
+            storage_shared& operator=(const storage_shared& other)  = default;
+            storage_shared(storage_shared&& other) noexcept = default;
+            storage_shared& operator=(storage_shared&& other) noexcept = default;
+
+            void clear() 
+            /*!
+                ensures
+                    - #is_empty() == true
+            !*/
+            { 
+                ptr     = nullptr;
+                type_id_ = nullptr;
+            }
+
+            void* get_ptr()       
+            /*!
+                ensures
+                    - returns a pointer to the underlying object or nullptr if is_empty()
+            !*/
+            {
+                return ptr.get();
+            }
+
+            const void* get_ptr() const 
+            /*!
+                ensures
+                    - returns a const pointer to the underlying object or nullptr if is_empty()
+            !*/
+            {
+                return ptr.get();
+            }
+
+            std::type_index type_id() const
+            /*!
+                requires
+                    - is_empty() == false
+                ensures
+                    - returns the std::type_index of the type contained within this object.
+                      I.e. if this object contains the type T then this returns std::type_index{typeid(T)}.
+            !*/
+            {
+                DLIB_ASSERT(!this->is_empty());
+                return type_id_();
+            }
+
+        private:
+            std::shared_ptr<void> ptr    = nullptr;
+            std::type_index (*type_id_)() = nullptr;
+        };
+
+// -----------------------------------------------------------------------------------------------------
+
+        class storage_view : public storage_base<storage_view>
+        {
+            /*!
+                WHAT THIS OBJECT REPRESENTS
+                    This object is a storage type that uses type erasure to erase any type.
+
+                    This particular storage type is a view type, similar to std::string_view or
+                    std::span.  So underlying objects are only ever referenced, not copied, moved or
+                    destructed.  That is, instances of this object take no ownership of the objects
+                    they contain.  So they are only valid as long as the contained object exists.
+                    So storage_view merely holds a pointer to the underlying object.
+            !*/
+
+        public:
+            storage_view() = default;
+            /*!
+                ensures
+                    - #is_empty() == true
+                    - for all T: #contains<T>() == false
+            !*/
+            
+            template <
+                class T,
+                class T_ = std::decay_t<T>,
+                T_is_not_this_type<storage_view, T> = true
+            >
+            storage_view(T &&t) noexcept
+            /*!
+                ensures
+                    - #get_ptr() == &t
+                    - #is_empty() == false 
+                    - #contains<std::decay_t<T>>() == true
+            !*/
+            :   ptr{&t},
+                type_id_{[] {
+                    return std::type_index{typeid(T_)};
+                }}
+            {
+            }
+            
+            // This object has the same copy/move semantics as a void*.
+            storage_view(const storage_view& other)             = default;
+            storage_view& operator=(const storage_view& other)  = default;
+            storage_view(storage_view&& other) noexcept = default;
+            storage_view& operator=(storage_view&& other) noexcept = default;
+
+            void clear() 
+            /*!
+                ensures
+                    - #is_empty() == true
+            !*/
+            { 
+                ptr     = nullptr;
+                type_id_ = nullptr;
+            }
+
+            void* get_ptr()       
+            /*!
+                ensures
+                    - returns a pointer to the underlying object or nullptr if is_empty()
+            !*/
+            {
+                return ptr;
+            }
+
+            const void* get_ptr() const 
+            /*!
+                ensures
+                    - returns a const pointer to the underlying object or nullptr if is_empty()
+            !*/
+            {
+                return ptr;
+            }
+
+            std::type_index type_id() const
+            /*!
+                requires
+                    - is_empty() == false
+                ensures
+                    - returns the std::type_index of the type contained within this object.
+                      I.e. if this object contains the type T then this returns std::type_index{typeid(T)}.
+            !*/
+            {
+                DLIB_ASSERT(!this->is_empty());
+                return type_id_();
+            }
+
+        private:
+            void* ptr = nullptr;
+            std::type_index (*type_id_)() = nullptr;
+        };
+
+// -----------------------------------------------------------------------------------------------------
+
+    }
+}
+
+#endif //DLIB_TYPE_ERASURE_H_

difpoint/lib/dlib/dlib/array.h

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

difpoint/lib/dlib/dlib/array/array_kernel.h

@@ -0,0 +1,809 @@
+// Copyright (C) 2003  Davis E. King (davis@dlib.net)
+// 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_
+

difpoint/lib/dlib/dlib/array/array_kernel_abstract.h

@@ -0,0 +1,360 @@
+// Copyright (C) 2003  Davis E. King (davis@dlib.net)
+// 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_
+

difpoint/lib/dlib/dlib/array/array_tools.h

@@ -0,0 +1,38 @@
+// Copyright (C) 2013  Davis E. King (davis@dlib.net)
+// 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_
+

difpoint/lib/dlib/dlib/array/array_tools_abstract.h

@@ -0,0 +1,33 @@
+// Copyright (C) 2013  Davis E. King (davis@dlib.net)
+// 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_
+

difpoint/lib/dlib/dlib/array2d.h

@@ -0,0 +1,12 @@
+// Copyright (C) 2006  Davis E. King (davis@dlib.net)
+// 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_
+

difpoint/lib/dlib/dlib/array2d/array2d_generic_image.h

@@ -0,0 +1,67 @@
+// Copyright (C) 2014  Davis E. King (davis@dlib.net)
+// 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_
+

difpoint/lib/dlib/dlib/array2d/array2d_kernel.h

@@ -0,0 +1,524 @@
+// Copyright (C) 2006  Davis E. King (davis@dlib.net)
+// 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) {}
+            row(row&& r) = default;
+            row& operator=(row&& r) = default;
+
+            T* data = nullptr;
+            long nc_ = 0;
+
+
+            // restricted functions
+            row(const row&) = delete;
+            row& operator=(const row&) = delete;
+        };
+
+        // -----------------------------------
+
+        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_ 
+

difpoint/lib/dlib/dlib/array2d/array2d_kernel_abstract.h

@@ -0,0 +1,339 @@
+// Copyright (C) 2006  Davis E. King (davis@dlib.net)
+// 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_ 
+

difpoint/lib/dlib/dlib/array2d/serialize_pixel_overloads.h

@@ -0,0 +1,371 @@
+// Copyright (C) 2006  Davis E. King (davis@dlib.net)
+// 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_
+

difpoint/lib/dlib/dlib/assert.h

@@ -0,0 +1,217 @@
+// Copyright (C) 2003  Davis E. King (davis@dlib.net)
+// 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_
+

difpoint/lib/dlib/dlib/base64.h

@@ -0,0 +1,9 @@
+// Copyright (C) 2006  Davis E. King (davis@dlib.net)
+// 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_
+

difpoint/lib/dlib/dlib/base64/base64_kernel_1.cpp

@@ -0,0 +1,403 @@
+// Copyright (C) 2006  Davis E. King (davis@dlib.net)
+// 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_
+

difpoint/lib/dlib/dlib/base64/base64_kernel_1.h

@@ -0,0 +1,92 @@
+// Copyright (C) 2006  Davis E. King (davis@dlib.net)
+// 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_
+

difpoint/lib/dlib/dlib/base64/base64_kernel_abstract.h

@@ -0,0 +1,121 @@
+// Copyright (C) 2006  Davis E. King (davis@dlib.net)
+// 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_
+

difpoint/lib/dlib/dlib/bayes_utils.h

@@ -0,0 +1,11 @@
+// Copyright (C) 2007  Davis E. King (davis@dlib.net)
+// 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_ 
+
+
+

difpoint/lib/dlib/dlib/bayes_utils/bayes_utils.h

@@ -0,0 +1,1677 @@
+// Copyright (C) 2007  Davis E. King (davis@dlib.net)
+// 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;
+                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_
+

difpoint/lib/dlib/dlib/bayes_utils/bayes_utils_abstract.h

@@ -0,0 +1,1042 @@
+// Copyright (C) 2007  Davis E. King (davis@dlib.net)
+// 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_
+
+

difpoint/lib/dlib/dlib/bigint.h

@@ -0,0 +1,43 @@
+// Copyright (C) 2003  Davis E. King (davis@dlib.net)
+// 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_
+

difpoint/lib/dlib/dlib/bigint/bigint_kernel_1.cpp

@@ -0,0 +1,1720 @@
+// Copyright (C) 2003  Davis E. King (davis@dlib.net)
+// 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_
+

difpoint/lib/dlib/dlib/bigint/bigint_kernel_1.h

@@ -0,0 +1,543 @@
+// Copyright (C) 2003  Davis E. King (davis@dlib.net)
+// 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_
+

difpoint/lib/dlib/dlib/bigint/bigint_kernel_2.cpp

@@ -0,0 +1,1945 @@
+// Copyright (C) 2003  Davis E. King (davis@dlib.net)
+// 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::round(a[i*2].real()));
+                num1 += carry;
+                carry = 0;
+                if (num1 > 255)
+                {
+                    carry = num1 >> 8;
+                    num1 = (num1&0xFF);
+                }
+
+                uint64 num2 = static_cast<uint64>(std::round(a[i*2+1].real()));
+                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_
+