pax_global_header00006660000000000000000000000064146341027020014511gustar00rootroot0000000000000052 comment=04b33b582c1875528b4089eacd5d7b8321075967 lisitsyn-tapkee-04b33b5/000077500000000000000000000000001463410270200151625ustar00rootroot00000000000000lisitsyn-tapkee-04b33b5/.clang-format000066400000000000000000000001111463410270200175260ustar00rootroot00000000000000BasedOnStyle: Microsoft PointerAlignment: Left ReferenceAlignment: Left lisitsyn-tapkee-04b33b5/.clang_complete000066400000000000000000000000141463410270200201320ustar00rootroot00000000000000-I./include lisitsyn-tapkee-04b33b5/.devcontainer/000077500000000000000000000000001463410270200177215ustar00rootroot00000000000000lisitsyn-tapkee-04b33b5/.devcontainer/devcontainer.json000066400000000000000000000002031463410270200232700ustar00rootroot00000000000000{ "image": "mcr.microsoft.com/devcontainers/universal:2", "features": { "ghcr.io/devcontainers/features/conda:1": {} } } lisitsyn-tapkee-04b33b5/.gitattributes000066400000000000000000000001021463410270200200460ustar00rootroot00000000000000# Auto detect text files and perform LF normalization * text=inputlisitsyn-tapkee-04b33b5/.github/000077500000000000000000000000001463410270200165225ustar00rootroot00000000000000lisitsyn-tapkee-04b33b5/.github/workflows/000077500000000000000000000000001463410270200205575ustar00rootroot00000000000000lisitsyn-tapkee-04b33b5/.github/workflows/codeql.yml000066400000000000000000000017301463410270200225520ustar00rootroot00000000000000name: "CodeQL" on: push: branches: [ "main" ] pull_request: branches: [ "main" ] schedule: - cron: '15 17 * * 3' jobs: analyze: name: Analyze runs-on: ubuntu-latest permissions: actions: read contents: read security-events: write strategy: fail-fast: false matrix: language: [ 'cpp' ] steps: - name: Checkout repository uses: actions/checkout@v3 - name: Install dependencies uses: awalsh128/cache-apt-pkgs-action@latest with: packages: libeigen3-dev libarpack2-dev libgtest-dev libfmt-dev # Initializes the CodeQL tools for scanning. - name: Initialize CodeQL uses: github/codeql-action/init@v2 with: languages: ${{ matrix.language }} - name: Autobuild run: | make codeql - name: Perform CodeQL Analysis uses: github/codeql-action/analyze@v2 with: category: "/language:${{matrix.language}}" lisitsyn-tapkee-04b33b5/.github/workflows/linux.yml000066400000000000000000000014131463410270200224400ustar00rootroot00000000000000name: Linux on: push: branches: [ "main" ] pull_request: branches: [ "main" ] jobs: build: name: "Build and Test" runs-on: ubuntu-latest strategy: matrix: build_type: [Debug, Release] steps: - uses: actions/checkout@v3 - name: Install dependencies run: sudo apt-get install -y libeigen3-dev libarpack2-dev libgtest-dev libfmt-dev libcxxopts-dev - name: Configure run: cmake -B ${{github.workspace}}/build -DBUILD_TESTS=ON -DCMAKE_BUILD_TYPE=${{matrix.build_type}} - name: Build run: cmake --build ${{github.workspace}}/build --config ${{matrix.build_type}} - name: Test working-directory: ${{github.workspace}}/build run: ctest -C ${{matrix.build_type}} --output-on-failure -VV lisitsyn-tapkee-04b33b5/.github/workflows/macos.yml000066400000000000000000000013371463410270200224100ustar00rootroot00000000000000name: MacOS on: push: branches: [ "main" ] pull_request: branches: [ "main" ] jobs: build: name: "Build and Test" runs-on: macos-latest strategy: matrix: build_type: [Debug, Release] steps: - uses: actions/checkout@v3 - name: Install dependencies run: brew install arpack eigen googletest fmt cxxopts - name: Configure run: cmake -B ${{github.workspace}}/build -DBUILD_TESTS=ON -DCMAKE_BUILD_TYPE=${{matrix.build_type}} - name: Build run: cmake --build ${{github.workspace}}/build --config ${{matrix.build_type}} - name: Test working-directory: ${{github.workspace}}/build run: ctest -C ${{matrix.build_type}} --output-on-failure -VV lisitsyn-tapkee-04b33b5/.github/workflows/nanobind.yml000066400000000000000000000017331463410270200230760ustar00rootroot00000000000000name: Nanobind on: # TODO probably change/add main later. Ah, perhaps this wf can be part of linux.yml? push: branches: [ "nanobind" ] # pull_request: # branches: [ ] jobs: build: name: "Build Python interface" runs-on: ubuntu-latest steps: - uses: actions/checkout@v3 - name: Python setup uses: actions/setup-python@v5 with: python-version: '3.11.9' - name: Install dependencies run: | sudo apt-get install -y libarpack2-dev libcxxopts-dev libeigen3-dev libfmt-dev python3.11-dev python -m pip install nanobind numpy - name: Configure run: cmake -B ${{github.workspace}}/build -DBUILD_NANOBIND=ON - name: Build # TODO there are A LOT of warnings in the logs from nanobind (-pedantic, -Wshadow). run: cmake --build ${{github.workspace}}/build - name: Test working-directory: ${{github.workspace}} run: PYTHONPATH=. python test/test_nanobind_extension.py lisitsyn-tapkee-04b33b5/.github/workflows/windows.yml000066400000000000000000000015201463410270200227720ustar00rootroot00000000000000name: Windows on: push: branches: [ "main" ] pull_request: branches: [ "main" ] jobs: build: name: "Build and Test" runs-on: windows-latest strategy: matrix: build_type: [Release] steps: - uses: actions/checkout@v3 - name: Install Miniconda uses: conda-incubator/setup-miniconda@v2.2.0 with: channels: conda-forge - name: Install conda packages run: conda install gtest eigen fmt cxxopts - name: Configure run: cmake -B ${{github.workspace}}/build -DBUILD_TESTS=ON -DCMAKE_BUILD_TYPE=${{matrix.build_type}} - name: Build run: cmake --build ${{github.workspace}}/build --config ${{matrix.build_type}} - name: Test working-directory: ${{github.workspace}}/build run: ctest -C ${{matrix.build_type}} --output-on-failure -VV lisitsyn-tapkee-04b33b5/.gitignore000066400000000000000000000000501463410270200171450ustar00rootroot00000000000000build/ bin/ lib/ *.o *.gcda *.gcno *.*~ lisitsyn-tapkee-04b33b5/.gitmodules000066400000000000000000000001231463410270200173330ustar00rootroot00000000000000[submodule "data"] path = data url = https://github.com/lisitsyn/tapkee_data.git lisitsyn-tapkee-04b33b5/AUTHORS000066400000000000000000000005401463410270200162310ustar00rootroot00000000000000Sergey Lisitsyn Fernando José Iglesias García Laurens van der Maaten (barnes-hut-sne) John Langford and Dinoj Surendran (CoverTree) Evgeniy Andreev (FibonacciHeap class) David Harmon (ARPACK wrapper code) Daisuke Okanohara (redsvd) Christopher Diggins and Pablo Aguilar and Kevlin Henney (any type) lisitsyn-tapkee-04b33b5/CMakeLists.txt000066400000000000000000000212271463410270200177260ustar00rootroot00000000000000cmake_minimum_required (VERSION 3.24) project (Tapkee LANGUAGES CXX) # set paths set (CMAKE_CXX_STANDARD 23) set (TAPKEE_INCLUDE_DIR "${CMAKE_CURRENT_SOURCE_DIR}/include") set (TAPKEE_SRC_DIR "${CMAKE_CURRENT_SOURCE_DIR}/src") set (TAPKEE_TESTS_DIR "${CMAKE_CURRENT_SOURCE_DIR}/test/unit") set (CMAKE_MODULE_PATH "${CMAKE_CURRENT_SOURCE_DIR}/src/cmake") set (CMAKE_LIBRARY_OUTPUT_DIRECTORY "${CMAKE_CURRENT_SOURCE_DIR}/lib") set (CMAKE_ARCHIVE_OUTPUT_DIRECTORY "${CMAKE_CURRENT_SOURCE_DIR}/lib") set (CMAKE_RUNTIME_OUTPUT_DIRECTORY "${CMAKE_CURRENT_SOURCE_DIR}/bin") # Eigen3 detection find_package(Eigen3 3.3 REQUIRED NO_MODULE) set (EIGEN3_LIBRARY_TO_LINK "Eigen3::Eigen") # fmt find_package(fmt REQUIRED) set (FMT_LIBRARY_TO_LINK "fmt::fmt-header-only") # cxxopts find_package(cxxopts REQUIRED) # ARPACK detection find_package(Arpack) if (ARPACK_FOUND) link_directories("${ARPACK_PATH}") endif() # OpenMP detection find_package(OpenMP) if (OPENMP_FOUND) set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} ${OpenMP_C_FLAGS}") set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} ${OpenMP_CXX_FLAGS}") set(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} ${OpenMP_EXE_LINKER_FLAGS}") endif() # ViennaCL detection find_package(OpenCL) if (OPENCL_FOUND) find_package(ViennaCL) if (VIENNACL_FOUND) set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} ${OPENCL_C_FLAGS}") set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} ${OPENCL_CXX_FLAGS}") set(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} ${OPENCL_EXE_LINKER_FLAGS}") include_directories("${VIENNACL_INCLUDE_DIRS}") endif() endif() include_directories("${TAPKEE_INCLUDE_DIR}") # CLI executable add_executable(tapkee "${TAPKEE_SRC_DIR}/cli/main.cpp") # Examples option(BUILD_EXAMPLES "Whether to build examples or not" OFF) if (BUILD_EXAMPLES) add_subdirectory(examples) endif() # library interface file(GLOB_RECURSE headers_library "${TAPKEE_INCLUDE_DIR}/*.hpp") add_library(tapkee_library INTERFACE) target_include_directories(tapkee_library INTERFACE "${TAPKEE_INCLUDE_DIR}") if (ARPACK_FOUND) target_link_libraries(tapkee PUBLIC arpack) target_link_libraries(tapkee_library INTERFACE arpack) add_definitions(-DTAPKEE_WITH_ARPACK) endif() if (VIENNACL_FOUND) target_link_libraries(tapkee PUBLIC OpenCL) target_link_libraries(tapkee_library INTERFACE OpenCL) add_definitions(-DTAPKEE_WITH_VIENNACL) endif() target_link_libraries(tapkee PRIVATE "${FMT_LIBRARY_TO_LINK}") target_link_libraries(tapkee_library INTERFACE "${FMT_LIBRARY_TO_LINK}") target_link_libraries(tapkee PRIVATE "${EIGEN3_LIBRARY_TO_LINK}") target_link_libraries(tapkee_library INTERFACE "${EIGEN3_LIBRARY_TO_LINK}") if (TAPKEE_CUSTOM_INSTALL_DIR) set (TAPKEE_INSTALL_DIR "${TAPKEE_CUSTOM_INSTALL_DIR}") else() set (TAPKEE_INSTALL_DIR "${CMAKE_INSTALL_PREFIX}/include/tapkee") endif() install( DIRECTORY "${TAPKEE_INCLUDE_DIR}/tapkee" DESTINATION "${TAPKEE_INSTALL_DIR}" ) install( DIRECTORY "${TAPKEE_INCLUDE_DIR}/stichwort" DESTINATION "${TAPKEE_INSTALL_DIR}" ) # G++ specific flags option(USE_GCOV "Use gcov to analyze test coverage" OFF) if (CMAKE_COMPILER_IS_GNUCXX) set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wall -Wextra -pedantic -Wno-long-long -Wshadow") if (USE_GCOV) set(CMAKE_BUILD_TYPE Debug) set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -fprofile-arcs -ftest-coverage") set(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} -fprofile-arcs -ftest-coverage") add_custom_target(lcov DEPENDS tapkee) add_custom_command(TARGET lcov COMMAND mkdir -p coverage WORKING_DIRECTORY "${CMAKE_BINARY_DIR}" VERBATIM) add_custom_command(TARGET lcov COMMAND lcov --directory . --zerocounters WORKING_DIRECTORY "${CMAKE_BINARY_DIR}" VERBATIM) add_custom_command(TARGET lcov COMMAND make test WORKING_DIRECTORY "${CMAKE_BINARY_DIR}" VERBATIM) add_custom_command(TARGET lcov COMMAND lcov --directory . --capture --output-file ./coverage/out.info WORKING_DIRECTORY "${CMAKE_BINARY_DIR}" VERBATIM) add_custom_command(TARGET lcov COMMAND lcov --remove ./coverage/out.info /usr/local/include\\* /usr/include\\* unit\\* --output ./coverage/clean.info "${CMAKE_BINARY_DIR}" VERBATIM) add_custom_command(TARGET lcov COMMAND genhtml -o ./coverage ./coverage/clean.info --branch-coverage --demangle-cpp WORKING_DIRECTORY "${CMAKE_BINARY_DIR}" VERBATIM) endif() endif() if (MSVC) set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} /bigobj") endif() # Part of nanobind's setting up the build system, configuring optimized build # unless otherwise specified, to avoid slow binding code and large binaries. # https://nanobind.readthedocs.io/en/latest/building.html#preliminaries if (NOT CMAKE_BUILD_TYPE AND NOT CMAKE_CONFIGURATION_TYPES) set(CMAKE_BUILD_TYPE Release CACHE STRING "Choose the type of build." FORCE) set_property(CACHE CMAKE_BUILD_TYPE PROPERTY STRINGS "Debug" "Release" "MinSizeRel" "RelWithDebInfo") endif() if (CMAKE_BUILD_TYPE MATCHES Debug) add_definitions(-DTAPKEE_DEBUG) endif() option(GPL_FREE "Build without GPL-licensed components" OFF) if (NOT GPL_FREE) add_definitions(-DTAPKEE_USE_LGPL_COVERTREE) endif() option(BUILD_TESTS "Build tests" OFF) if (BUILD_TESTS) find_package(GTest REQUIRED) enable_testing() aux_source_directory("${TAPKEE_TESTS_DIR}" "TAPKEE_TESTS_SOURCES") foreach(i ${TAPKEE_TESTS_SOURCES}) get_filename_component(exe ${i} NAME_WE) add_executable(test_${exe} ${i}) target_link_libraries(test_${exe} PUBLIC GTest::gtest GTest::gtest_main) target_link_libraries(test_${exe} PRIVATE ${FMT_LIBRARY_TO_LINK}) target_link_libraries(test_${exe} PRIVATE ${EIGEN3_LIBRARY_TO_LINK}) if (ARPACK_FOUND) target_link_libraries(test_${exe} PUBLIC arpack) endif() if (VIENNACL_FOUND) target_link_libraries(test_${exe} PUBLIC OpenCL) endif() add_test( NAME ${exe} WORKING_DIRECTORY "${CMAKE_CURRENT_SOURCE_DIR}" COMMAND "${CMAKE_RUNTIME_OUTPUT_DIRECTORY}/test_${exe}" --gtest_color=yes) endforeach() endif() option(BUILD_NANOBIND "Build nanobind Python extension" OFF) # https://nanobind.readthedocs.io/en/latest/building.html # TODO for faster nanobind build, I tried removing the # add_executable tapkee and that quickly didn't work. It would # be nice if it could be done without requiring a new option # BUILD_CLI, or so, maybe if there's a CMake command to # configure not building tapkee inside the if BUILD_NANOBIND. if (BUILD_NANOBIND) message(STATUS "Detecting and configuring nanobind") find_package(Python COMPONENTS Interpreter Development.Module REQUIRED) # Detect the installed nanobind package and import it into CMake execute_process( COMMAND "${Python_EXECUTABLE}" -m nanobind --cmake_dir OUTPUT_VARIABLE NB_DIR OUTPUT_STRIP_TRAILING_WHITESPACE ERROR_VARIABLE NB_DIR) list(APPEND CMAKE_PREFIX_PATH "${NB_DIR}") find_package(nanobind CONFIG REQUIRED) # Build extension (the library that'll be imported from the Python interpreter) include_directories("${TAPKEE_SRC_DIR}") # about TODO in nanobind_extension.cpp including src/utils.hpp nanobind_add_module(pytapkee src/python/nanobind_extension.cpp) # TODO fix paths. target_link_libraries(pytapkee PRIVATE "${EIGEN3_LIBRARY_TO_LINK}") target_link_libraries(pytapkee PRIVATE arpack) # TODO ARPACK guard; TODO without ARPACK(?) target_link_libraries(pytapkee PRIVATE "${FMT_LIBRARY_TO_LINK}") # Rename so that it can be imported as tapkee iso pytapkee. # TODO can this go into a separate CMake file? add_custom_command(TARGET pytapkee POST_BUILD COMMAND ${CMAKE_COMMAND} -P ${CMAKE_BINARY_DIR}/rename_pytapkee.cmake COMMENT "Renaming nanobind's extension pytapkee*.so to tapkee*.so") # Create the custom script to rename the file file(WRITE ${CMAKE_BINARY_DIR}/rename_pytapkee.cmake " # Find the file that starts with 'pytapkee' and ends with '.so' in the lib directory file(GLOB PYLIBRARY_FILE \"${CMAKE_LIBRARY_OUTPUT_DIRECTORY}/pytapkee*.so\") # Ensure exactly one file is found list(LENGTH PYLIBRARY_FILE FILE_COUNT) if(NOT FILE_COUNT EQUAL 1) message(FATAL_ERROR \"Expected exactly one file starting with 'pytapkee' in lib, but found \${FILE_COUNT}\") endif() # Get the first (and only) matched file list(GET PYLIBRARY_FILE 0 SOURCE_FILE) # Extract the filename from the full path get_filename_component(FILENAME \${SOURCE_FILE} NAME) string(REPLACE \"pytapkee\" \"tapkee\" DEST_FILENAME \${FILENAME}) # Construct the full destination path set(DEST_FILE \"${CMAKE_LIBRARY_OUTPUT_DIRECTORY}/\${DEST_FILENAME}\") file(RENAME \${SOURCE_FILE} \${DEST_FILE}) if(EXISTS \${DEST_FILE} AND NOT EXISTS \${SOURCE_FILE}) message(STATUS \"File renamed from \${SOURCE_FILE} to \${DEST_FILE}\") else() message(FATAL_ERROR \"Error renaming file from \${SOURCE_FILE} to \${DEST_FILE}\") endif()") message(STATUS "Detecting and configuring nanobind - done") endif() export( TARGETS tapkee_library NAMESPACE tapkee:: FILE ${PROJECT_BINARY_DIR}/tapkee.cmake ) lisitsyn-tapkee-04b33b5/CODE_OF_CONDUCT.md000066400000000000000000000121421463410270200177610ustar00rootroot00000000000000# Contributor Covenant Code of Conduct ## Our Pledge We as members, contributors, and leaders pledge to make participation in our community a harassment-free experience for everyone, regardless of age, body size, visible or invisible disability, ethnicity, sex characteristics, gender identity and expression, level of experience, education, socio-economic status, nationality, personal appearance, race, religion, or sexual identity and orientation. We pledge to act and interact in ways that contribute to an open, welcoming, diverse, inclusive, and healthy community. ## Our Standards Examples of behavior that contributes to a positive environment for our community include: * Demonstrating empathy and kindness toward other people * Being respectful of differing opinions, viewpoints, and experiences * Giving and gracefully accepting constructive feedback * Accepting responsibility and apologizing to those affected by our mistakes, and learning from the experience * Focusing on what is best not just for us as individuals, but for the overall community Examples of unacceptable behavior include: * The use of sexualized language or imagery, and sexual attention or advances of any kind * Trolling, insulting or derogatory comments, and personal or political attacks * Public or private harassment * Publishing others' private information, such as a physical or email address, without their explicit permission * Other conduct which could reasonably be considered inappropriate in a professional setting ## Enforcement Responsibilities Community leaders are responsible for clarifying and enforcing our standards of acceptable behavior and will take appropriate and fair corrective action in response to any behavior that they deem inappropriate, threatening, offensive, or harmful. Community leaders have the right and responsibility to remove, edit, or reject comments, commits, code, wiki edits, issues, and other contributions that are not aligned to this Code of Conduct, and will communicate reasons for moderation decisions when appropriate. ## Scope This Code of Conduct applies within all community spaces, and also applies when an individual is officially representing the community in public spaces. Examples of representing our community include using an official e-mail address, posting via an official social media account, or acting as an appointed representative at an online or offline event. ## Enforcement Instances of abusive, harassing, or otherwise unacceptable behavior may be reported to the community leaders responsible for enforcement at lisitsyn@hey.com. All complaints will be reviewed and investigated promptly and fairly. All community leaders are obligated to respect the privacy and security of the reporter of any incident. ## Enforcement Guidelines Community leaders will follow these Community Impact Guidelines in determining the consequences for any action they deem in violation of this Code of Conduct: ### 1. Correction **Community Impact**: Use of inappropriate language or other behavior deemed unprofessional or unwelcome in the community. **Consequence**: A private, written warning from community leaders, providing clarity around the nature of the violation and an explanation of why the behavior was inappropriate. A public apology may be requested. ### 2. Warning **Community Impact**: A violation through a single incident or series of actions. **Consequence**: A warning with consequences for continued behavior. No interaction with the people involved, including unsolicited interaction with those enforcing the Code of Conduct, for a specified period of time. This includes avoiding interactions in community spaces as well as external channels like social media. Violating these terms may lead to a temporary or permanent ban. ### 3. Temporary Ban **Community Impact**: A serious violation of community standards, including sustained inappropriate behavior. **Consequence**: A temporary ban from any sort of interaction or public communication with the community for a specified period of time. No public or private interaction with the people involved, including unsolicited interaction with those enforcing the Code of Conduct, is allowed during this period. Violating these terms may lead to a permanent ban. ### 4. Permanent Ban **Community Impact**: Demonstrating a pattern of violation of community standards, including sustained inappropriate behavior, harassment of an individual, or aggression toward or disparagement of classes of individuals. **Consequence**: A permanent ban from any sort of public interaction within the community. ## Attribution This Code of Conduct is adapted from the [Contributor Covenant][homepage], version 2.0, available at https://www.contributor-covenant.org/version/2/0/code_of_conduct.html. Community Impact Guidelines were inspired by [Mozilla's code of conduct enforcement ladder](https://github.com/mozilla/diversity). [homepage]: https://www.contributor-covenant.org For answers to common questions about this code of conduct, see the FAQ at https://www.contributor-covenant.org/faq. Translations are available at https://www.contributor-covenant.org/translations. lisitsyn-tapkee-04b33b5/Dockerfile000066400000000000000000000014161463410270200171560ustar00rootroot00000000000000FROM ubuntu:xenial RUN apt-get update && \ apt-get install libeigen3-dev libarpack2-dev cmake g++ \ valgrind python-numpy xsltproc libgtest-dev \ --force-yes -y --no-install-recommends -q0 COPY include /tapkee/include COPY src /tapkee/src COPY test /tapkee/test COPY CMakeLists.txt /tapkee/CMakeLists.txt RUN cd /tapkee && \ mkdir -p build && \ cd build && \ cmake -DBUILD_TESTS=ON .. && \ make && \ ctest -VV RUN cd /tapkee && \ python test/generate_swissroll.py 100 && \ CALLENV='valgrind --leak-check=full --xml=yes --xml-file=/dev/stdout' \ TAPKEE_ELF='bin/tapkee' \ INPUT_FILE='input.dat' \ OUTPUT_FILE='/dev/null' \ TRANSFORM='xsltproc test/valgrind_tests_transformer.xslt /dev/stdin' \ test/valgrind_run_all.sh lisitsyn-tapkee-04b33b5/LGPL-LICENSE000066400000000000000000000167431463410270200167360ustar00rootroot00000000000000 GNU LESSER GENERAL PUBLIC LICENSE Version 3, 29 June 2007 Copyright (C) 2007 Free Software Foundation, Inc. Everyone is permitted to copy and distribute verbatim copies of this license document, but changing it is not allowed. This version of the GNU Lesser General Public License incorporates the terms and conditions of version 3 of the GNU General Public License, supplemented by the additional permissions listed below. 0. Additional Definitions. As used herein, "this License" refers to version 3 of the GNU Lesser General Public License, and the "GNU GPL" refers to version 3 of the GNU General Public License. "The Library" refers to a covered work governed by this License, other than an Application or a Combined Work as defined below. An "Application" is any work that makes use of an interface provided by the Library, but which is not otherwise based on the Library. Defining a subclass of a class defined by the Library is deemed a mode of using an interface provided by the Library. A "Combined Work" is a work produced by combining or linking an Application with the Library. The particular version of the Library with which the Combined Work was made is also called the "Linked Version". The "Minimal Corresponding Source" for a Combined Work means the Corresponding Source for the Combined Work, excluding any source code for portions of the Combined Work that, considered in isolation, are based on the Application, and not on the Linked Version. The "Corresponding Application Code" for a Combined Work means the object code and/or source code for the Application, including any data and utility programs needed for reproducing the Combined Work from the Application, but excluding the System Libraries of the Combined Work. 1. Exception to Section 3 of the GNU GPL. You may convey a covered work under sections 3 and 4 of this License without being bound by section 3 of the GNU GPL. 2. Conveying Modified Versions. If you modify a copy of the Library, and, in your modifications, a facility refers to a function or data to be supplied by an Application that uses the facility (other than as an argument passed when the facility is invoked), then you may convey a copy of the modified version: a) under this License, provided that you make a good faith effort to ensure that, in the event an Application does not supply the function or data, the facility still operates, and performs whatever part of its purpose remains meaningful, or b) under the GNU GPL, with none of the additional permissions of this License applicable to that copy. 3. Object Code Incorporating Material from Library Header Files. The object code form of an Application may incorporate material from a header file that is part of the Library. You may convey such object code under terms of your choice, provided that, if the incorporated material is not limited to numerical parameters, data structure layouts and accessors, or small macros, inline functions and templates (ten or fewer lines in length), you do both of the following: a) Give prominent notice with each copy of the object code that the Library is used in it and that the Library and its use are covered by this License. b) Accompany the object code with a copy of the GNU GPL and this license document. 4. Combined Works. You may convey a Combined Work under terms of your choice that, taken together, effectively do not restrict modification of the portions of the Library contained in the Combined Work and reverse engineering for debugging such modifications, if you also do each of the following: a) Give prominent notice with each copy of the Combined Work that the Library is used in it and that the Library and its use are covered by this License. b) Accompany the Combined Work with a copy of the GNU GPL and this license document. c) For a Combined Work that displays copyright notices during execution, include the copyright notice for the Library among these notices, as well as a reference directing the user to the copies of the GNU GPL and this license document. d) Do one of the following: 0) Convey the Minimal Corresponding Source under the terms of this License, and the Corresponding Application Code in a form suitable for, and under terms that permit, the user to recombine or relink the Application with a modified version of the Linked Version to produce a modified Combined Work, in the manner specified by section 6 of the GNU GPL for conveying Corresponding Source. 1) Use a suitable shared library mechanism for linking with the Library. A suitable mechanism is one that (a) uses at run time a copy of the Library already present on the user's computer system, and (b) will operate properly with a modified version of the Library that is interface-compatible with the Linked Version. e) Provide Installation Information, but only if you would otherwise be required to provide such information under section 6 of the GNU GPL, and only to the extent that such information is necessary to install and execute a modified version of the Combined Work produced by recombining or relinking the Application with a modified version of the Linked Version. (If you use option 4d0, the Installation Information must accompany the Minimal Corresponding Source and Corresponding Application Code. If you use option 4d1, you must provide the Installation Information in the manner specified by section 6 of the GNU GPL for conveying Corresponding Source.) 5. Combined Libraries. You may place library facilities that are a work based on the Library side by side in a single library together with other library facilities that are not Applications and are not covered by this License, and convey such a combined library under terms of your choice, if you do both of the following: a) Accompany the combined library with a copy of the same work based on the Library, uncombined with any other library facilities, conveyed under the terms of this License. b) Give prominent notice with the combined library that part of it is a work based on the Library, and explaining where to find the accompanying uncombined form of the same work. 6. Revised Versions of the GNU Lesser General Public License. The Free Software Foundation may publish revised and/or new versions of the GNU Lesser General Public License from time to time. Such new versions will be similar in spirit to the present version, but may differ in detail to address new problems or concerns. Each version is given a distinguishing version number. If the Library as you received it specifies that a certain numbered version of the GNU Lesser General Public License "or any later version" applies to it, you have the option of following the terms and conditions either of that published version or of any later version published by the Free Software Foundation. If the Library as you received it does not specify a version number of the GNU Lesser General Public License, you may choose any version of the GNU Lesser General Public License ever published by the Free Software Foundation. If the Library as you received it specifies that a proxy can decide whether future versions of the GNU Lesser General Public License shall apply, that proxy's public statement of acceptance of any version is permanent authorization for you to choose that version for the Library. lisitsyn-tapkee-04b33b5/LICENSE000066400000000000000000000031031463410270200161640ustar00rootroot00000000000000Copyright (c) 2012-2023, Sergey Lisitsyn and Fernando José Iglesias García All rights reserved. Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met: * Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer. * Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution. * Neither the name of the Tapkee nor the names of its contributors may be used to endorse or promote products derived from this software without specific prior written permission. THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE DEVELOPERS NOR THE CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. lisitsyn-tapkee-04b33b5/Makefile000066400000000000000000000067131463410270200166310ustar00rootroot00000000000000python_plotter := python -c 'from pylab import*;X=loadtxt(sys.stdin);scatter(X[0],X[1]);title("Embedding");grid();show()' plotter := $(python_plotter) default: @(git submodule update --init) @(mkdir -p build; cd build; cmake -DBUILD_EXAMPLES=ON ..; make) install: default @(cd build; make install) test: @(git submodule update --init) @(mkdir -p build; cd build; cmake -DBUILD_TESTS=ON ..; make) @(cd build; ctest -VV) codeql: @(mkdir -p build; cd build; cmake -DBUILD_TESTS=ON -DBUILD_EXAMPLES=ON ..; make) minimal: default @(echo '--- Code ---'; \ cat ./examples/minimal/minimal.cpp;\ echo '--- Description ---'; \ cat ./examples/minimal/minimal.md; \ echo '--- Running ---'; \ echo 'Result is: '; \ ./bin/minimal) rna: default @(echo '--- Code ---'; \ cat ./examples/rna/rna.cpp; \ echo '--- Description ---'; \ cat ./examples/rna/rna.md; \ echo '--- Plotting ---'; \ ./bin/rna examples/rna/rna.dat | $(plotter) \ ); precomputed: default @(echo '--- Code ---'; \ cat ./examples/precomputed/precomputed.cpp;\ echo '--- Description ---'; \ cat ./examples/precomputed/precomputed.md; \ echo '--- Running ---'; \ echo 'Result is: '; \ ./bin/precomputed) langs: @(if (python -c 'from modshogun import LocallyLinearEmbedding' > /dev/null 2>&1); \ then \ echo '--- Description ---'; \ cat ./examples/langs/langs.md; \ echo '--- Python example ---'; \ cat examples/langs/lle.py; \ echo '--- Running ---'; \ python examples/langs/lle.py; \ echo '--- Octave example ---'; \ cat examples/langs/ltsa.m; \ echo '--- Running ---'; \ octave examples/langs/ltsa.m; \ else \ echo 'Shogun machine learning toolbox is not installed or compiled without Tapkee (may lack some dependencies)' \ ' (https://github.com/shogun-toolbox/shogun)'; \ fi;) promoters: @(if (python -c 'from modshogun import LocallyLinearEmbedding' > /dev/null 2>&1); \ then \ echo '--- Description ---'; \ cat ./examples/promoters/promoters.md; \ echo '--- Embedding and plotting (please wait, a window will appear in a minute) ---'; \ python examples/promoters/promoters.py data/mml.txt; \ else \ echo 'Shogun machine learning toolbox is not installed or compiled without Tapkee (may lack some dependencies)' \ ' (https://github.com/shogun-toolbox/shogun)'; \ fi;) mnist: default @(echo '--- Description ---'; \ cat ./examples/mnist/mnist.md; \ echo '--- Embedding and plotting (please wait, a window will appear in a minute) ---'; \ python examples/mnist/mnist.py data/mnist.json) faces: default @(echo '--- Description ---'; \ cat ./examples/faces/faces.md; \ echo '--- Embedding and plotting (please wait, a window will appear in a few seconds) ---'; \ python examples/faces/faces.py data/faces) format: default @(find . -iname *.hpp -o -iname *.cpp -iname *.h | xargs clang-format -i) .PHONY: test minimal rna precomputed promoters mnist faces lisitsyn-tapkee-04b33b5/README.md000066400000000000000000000335231463410270200164470ustar00rootroot00000000000000Tapkee is a C++ template library for dimensionality reduction with some bias on spectral methods. The Tapkee origins from the code developed during [GSoC 2011](http://www.google-melange.com/gsoc/homepage/google/gsoc2011) as the part of the [Shogun machine learning toolbox](https://github.com/shogun-toolbox/shogun). The project aim is to provide efficient and flexible standalone library for dimensionality reduction which can be easily integrated to existing codebases. Tapkee leverages capabilities of effective [Eigen3 linear algebra library](http://eigen.tuxfamily.org) and optionally makes use of the [ARPACK eigensolver](http://www.caam.rice.edu/software/ARPACK/). The library uses CoverTree and VP-tree data structures to compute nearest neighbors. To achieve greater flexibility we provide a callback interface which decouples dimension reduction algorithms from the data representation and storage schemes. The library is distributed under permissive [BSD 3-clause license](https://github.com/lisitsyn/tapkee/blob/master/include/LICENSE) (except a few rather optional parts that are distributed under other open sources licenses, see Licensing section of this document). If you use this software in any publication we would be happy if you cite the following paper: Sergey Lisitsyn and Christian Widmer and Fernando J. Iglesias Garcia. Tapkee: An Efficient Dimension Reduction Library. Journal of Machine Learning Research, 14: 2355-2359, 2013. To get started with dimension reduction you may try the [go.py script](https://github.com/lisitsyn/tapkee/blob/master/examples/go.py) that embeds common datasets (swissroll, helix, scurve) using the Tapkee library and outputs it with the help of Matplotlib library. To use the script build the sample application (see the Application section for more details) and call go.py with the following command: ./examples/go.py [swissroll|helix|scurve|...] [lle|isomap|...] You may also try out an minimal example using `make minimal` (examples/minimal) and the RNA example using `make rna` (examples/rna). There are also a few graphical examples. To run MNIST digits embedding example use `make mnist` (examples/mnist), to run promoters embedding example use `make promoters` (examples/promoters) and to run embedding for faces dataset use `make faces` (examples/faces). All graphical examples require Matplotlib which can be usually installed with a package manager. The promoters example also has non-trivial dependency on Shogun machine learning toolbox (minimal version is 2.1.0). We also provide some examples of usage Tapkee in Shogun as `make langs` (examples/langs) example. API --- We provide an interface based on the method chaining technique. The chain starts with the call of the `with(const ParametersSet&)` method, which is used to provide parameters like the method to use and its settings. The provided argument is formed with the following syntax: (keyword1=value1, keyword2=value2) Such syntax is possible due to comma operator overloading which groups all assigned keywords in the comma separated list. Keywords are defined in the `tapkee` namespace. Currently, the following keywords are defined: `method`, `eigen_method`, `neighbors_method`, `num_neighbors`, `target_dimension`, `diffusion_map_timesteps`, `gaussian_kernel_width`, `max_iteration`, `spe_global_strategy`, `spe_num_updates`, `spe_tolerance`, `landmark_ratio`, `nullspace_shift`, `klle_shift`, `check_connectivity`, `fa_epsilon`, `progress_function`, `cancel_function`, `sne_perplexity`, `sne_theta`. See the documentation for their detailed meaning. As an example of parameters setting, if you want to use the Isomap algorithm with the number of neighbors set to 15: tapkee::with((method=Isomap,num_neighbors=15)) Please note that the inner parentheses are necessary as it uses the comma operator which appears to be ambiguous in this case. Next, you may either embed the provided matrix with: tapkee::with((method=Isomap,num_neighbors=15)).embedUsing(matrix); Or provide callbacks (kernel, distance and features) using any combination of the `withKernel(KernelCallback)`, `withDistance(DistanceCallback)` and `withFeatures(FeaturesCallback)` member functions: tapkee::with((method=Isomap,num_neighbors=15)) .withKernel(kernel_callback) .withDistance(distance_callback) .withFeatures(features_callback) Once callbacks are initialized you may either embed data using an STL-compatible sequence of indices or objects (that supports the `begin()` and `end()` methods to obtain the corresponding iterators) with the `embedUsing(Sequence)` member function or embed the data using a sequence range with the `embedRange(RandomAccessIterator, RandomAccessIterator)` member function. As a summary - a few examples: TapkeeOutput output = with((method=Isomap,num_neighbors=15)) .embedUsing(matrix); TapkeeOutput output = with((method=Isomap,num_neighbors=15)) .withDistance(distance_callback) .embedUsing(indices); TapkeeOutput output = with((method=Isomap,num_neighbors=15)) .withDistance(distance_callback) .embedRange(indices.begin(),indices.end()); Minimal example --------------- A minimal working example of a program that uses the library is: #include #include using namespace std; using namespace tapkee; struct MyDistanceCallback { ScalarType distance(IndexType l, IndexType r) { return abs(l-r); } }; int main(int argc, const char** argv) { const int N = 100; vector indices(N); for (int i=0; i` Please note that if you don't include Eigen3 in your project there is no need to define that variable - in this case Eigen3 will be included by Tapkee. This issue comes from the need of including the Eigen3 library only once when using some specific parameters (like debug and extensions). If you are able to use less restrictive licenses (such as LGPLv3) you may define the following variable: - `TAPKEE_USE_LGPL_COVERTREE` to use Covertree code by John Langford. When compiling your software that includes Tapkee be sure Eigen3 headers are in include path and your code is linked against ARPACK library (-larpack key for g++ and clang++). For an example of integration you may check [Tapkee adapter in Shogun](https://github.com/shogun-toolbox/shogun/blob/master/src/shogun/lib/tapkee/tapkee_shogun.cpp). When working with installed headers you may check which version of the library do you have with checking the values of `TAPKEE_WORLD_VERSION`, `TAPKEE_MAJOR_VERSION` and `TAPKEE_MINOR_VERSION` defines. We welcome any integration so please contact authors if you have got any questions. If you have successfully used the library please also let authors know about that - mentions of any applications are very appreciated. Customization ------------- Tapkee is designed to be highly customizable with preprocessor definitions. If you want to use float as internal numeric type (default is double) you may do that with definition of `#define TAPKEE_CUSTOM_NUMTYPE float` before including [defines header](https://github.com/lisitsyn/tapkee/blob/master/include/tapkee_defines.hpp). If you use some non-standard STL-compatible realization of vector, map and pair you may redefine them with `TAPKEE_INTERNAL_VECTOR`, `TAPKEE_INTERNAL_PAIR`, `TAPKEE_INTERNAL_MAP` (they are set to std::vector, std::pair and std::map by default otherwise). You may define `TAPKEE_USE_FIBONACCI_HEAP` or `TAPKEE_USE_PRIORITY_QUEUE` to select which data structure should be used in the shortest paths computing algorithm. By default a priority queue is used. Other properties can be loaded from some provided header file using `#define TAPKEE_CUSTOM_PROPERTIES`. Currently such file should define only one variable - `COVERTREE_BASE` which defines the base of the CoverTree (default is 1.3). Command line application ----------- Tapkee comes with a sample application which can be used to construct low-dimensional representations of dense feature matrices. For more information on its usage please run: `./bin/tapkee -h` The application takes plain ASCII file containing dense matrix (each vector is a column and each line contains values of some feature). The output of the application is stored into the provided file in the same format (each line is feature). To compile the application please use [CMake](http://cmake.org/). The workflow of compilation Tapkee with CMake is usual. When using Unix-based systems you may use the following command to compile the Tapkee application: `mkdir build && cd build && cmake [definitions] .. && make` There are a few cases when you'd want to put some definitions: - To enable unit-tests compilation add to `-DBUILD_TESTS=1` to `[definitions]` when building. Please note that building unit-tests require googletest. If you are running Ubuntu you may install `libgtest-dev` package for that. Otherwise, if you have gtest sources around you may provide them as `-DGTEST_SOURCE_DIR` and `-DGTEST_INCLUDES_DIR`. You may also download gtest with the following command: `wget https://github.com/google/googletest/archive/release-1.8.0.tar.gz && tar xfv release-1.8.0.tar.gz` Downloaded sources will be used by Tapkee. To run tests use `make test` command (or better 'ctest -VV'). - To let make script store test coverage information using GCOV and add a target for output test coverage in HTML with LCOV add the `-DUSE_GCOV=1` flag to `[definitions]`. - To enable precomputation of kernel/distance matrices which can speed-up algorithms (but requires much more memory) add `-DPRECOMPUTED=1` to `[definitions]` when building. - To build application without parts licensed by LGPLv3 use `-DGPL_FREE=1` definition. The library requires Eigen3 to be available in your path. The ARPACK library is also highly recommended to achieve best performance. On Debian/Ubuntu these packages can be installed with sudo apt-get install libeigen3-dev libarpack2-dev If you are using Mac OS X and Macports you can install these packages with sudo port install eigen3 && sudo port install arpack` In case you want to use some non-default compiler use `CC=your-C-compiler CXX=your-C++-compiler cmake [definitions] ..` when running cmake. Directory contents ------------------ The repository of Tapkee contains the following directories: - `src/` that contains simple command-line application (`src/cli`) and CMake module finders (`src/cmake`). - `includes/` that contains the library itself in the `includes/tapkee` subdirectory. - `test/` that contains unit-tests in the `test/unit` subdirectory and a few helper scripts. - `examples/` that contains a few examples including already mentioned (these examples are supposed to be called through `make` as described above, e.g. `make minimal`). - `data/` a git submodule that contains data required for examples. To initialize this submodule use `git submodule update --init`. - `doc/` that contains Doxygen interface file which is used to generate HTML documentation of the library. Calling `doxygen doc/Doxyfile` will generate it in this folder. Once built, the root will also contain the following directories: - `bin` that contains binaries (`tapkee` that is command line application and various tests with common naming `test_*`) - `lib` that contains gtest shared libraries. Need help? ---------- If you need any help or advice don't hesitate to send [an email](mailto://lisitsyn@hey.com) or fire [an issue at github](https://github.com/lisitsyn/tapkee/issues/new). Supported platforms ------------------- Tapkee is tested to be fully functional on Linux (ICC, GCC, Clang compilers) and Mac OS X (GCC and Clang compilers). It also compiles under Windows natively (MSVS 2012 compiler) with a few known issues. In general, Tapkee uses no platform specific code and should work on other systems as well. Please [let us know](mailto://lisitsyn@hey.com) if you have successfully compiled or have got any issues on any other system not listed above. Supported dimension reduction methods ------------------------------------- Tapkee provides implementations of the following dimension reduction methods (urls to descriptions provided): * Locally Linear Embedding and Kernel Locally Linear Embedding (LLE/KLLE) * Neighborhood Preserving Embedding (NPE) * Local Tangent Space Alignment (LTSA) * Linear Local Tangent Space Alignment (LLTSA) * Hessian Locally Linear Embedding (HLLE) * Laplacian eigenmaps * Locality Preserving Projections * Diffusion map * Isomap and landmark Isomap * Multidimensional scaling and landmark Multidimensional scaling (MDS/lMDS) * Stochastic Proximity Embedding (SPE) * Principal Component Analysis (PCA) * Kernel Principal Component Analysis (PCA) * Random projection * Factor analysis * t-SNE * Barnes-Hut-SNE Licensing --------- The library is distributed under the [BSD 3-clause](https://github.com/lisitsyn/tapkee/blob/master/LICENSE) license. Exceptions are: - [Barnes-Hut-SNE code](https://github.com/lisitsyn/tapkee/blob/master/include/external/barnes_hut_sne/) by Laurens van der Maaten which is distributed under the BSD 4-clause license. - [Covertree code](https://github.com/lisitsyn/tapkee/blob/master/include/neighbors/covertree.hpp) by John Langford and Dinoj Surendran which is distributed under the [LGPLv3 license](https://github.com/lisitsyn/tapkee/blob/master/LGPL-LICENSE). lisitsyn-tapkee-04b33b5/data/000077500000000000000000000000001463410270200160735ustar00rootroot00000000000000lisitsyn-tapkee-04b33b5/doc/000077500000000000000000000000001463410270200157275ustar00rootroot00000000000000lisitsyn-tapkee-04b33b5/doc/Doxyfile000066400000000000000000002000401463410270200174310ustar00rootroot00000000000000# Doxyfile 1.6.2 # This file describes the settings to be used by the documentation system # doxygen (www.doxygen.org) for a project # # All text after a hash (#) is considered a comment and will be ignored # The format is: # TAG = value [value, ...] # For lists items can also be appended using: # TAG += value [value, ...] # Values that contain spaces should be placed between quotes (" ") #--------------------------------------------------------------------------- # Project related configuration options #--------------------------------------------------------------------------- # This tag specifies the encoding used for all characters in the config file # that follow. The default is UTF-8 which is also the encoding used for all # text before the first occurrence of this tag. Doxygen uses libiconv (or the # iconv built into libc) for the transcoding. See # http://www.gnu.org/software/libiconv for the list of possible encodings. DOXYFILE_ENCODING = UTF-8 # The PROJECT_NAME tag is a single word (or a sequence of words surrounded # by quotes) that should identify the project. PROJECT_NAME = "Tapkee" # The PROJECT_NUMBER tag can be used to enter a project or revision number. # This could be handy for archiving the generated documentation or # if some version control system is used. PROJECT_NUMBER = # The OUTPUT_DIRECTORY tag is used to specify the (relative or absolute) # base path where the generated documentation will be put. # If a relative path is entered, it will be relative to the location # where doxygen was started. If left blank the current directory will be used. OUTPUT_DIRECTORY = ./doc # If the CREATE_SUBDIRS tag is set to YES, then doxygen will create # 4096 sub-directories (in 2 levels) under the output directory of each output # format and will distribute the generated files over these directories. # Enabling this option can be useful when feeding doxygen a huge amount of # source files, where putting all generated files in the same directory would # otherwise cause performance problems for the file system. CREATE_SUBDIRS = NO # The OUTPUT_LANGUAGE tag is used to specify the language in which all # documentation generated by doxygen is written. Doxygen will use this # information to generate all constant output in the proper language. # The default language is English, other supported languages are: # Afrikaans, Arabic, Brazilian, Catalan, Chinese, Chinese-Traditional, # Croatian, Czech, Danish, Dutch, Esperanto, Farsi, Finnish, French, German, # Greek, Hungarian, Italian, Japanese, Japanese-en (Japanese with English # messages), Korean, Korean-en, Lithuanian, Norwegian, Macedonian, Persian, # Polish, Portuguese, Romanian, Russian, Serbian, Serbian-Cyrilic, Slovak, # Slovene, Spanish, Swedish, Ukrainian, and Vietnamese. OUTPUT_LANGUAGE = English # If the BRIEF_MEMBER_DESC tag is set to YES (the default) Doxygen will # include brief member descriptions after the members that are listed in # the file and class documentation (similar to JavaDoc). # Set to NO to disable this. BRIEF_MEMBER_DESC = NO # If the REPEAT_BRIEF tag is set to YES (the default) Doxygen will prepend # the brief description of a member or function before the detailed description. # Note: if both HIDE_UNDOC_MEMBERS and BRIEF_MEMBER_DESC are set to NO, the # brief descriptions will be completely suppressed. REPEAT_BRIEF = YES # This tag implements a quasi-intelligent brief description abbreviator # that is used to form the text in various listings. Each string # in this list, if found as the leading text of the brief description, will be # stripped from the text and the result after processing the whole list, is # used as the annotated text. Otherwise, the brief description is used as-is. # If left blank, the following values are used ("$name" is automatically # replaced with the name of the entity): "The $name class" "The $name widget" # "The $name file" "is" "provides" "specifies" "contains" # "represents" "a" "an" "the" ABBREVIATE_BRIEF = # If the ALWAYS_DETAILED_SEC and REPEAT_BRIEF tags are both set to YES then # Doxygen will generate a detailed section even if there is only a brief # description. ALWAYS_DETAILED_SEC = YES # If the INLINE_INHERITED_MEMB tag is set to YES, doxygen will show all # inherited members of a class in the documentation of that class as if those # members were ordinary class members. Constructors, destructors and assignment # operators of the base classes will not be shown. INLINE_INHERITED_MEMB = YES # If the FULL_PATH_NAMES tag is set to YES then Doxygen will prepend the full # path before files name in the file list and in the header files. If set # to NO the shortest path that makes the file name unique will be used. FULL_PATH_NAMES = NO # If the FULL_PATH_NAMES tag is set to YES then the STRIP_FROM_PATH tag # can be used to strip a user-defined part of the path. Stripping is # only done if one of the specified strings matches the left-hand part of # the path. The tag can be used to show relative paths in the file list. # If left blank the directory from which doxygen is run is used as the # path to strip. STRIP_FROM_PATH = # The STRIP_FROM_INC_PATH tag can be used to strip a user-defined part of # the path mentioned in the documentation of a class, which tells # the reader which header file to include in order to use a class. # If left blank only the name of the header file containing the class # definition is used. Otherwise one should specify the include paths that # are normally passed to the compiler using the -I flag. STRIP_FROM_INC_PATH = # If the SHORT_NAMES tag is set to YES, doxygen will generate much shorter # (but less readable) file names. This can be useful is your file systems # doesn't support long names like on DOS, Mac, or CD-ROM. SHORT_NAMES = NO # If the JAVADOC_AUTOBRIEF tag is set to YES then Doxygen # will interpret the first line (until the first dot) of a JavaDoc-style # comment as the brief description. If set to NO, the JavaDoc # comments will behave just like regular Qt-style comments # (thus requiring an explicit @brief command for a brief description.) JAVADOC_AUTOBRIEF = NO # If the QT_AUTOBRIEF tag is set to YES then Doxygen will # interpret the first line (until the first dot) of a Qt-style # comment as the brief description. If set to NO, the comments # will behave just like regular Qt-style comments (thus requiring # an explicit \brief command for a brief description.) QT_AUTOBRIEF = NO # The MULTILINE_CPP_IS_BRIEF tag can be set to YES to make Doxygen # treat a multi-line C++ special comment block (i.e. a block of //! or /// # comments) as a brief description. This used to be the default behaviour. # The new default is to treat a multi-line C++ comment block as a detailed # description. Set this tag to YES if you prefer the old behaviour instead. MULTILINE_CPP_IS_BRIEF = YES # If the INHERIT_DOCS tag is set to YES (the default) then an undocumented # member inherits the documentation from any documented member that it # re-implements. INHERIT_DOCS = YES # If the SEPARATE_MEMBER_PAGES tag is set to YES, then doxygen will produce # a new page for each member. If set to NO, the documentation of a member will # be part of the file/class/namespace that contains it. SEPARATE_MEMBER_PAGES = NO # The TAB_SIZE tag can be used to set the number of spaces in a tab. # Doxygen uses this value to replace tabs by spaces in code fragments. TAB_SIZE = 4 # This tag can be used to specify a number of aliases that acts # as commands in the documentation. An alias has the form "name=value". # For example adding "sideeffect=\par Side Effects:\n" will allow you to # put the command \sideeffect (or @sideeffect) in the documentation, which # will result in a user-defined paragraph with heading "Side Effects:". # You can put \n's in the value part of an alias to insert newlines. ALIASES = # Set the OPTIMIZE_OUTPUT_FOR_C tag to YES if your project consists of C # sources only. Doxygen will then generate output that is more tailored for C. # For instance, some of the names that are used will be different. The list # of all members will be omitted, etc. OPTIMIZE_OUTPUT_FOR_C = NO # Set the OPTIMIZE_OUTPUT_JAVA tag to YES if your project consists of Java # sources only. Doxygen will then generate output that is more tailored for # Java. For instance, namespaces will be presented as packages, qualified # scopes will look different, etc. OPTIMIZE_OUTPUT_JAVA = NO # Set the OPTIMIZE_FOR_FORTRAN tag to YES if your project consists of Fortran # sources only. Doxygen will then generate output that is more tailored for # Fortran. OPTIMIZE_FOR_FORTRAN = NO # Set the OPTIMIZE_OUTPUT_VHDL tag to YES if your project consists of VHDL # sources. Doxygen will then generate output that is tailored for # VHDL. OPTIMIZE_OUTPUT_VHDL = NO # Doxygen selects the parser to use depending on the extension of the files it parses. # With this tag you can assign which parser to use for a given extension. # Doxygen has a built-in mapping, but you can override or extend it using this tag. # The format is ext=language, where ext is a file extension, and language is one of # the parsers supported by doxygen: IDL, Java, Javascript, C#, C, C++, D, PHP, # Objective-C, Python, Fortran, VHDL, C, C++. For instance to make doxygen treat # .inc files as Fortran files (default is PHP), and .f files as C (default is Fortran), # use: inc=Fortran f=C. Note that for custom extensions you also need to set FILE_PATTERNS otherwise the files are not read by doxygen. EXTENSION_MAPPING = # If you use STL classes (i.e. std::string, std::vector, etc.) but do not want # to include (a tag file for) the STL sources as input, then you should # set this tag to YES in order to let doxygen match functions declarations and # definitions whose arguments contain STL classes (e.g. func(std::string); v.s. # func(std::string) {}). This also make the inheritance and collaboration # diagrams that involve STL classes more complete and accurate. BUILTIN_STL_SUPPORT = YES # If you use Microsoft's C++/CLI language, you should set this option to YES to # enable parsing support. CPP_CLI_SUPPORT = NO # Set the SIP_SUPPORT tag to YES if your project consists of sip sources only. # Doxygen will parse them like normal C++ but will assume all classes use public # instead of private inheritance when no explicit protection keyword is present. SIP_SUPPORT = NO # For Microsoft's IDL there are propget and propput attributes to indicate getter # and setter methods for a property. Setting this option to YES (the default) # will make doxygen to replace the get and set methods by a property in the # documentation. This will only work if the methods are indeed getting or # setting a simple type. If this is not the case, or you want to show the # methods anyway, you should set this option to NO. IDL_PROPERTY_SUPPORT = YES # If member grouping is used in the documentation and the DISTRIBUTE_GROUP_DOC # tag is set to YES, then doxygen will reuse the documentation of the first # member in the group (if any) for the other members of the group. By default # all members of a group must be documented explicitly. DISTRIBUTE_GROUP_DOC = NO # Set the SUBGROUPING tag to YES (the default) to allow class member groups of # the same type (for instance a group of public functions) to be put as a # subgroup of that type (e.g. under the Public Functions section). Set it to # NO to prevent subgrouping. Alternatively, this can be done per class using # the \nosubgrouping command. SUBGROUPING = YES # When TYPEDEF_HIDES_STRUCT is enabled, a typedef of a struct, union, or enum # is documented as struct, union, or enum with the name of the typedef. So # typedef struct TypeS {} TypeT, will appear in the documentation as a struct # with name TypeT. When disabled the typedef will appear as a member of a file, # namespace, or class. And the struct will be named TypeS. This can typically # be useful for C code in case the coding convention dictates that all compound # types are typedef'ed and only the typedef is referenced, never the tag name. TYPEDEF_HIDES_STRUCT = YES # The SYMBOL_CACHE_SIZE determines the size of the internal cache use to # determine which symbols to keep in memory and which to flush to disk. # When the cache is full, less often used symbols will be written to disk. # For small to medium size projects (<1000 input files) the default value is # probably good enough. For larger projects a too small cache size can cause # doxygen to be busy swapping symbols to and from disk most of the time # causing a significant performance penality. # If the system has enough physical memory increasing the cache will improve the # performance by keeping more symbols in memory. Note that the value works on # a logarithmic scale so increasing the size by one will rougly double the # memory usage. The cache size is given by this formula: # 2^(16+SYMBOL_CACHE_SIZE). The valid range is 0..9, the default is 0, # corresponding to a cache size of 2^16 = 65536 symbols SYMBOL_CACHE_SIZE = 0 #--------------------------------------------------------------------------- # Build related configuration options #--------------------------------------------------------------------------- # If the EXTRACT_ALL tag is set to YES doxygen will assume all entities in # documentation are documented, even if no documentation was available. # Private class members and static file members will be hidden unless # the EXTRACT_PRIVATE and EXTRACT_STATIC tags are set to YES EXTRACT_ALL = YES # If the EXTRACT_PRIVATE tag is set to YES all private members of a class # will be included in the documentation. EXTRACT_PRIVATE = YES # If the EXTRACT_STATIC tag is set to YES all static members of a file # will be included in the documentation. EXTRACT_STATIC = YES # If the EXTRACT_LOCAL_CLASSES tag is set to YES classes (and structs) # defined locally in source files will be included in the documentation. # If set to NO only classes defined in header files are included. EXTRACT_LOCAL_CLASSES = YES # This flag is only useful for Objective-C code. When set to YES local # methods, which are defined in the implementation section but not in # the interface are included in the documentation. # If set to NO (the default) only methods in the interface are included. EXTRACT_LOCAL_METHODS = NO # If this flag is set to YES, the members of anonymous namespaces will be # extracted and appear in the documentation as a namespace called # 'anonymous_namespace{file}', where file will be replaced with the base # name of the file that contains the anonymous namespace. By default # anonymous namespace are hidden. EXTRACT_ANON_NSPACES = NO # If the HIDE_UNDOC_MEMBERS tag is set to YES, Doxygen will hide all # undocumented members of documented classes, files or namespaces. # If set to NO (the default) these members will be included in the # various overviews, but no documentation section is generated. # This option has no effect if EXTRACT_ALL is enabled. HIDE_UNDOC_MEMBERS = NO # If the HIDE_UNDOC_CLASSES tag is set to YES, Doxygen will hide all # undocumented classes that are normally visible in the class hierarchy. # If set to NO (the default) these classes will be included in the various # overviews. This option has no effect if EXTRACT_ALL is enabled. HIDE_UNDOC_CLASSES = NO # If the HIDE_FRIEND_COMPOUNDS tag is set to YES, Doxygen will hide all # friend (class|struct|union) declarations. # If set to NO (the default) these declarations will be included in the # documentation. HIDE_FRIEND_COMPOUNDS = NO # If the HIDE_IN_BODY_DOCS tag is set to YES, Doxygen will hide any # documentation blocks found inside the body of a function. # If set to NO (the default) these blocks will be appended to the # function's detailed documentation block. HIDE_IN_BODY_DOCS = NO # The INTERNAL_DOCS tag determines if documentation # that is typed after a \internal command is included. If the tag is set # to NO (the default) then the documentation will be excluded. # Set it to YES to include the internal documentation. INTERNAL_DOCS = NO # If the CASE_SENSE_NAMES tag is set to NO then Doxygen will only generate # file names in lower-case letters. If set to YES upper-case letters are also # allowed. This is useful if you have classes or files whose names only differ # in case and if your file system supports case sensitive file names. Windows # and Mac users are advised to set this option to NO. CASE_SENSE_NAMES = YES # If the HIDE_SCOPE_NAMES tag is set to NO (the default) then Doxygen # will show members with their full class and namespace scopes in the # documentation. If set to YES the scope will be hidden. HIDE_SCOPE_NAMES = YES # If the SHOW_INCLUDE_FILES tag is set to YES (the default) then Doxygen # will put a list of the files that are included by a file in the documentation # of that file. SHOW_INCLUDE_FILES = YES # If the FORCE_LOCAL_INCLUDES tag is set to YES then Doxygen # will list include files with double quotes in the documentation # rather than with sharp brackets. FORCE_LOCAL_INCLUDES = NO # If the INLINE_INFO tag is set to YES (the default) then a tag [inline] # is inserted in the documentation for inline members. INLINE_INFO = NO # If the SORT_MEMBER_DOCS tag is set to YES (the default) then doxygen # will sort the (detailed) documentation of file and class members # alphabetically by member name. If set to NO the members will appear in # declaration order. SORT_MEMBER_DOCS = YES # If the SORT_BRIEF_DOCS tag is set to YES then doxygen will sort the # brief documentation of file, namespace and class members alphabetically # by member name. If set to NO (the default) the members will appear in # declaration order. SORT_BRIEF_DOCS = NO # If the SORT_MEMBERS_CTORS_1ST tag is set to YES then doxygen will sort the (brief and detailed) documentation of class members so that constructors and destructors are listed first. If set to NO (the default) the constructors will appear in the respective orders defined by SORT_MEMBER_DOCS and SORT_BRIEF_DOCS. This tag will be ignored for brief docs if SORT_BRIEF_DOCS is set to NO and ignored for detailed docs if SORT_MEMBER_DOCS is set to NO. SORT_MEMBERS_CTORS_1ST = NO # If the SORT_GROUP_NAMES tag is set to YES then doxygen will sort the # hierarchy of group names into alphabetical order. If set to NO (the default) # the group names will appear in their defined order. SORT_GROUP_NAMES = NO # If the SORT_BY_SCOPE_NAME tag is set to YES, the class list will be # sorted by fully-qualified names, including namespaces. If set to # NO (the default), the class list will be sorted only by class name, # not including the namespace part. # Note: This option is not very useful if HIDE_SCOPE_NAMES is set to YES. # Note: This option applies only to the class list, not to the # alphabetical list. SORT_BY_SCOPE_NAME = NO # The GENERATE_TODOLIST tag can be used to enable (YES) or # disable (NO) the todo list. This list is created by putting \todo # commands in the documentation. GENERATE_TODOLIST = YES # The GENERATE_TESTLIST tag can be used to enable (YES) or # disable (NO) the test list. This list is created by putting \test # commands in the documentation. GENERATE_TESTLIST = YES # The GENERATE_BUGLIST tag can be used to enable (YES) or # disable (NO) the bug list. This list is created by putting \bug # commands in the documentation. GENERATE_BUGLIST = YES # The GENERATE_DEPRECATEDLIST tag can be used to enable (YES) or # disable (NO) the deprecated list. This list is created by putting # \deprecated commands in the documentation. GENERATE_DEPRECATEDLIST= YES # The ENABLED_SECTIONS tag can be used to enable conditional # documentation sections, marked by \if sectionname ... \endif. ENABLED_SECTIONS = # The MAX_INITIALIZER_LINES tag determines the maximum number of lines # the initial value of a variable or define consists of for it to appear in # the documentation. If the initializer consists of more lines than specified # here it will be hidden. Use a value of 0 to hide initializers completely. # The appearance of the initializer of individual variables and defines in the # documentation can be controlled using \showinitializer or \hideinitializer # command in the documentation regardless of this setting. MAX_INITIALIZER_LINES = 30 # Set the SHOW_USED_FILES tag to NO to disable the list of files generated # at the bottom of the documentation of classes and structs. If set to YES the # list will mention the files that were used to generate the documentation. SHOW_USED_FILES = YES # If the sources in your project are distributed over multiple directories # then setting the SHOW_DIRECTORIES tag to YES will show the directory hierarchy # in the documentation. The default is NO. SHOW_DIRECTORIES = YES # Set the SHOW_FILES tag to NO to disable the generation of the Files page. # This will remove the Files entry from the Quick Index and from the # Folder Tree View (if specified). The default is YES. SHOW_FILES = YES # Set the SHOW_NAMESPACES tag to NO to disable the generation of the # Namespaces page. # This will remove the Namespaces entry from the Quick Index # and from the Folder Tree View (if specified). The default is YES. SHOW_NAMESPACES = YES # The FILE_VERSION_FILTER tag can be used to specify a program or script that # doxygen should invoke to get the current version for each file (typically from # the version control system). Doxygen will invoke the program by executing (via # popen()) the command , where is the value of # the FILE_VERSION_FILTER tag, and is the name of an input file # provided by doxygen. Whatever the program writes to standard output # is used as the file version. See the manual for examples. FILE_VERSION_FILTER = # The LAYOUT_FILE tag can be used to specify a layout file which will be parsed by # doxygen. The layout file controls the global structure of the generated output files # in an output format independent way. The create the layout file that represents # doxygen's defaults, run doxygen with the -l option. You can optionally specify a # file name after the option, if omitted DoxygenLayout.xml will be used as the name # of the layout file. LAYOUT_FILE = #--------------------------------------------------------------------------- # configuration options related to warning and progress messages #--------------------------------------------------------------------------- # The QUIET tag can be used to turn on/off the messages that are generated # by doxygen. Possible values are YES and NO. If left blank NO is used. QUIET = YES # The WARNINGS tag can be used to turn on/off the warning messages that are # generated by doxygen. Possible values are YES and NO. If left blank # NO is used. WARNINGS = YES # If WARN_IF_UNDOCUMENTED is set to YES, then doxygen will generate warnings # for undocumented members. If EXTRACT_ALL is set to YES then this flag will # automatically be disabled. WARN_IF_UNDOCUMENTED = YES # If WARN_IF_DOC_ERROR is set to YES, doxygen will generate warnings for # potential errors in the documentation, such as not documenting some # parameters in a documented function, or documenting parameters that # don't exist or using markup commands wrongly. WARN_IF_DOC_ERROR = YES # This WARN_NO_PARAMDOC option can be abled to get warnings for # functions that are documented, but have no documentation for their parameters # or return value. If set to NO (the default) doxygen will only warn about # wrong or incomplete parameter documentation, but not about the absence of # documentation. WARN_NO_PARAMDOC = NO # The WARN_FORMAT tag determines the format of the warning messages that # doxygen can produce. The string should contain the $file, $line, and $text # tags, which will be replaced by the file and line number from which the # warning originated and the warning text. Optionally the format may contain # $version, which will be replaced by the version of the file (if it could # be obtained via FILE_VERSION_FILTER) WARN_FORMAT = "$file:$line: $text " # The WARN_LOGFILE tag can be used to specify a file to which warning # and error messages should be written. If left blank the output is written # to stderr. WARN_LOGFILE = #--------------------------------------------------------------------------- # configuration options related to the input files #--------------------------------------------------------------------------- # The INPUT tag can be used to specify the files and/or directories that contain # documented source files. You may enter file names like "myfile.cpp" or # directories like "/usr/src/myproject". Separate the files or directories # with spaces. INPUT = ./include # This tag can be used to specify the character encoding of the source files # that doxygen parses. Internally doxygen uses the UTF-8 encoding, which is # also the default input encoding. Doxygen uses libiconv (or the iconv built # into libc) for the transcoding. See http://www.gnu.org/software/libiconv for # the list of possible encodings. INPUT_ENCODING = UTF-8 # If the value of the INPUT tag contains directories, you can use the # FILE_PATTERNS tag to specify one or more wildcard pattern (like *.cpp # and *.h) to filter out the source-files in the directories. If left # blank the following patterns are tested: # *.c *.cc *.cxx *.cpp *.c++ *.java *.ii *.ixx *.ipp *.i++ *.inl *.h *.hh *.hxx # *.hpp *.h++ *.idl *.odl *.cs *.php *.php3 *.inc *.m *.mm *.py *.f90 FILE_PATTERNS = *.hpp # The RECURSIVE tag can be used to turn specify whether or not subdirectories # should be searched for input files as well. Possible values are YES and NO. # If left blank NO is used. RECURSIVE = YES # The EXCLUDE tag can be used to specify files and/or directories that should # excluded from the INPUT source files. This way you can easily exclude a # subdirectory from a directory tree whose root is specified with the INPUT tag. EXCLUDE = # The EXCLUDE_SYMLINKS tag can be used select whether or not files or # directories that are symbolic links (a Unix filesystem feature) are excluded # from the input. EXCLUDE_SYMLINKS = YES # If the value of the INPUT tag contains directories, you can use the # EXCLUDE_PATTERNS tag to specify one or more wildcard patterns to exclude # certain files from those directories. Note that the wildcards are matched # against the file with absolute path, so to exclude all test directories # for example use the pattern */test/* EXCLUDE_PATTERNS = # The EXCLUDE_SYMBOLS tag can be used to specify one or more symbol names # (namespaces, classes, functions, etc.) that should be excluded from the # output. The symbol name can be a fully qualified name, a word, or if the # wildcard * is used, a substring. Examples: ANamespace, AClass, # AClass::ANamespace, ANamespace::*Test EXCLUDE_SYMBOLS = # The EXAMPLE_PATH tag can be used to specify one or more files or # directories that contain example code fragments that are included (see # the \include command). EXAMPLE_PATH = # If the value of the EXAMPLE_PATH tag contains directories, you can use the # EXAMPLE_PATTERNS tag to specify one or more wildcard pattern (like *.cpp # and *.h) to filter out the source-files in the directories. If left # blank all files are included. EXAMPLE_PATTERNS = # If the EXAMPLE_RECURSIVE tag is set to YES then subdirectories will be # searched for input files to be used with the \include or \dontinclude # commands irrespective of the value of the RECURSIVE tag. # Possible values are YES and NO. If left blank NO is used. EXAMPLE_RECURSIVE = YES # The IMAGE_PATH tag can be used to specify one or more files or # directories that contain image that are included in the documentation (see # the \image command). IMAGE_PATH = . # The INPUT_FILTER tag can be used to specify a program that doxygen should # invoke to filter for each input file. Doxygen will invoke the filter program # by executing (via popen()) the command , where # is the value of the INPUT_FILTER tag, and is the name of an # input file. Doxygen will then use the output that the filter program writes # to standard output. # If FILTER_PATTERNS is specified, this tag will be # ignored. INPUT_FILTER = # The FILTER_PATTERNS tag can be used to specify filters on a per file pattern # basis. # Doxygen will compare the file name with each pattern and apply the # filter if there is a match. # The filters are a list of the form: # pattern=filter (like *.cpp=my_cpp_filter). See INPUT_FILTER for further # info on how filters are used. If FILTER_PATTERNS is empty, INPUT_FILTER # is applied to all files. FILTER_PATTERNS = # If the FILTER_SOURCE_FILES tag is set to YES, the input filter (if set using # INPUT_FILTER) will be used to filter the input files when producing source # files to browse (i.e. when SOURCE_BROWSER is set to YES). FILTER_SOURCE_FILES = NO #--------------------------------------------------------------------------- # configuration options related to source browsing #--------------------------------------------------------------------------- # If the SOURCE_BROWSER tag is set to YES then a list of source files will # be generated. Documented entities will be cross-referenced with these sources. # Note: To get rid of all source code in the generated output, make sure also # VERBATIM_HEADERS is set to NO. SOURCE_BROWSER = YES # Setting the INLINE_SOURCES tag to YES will include the body # of functions and classes directly in the documentation. INLINE_SOURCES = NO # Setting the STRIP_CODE_COMMENTS tag to YES (the default) will instruct # doxygen to hide any special comment blocks from generated source code # fragments. Normal C and C++ comments will always remain visible. STRIP_CODE_COMMENTS = YES # If the REFERENCED_BY_RELATION tag is set to YES # then for each documented function all documented # functions referencing it will be listed. REFERENCED_BY_RELATION = NO # If the REFERENCES_RELATION tag is set to YES # then for each documented function all documented entities # called/used by that function will be listed. REFERENCES_RELATION = NO # If the REFERENCES_LINK_SOURCE tag is set to YES (the default) # and SOURCE_BROWSER tag is set to YES, then the hyperlinks from # functions in REFERENCES_RELATION and REFERENCED_BY_RELATION lists will # link to the source code. # Otherwise they will link to the documentation. REFERENCES_LINK_SOURCE = NO # If the USE_HTAGS tag is set to YES then the references to source code # will point to the HTML generated by the htags(1) tool instead of doxygen # built-in source browser. The htags tool is part of GNU's global source # tagging system (see http://www.gnu.org/software/global/global.html). You # will need version 4.8.6 or higher. USE_HTAGS = NO # If the VERBATIM_HEADERS tag is set to YES (the default) then Doxygen # will generate a verbatim copy of the header file for each class for # which an include is specified. Set to NO to disable this. VERBATIM_HEADERS = NO #--------------------------------------------------------------------------- # configuration options related to the alphabetical class index #--------------------------------------------------------------------------- # If the ALPHABETICAL_INDEX tag is set to YES, an alphabetical index # of all compounds will be generated. Enable this if the project # contains a lot of classes, structs, unions or interfaces. ALPHABETICAL_INDEX = YES # If the alphabetical index is enabled (see ALPHABETICAL_INDEX) then # the COLS_IN_ALPHA_INDEX tag can be used to specify the number of columns # in which this list will be split (can be a number in the range [1..20]) COLS_IN_ALPHA_INDEX = 5 # In case all classes in a project start with a common prefix, all # classes will be put under the same header in the alphabetical index. # The IGNORE_PREFIX tag can be used to specify one or more prefixes that # should be ignored while generating the index headers. IGNORE_PREFIX = C #--------------------------------------------------------------------------- # configuration options related to the HTML output #--------------------------------------------------------------------------- # If the GENERATE_HTML tag is set to YES (the default) Doxygen will # generate HTML output. GENERATE_HTML = YES # The HTML_OUTPUT tag is used to specify where the HTML docs will be put. # If a relative path is entered the value of OUTPUT_DIRECTORY will be # put in front of it. If left blank `html' will be used as the default path. HTML_OUTPUT = html # The HTML_FILE_EXTENSION tag can be used to specify the file extension for # each generated HTML page (for example: .htm,.php,.asp). If it is left blank # doxygen will generate files with .html extension. HTML_FILE_EXTENSION = .html # The HTML_HEADER tag can be used to specify a personal HTML header for # each generated HTML page. If it is left blank doxygen will generate a # standard header. HTML_HEADER = # The HTML_FOOTER tag can be used to specify a personal HTML footer for # each generated HTML page. If it is left blank doxygen will generate a # standard footer. HTML_FOOTER = # The HTML_STYLESHEET tag can be used to specify a user-defined cascading # style sheet that is used by each HTML page. It can be used to # fine-tune the look of the HTML output. If the tag is left blank doxygen # will generate a default style sheet. Note that doxygen will try to copy # the style sheet file to the HTML output directory, so don't put your own # stylesheet in the HTML output directory as well, or it will be erased! HTML_STYLESHEET = # If the HTML_TIMESTAMP tag is set to YES then the footer of each generated HTML # page will contain the date and time when the page was generated. Setting # this to NO can help when comparing the output of multiple runs. HTML_TIMESTAMP = NO # If the HTML_ALIGN_MEMBERS tag is set to YES, the members of classes, # files or namespaces will be aligned in HTML using tables. If set to # NO a bullet list will be used. HTML_ALIGN_MEMBERS = YES # If the HTML_DYNAMIC_SECTIONS tag is set to YES then the generated HTML # documentation will contain sections that can be hidden and shown after the # page has loaded. For this to work a browser that supports # JavaScript and DHTML is required (for instance Mozilla 1.0+, Firefox # Netscape 6.0+, Internet explorer 5.0+, Konqueror, or Safari). HTML_DYNAMIC_SECTIONS = NO # If the GENERATE_DOCSET tag is set to YES, additional index files # will be generated that can be used as input for Apple's Xcode 3 # integrated development environment, introduced with OSX 10.5 (Leopard). # To create a documentation set, doxygen will generate a Makefile in the # HTML output directory. Running make will produce the docset in that # directory and running "make install" will install the docset in # ~/Library/Developer/Shared/Documentation/DocSets so that Xcode will find # it at startup. # See http://developer.apple.com/tools/creatingdocsetswithdoxygen.html for more information. GENERATE_DOCSET = NO # When GENERATE_DOCSET tag is set to YES, this tag determines the name of the # feed. A documentation feed provides an umbrella under which multiple # documentation sets from a single provider (such as a company or product suite) # can be grouped. DOCSET_FEEDNAME = "Doxygen generated docs" # When GENERATE_DOCSET tag is set to YES, this tag specifies a string that # should uniquely identify the documentation set bundle. This should be a # reverse domain-name style string, e.g. com.mycompany.MyDocSet. Doxygen # will append .docset to the name. DOCSET_BUNDLE_ID = org.doxygen.Project # If the GENERATE_HTMLHELP tag is set to YES, additional index files # will be generated that can be used as input for tools like the # Microsoft HTML help workshop to generate a compiled HTML help file (.chm) # of the generated HTML documentation. GENERATE_HTMLHELP = NO # If the GENERATE_HTMLHELP tag is set to YES, the CHM_FILE tag can # be used to specify the file name of the resulting .chm file. You # can add a path in front of the file if the result should not be # written to the html output directory. CHM_FILE = # If the GENERATE_HTMLHELP tag is set to YES, the HHC_LOCATION tag can # be used to specify the location (absolute path including file name) of # the HTML help compiler (hhc.exe). If non-empty doxygen will try to run # the HTML help compiler on the generated index.hhp. HHC_LOCATION = # If the GENERATE_HTMLHELP tag is set to YES, the GENERATE_CHI flag # controls if a separate .chi index file is generated (YES) or that # it should be included in the master .chm file (NO). GENERATE_CHI = NO # If the GENERATE_HTMLHELP tag is set to YES, the CHM_INDEX_ENCODING # is used to encode HtmlHelp index (hhk), content (hhc) and project file # content. CHM_INDEX_ENCODING = # If the GENERATE_HTMLHELP tag is set to YES, the BINARY_TOC flag # controls whether a binary table of contents is generated (YES) or a # normal table of contents (NO) in the .chm file. BINARY_TOC = NO # The TOC_EXPAND flag can be set to YES to add extra items for group members # to the contents of the HTML help documentation and to the tree view. TOC_EXPAND = YES # If the GENERATE_QHP tag is set to YES and both QHP_NAMESPACE and QHP_VIRTUAL_FOLDER # are set, an additional index file will be generated that can be used as input for # Qt's qhelpgenerator to generate a Qt Compressed Help (.qch) of the generated # HTML documentation. GENERATE_QHP = NO # If the QHG_LOCATION tag is specified, the QCH_FILE tag can # be used to specify the file name of the resulting .qch file. # The path specified is relative to the HTML output folder. QCH_FILE = # The QHP_NAMESPACE tag specifies the namespace to use when generating # Qt Help Project output. For more information please see # http://doc.trolltech.com/qthelpproject.html#namespace QHP_NAMESPACE = # The QHP_VIRTUAL_FOLDER tag specifies the namespace to use when generating # Qt Help Project output. For more information please see # http://doc.trolltech.com/qthelpproject.html#virtual-folders QHP_VIRTUAL_FOLDER = doc # If QHP_CUST_FILTER_NAME is set, it specifies the name of a custom filter to add. # For more information please see # http://doc.trolltech.com/qthelpproject.html#custom-filters QHP_CUST_FILTER_NAME = # The QHP_CUST_FILT_ATTRS tag specifies the list of the attributes of the custom filter to add.For more information please see # Qt Help Project / Custom Filters. QHP_CUST_FILTER_ATTRS = # The QHP_SECT_FILTER_ATTRS tag specifies the list of the attributes this project's # filter section matches. # Qt Help Project / Filter Attributes. QHP_SECT_FILTER_ATTRS = # If the GENERATE_QHP tag is set to YES, the QHG_LOCATION tag can # be used to specify the location of Qt's qhelpgenerator. # If non-empty doxygen will try to run qhelpgenerator on the generated # .qhp file. QHG_LOCATION = # If the GENERATE_ECLIPSEHELP tag is set to YES, additional index files # will be generated, which together with the HTML files, form an Eclipse help # plugin. To install this plugin and make it available under the help contents # menu in Eclipse, the contents of the directory containing the HTML and XML # files needs to be copied into the plugins directory of eclipse. The name of # the directory within the plugins directory should be the same as # the ECLIPSE_DOC_ID value. After copying Eclipse needs to be restarted before the help appears. GENERATE_ECLIPSEHELP = NO # A unique identifier for the eclipse help plugin. When installing the plugin # the directory name containing the HTML and XML files should also have # this name. ECLIPSE_DOC_ID = org.doxygen.Project # The DISABLE_INDEX tag can be used to turn on/off the condensed index at # top of each HTML page. The value NO (the default) enables the index and # the value YES disables it. DISABLE_INDEX = NO # This tag can be used to set the number of enum values (range [1..20]) # that doxygen will group on one line in the generated HTML documentation. ENUM_VALUES_PER_LINE = 4 # The GENERATE_TREEVIEW tag is used to specify whether a tree-like index # structure should be generated to display hierarchical information. # If the tag value is set to YES, a side panel will be generated # containing a tree-like index structure (just like the one that # is generated for HTML Help). For this to work a browser that supports # JavaScript, DHTML, CSS and frames is required (i.e. any modern browser). # Windows users are probably better off using the HTML help feature. GENERATE_TREEVIEW = NO # By enabling USE_INLINE_TREES, doxygen will generate the Groups, Directories, # and Class Hierarchy pages using a tree view instead of an ordered list. USE_INLINE_TREES = NO # If the treeview is enabled (see GENERATE_TREEVIEW) then this tag can be # used to set the initial width (in pixels) of the frame in which the tree # is shown. TREEVIEW_WIDTH = 250 # Use this tag to change the font size of Latex formulas included # as images in the HTML documentation. The default is 10. Note that # when you change the font size after a successful doxygen run you need # to manually remove any form_*.png images from the HTML output directory # to force them to be regenerated. FORMULA_FONTSIZE = 10 # When the SEARCHENGINE tag is enabled doxygen will generate a search box for the HTML output. The underlying search engine uses javascript # and DHTML and should work on any modern browser. Note that when using HTML help (GENERATE_HTMLHELP), Qt help (GENERATE_QHP), or docsets (GENERATE_DOCSET) there is already a search function so this one should # typically be disabled. For large projects the javascript based search engine # can be slow, then enabling SERVER_BASED_SEARCH may provide a better solution. SEARCHENGINE = YES # When the SERVER_BASED_SEARCH tag is enabled the search engine will be implemented using a PHP enabled web server instead of at the web client using Javascript. Doxygen will generate the search PHP script and index # file to put on the web server. The advantage of the server based approach is that it scales better to large projects and allows full text search. The disadvances is that it is more difficult to setup # and does not have live searching capabilities. SERVER_BASED_SEARCH = NO #--------------------------------------------------------------------------- # configuration options related to the LaTeX output #--------------------------------------------------------------------------- # If the GENERATE_LATEX tag is set to YES (the default) Doxygen will # generate Latex output. GENERATE_LATEX = NO # The LATEX_OUTPUT tag is used to specify where the LaTeX docs will be put. # If a relative path is entered the value of OUTPUT_DIRECTORY will be # put in front of it. If left blank `latex' will be used as the default path. LATEX_OUTPUT = latex # The LATEX_CMD_NAME tag can be used to specify the LaTeX command name to be # invoked. If left blank `latex' will be used as the default command name. # Note that when enabling USE_PDFLATEX this option is only used for # generating bitmaps for formulas in the HTML output, but not in the # Makefile that is written to the output directory. LATEX_CMD_NAME = latex # The MAKEINDEX_CMD_NAME tag can be used to specify the command name to # generate index for LaTeX. If left blank `makeindex' will be used as the # default command name. MAKEINDEX_CMD_NAME = makeindex # If the COMPACT_LATEX tag is set to YES Doxygen generates more compact # LaTeX documents. This may be useful for small projects and may help to # save some trees in general. COMPACT_LATEX = NO # The PAPER_TYPE tag can be used to set the paper type that is used # by the printer. Possible values are: a4, a4wide, letter, legal and # executive. If left blank a4wide will be used. PAPER_TYPE = a4wide # The EXTRA_PACKAGES tag can be to specify one or more names of LaTeX # packages that should be included in the LaTeX output. EXTRA_PACKAGES = amsmath amscd amsxtra amsfonts amssymb amsthm # The LATEX_HEADER tag can be used to specify a personal LaTeX header for # the generated latex document. The header should contain everything until # the first chapter. If it is left blank doxygen will generate a # standard header. Notice: only use this tag if you know what you are doing! LATEX_HEADER = # If the PDF_HYPERLINKS tag is set to YES, the LaTeX that is generated # is prepared for conversion to pdf (using ps2pdf). The pdf file will # contain links (just like the HTML output) instead of page references # This makes the output suitable for online browsing using a pdf viewer. PDF_HYPERLINKS = YES # If the USE_PDFLATEX tag is set to YES, pdflatex will be used instead of # plain latex in the generated Makefile. Set this option to YES to get a # higher quality PDF documentation. USE_PDFLATEX = YES # If the LATEX_BATCHMODE tag is set to YES, doxygen will add the \\batchmode. # command to the generated LaTeX files. This will instruct LaTeX to keep # running if errors occur, instead of asking the user for help. # This option is also used when generating formulas in HTML. LATEX_BATCHMODE = YES # If LATEX_HIDE_INDICES is set to YES then doxygen will not # include the index chapters (such as File Index, Compound Index, etc.) # in the output. LATEX_HIDE_INDICES = NO # If LATEX_SOURCE_CODE is set to YES then doxygen will include source code with syntax highlighting in the LaTeX output. Note that which sources are shown also depends on other settings such as SOURCE_BROWSER. LATEX_SOURCE_CODE = NO #--------------------------------------------------------------------------- # configuration options related to the RTF output #--------------------------------------------------------------------------- # If the GENERATE_RTF tag is set to YES Doxygen will generate RTF output # The RTF output is optimized for Word 97 and may not look very pretty with # other RTF readers or editors. GENERATE_RTF = NO # The RTF_OUTPUT tag is used to specify where the RTF docs will be put. # If a relative path is entered the value of OUTPUT_DIRECTORY will be # put in front of it. If left blank `rtf' will be used as the default path. RTF_OUTPUT = rtf # If the COMPACT_RTF tag is set to YES Doxygen generates more compact # RTF documents. This may be useful for small projects and may help to # save some trees in general. COMPACT_RTF = NO # If the RTF_HYPERLINKS tag is set to YES, the RTF that is generated # will contain hyperlink fields. The RTF file will # contain links (just like the HTML output) instead of page references. # This makes the output suitable for online browsing using WORD or other # programs which support those fields. # Note: wordpad (write) and others do not support links. RTF_HYPERLINKS = NO # Load stylesheet definitions from file. Syntax is similar to doxygen's # config file, i.e. a series of assignments. You only have to provide # replacements, missing definitions are set to their default value. RTF_STYLESHEET_FILE = # Set optional variables used in the generation of an rtf document. # Syntax is similar to doxygen's config file. RTF_EXTENSIONS_FILE = #--------------------------------------------------------------------------- # configuration options related to the man page output #--------------------------------------------------------------------------- # If the GENERATE_MAN tag is set to YES (the default) Doxygen will # generate man pages GENERATE_MAN = NO # The MAN_OUTPUT tag is used to specify where the man pages will be put. # If a relative path is entered the value of OUTPUT_DIRECTORY will be # put in front of it. If left blank `man' will be used as the default path. MAN_OUTPUT = man # The MAN_EXTENSION tag determines the extension that is added to # the generated man pages (default is the subroutine's section .3) MAN_EXTENSION = .3 # If the MAN_LINKS tag is set to YES and Doxygen generates man output, # then it will generate one additional man file for each entity # documented in the real man page(s). These additional files # only source the real man page, but without them the man command # would be unable to find the correct page. The default is NO. MAN_LINKS = NO #--------------------------------------------------------------------------- # configuration options related to the XML output #--------------------------------------------------------------------------- # If the GENERATE_XML tag is set to YES Doxygen will # generate an XML file that captures the structure of # the code including all documentation. GENERATE_XML = NO # The XML_OUTPUT tag is used to specify where the XML pages will be put. # If a relative path is entered the value of OUTPUT_DIRECTORY will be # put in front of it. If left blank `xml' will be used as the default path. XML_OUTPUT = xml # The XML_SCHEMA tag can be used to specify an XML schema, # which can be used by a validating XML parser to check the # syntax of the XML files. XML_SCHEMA = # The XML_DTD tag can be used to specify an XML DTD, # which can be used by a validating XML parser to check the # syntax of the XML files. XML_DTD = # If the XML_PROGRAMLISTING tag is set to YES Doxygen will # dump the program listings (including syntax highlighting # and cross-referencing information) to the XML output. Note that # enabling this will significantly increase the size of the XML output. XML_PROGRAMLISTING = YES #--------------------------------------------------------------------------- # configuration options for the AutoGen Definitions output #--------------------------------------------------------------------------- # If the GENERATE_AUTOGEN_DEF tag is set to YES Doxygen will # generate an AutoGen Definitions (see autogen.sf.net) file # that captures the structure of the code including all # documentation. Note that this feature is still experimental # and incomplete at the moment. GENERATE_AUTOGEN_DEF = NO #--------------------------------------------------------------------------- # configuration options related to the Perl module output #--------------------------------------------------------------------------- # If the GENERATE_PERLMOD tag is set to YES Doxygen will # generate a Perl module file that captures the structure of # the code including all documentation. Note that this # feature is still experimental and incomplete at the # moment. GENERATE_PERLMOD = NO # If the PERLMOD_LATEX tag is set to YES Doxygen will generate # the necessary Makefile rules, Perl scripts and LaTeX code to be able # to generate PDF and DVI output from the Perl module output. PERLMOD_LATEX = NO # If the PERLMOD_PRETTY tag is set to YES the Perl module output will be # nicely formatted so it can be parsed by a human reader. # This is useful # if you want to understand what is going on. # On the other hand, if this # tag is set to NO the size of the Perl module output will be much smaller # and Perl will parse it just the same. PERLMOD_PRETTY = YES # The names of the make variables in the generated doxyrules.make file # are prefixed with the string contained in PERLMOD_MAKEVAR_PREFIX. # This is useful so different doxyrules.make files included by the same # Makefile don't overwrite each other's variables. PERLMOD_MAKEVAR_PREFIX = #--------------------------------------------------------------------------- # Configuration options related to the preprocessor #--------------------------------------------------------------------------- # If the ENABLE_PREPROCESSING tag is set to YES (the default) Doxygen will # evaluate all C-preprocessor directives found in the sources and include # files. ENABLE_PREPROCESSING = YES # If the MACRO_EXPANSION tag is set to YES Doxygen will expand all macro # names in the source code. If set to NO (the default) only conditional # compilation will be performed. Macro expansion can be done in a controlled # way by setting EXPAND_ONLY_PREDEF to YES. MACRO_EXPANSION = YES # If the EXPAND_ONLY_PREDEF and MACRO_EXPANSION tags are both set to YES # then the macro expansion is limited to the macros specified with the # PREDEFINED and EXPAND_AS_DEFINED tags. EXPAND_ONLY_PREDEF = NO # If the SEARCH_INCLUDES tag is set to YES (the default) the includes files # in the INCLUDE_PATH (see below) will be search if a #include is found. SEARCH_INCLUDES = YES # The INCLUDE_PATH tag can be used to specify one or more directories that # contain include files that are not input files but should be processed by # the preprocessor. INCLUDE_PATH = . # You can use the INCLUDE_FILE_PATTERNS tag to specify one or more wildcard # patterns (like *.h and *.hpp) to filter out the header-files in the # directories. If left blank, the patterns specified with FILE_PATTERNS will # be used. INCLUDE_FILE_PATTERNS = *.hpp # The PREDEFINED tag can be used to specify one or more macro names that # are defined before the preprocessor is started (similar to the -D option of # gcc). The argument of the tag is a list of macros of the form: name # or name=definition (no spaces). If the definition and the = are # omitted =1 is assumed. To prevent a macro definition from being # undefined via #undef or recursively expanded use the := operator # instead of the = operator. PREDEFINED = DOXYGEN_SHOULD_SKIP_THIS TAPKEE_WITH_ARPACK TAPKEE_USE_LGPL_COVERTREE # If the MACRO_EXPANSION and EXPAND_ONLY_PREDEF tags are set to YES then # this tag can be used to specify a list of macro names that should be expanded. # The macro definition that is found in the sources will be used. # Use the PREDEFINED tag if you want to use a different macro definition. EXPAND_AS_DEFINED = # If the SKIP_FUNCTION_MACROS tag is set to YES (the default) then # doxygen's preprocessor will remove all function-like macros that are alone # on a line, have an all uppercase name, and do not end with a semicolon. Such # function macros are typically used for boiler-plate code, and will confuse # the parser if not removed. SKIP_FUNCTION_MACROS = YES #--------------------------------------------------------------------------- # Configuration::additions related to external references #--------------------------------------------------------------------------- # The TAGFILES option can be used to specify one or more tagfiles. # Optionally an initial location of the external documentation # can be added for each tagfile. The format of a tag file without # this location is as follows: # # TAGFILES = file1 file2 ... # Adding location for the tag files is done as follows: # # TAGFILES = file1=loc1 "file2 = loc2" ... # where "loc1" and "loc2" can be relative or absolute paths or # URLs. If a location is present for each tag, the installdox tool # does not have to be run to correct the links. # Note that each tag file must have a unique name # (where the name does NOT include the path) # If a tag file is not located in the directory in which doxygen # is run, you must also specify the path to the tagfile here. TAGFILES = # When a file name is specified after GENERATE_TAGFILE, doxygen will create # a tag file that is based on the input files it reads. GENERATE_TAGFILE = # If the ALLEXTERNALS tag is set to YES all external classes will be listed # in the class index. If set to NO only the inherited external classes # will be listed. ALLEXTERNALS = NO # If the EXTERNAL_GROUPS tag is set to YES all external groups will be listed # in the modules index. If set to NO, only the current project's groups will # be listed. EXTERNAL_GROUPS = YES # The PERL_PATH should be the absolute path and name of the perl script # interpreter (i.e. the result of `which perl'). PERL_PATH = /usr/bin/perl #--------------------------------------------------------------------------- # Configuration options related to the dot tool #--------------------------------------------------------------------------- # If the CLASS_DIAGRAMS tag is set to YES (the default) Doxygen will # generate a inheritance diagram (in HTML, RTF and LaTeX) for classes with base # or super classes. Setting the tag to NO turns the diagrams off. Note that # this option is superseded by the HAVE_DOT option below. This is only a # fallback. It is recommended to install and use dot, since it yields more # powerful graphs. CLASS_DIAGRAMS = NO # You can define message sequence charts within doxygen comments using the \msc # command. Doxygen will then run the mscgen tool (see # http://www.mcternan.me.uk/mscgen/) to produce the chart and insert it in the # documentation. The MSCGEN_PATH tag allows you to specify the directory where # the mscgen tool resides. If left empty the tool is assumed to be found in the # default search path. MSCGEN_PATH = # If set to YES, the inheritance and collaboration graphs will hide # inheritance and usage relations if the target is undocumented # or is not a class. HIDE_UNDOC_RELATIONS = YES # If you set the HAVE_DOT tag to YES then doxygen will assume the dot tool is # available from the path. This tool is part of Graphviz, a graph visualization # toolkit from AT&T and Lucent Bell Labs. The other options in this section # have no effect if this option is set to NO (the default) HAVE_DOT = YES # By default doxygen will write a font called FreeSans.ttf to the output # directory and reference it in all dot files that doxygen generates. This # font does not include all possible unicode characters however, so when you need # these (or just want a differently looking font) you can specify the font name # using DOT_FONTNAME. You need need to make sure dot is able to find the font, # which can be done by putting it in a standard location or by setting the # DOTFONTPATH environment variable or by setting DOT_FONTPATH to the directory # containing the font. DOT_FONTNAME = FreeSans # The DOT_FONTSIZE tag can be used to set the size of the font of dot graphs. # The default size is 10pt. DOT_FONTSIZE = 10 # By default doxygen will tell dot to use the output directory to look for the # FreeSans.ttf font (which doxygen will put there itself). If you specify a # different font using DOT_FONTNAME you can set the path where dot # can find it using this tag. DOT_FONTPATH = # If the CLASS_GRAPH and HAVE_DOT tags are set to YES then doxygen # will generate a graph for each documented class showing the direct and # indirect inheritance relations. Setting this tag to YES will force the # the CLASS_DIAGRAMS tag to NO. CLASS_GRAPH = NO # If the COLLABORATION_GRAPH and HAVE_DOT tags are set to YES then doxygen # will generate a graph for each documented class showing the direct and # indirect implementation dependencies (inheritance, containment, and # class references variables) of the class with other documented classes. COLLABORATION_GRAPH = NO # If the GROUP_GRAPHS and HAVE_DOT tags are set to YES then doxygen # will generate a graph for groups, showing the direct groups dependencies GROUP_GRAPHS = NO # If the UML_LOOK tag is set to YES doxygen will generate inheritance and # collaboration diagrams in a style similar to the OMG's Unified Modeling # Language. UML_LOOK = NO # If set to YES, the inheritance and collaboration graphs will show the # relations between templates and their instances. TEMPLATE_RELATIONS = NO # If the ENABLE_PREPROCESSING, SEARCH_INCLUDES, INCLUDE_GRAPH, and HAVE_DOT # tags are set to YES then doxygen will generate a graph for each documented # file showing the direct and indirect include dependencies of the file with # other documented files. INCLUDE_GRAPH = NO # If the ENABLE_PREPROCESSING, SEARCH_INCLUDES, INCLUDED_BY_GRAPH, and # HAVE_DOT tags are set to YES then doxygen will generate a graph for each # documented header file showing the documented files that directly or # indirectly include this file. INCLUDED_BY_GRAPH = NO # If the CALL_GRAPH and HAVE_DOT options are set to YES then # doxygen will generate a call dependency graph for every global function # or class method. Note that enabling this option will significantly increase # the time of a run. So in most cases it will be better to enable call graphs # for selected functions only using the \callgraph command. CALL_GRAPH = NO # If the CALLER_GRAPH and HAVE_DOT tags are set to YES then # doxygen will generate a caller dependency graph for every global function # or class method. Note that enabling this option will significantly increase # the time of a run. So in most cases it will be better to enable caller # graphs for selected functions only using the \callergraph command. CALLER_GRAPH = NO # If the GRAPHICAL_HIERARCHY and HAVE_DOT tags are set to YES then doxygen # will graphical hierarchy of all classes instead of a textual one. GRAPHICAL_HIERARCHY = NO # If the DIRECTORY_GRAPH, SHOW_DIRECTORIES and HAVE_DOT tags are set to YES # then doxygen will show the dependencies a directory has on other directories # in a graphical way. The dependency relations are determined by the #include # relations between the files in the directories. DIRECTORY_GRAPH = NO # The DOT_IMAGE_FORMAT tag can be used to set the image format of the images # generated by dot. Possible values are png, jpg, or gif # If left blank png will be used. DOT_IMAGE_FORMAT = png # The tag DOT_PATH can be used to specify the path where the dot tool can be # found. If left blank, it is assumed the dot tool can be found in the path. DOT_PATH = # The DOTFILE_DIRS tag can be used to specify one or more directories that # contain dot files that are included in the documentation (see the # \dotfile command). DOTFILE_DIRS = # The DOT_GRAPH_MAX_NODES tag can be used to set the maximum number of # nodes that will be shown in the graph. If the number of nodes in a graph # becomes larger than this value, doxygen will truncate the graph, which is # visualized by representing a node as a red box. Note that doxygen if the # number of direct children of the root node in a graph is already larger than # DOT_GRAPH_MAX_NODES then the graph will not be shown at all. Also note # that the size of a graph can be further restricted by MAX_DOT_GRAPH_DEPTH. DOT_GRAPH_MAX_NODES = 50 # The MAX_DOT_GRAPH_DEPTH tag can be used to set the maximum depth of the # graphs generated by dot. A depth value of 3 means that only nodes reachable # from the root by following a path via at most 3 edges will be shown. Nodes # that lay further from the root node will be omitted. Note that setting this # option to 1 or 2 may greatly reduce the computation time needed for large # code bases. Also note that the size of a graph can be further restricted by # DOT_GRAPH_MAX_NODES. Using a depth of 0 means no depth restriction. MAX_DOT_GRAPH_DEPTH = 0 # Set the DOT_TRANSPARENT tag to YES to generate images with a transparent # background. This is disabled by default, because dot on Windows does not # seem to support this out of the box. Warning: Depending on the platform used, # enabling this option may lead to badly anti-aliased labels on the edges of # a graph (i.e. they become hard to read). DOT_TRANSPARENT = YES # Set the DOT_MULTI_TARGETS tag to YES allow dot to generate multiple output # files in one run (i.e. multiple -o and -T options on the command line). This # makes dot run faster, but since only newer versions of dot (>1.8.10) # support this, this feature is disabled by default. DOT_MULTI_TARGETS = NO # If the GENERATE_LEGEND tag is set to YES (the default) Doxygen will # generate a legend page explaining the meaning of the various boxes and # arrows in the dot generated graphs. GENERATE_LEGEND = NO # If the DOT_CLEANUP tag is set to YES (the default) Doxygen will # remove the intermediate dot files that are used to generate # the various graphs. DOT_CLEANUP = YES GENERATE_TREEVIEW = YES lisitsyn-tapkee-04b33b5/doc/methods/000077500000000000000000000000001463410270200173725ustar00rootroot00000000000000lisitsyn-tapkee-04b33b5/doc/methods/dm.markdown000066400000000000000000000024671463410270200215470ustar00rootroot00000000000000Diffusion map ------------- The diffusion map algorithm performs the following steps to embed feature vectors $ x\_1, \dots, x\_N $: * Compute $ N \times N $ gaussian kernel matrix $ K $ such that $$ K\_{i,j} = exp \left\\{ - \frac{d^2(x\_i,x\_j)}{\omega} \right\\},$$ where $ d : X \times X \to \mathbb{R} $ is a distance function and $ \omega > 0 $ is a width of the kernel. * Transform the matrix $ K $ using the following equations $$ K\_{i,j} \leftarrow \frac{K\_{i,j}}{(p\_i p\_j)^q},$$ where $ p\_i = \sum\_{j=1}^{N} K\_{j,i}$. Only $ q=1 $ for 'standard' diffusion map is currently supported. Then, recompute $ p\_i = \sum\_{j=1}^{N} K\_{j,i} $ again and do $$ K\_{i,j} \leftarrow \frac{K\_{i,j}}{\sqrt{p\_i p\_j}}.$$ * Construct embedding with $ \dim = d $ from the solution of the following partial eigenproblem $$ K f = \lambda f $$ for $d+1 $ largest eigenvalues. Form the embedding matrix such that the $i$-th coordinate ($ i=1,\dots,N $) of $j$-th largest eigenvector ($ j=2,\dots,d+1$ ) corresponds to $j$-th coordinate of projected $i$-th vector, normalized by $\lambda_i^t$ and the first eigenvector corresponding to $\lambda_1 = 1$. References ---------- * Coifman, R., & Lafon, S. (2006). [Diffusion maps](http://linkinghub.elsevier.com/retrieve/pii/S1063520306000546) lisitsyn-tapkee-04b33b5/doc/methods/fa.markdown000066400000000000000000000020341463410270200215230ustar00rootroot00000000000000Factor analysis --------------- Factor analysis aims at describing how several observed variables are correlated to each other by means of identifying a set of unobserved variables, the so-called factors. Desirably, the number of factors is shorter than the number of observed variables. Factor analysis is an iterative algorithm. First of all the projection matrix is initialized randomly and the factors variance is set to the identity. Then, every iteration consists of the following steps: * Compute the regularized inverse covariance matrix of the projection. * Update the factors variance matrix. * Update the projection matrix. * Check for convergence using the log-likelihood of the model. If the difference between the current log-likelihood and the previous iteration's log-likelihood is below a threshold, then the algorithm has converged. References ---------- * Spearman, C. (1904). [General Intelligence, Objectively Determined and Measured](http://www.mendeley.com/catalog/general-intelligence-objectively-determined-measured/). lisitsyn-tapkee-04b33b5/doc/methods/hlle.markdown000066400000000000000000000041221463410270200220610ustar00rootroot00000000000000Hessian Locally Linear Embedding -------------------------------- Just like the Local Tangent Space Alignment, the Hessian Locally Linear Embedding algorithm is very similar to the Locally Linear Embedding algorithm. Given a set of feature vectors $X = \{ x\_1, x\_2, \dots x\_N \} $ the HLLE algorithm proposes to perform the following steps: * Identify nearest neighbors. For each $ x \in X $ identify its $ k $ nearest neighbors, i.e. a set $ \mathcal{N}\_x $ of $ k $ feature vectors such that $$ \arg\min\_{\mathcal{N}_x} \sum\_{x\_n \in \mathcal{N}\_x}\| x - x\_n \|\_2^2 $$ * Analyze hessian of each local patch. For each $ x \in X $ compute the Gram matrix $ G $ of its neighbors such that $ G\_{i,j} = (\mathcal{N}\_x^{i} , \mathcal{N}\_x^{j}) $ and center it. Compute its $ t $ (the number of required features) eigenvectors $ v\_1, \dots v\_t $. Construct hessian approximating matrix $$ Y = \begin{bmatrix} 1\_k & v\_1 & \dots & v\_t & v\_1\cdot v\_1 & \dots & v\_1\cdot v\_t & \dots \end{bmatrix}, $$ where $ \cdot : X \times X \to X $ denotes coefficient-wise product. Normalize columns of the matrix $ Y $ and then compute matrix $$ Q = Y Y^{T}$$ and put it to the sparse alignment matrix $ L $ (initially set by zeroes) using the following procedure: $$ L \leftarrow L + Q. $$ * Embedding through eigendecomposition. To obtain $ t $ features (coordinates) of embedded vectors solve the partial eigenproblem $$ L f = \lambda f, $$ for smallest eigenvalues $ \lambda\_1, \dots, \lambda\_t, \lambda\_{t+1} $ and its corresponding eigenvectors $ f\_1, \dots, f\_t, f\_{t+1} $. Drop the smallest eigenvalue $ \lambda\_1 \sim 0 $ (with its corresponding eigenvector) and form embedding matrix such that $i$-th coordinate ($ i=1,\dots,N $) of $j$-th eigenvector ($ j=1,\dots,t$ ) corresponds to $j$-th coordinate of projected $i$-th vector. References ---------- * Donoho, D., & Grimes, C. (2003). [Hessian eigenmaps: new locally linear embedding techniques for high-dimensional data](http://www-stat.stanford.edu/~donoho/Reports/2003/HessianEigenmaps.pdf) lisitsyn-tapkee-04b33b5/doc/methods/isomap.markdown000066400000000000000000000022631463410270200224310ustar00rootroot00000000000000Isomap ------ The Isomap algorithm can be considered as a modification of the classic Multidimensional Scaling algorithm. The algorithm itself consists of the following steps: * For each feature vector $ x \in X $ find $ k $ its nearest neighbors and construct the sparse neighborhood graph. * Compute squared distances matrix $ D $ such as $ D_{i,j} = d^2(x_i,x_j) $. * Relax distances with shortest (so-called geodesic) distances on the sparse neighborhood graph (e.g. with Dijkstra's algorithm). * Center the matrix $ D $ with subtracting row mean, column mean and adding the grand mean. Multiply $ D $ element-wise with $ -0.5 $. * Compute embedding with the $ t$ eigenvectors that correspond to the largest eigenvalues of the matrix $ D $; normalize these vectors with dividing each eigenvector by the square root of its corresponding eigenvalue. Form the final embedding with eigenvectors as rows and projected feature vectors as columns. References ---------- * Tenenbaum, J. B., De Silva, V., & Langford, J. C. (2000). [A global geometric framework for nonlinear dimensionality reduction](http://www.robots.ox.ac.uk/~az/lectures/ml/tenenbaum-isomap-Science2000.pdf) lisitsyn-tapkee-04b33b5/doc/methods/kpca.markdown000066400000000000000000000016601463410270200220570ustar00rootroot00000000000000Kernel Principal Component Analysis ----------------------------------- The Kernel Principal Component Analysis algorithm is a generalization of the PCA algorithm. The algorithm performs the following steps * Compute the kernel matrix $K$ such that $K\_{i,j} = k(x\_i,x\_j)$ where $k : X \times X \to \mathbb{R}$ is a Mercer kernel function and $X$ is a set of feature vectors $\\{ x\_1, x\_2, \dots, x\_N \\}$ * Center the matrix $K$ with subtracting row mean, column mean and adding the grand mean. * Compute embedding with the $ t$ eigenvectors that correspond to the largest eigenvalues of the matrix $ D $; normalize these vectors with dividing each eigenvectors with square root of its corresponding eigenvalue. Form the final embedding with eigenvectors as rows and projected feature vectors as columns. References ---------- * Schölkopf, B., Smola, A., & Müller, K. R. (1997). Kernel principal component analysis lisitsyn-tapkee-04b33b5/doc/methods/le.markdown000066400000000000000000000032021463410270200215330ustar00rootroot00000000000000Laplacian Eigenmaps ------------------- The Laplacian Eigenmaps algorithm performs the following simple steps to embed given feature vectors $ x\_1, \dots, x\_N $: * Identify nearest neighbors. For each $ x \in X $ identify its $ k $ nearest neighbors, i.e. a set $ \mathcal{N}\_x $ of $ k $ feature vectors such that $$ \arg\min\_{\mathcal{N}\_x} \sum\_{x\_n \in \mathcal{N}\_x} d(x,x\_n), $$ where $ d : X \times X \to \mathbb{R} $ is a distance function. * Construct weight matrix. Initially setting $N\times N$ matrix $ W $ to zero, set $$ W\_{i,j} = exp \left\\{ - \frac{d^2(x\_i,x\_j)}{\tau} \right\\} $$ iff for $i$-th vector $x\_i$ neighbors set $\mathcal{N}\_{x\_i}$ contains $ x\_j $ and vice versa (so-called mutual neighborhood). Find a diagonal matrix $ D $ such that $ D\_{i,i} = \sum\_{j=1}^{N} W\_{j,i} $. * Find embedding throught eigendecomposition. To obtain $ t $ features (coordinates) of embedded vectors solve the partial generalized eigenproblem $$ (D-W) f = \lambda D f, $$ for smallest eigenvalues $ \lambda\_1, \dots, \lambda\_t, \lambda\_{t+1} $ and its corresponding eigenvectors $ f\_1, \dots, f\_t, f\_{t+1} $. Drop the smallest eigenvalue $ \lambda\_1 \sim 0 $ (with the corresponding eigenvector) and form embedding matrix such that $i$-th coordinate ($ i=1,\dots,N $) of $j$-th eigenvector ($ j=1,\dots,t$ ) corresponds to $j$-th coordinate of projected $i$-th vector. References ---------- * Belkin, M., & Niyogi, P. (2002). [Laplacian Eigenmaps and Spectral Techniques for Embedding and Clustering](http://citeseerx.ist.psu.edu/viewdoc/download?doi=10.1.1.19.9400&rep=rep1&type=pdf) lisitsyn-tapkee-04b33b5/doc/methods/lle.markdown000066400000000000000000000074501463410270200217200ustar00rootroot00000000000000Locally Linear Embedding ------------------------ Given a set of feature vectors $X = \{ x\_1, x\_2, \dots x\_N \} $ the Locally Linear Embedding algorithm proposes to perform the following steps: * Identify nearest neighbors. For each $ x \in X $ identify its $ k $ nearest neighbors, i.e. a set $ \mathcal{N}\_x $ of $ k $ feature vectors such that $$ \arg\min\_{\mathcal{N}\_x} \sum\_{x\_n \in \mathcal{N}\_x}\| x - x\_n \|\_2^2 $$ * Compute linear reconstruction weights. For each $ x \in X $ compute weight vector $ w \in \mathbb{R}^n $ that minimizes $$ \| x - \sum\_{i=1}^{k} w\_i \mathcal{N}\_x^{i} \|\_2, ~~ \text{w.r.t.} ~~ \|w\|\_2 = 1$$ where $ \mathcal{N}\_x^{i} $ is a $ i$-th element of the set $ \mathcal{N}\_x $. The solution of the problem stated above can be found from the normalized solution of the following equation: $$ G w = 1\_k, $$ where $ G $ is a $ k \times k $ matrix such that $ G\_{i,j} = (x - \mathcal{N}\_x^{i})(x - \mathcal{N}\_x^{j}) $ and $ 1\_k \in \mathbb{R}^k $ is a vector of all ones. Obviously, the problem comes ill-posed in case $ k $ gets more than dimension of feature space $ X $. This can be avoided with the regularization: $$ G \leftarrow G + \varepsilon E, $$ where $E$ is an identity matrix and $ \varepsilon $ is a pre-defined constant reconstruction shift (usually $ 10^{-3}$). Once $ w $ is computed it is stored into the sparse alignment matrix $ L $ (initially set by zero) with the following procedure: $$ L\_{I,I} \leftarrow L\_{I,I} + W, $$ where $ I $ is a set containing indices of all element of the set $\mathcal{N}\_x$ and $ x $ itself, $ L\_{I,I} $ denotes all $ (i,j) $ elements of the sparse matrix L such that $ i,j \in I$ and $$ W = \begin{bmatrix} 1 & -w \\ -w^{T} & w^T w \end{bmatrix}$$. * Embedding through eigendecomposition. To obtain $ t $ features (coordinates) of embedded vectors solve the partial eigenproblem $$ L f = \lambda f, $$ for smallest eigenvalues $ \lambda\_1, \dots, \lambda\_t, \lambda\_{t+1} $ and its corresponding eigenvectors $ f\_1, \dots, f\_t, f\_{t+1} $. Drop the smallest eigenvalue $ \lambda\_1 \sim 0 $ (with the corresponding eigenvector) and form embedding matrix such that $i$-th coordinate ($ i=1,\dots,N $) of $j$-th eigenvector ($ j=1,\dots,t$ ) corresponds to $j$-th coordinate of projected $i$-th vector. Kernel Locally Linear Embedding ------------------------------- The Locally Linear Embedding algorithm can be generalized for spaces with defined dot product function $ k(x,y) $ (so-called [RKHS](http://en.wikipedia.org/wiki/Reproducing\_kernel\_Hilbert\_space)) in the elegant way. Using the following equation $$ || x - y||\_2^2 = (x,x) - 2 (x,y) + (y,y) $$ we may transform the nearest neighbors problem to the following form: $$ \arg\min\_{\mathcal{N}\_x} \sum\_{x\_n \in \mathcal{N}\_x} \left[ k(x,x) - 2 k(x,x\_n) + k(x\_n, x\_n) \right] . $$ The matrix $ G $ can be formulated in terms of dot product as well. To find $ G $ using only dot products we can compute the Gram matrix $ K $ such that $ K\_{i,j} = k(x\_i, x\_j)$ and center it using the matrix $ C\_k = E\_k - \frac{1}{k} 1 1^{T}$: $$ G = K C\_k K. $$ There is an efficient way to compute that - it is can be done with subtracting a column mean of $ K $ from each column of $ K $, subtracting a row mean of $ K $ from each row of $ K $ and adding the grand mean of all elements of $ K $ to $ K $. References ---------- * [Sam Roweis' page on LLE](http://www.cs.nyu.edu/~roweis/lle/) * Saul, L. K., Ave, P., Park, F., & Roweis, S. T. (2001). [An introduction to Locally Linear Embedding](http://citeseerx.ist.psu.edu/viewdoc/download?doi=10.1.1.123.7319&rep=rep1&type=pdf) * Zhao, D. (2006) [Formulating LLE using alignment technique](http://linkinghub.elsevier.com/retrieve/pii/S0031320306002160) lisitsyn-tapkee-04b33b5/doc/methods/lltsa.markdown000066400000000000000000000021141463410270200222530ustar00rootroot00000000000000Linear Local Tangent Space Alignment ------------------------------------ The Linear Local Tangent Space Alignment is a modification of the LTSA algorithm. Main difference (just like in NPE and LLE) of linear and original LTSA methods lies in the way of constructing embedding. Instead of solving common for LLE and LTSA eigenproblem, LLTSA requires solving the following generalized eigenproblem: $$ R L R^T f = \lambda R R^T f, $$ where $ R $ is a matrix containing all feature vectors $ x\_1, \dots, x\_N $ row-wise. The problem is solved for smallest eigenvalues $ \lambda\_1 \leq \lambda\_2 \leq \dots \leq \lambda\_t $ and its corresponding eigenvectors $ f\_1, \dots, f\_t $. To find final embedding LLTSA forms a matrix such that $i$-th coordinate ($ i=1,\dots,N $) of $j$-th eigenvector ($ j=1,\dots,t$ ) corresponds to $j$-th coordinate of projected $i$-th vector. References ---------- * Zhang, T., Yang, J., Zhao, D., & Ge, X. (2007). [Linear local tangent space alignment and application to face recognition](http://citeseerx.ist.psu.edu/viewdoc/summary?doi=10.1.1.85.2698) lisitsyn-tapkee-04b33b5/doc/methods/lpp.markdown000066400000000000000000000020651463410270200217340ustar00rootroot00000000000000Locality Preserving Projections ------------------------------- The Locality Preserving Projections algorithm can be viewed as a linear approximation of the Laplacian Eigenmaps algorithm. It reproduces first two steps of the Laplacian Eigenmaps and the difference lies in the step 3. To obtain $ t $ features (coordinates) of embedded vectors LPP solves the partial generalized eigenproblem $$ R (D-W) R^{T} f = \lambda R D R^{T} f, $$ where $ R $ contains all feature vectors row-wise, for smallest eigenvalues $ \lambda\_1, \dots, \lambda\_t, \lambda\_{t+1} $ and its corresponding eigenvectors $ f\_1, \dots, f\_t, f\_{t+1} $. Drop the smallest eigenvalue $ \lambda\_1 \sim 0 $ (with the corresponding eigenvector) and form embedding matrix such that $i$-th coordinate ($ i=1,\dots,N $) of $j$-th eigenvector ($ j=1,\dots,t$ ) corresponds to $j$-th coordinate of projected $i$-th vector. References ---------- * He, X., & Niyogi, P. (2003). [Locality Preserving Projections](http://citeseerx.ist.psu.edu/viewdoc/download?doi=10.1.1.85.7147&rep=rep1&type=pdf) lisitsyn-tapkee-04b33b5/doc/methods/ltsa.markdown000066400000000000000000000043341463410270200221050ustar00rootroot00000000000000Local Tangent Space Alignment ----------------------------- The Local Tangent Space Alignment algorithm is pretty similar to the Locally Linear Embedding algorithm. Given a set of feature vectors $X = \{ x\_1, x\_2, \dots x\_N \} $ the Local Tangent Space Alignment algorithm performs the following steps: * Identify nearest neighbors. For each $ x \in X $ identify its $ k $ nearest neighbors, i.e. a set $ \mathcal{N}\_x $ of $ k $ feature vectors such that $$ \arg\min\_{\mathcal{N}\_x} \sum\_{x\_n \in \mathcal{N}\_x}\| x - x\_n \|\_2^2 $$ * Perform principal component analysis of each local neighborhood patch. For each $ x \in X $ compute the Gram matrix $ G $ of its neighbors such that $ G\_{i,j} = (\mathcal{N}\_x^{i} , \mathcal{N}\_x^{j}) $ and center it. Compute its $ t $ (the number of required features) eigenvectors and store it in the matrix $ V $. Compute matrix $$ Q = \begin{bmatrix} 1\_k & V \end{bmatrix} \begin{bmatrix} 1\_k \\ V \end{bmatrix} $$ and put it to the sparse alignment matrix $ L $ (initially set by zeroes) using the following procedure: $$ L \leftarrow L + E\_k - Q. $$ * Embedding through eigendecomposition. To obtain $ t $ features (coordinates) of embedded vectors solve the partial eigenproblem $$ L f = \lambda f, $$ for smallest eigenvalues $ \lambda\_1, \dots, \lambda\_t, \lambda\_{t+1} $ and its corresponding eigenvectors $ f\_1, \dots, f\_t, f\_{t+1} $. Drop the smallest eigenvalue $ \lambda\_1 \sim 0 $ (with the corresponding eigenvector) and form embedding matrix such that $i$-th coordinate ($ i=1,\dots,N $) of $j$-th eigenvector ($ j=1,\dots,t$ ) corresponds to $j$-th coordinate of projected $i$-th vector. Kernel Local Tangent Space Alignment ------------------------------------ Like the Locally Linear Embedding algorithm, LTSA allows generalization for Mercer kernel functions. Nearest neighbors computation in KLTSA is identical to one in KLTSA and the matrix $ G $ in the step 2 is naturally replaced with matrix $ K\_{i,j} = k(\mathcal{N}\_x^{i},\mathcal{N}\_x^{j}) $. References ---------- * Zhang, Z., & Zha, H. (2002). [Principal Manifolds and Nonlinear Dimension Reduction via Local Tangent Space Alignment](http://arxiv.org/abs/cs/0212008) lisitsyn-tapkee-04b33b5/doc/methods/mds.markdown000066400000000000000000000015621463410270200217250ustar00rootroot00000000000000Classic multidimensional scaling -------------------------------- The classic multidimensional scaling algorithm is probably the simplest dimensionality reduction algorithm which reduced data in an attempt to keep pairwise distances the same. The algorithm itself is: * For a given set of vectors $ X = x\_1, x\_2, \dots, x\_N $ compute the pairwise distances matrix $ D $ such that $ D\_{i,j} = d(x\_i,x\_j) $, * Square each element of the distances matrix $ D $ and center the matrix with subtracting row mean, column mean and adding the grand mean. * Compute embedding with the $ t$ eigenvectors that correspond to the largest eigenvalues of the matrix $ D $; normalize these vectors with dividing each eigenvectors with square root of its corresponding eigenvalue. Form the final embedding with eigenvectors as rows and projected feature vectors as columns. lisitsyn-tapkee-04b33b5/doc/methods/npe.markdown000066400000000000000000000022231463410270200217170ustar00rootroot00000000000000Neighborhood Preserving Embedding --------------------------------- The Neighborhood Preserving Embedding (NPE) algorithm can be considered as a linear approximation of the Locally Linear Embedding algorithm. Thus most of computation routines can be shared with LLE. The NPE algorithm uses steps 1 and 2 of the Locally Linear Embedding and the main difference lies in the eigendecomposition based embedding. According to the NPE algorithm embedding can be found from the solution of the following partial generalized eigenproblem: $$ R L R f = \lambda R R^T f $$ where $ R $ is a matrix containing all feature vectors $ x\_1 , \dots , x\_N $ row-wise. The problem is solved for smallest eigenvalues $ \lambda\_1, \dots, \lambda\_t $ and its corresponding eigenvectors $ f\_1, \dots, f\_t $. The final embedding is obtained with a matrix such that $i$-th coordinate ($ i=1,\dots,N $) of $j$-th eigenvector ($ j=1,\dots,t$ ) corresponds to $j$-th coordinate of projected $i$-th vector. References * He, X., Cai, D., Yan, S., & Zhang, H.-J. (2005). [Neighborhood preserving embedding](http://ieeexplore.ieee.org/lpdocs/epic03/wrapper.htm?arnumber=1544858) lisitsyn-tapkee-04b33b5/doc/methods/pca.markdown000066400000000000000000000011041463410270200216750ustar00rootroot00000000000000Principal Component Analysis ---------------------------- The Principal Component Analysis is probably the oldest dimension reduction algorithm which comes in various flavours today. The simplest 'version' of the PCA algorithm could look like that: * Subtract mean feature vector from each feature vector of a set $ X = \{ x\_1, x\_2, \dots, x\_N \} $. * Compute the covariance matrix $ C $ using all feature vectors. * Find top $ t $ (desired dimension of embedded space) and form projection matrix $ P $ with eigenvectors as columns. * Project the data with $ Y = P X $. lisitsyn-tapkee-04b33b5/doc/methods/rp.markdown000066400000000000000000000010701463410270200215550ustar00rootroot00000000000000Random projection ----------------- The Random projection algorithm is yet more simple algorithm (comparing to PCA and MDS). It can be said that the algorithm is based on Johnson-Lindenstrauss lemma that states that a small number of vectors in high-dimensional space can be embedded into a space of much lower dimension with keeping pairwise distances nearly preserved. The algorithm itself is: * Construct random basis matrix $ P $ with normalized random gaussian vectors as columns. * Project data with left multiplication with generated matrix $ Y = P X $. lisitsyn-tapkee-04b33b5/doc/methods/spe.markdown000066400000000000000000000025311463410270200217260ustar00rootroot00000000000000Stochastic Proximity Embedding ------------------------------ Stochastic Proximity Embedding (SPE) acts on a set of $ N $ vectors $Y = \{ y\_1, y\_2, \dots y\_N \} $ with corresponding symmetric distance matrix $ D\_{ij} $ in the following manner: 1. Choose an initial learning rate $ \lambda$. 2. Initialize randomly the point coordinates in the embedded space $X = \{ x\_1, x\_2, \dots x\_N \} $. 3. Select at random a pair of points with indices $ i $ and $ j $. For a prescribed number of iterations $ S $, compute their distances in the embedded space, $$ d\_{i,j} = \| x\_i - x\_j \| $$; if $ d\_{i,j} \neq D\_{i,j} $ then update the coordinates of the selected points by $$ x\_i \leftarrow x\_i + \lambda \frac{1}{2} \frac{D\_{ij} - d\_{ij}}{d\_{ij} + \epsilon} (x\_i - x\_j), $$ $$ x\_j \leftarrow x\_j + \lambda \frac{1}{2} \frac{D\_{ij} - d\_{ij}}{d\_{ij} + \epsilon} (x\_j - x\_i). $$ 4. Decrease the learning rate $ \lambda $ by $ \delta \lambda | 0 < \delta < 1 $. $ \lambda $ is decreased to avoid oscillatory behaviour. 5. Repeat steps 3 and 4 for a predetermined number of iterations $ C $. SPE is an interesting method because of its simplicity and efficiency, as it scales linearly with the sample size $ N $. Reference --------- * D. K. Agrafiotis. "Stochastic Proximity Embedding," *Journal of Computational Chemistry*, 2003. lisitsyn-tapkee-04b33b5/doc/methods/tsne.markdown000066400000000000000000000047221463410270200221140ustar00rootroot00000000000000Stochastic Neighbour Embedding ------------------------------ Stochastic Neighbour Embedding (SNE) uses conditional probability densities in order to model pairwise similarities between data points, rather than using Euclidean distances directly. The similarity of the point $x\_j$ to the point $x\_i$ is the conditional probability $p\_{j|i}$, which is the probability that $x\_j$ would be $x\_i$'s neighbour taking into account that neighbourhoods are built in proportion to Gaussian probability densities centered at $x\_{i}$. Formally, $$ p\_{j|i} = \frac{exp(-\|x\_i - x\_j\|^2 / 2 \sigma\_i^2)}{\sum\_{k \neq i} exp(-\|x\_i - x\_k\|^2 / 2 \sigma\_i^2)} $$ where $\sigma\_i$ is the variance of the Gaussian centered on $x\_i$, whose computation will be later explained. The similarities in the low-dimensional space are defined in a similar way. However, the variance of the Gaussian distributions employed are fixed to $\frac{1}{\sqrt{2}}$ this time, i.e. $$ q\_{j|i} = \frac{exp(-\|x\_i - x\_j\|^2)}{\sum\_{k \neq i} exp(-\|x\_i - x\_k\|^2)}. $$ Intuitively, if the low-dimensional points $y\_i$ and $y\_j$ map correctly the similarity between their high-dimensional counterparts $x\_i$ and $x\_j$, then $p\_{j|i}$ and $q\_{j|i}$ will be close to each other. SNE aims at making these quantities as close as possible minimizing the sum of Kullback-Leibler divergences over all the data set. Thus, the cost function is $$C = \sum\_{i} KL(P\_i \| Q\_i) = \sum\_{i} \sum\_{j} p\_{j|i} \log \frac{p\_{j|i}}{q\_{j|i}}.$$ Unfortunately, there exists no optimal value of the Gaussian variance for all the points in the data set since the data may vary considerably throughout the data set. SNE chooses the value of each $sigma\_i$ performing binary search so that a user specified value for the Shannon entropy of $P\_i$ is achieved. t-Distributed Stochastic Neighbour Embedding -------------------------------------------- There are two main issues related to SNE that t-Distributed Stochastic Neighbour Embedding (t-SNE) addresses: * SNE's cost function using gradient descent is faster optimized using symmetric similarities. Therefore, t-SNE uses joint probability distributions $p\_{ij}$ and $q\_{ij}$ instead of conditional distributions. * t-SNE uses Student's t instead of Gaussian distributions to handle better the so-called crowding problem. References ---------- * Van der Maaten, L., Hinton, G. (2008). [Visualizing Data using t-SNE](http://jmlr.csail.mit.edu/papers/v9/vandermaaten08a.html). lisitsyn-tapkee-04b33b5/examples/000077500000000000000000000000001463410270200170005ustar00rootroot00000000000000lisitsyn-tapkee-04b33b5/examples/CMakeLists.txt000066400000000000000000000001411463410270200215340ustar00rootroot00000000000000project(examples) add_subdirectory(minimal) add_subdirectory(rna) add_subdirectory(precomputed) lisitsyn-tapkee-04b33b5/examples/cbcl/000077500000000000000000000000001463410270200177035ustar00rootroot00000000000000lisitsyn-tapkee-04b33b5/examples/cbcl/cbcl.md000066400000000000000000000010241463410270200211250ustar00rootroot00000000000000In this example we embed high-dimensional data which is a set of synthesized images of faces (with size 200 x 200). The Local Tangent Space Alignment method is used to embed the data to 2d euclidean space. It is worth to note that the images set considered in this example has intrinsic dimensionality of 2 which is clearly 'catched' by the algorithm. Credit is hereby given to the Massachusetts Institute of Technology and to the Center for Biological and Computational Learning for providing the database of facial images. lisitsyn-tapkee-04b33b5/examples/cbcl/cbcl.py000066400000000000000000000041011463410270200211540ustar00rootroot00000000000000import numpy import datetime import json import subprocess import sys import os import glob import tempfile import scipy.misc from PIL import Image def load(dir): images = [] vecs = [] for f in glob.glob(os.path.join(dir,'*.pgm')): image = numpy.array(Image.open(f)) images.append((f,image)) vecs.append(image.ravel()) return numpy.vstack(vecs), images def embed(feature_matrix): input_file = tempfile.NamedTemporaryFile(prefix='cbcl_input') output_file = tempfile.NamedTemporaryFile(prefix='cbcl_output') numpy.savetxt(input_file.name, feature_matrix, delimiter=',') runner_string = './bin/tapkee -i %s -o %s -m ltsa -k 80 --transpose-output --verbose --benchmark' % (input_file.name, output_file.name) process = subprocess.run(runner_string, shell=True, capture_output=True, text=True) print(process.stderr) if process.returncode != 0: raise Exception('Failed to embed') embedding = numpy.loadtxt(output_file.name, delimiter=',') return embedding def export_json(outfile, embedding, images): json_dict = {} N = embedding.shape[1] json_dict['data'] = [{'cx':embedding[0,i], 'cy':embedding[1,i], 'fname':images[i][0]} for i in xrange(N)] json.dump(json_dict, open(outfile, 'w')) def plot_embedding(embedding,images): import matplotlib.pyplot as plt from matplotlib.offsetbox import TextArea, DrawingArea, OffsetImage, AnnotationBbox fig = plt.figure() ax = fig.add_subplot(111) ax.scatter(embedding[0],embedding[1],alpha=0.0) for i in range(embedding.shape[1]): img = numpy.zeros((images[i][1].shape[0], images[i][1].shape[1], 4)) img[:,:,0] = images[i][1]/255.0 img[:,:,1] = images[i][1]/255.0 img[:,:,2] = images[i][1]/255.0 img[:,:,3] = 1.0 img[(images[i][1]==28), 3] = 0 imagebox = OffsetImage(img,cmap=plt.cm.gray,zoom=0.2) ab = AnnotationBbox(imagebox, (embedding[0][i], embedding[1,i]), pad=0.001, frameon=False) ax.add_artist(ab) plt.show() if __name__ == "__main__": feature_matrix, images = load('data/cbcl') embedding = embed(feature_matrix) if len(sys.argv)==3: export_json(sys.argv[2], embedding, images) plot_embedding(embedding,images) lisitsyn-tapkee-04b33b5/examples/faces/000077500000000000000000000000001463410270200200615ustar00rootroot00000000000000lisitsyn-tapkee-04b33b5/examples/faces/faces.md000066400000000000000000000004001463410270200214560ustar00rootroot00000000000000In this example we embed images of faces with the diffusion map algorithm. The dataset is pretty small (only 50 vectors) and doesn`t have explicit latent variables beneath - this makes it hard for the algorithm to find an efficient 2d representation. lisitsyn-tapkee-04b33b5/examples/faces/faces.py000066400000000000000000000041031463410270200215120ustar00rootroot00000000000000from __future__ import print_function import numpy, datetime, json, subprocess, sys, os, glob import imageio def load(dir): images = [] vecs = [] for f in glob.glob(os.path.join(dir,'*.pgm')): image = numpy.array(imageio.imread(f)) images.append((f,image)) image_vector = image.ravel().astype(numpy.float32) image_vector /= numpy.linalg.norm(image_vector) vecs.append(image_vector) return numpy.vstack(vecs), images def embed(feature_matrix): input_file = 'tmp_faces_input' numpy.savetxt(input_file, feature_matrix, delimiter=',') output_file = 'tmp_faces_output.dat' run_string = './bin/tapkee -i %s -o %s -m diffusion_map --verbose --benchmark' % (input_file,output_file) output = subprocess.check_output(run_string, shell=True) print(output) embedding = numpy.loadtxt(output_file, delimiter=',').T print(embedding) os.remove(output_file) os.remove(input_file) return embedding def export_json(outfile,embedding,images): json_dict = {} N = embedding.shape[1] import scipy.misc for i in range(N): scipy.misc.imsave('data/faces/%d.png'% i, images[i][1]) json_dict['data'] = [{'cx':embedding[0,i], 'cy':embedding[1,i], 'fname':'%d.png' % i} for i in range(N)] json.dump(json_dict, open(outfile, 'w')) def plot_embedding(embedding,images): import matplotlib.pyplot as plt from matplotlib.offsetbox import TextArea, DrawingArea, OffsetImage, AnnotationBbox fig = plt.figure() ax = fig.add_subplot(111) ax.scatter(embedding[0],embedding[1],alpha=0.0) for i in range(embedding.shape[1]): img = numpy.zeros((images[i][1].shape[0],images[i][1].shape[1],4)) img[:,:,0] = images[i][1] / 255.0 img[:,:,1] = images[i][1] / 255.0 img[:,:,2] = images[i][1] / 255.0 img[:,:,3] = 1.0 imagebox = OffsetImage(img, cmap=plt.cm.gray, zoom=0.25) ab = AnnotationBbox(imagebox, (embedding[0][i], embedding[1,i]), pad=0.001, frameon=False) ax.add_artist(ab) plt.show() if __name__ == "__main__": feature_matrix, images = load(sys.argv[1]) embedding = embed(feature_matrix) if len(sys.argv)==3: export_json(sys.argv[2],embedding, images) plot_embedding(embedding,images) lisitsyn-tapkee-04b33b5/examples/go.py000077500000000000000000000042461463410270200177700ustar00rootroot00000000000000#!/usr/bin/env python from __future__ import print_function import sys import os import subprocess import re import tempfile import numpy as np from utils import generate_data, plot supported_methods = { 'lle': 'Locally Linear Embedding', 'ltsa': 'Local Tangent Space Alignment', 'isomap': 'Isomap', 'mds': 'Multidimensional Scaling', 'pca': 'Principal Component Analysis', 'kpca': 'Kernel Principal Component Analysis', 't-sne': 't-distributed Stochastic Neighborhood Embedding', 'dm': 'Diffusion Map', } def embed(data,method): input_file = tempfile.NamedTemporaryFile(prefix='tapkee_input') output_file = tempfile.NamedTemporaryFile(prefix='tapkee_output') np.savetxt(input_file.name, data.T,delimiter=',') tapkee_binary = 'bin/tapkee' runner_string = '%s -i %s -o %s -m %s -k 20 --precompute --debug --verbose --transpose-output --benchmark' % ( tapkee_binary, input_file.name, output_file.name, method ) print('-- To reproduce this use the following command `{}`'.format(runner_string)) process = subprocess.run(runner_string, shell=True, capture_output=True, text=True) print(process.stderr) if process.returncode != 0: raise Exception('Failed to embed') if match := re.search(r'Parameter dimension reduction method = \[([a-zA-Z0-9() ]+)\]', process.stderr): used_method = match.group(1) else: used_method = '' embedded_data = np.loadtxt(output_file, delimiter=',') return embedded_data, used_method if __name__ == "__main__": import argparse parser = argparse.ArgumentParser(description='Graphical example of dimension reduction with Tapkee.') parser.add_argument('dataset', type=str, nargs=1, help='A dataset to embed. One of the following: %s' % str(['swissroll', 'scurve', 'helix', 'twinpeaks'])) parser.add_argument('method', type=str, nargs=1, help='A method to use. Any of the methods supported by Tapkee') args = parser.parse_args() dataset = args.dataset[0] method = args.method[0] print('-- Loading %s data' % dataset) data, colors = generate_data(dataset) print('-- Embedding %s data with %s' % (dataset, method)) embedded_data, used_method = embed(data, method) print('-- Plotting embedded data') plot(data, embedded_data, colors, used_method) lisitsyn-tapkee-04b33b5/examples/langs/000077500000000000000000000000001463410270200201045ustar00rootroot00000000000000lisitsyn-tapkee-04b33b5/examples/langs/langs.md000066400000000000000000000002071463410270200215310ustar00rootroot00000000000000In these examples we show how Tapkee can be used as part of the Shogun machine learning toolbox with different programming languages. lisitsyn-tapkee-04b33b5/examples/langs/lle.py000066400000000000000000000023761463410270200212420ustar00rootroot00000000000000import modshogun as sg import numpy as np #generate swissroll data def swissroll(N=1000): tt = np.array((5*np.pi/4)*(1+2*np.random.rand(N))) height = np.array((np.random.rand(N)-0.5)) noise = 0.1 X = np.array([(tt+noise*np.random.randn(N))*np.cos(tt), 10*height, (tt+noise*np.random.randn(N))*np.sin(tt)]) return X # load data feature_matrix = swissroll() # create features instance features = sg.RealFeatures(feature_matrix) # create Kernel Locally Linear Embedding converter instance converter = sg.KernelLocallyLinearEmbedding() # set target dimensionality converter.set_target_dim(2) # set number of neighbors converter.set_k(10) # set nullspace shift (optional) converter.set_nullspace_shift(-1e-6) # create Gaussian kernel instance kernel = sg.GaussianKernel(100,10.0) # enable converter instance to use created kernel instance converter.set_kernel(kernel) # compute embedding with Kernel Locally Linear Embedding method embedding = converter.embed(features) # compute linear kernel matrix kernel_matrix = np.dot(feature_matrix.T,feature_matrix) # create Custom Kernel instance custom_kernel = sg.CustomKernel(kernel_matrix) # construct embedding based on created kernel kernel_embedding = converter.embed_kernel(custom_kernel) lisitsyn-tapkee-04b33b5/examples/langs/ltsa.m000066400000000000000000000012051463410270200212230ustar00rootroot00000000000000N = 1000; tt = 5*pi/4*(1+2*rand(1,N)); height = rand(1,N)-0.5; noise = 0.01; matrix = [tt+noise.*rand(1,N).*cos(tt); 10*height; tt+noise.*rand(1,N).*sin(tt)]; init_shogun # load data # create features instance features = RealFeatures(matrix); # create Local Tangent Space Alignment converter instance converter = LocalTangentSpaceAlignment(); # set target dimensionality converter.set_target_dim(2); # set number of neighbors converter.set_k(20); # set nullspace shift (optional) converter.set_nullspace_shift(-1e-6); # compute embedding with Local Tangent Space Alignment method embedding = converter.embed(features); lisitsyn-tapkee-04b33b5/examples/minimal/000077500000000000000000000000001463410270200204265ustar00rootroot00000000000000lisitsyn-tapkee-04b33b5/examples/minimal/CMakeLists.txt000066400000000000000000000001561463410270200231700ustar00rootroot00000000000000project (minimal) add_executable (minimal minimal.cpp) target_link_libraries(minimal PUBLIC tapkee_library) lisitsyn-tapkee-04b33b5/examples/minimal/minimal.cpp000066400000000000000000000012721463410270200225620ustar00rootroot00000000000000#include using namespace std; using namespace tapkee; struct MyDistanceCallback { ScalarType distance(IndexType l, IndexType r) { return abs(static_cast(l) - static_cast(r)); } }; int main(int argc, const char **argv) { const int N = 100; vector indices(N); for (int i = 0; i < N; i++) indices[i] = i; MyDistanceCallback distance; TapkeeOutput output = with((method = MultidimensionalScaling, target_dimension = 1)) .withDistance(distance) .embedUsing(indices); cout << output.embedding.transpose() << endl; return 0; } lisitsyn-tapkee-04b33b5/examples/minimal/minimal.md000066400000000000000000000012651463410270200224020ustar00rootroot00000000000000In this example the simplest case of using the Tapkee library is considered. For the sake of simplicity, the input data used in this example is a one dimensional range of real values from 0.0 to 99.0 with step 1.0. Therefore, it actually does not reduce the dimensionality but maps vectors using the provided distances. In this example the Multidimensional Scaling (MDS) algorithm is used (in its classic metric formulation). MDS requires only distance callback and the `MyDistanceCallback` struct implements that with the absolute value of the difference between two data points. The output of such preprocessing is the centered input data (i.e. 0.0 maps to -49.5 and 99.0 maps to 49.5) lisitsyn-tapkee-04b33b5/examples/mnist/000077500000000000000000000000001463410270200201325ustar00rootroot00000000000000lisitsyn-tapkee-04b33b5/examples/mnist/mnist.md000066400000000000000000000005751463410270200216150ustar00rootroot00000000000000In this example MNIST digits represented by 28 x 28 images are embedded using the Barnes-Hut-SNE method. The original data is represented by 784 dimensional vectors (each pixel intensity is a feature). The dimension reduction method used in this example attempts to group vectors which represent the same digit (in an unsupervised manner - no labels are provided) in 2d space. lisitsyn-tapkee-04b33b5/examples/mnist/mnist.py000066400000000000000000000041341463410270200216400ustar00rootroot00000000000000from __future__ import print_function import numpy, datetime, json, subprocess, sys, os def embed(fname): input_file = 'tmp_mnist_input.dat' with open(fname,'r') as file: json_data = json.load(file) N, d = json_data['N'], json_data['d'] X = numpy.zeros((N,d)) for i in range(N): X[i,json_data['data'][str(i)]] = 1.0 numpy.savetxt(input_file, X.T, fmt='%.1f', delimiter=',') output_file = 'tmp_mnist_output.dat' run_string = './bin/tapkee -i %s -o %s -m t-sne --verbose --benchmark' % (input_file,output_file) output = subprocess.check_output(run_string, shell=True) embedding = numpy.loadtxt(output_file, delimiter=',').T os.remove(input_file) os.remove(output_file) return embedding, X def plot_embedding(embedding,data): import matplotlib.pyplot as plt from matplotlib.offsetbox import TextArea, DrawingArea, OffsetImage, AnnotationBbox fig = plt.figure() ax = fig.add_subplot(111) ax.scatter(embedding[0],embedding[1],alpha=0.0) for i in range(embedding.shape[1]): img = numpy.zeros((28,28,4)) img[:,:,0] = 1.0 - data[i,:].reshape(28,28) img[:,:,1] = 1.0 - data[i,:].reshape(28,28) img[:,:,2] = 1.0 - data[i,:].reshape(28,28) img[:,:,3] = data[i,:].reshape(28,28) imagebox = OffsetImage(img,cmap=plt.cm.gray,zoom=0.5) ab = AnnotationBbox(imagebox, (embedding[0][i], embedding[1,i]),pad=0.001,frameon=False) ax.add_artist(ab) plt.title('MNIST embedding') plt.axis('off') #plt.grid() plt.show() def export_json(outfile,embedding,data): json_dict = {} N = embedding.shape[1] print('N', N) import scipy.misc for i in range(N): img = numpy.zeros((28,28,4)) img[:,:,0] = 1.0 - data[i,:].reshape(28,28) img[:,:,1] = 1.0 - data[i,:].reshape(28,28) img[:,:,2] = 1.0 - data[i,:].reshape(28,28) img[:,:,3] = data[i,:].reshape(28,28) scipy.misc.imsave('mnist/%d.png' % i,img) json_dict['data'] = [{'cx':embedding[0,i], 'cy':embedding[1,i], 'fname':'%d.png' % i} for i in range(N)] json.dump(json_dict, open(outfile, 'w')) if __name__ == "__main__": embedding, data = embed(sys.argv[1]) if len(sys.argv)==3: export_json(sys.argv[2],embedding,data) plot_embedding(embedding,data) lisitsyn-tapkee-04b33b5/examples/nanobind.py000077500000000000000000000006571463410270200211550ustar00rootroot00000000000000import lib.tapkee as tapkee from utils import generate_data, plot if __name__=='__main__': parameters = tapkee.ParametersSet() method = tapkee.parse_reduction_method('lle') parameters.add(tapkee.Parameter.create('dimension reduction method', method)) data, colors = generate_data('swissroll') embedded_data = tapkee.withParameters(parameters).embedUsing(data).embedding plot(data, embedded_data.T, colors) lisitsyn-tapkee-04b33b5/examples/precomputed/000077500000000000000000000000001463410270200213275ustar00rootroot00000000000000lisitsyn-tapkee-04b33b5/examples/precomputed/CMakeLists.txt000066400000000000000000000001761463410270200240730ustar00rootroot00000000000000project (precomputed) add_executable (precomputed precomputed.cpp) target_link_libraries(precomputed PUBLIC tapkee_library) lisitsyn-tapkee-04b33b5/examples/precomputed/precomputed.cpp000066400000000000000000000013271463410270200243650ustar00rootroot00000000000000#include #include using namespace std; using namespace tapkee; int main(int argc, const char **argv) { const int N = 100; DenseMatrix distances(N, N); vector indices(N); for (int i = 0; i < N; i++) { indices[i] = i; for (int j = 0; j < N; j++) distances(i, j) = abs(i - j); } precomputed_distance_callback distance(distances); TapkeeOutput output = with((method = MultidimensionalScaling, target_dimension = 1)) .withDistance(distance) .embedUsing(indices); cout << output.embedding.transpose() << endl; return 0; } lisitsyn-tapkee-04b33b5/examples/precomputed/precomputed.md000066400000000000000000000007661463410270200242110ustar00rootroot00000000000000In this example the usage of precomputed distance matrix callback is considered. Just like in the minimal example, distances are just absolute values of differences between indices and the Multidimensional Scaling (MDS) algorithm is used (in its classic metric formulation). The difference lies in the fact that distance matrix is used with no data explicitly formed. The output of the example coincides with the output of the minimal example and presents a range of real values from -49.5 to 49.5. lisitsyn-tapkee-04b33b5/examples/promoters/000077500000000000000000000000001463410270200210325ustar00rootroot00000000000000lisitsyn-tapkee-04b33b5/examples/promoters/promoters.md000066400000000000000000000013561463410270200234130ustar00rootroot00000000000000This example illustrates the use of Tapkee as a module of the Shogun Machine Learning Toolbox and its integration with other parts of the Toolbox. The data used in this example is formed by mammalian promoter genes (an important region of the DNA) that are encoded using strings. The embedding algorithm used is Multidimensional Scaling (MDS), thus the only callback that Tapkee needs is a distance callback. In particular, the distance callback used is a string kernel implemented in Shogun called the Weighted Degree (WD) kernel; this kernel is very common in genomics. As shown in the figure, the data points are embedded in the Euclidean plane with promoter genes that are similar to each other represented by points that are close in the plane. lisitsyn-tapkee-04b33b5/examples/promoters/promoters.py000066400000000000000000000025341463410270200234420ustar00rootroot00000000000000import numpy,os,re,sys,datetime,random,json from modshogun import WeightedDegreeStringKernel, StringCharFeatures, DNA, MultidimensionalScaling, KernelDistance def embed(file='data/mml.txt'): strings = [] with open(file) as f: strings = [s.rstrip() for s in f.readlines()] features = StringCharFeatures(strings,DNA) kernel = WeightedDegreeStringKernel(10) distance = KernelDistance(1.0,kernel) distance.init(features,features) converter = MultidimensionalScaling() converter.set_target_dim(2) return converter.embed_distance(distance).get_feature_matrix(), strings def plot_embedding(data,gc_content=None): import matplotlib.pyplot as plt from mpl_toolkits.mplot3d import Axes3D fig = plt.figure() ax = fig.add_subplot(111) ax.scatter(data[0],data[1]) plt.title('Promoters embedding') plt.grid() if gc_content: fig.colorbar(gc_content,orientation='horizontal') plt.show() def export_json(outfile, embedding, strings): data = {} N = len(strings) data['data'] = [{'string':strings[i][:20],'gc': float(strings[i].count('G')+strings[i].count('C'))/len(strings[i]), 'cx':embedding[0,i], 'cy':embedding[1,i]} for i in xrange(N)] json.dump(data, open(outfile, 'w')) if __name__ == "__main__": embedding, strings = embed(sys.argv[1]) if len(sys.argv)==3: export_json(sys.argv[2],embedding, strings) plot_embedding(embedding) lisitsyn-tapkee-04b33b5/examples/rna/000077500000000000000000000000001463410270200175605ustar00rootroot00000000000000lisitsyn-tapkee-04b33b5/examples/rna/CMakeLists.txt000066400000000000000000000001361463410270200223200ustar00rootroot00000000000000project (rna) add_executable (rna rna.cpp) target_link_libraries(rna PUBLIC tapkee_library) lisitsyn-tapkee-04b33b5/examples/rna/rna.cpp000066400000000000000000000017141463410270200210470ustar00rootroot00000000000000#include #include #include #include #include #include #include using namespace std; using namespace tapkee; struct MatchKernelCallback { ScalarType kernel(const string &l, const string &r) { return inner_product(l.begin(), l.end(), r.begin(), 0, plus(), equal_to()); } }; int main(int argc, const char **argv) { vector rnas; ifstream input_stream; input_stream.open(argv[1]); string line; while (!input_stream.eof()) { input_stream >> line; rnas.push_back(line); } MatchKernelCallback kernel; TapkeeOutput result = with((method = KernelLocallyLinearEmbedding, num_neighbors = 30)) .withKernel(kernel) .embedUsing(rnas); cout << result.embedding.transpose() << endl; return 0; } lisitsyn-tapkee-04b33b5/examples/rna/rna.dat000066400000000000000000000055001463410270200210320ustar00rootroot00000000000000UCUGUAAUCGGUAUUCUCUUUGC CACGACCAUGAGCACGUAACUCG CUGACUUGGCGGGCUCAAUAAGC AACGACGUGGUUUUCUGGGCUGC CUUUCGCACUGAGCCUAUUUCAC GGUAGUGACUGCCAGUCCGUUGG UGGGUGAACAACCGACGUAUUCA AGCGAUUGCCAGGACGACACAUU AGGGUCCCGAGCUGGACUUCGCU UGCAGCAGAUUGUGGAGUCCGCU CAUCAGGGAGGAACGCGAGCAGG CAGGUCGCUUGUAUCGCUCUCAG AAUAGCACCGGAAGUCCACCGCA AGGGUAAUAGUCUCACAGAACCU CGAGCCUGAAGAGUCAACUUUGG CUUUCCCAUCCUUUGCCAUACUU CAUGGAGUCCCCGUAGCGGGGGU GCUAAGCCAUUCUACGUCACGCA UUUAUCCACCUCAUGAUUCAGAA GUGCUUGCUAAGAUGGCAAGCAA UUACGGUAGUCUGUAAUAGGAAA UGUCUUCUUCACAGACACGGGUA AUUCAUUCCCACAAGGUGAUUGU CUUGAAUAACACGUGGGCAUACC AGCUCCGAUCCCCUAUCUACGCA CCACCAAGACACAUUCGCUAUGA CGCCGUGGUAGGCGAAUUCCUCU GCGCCUCAUUGCGUAGACGCCUG AGAGAGAGGACACUAUAACCACU GAAGGAAUCUACGAAGCAACUUG UACUUGGCUGCCUCAGACAGAAU AAGUCGAUUUUCUCGUCUUGAAU UCCCAUUCUCUCACAUACCAAAU CUAAAGUCGAUUUCCGGCACUAA CUUCUCAAUGGCCAGCCGCAUAU CAGAACAAAUCUGAGGUUUCGCA AACCGAAAUUUCGGCGGGCAGGU AGAGCCCUUUACUCCACAAGGAC CAUCUCCAUGGUGAGGUCGAAAA UCCGUUCACAUUACUCGUACGUU GUUACGUGCAUGUGCUAUAGCCU UAUUCCCUCGGGUAAUUUGAGAA UCUGUAAUCGGUAUUCUCUUUGC CACGACCAUGAGCACGUAACUCG CUGACUUGGCGGGCUCAAUAAGC AACGACGUGGUUUUCUGGGCUGC CUUUCGCACUGAGCCUAUUUCAC GGUAGUGACUGCCAGUCCGUUGG UGGGUGAACAACCGACGUAUUCA AGCGAUUGCCAGGACGACACAUU AGGGUCCCGAGCUGGACUUCGCU UGCAGCAGAUUGUGGAGUCCGCU CAUCAGGGAGGAACGCGAGCAGG CAGGUCGCUUGUAUCGCUCUCAG AAUAGCACCGGAAGUCCACCGCA AGGGUAAUAGUCUCACAGAACCU CGAGCCUGAAGAGUCAACUUUGG CUUUCCCAUCCUUUGCCAUACUU CAUGGAGUCCCCGUAGCGGGGGU GCUAAGCCAUUCUACGUCACGCA UUUAUCCACCUCAUGAUUCAGAA GUGCUUGCUAAGAUGGCAAGCAA UUACGGUAGUCUGUAAUAGGAAA UGUCUUCUUCACAGACACGGGUA AUUCAUUCCCACAAGGUGAUUGU CUUGAAUAACACGUGGGCAUACC AGCUCCGAUCCCCUAUCUACGCA CCACCAAGACACAUUCGCUAUGA CGCCGUGGUAGGCGAAUUCCUCU GCGCCUCAUUGCGUAGACGCCUG AGAGAGAGGACACUAUAACCACU GAAGGAAUCUACGAAGCAACUUG UACUUGGCUGCCUCAGACAGAAU AAGUCGAUUUUCUCGUCUUGAAU UCCCAUUCUCUCACAUACCAAAU CUAAAGUCGAUUUCCGGCACUAA CUUCUCAAUGGCCAGCCGCAUAU CAGAACAAAUCUGAGGUUUCGCA AACCGAAAUUUCGGCGGGCAGGU AGAGCCCUUUACUCCACAAGGAC CAUCUCCAUGGUGAGGUCGAAAA UCCGUUCACAUUACUCGUACGUU GUUACGUGCAUGUGCUAUAGCCU UAUUCCCUCGGGUAAUUUGAGAA UCUGUAAUCGGUAUUCUCUUUGC CACGACCAUGAGCACGUAACUCG CUGACUUGGCGGGCUCAAUAAGC AACGACGUGGUUUUCUGGGCUGC CUUUCGCACUGAGCCUAUUUCAC GGUAGUGACUGCCAGUCCGUUGG UGGGUGAACAACCGACGUAUUCA AGCGAUUGCCAGGACGACACAUU AGGGUCCCGAGCUGGACUUCGCU UGCAGCAGAUUGUGGAGUCCGCU CAUCAGGGAGGAACGCGAGCAGG CAGGUCGCUUGUAUCGCUCUCAG AAUAGCACCGGAAGUCCACCGCA AGGGUAAUAGUCUCACAGAACCU CGAGCCUGAAGAGUCAACUUUGG CUUUCCCAUCCUUUGCCAUACUU CAUGGAGUCCCCGUAGCGGGGGU GCUAAGCCAUUCUACGUCACGCA UUUAUCCACCUCAUGAUUCAGAA GUGCUUGCUAAGAUGGCAAGCAA UUACGGUAGUCUGUAAUAGGAAA UGUCUUCUUCACAGACACGGGUA AUUCAUUCCCACAAGGUGAUUGU CUUGAAUAACACGUGGGCAUACC AGCUCCGAUCCCCUAUCUACGCA CCACCAAGACACAUUCGCUAUGA CGCCGUGGUAGGCGAAUUCCUCU GCGCCUCAUUGCGUAGACGCCUG AGAGAGAGGACACUAUAACCACU GAAGGAAUCUACGAAGCAACUUG UACUUGGCUGCCUCAGACAGAAU AAGUCGAUUUUCUCGUCUUGAAU UCCCAUUCUCUCACAUACCAAAU CUAAAGUCGAUUUCCGGCACUAA CUUCUCAAUGGCCAGCCGCAUAU CAGAACAAAUCUGAGGUUUCGCA lisitsyn-tapkee-04b33b5/examples/rna/rna.md000066400000000000000000000006501463410270200206630ustar00rootroot00000000000000In this example RNA sequencies are embedded using the match kernel `MatchKernelCallback` (that is essentially an inverse of a Hamming distance). RNA sequencies are supposed to be read from the file provided via a command line argument (one sequence per line). As the Kernel Locally Linear Embedding algorithm requires only a kernel callback we just pass only the kernel callback using the `withKernel` member function. lisitsyn-tapkee-04b33b5/examples/utils.py000066400000000000000000000060321463410270200205130ustar00rootroot00000000000000import matplotlib.pyplot as plt import numpy as np def generate_data(type, N=1000, random_state=None): rng = np.random.RandomState(random_state) if type=='swissroll': tt = np.array((3*np.pi/2)*(1+2*rng.rand(N))) height = np.array((rng.rand(N)-0.5)) X = np.array([tt*np.cos(tt), 10*height, tt*np.sin(tt)]) return X, tt if type=='scurve': tt = np.array((3*np.pi*(rng.rand(N)-0.5))) height = np.array((rng.rand(N)-0.5)) X = np.array([np.sin(tt), 10*height, np.sign(tt)*(np.cos(tt)-1)]) return X, tt if type=='helix': tt = np.linspace(1,N,N).T / N tt = tt*2*np.pi X = np.r_[[(2+np.cos(8*tt))*np.cos(tt)], [(2+np.cos(8*tt))*np.sin(tt)], [np.sin(8*tt)]] return X, tt if type=='twinpeaks': X = rng.uniform(-1, 1, size=(N, 2)) tt = np.sin(np.pi * X[:, 0]) * np.tanh(X[:, 1]) tt += 0.1 * rng.normal(size=tt.shape) X = np.vstack([X.T, tt]) return X, tt if type=='klein': u = rng.uniform(0, 2 * np.pi, N) v = rng.uniform(0, 2 * np.pi, N) x = (2 + np.cos(u / 2) * np.sin(v) - np.sin(u / 2) * np.sin(2 * v)) * np.cos(u) y = (2 + np.cos(u / 2) * np.sin(v) - np.sin(u / 2) * np.sin(2 * v)) * np.sin(u) z = np.sin(u / 2) * np.sin(v) + np.cos(u / 2) * np.sin(2 * v) noise = 0.01 x += noise * rng.normal(size=x.shape) y += noise * rng.normal(size=y.shape) z += noise * rng.normal(size=z.shape) return np.vstack((x, y, z)), u raise Exception('Dataset is not supported') def plot(data, embedded_data, colors='m', method=None): fig = plt.figure() fig.set_facecolor('white') ax_original = fig.add_subplot(121, projection='3d') scatter_original = ax_original.scatter(data[0], data[1], data[2], c=colors, cmap=plt.cm.Spectral, s=5, picker=True) plt.axis('tight') plt.axis('off') plt.title('Original', fontsize=9) ax_embedding = fig.add_subplot(122) scatter_embedding = ax_embedding.scatter(embedded_data[0], embedded_data[1], c=colors, cmap=plt.cm.Spectral, s=5, picker=True) plt.axis('tight') plt.axis('off') plt.title('Embedding' + (' with ' + method) if method else '', fontsize=9, wrap=True) highlighted_points = [] # To store highlighted points # Function to highlight points on both plots def highlight(index): # Reset previous highlighted points for point in highlighted_points: point.remove() highlighted_points.clear() # Highlight the current point on both scatter plots point1 = ax_original.scatter([data[0][index]], [data[1][index]], [data[2][index]], color='white', s=25, edgecolor='black', zorder=3) point2 = ax_embedding.scatter([embedded_data[0][index]], [embedded_data[1][index]], color='white', s=25, edgecolor='black', zorder=3) highlighted_points.append(point1) highlighted_points.append(point2) fig.canvas.draw_idle() # Event handler for mouse motion def on_hover(event): if event.inaxes == ax_original: cont, ind = scatter_original.contains(event) elif event.inaxes == ax_embedding: cont, ind = scatter_embedding.contains(event) else: return if cont: index = ind['ind'][0] highlight(index) fig.canvas.mpl_connect('motion_notify_event', on_hover) plt.show() lisitsyn-tapkee-04b33b5/examples/words/000077500000000000000000000000001463410270200201365ustar00rootroot00000000000000lisitsyn-tapkee-04b33b5/examples/words/words.dat000066400000000000000000000124111463410270200217650ustar00rootroot00000000000000number people little sentence through before follow around another because different picture change animal letter mother answer should America between country school father thought something example always together important children without second enough Indian really almost sometimes mountain family better giving myself please pretty yellow script splint strand stripe struck strung absent banging basket bathtub bedbug blasted blended bobsled branch camping catnip chipmunk contest crashing dentist disrupt disrupted drinking dusted expanded finishing goblin himself hotrod hunted insisted insisting insulted invent invented jumping lapdog lasted lending mascot napkin picnic pigpen pinball planted plastic problem public publishing punishing rented rested ringing shifted shrimp shrinking shrunk sinking splash splashing squinted standing sunfish sunlit sunset suntan swishing talented throne tilted tiptop trusted twisted whiplash zigzag called circle friend nothing Blanch Carmen caterpillar chuckle complain crunch Curtis dinner doctor fellow fiddle fishing forever forgot gobble granddad grandpa grinned grumble insect jiggle jumble library market napper nibble perfect reward Rivera Sanchez served sister snuggle sparkle sprinkle squirt sudden sunburn surprise swimmer tadpole tickle twinkle twitch umbrella whisper whistle wiggle window Winkle writing afraid afternoon anything anyway anywhere applaud artist attack awesome awning babble baffle ballplayer baseball basketball battle beanstalk bedtime beehive begging behind birthday bleach bluebird blueprint bonnet bottle brainstorm breakfast breath bright broiler bruise bubble bundle butterfly button candle careful cattle charge cheerful cheese choice church classmate clever clutch collect colorful cowboy crinkle cruise cuddle cupcake dangle daylight decent delight dimple doghouse double dragon dragonfly driveway evergreen everyone everything everywhere explore fabric faithful finish firefighter flagpole flashlight flaunt flight fluffy forest forget Friday fright frozen garden giggle ginger giraffe gluestick graceful grapefruit grasshopper grateful growth gumball handwriting happen harmful health helpful herself hidden highway homemade homework hopeful hopscotch houseboat housefly huddle hummingbird hungry hurdle inside instead jellyfish jingle juggle jungle kickball kingfish kitten kneecap knight knockout knothole launch leather lighthouse lipstick living lunchbox middle mitten moment Monday muzzle necktie newscast newspaper nickname nighttime nowhere oatmeal object outside paddle painful pancake paperback peaceful peddle pencil pennies pillow poison poodle popcorn poster potpie pretzel purple puzzle quicksand rabbit rainbow rattle recycle refund restful return ribbon riddle rumble runway saddle sailboat sample sandbox sandpaper Saturday saucer scorch scrape scratch scream screen settle shadow shaking shameful shipwreck shrink sidewalk silence simple slight smiling smooth snooze snowball snowflake snowman someone somewhere splendid splotch sprain sprawl spread spring sprint spruce squawk startle stiffer strain strange stream street stretch strict strike string strong suitcase sunblock Sunday sunflower sunrise sunshine swerve swimming switch tablet tattle taught teacher tennis thankful thimble thinner thinnest thirst thread threat thrill throat Thursday topcoat traffic travel treetop trouble trumpet Tuesday tugboat tumble turtle useful vanish visitor waddle wealth weather Wednesday weekend wettest whatever whenever windmill wonderful wreath wrench wriggle wrinkle wristwatch written yardstick winter mitten brother frying grouch intern plants player prance prayer present prince program snatch sneeze speech swatch twelve twenty twitter against American course during general however possible president rather states system things though toward united suddenly zipper anyone arrive asleep August avenue behave bridge carpet cereal choose cookie corner crayon danger minute banana bucket carrot dollar finger flower gentle handle listen mirror monkey nickel nobody orange parent person pocket potato puppet rocket search secret seesaw shovel shower silent spider sponge squash squeak sticky summer supper ticket tiptoe tissue tomato tongue turkey unfair wonder airport anybody balloon bedroom bicycle brownie cartoon ceiling channel chicken garbage promise squeeze address blanket earache excited grandma grocery indoors January kitchen lullaby monster morning naughty October pajamas pretend quarter shampoo stomach they've tonight unhappy airplane alphabet bathroom favorite medicine December dinosaur elephant February football forehead headache hospital lollipop November outdoors question railroad remember sandwich scissors shoulder softball tomorrow upstairs vacation restroom astronaut beautiful bumblebee cardboard chocolate Christmas classroom cranberry drugstore furniture milkshake nightmare telephone difficult everybody hamburger September spaceship spaghetti stoplight underwear yesterday automobile blackboard downstairs photograph strawberry television toothbrush toothpaste grandfather grandmother kindergarten refrigerator pumpkin melted handed printed landed wanted filled showed hugged tugged planned jogged spilled smelled grilled slammed rushed spelled smiled closed helped jumped looked clapped tapped kicked dropped zipped wished pitched missed walked worked lisitsyn-tapkee-04b33b5/examples/words/words.md000066400000000000000000000023511463410270200216170ustar00rootroot00000000000000This example shows how Tapkee can be used with Python, thanks to the language bindings provided by Shogun. The data consists of words from the English vocabulary. These words belong to different grammar groups: there are several common nouns (e.g. cowboy, dragon), adjectives (e.g. harmful), proper nouns such as Rivera or America, verbs in different forms (e.g. in gerund such as finishing or in past participle like disrupted), among other classes. The method used for embedding is Kernel Locally Linear Embedding (KLLE) and the callback required in this case is a kernel callback. The kernel callback is defined in Python, in the function word_kernel. Note the power of using language bindings and how code written in target interfaces (Python in this case) is able to interact with the underlying C++ code. The word kernel used is rather simple and it is based on a measure of sequence similarity implemented in the difflib module of Python (import the difflib module and issue help(difflib.SequenceMatcher) from a Python console for more information, tested in both Python 2.7.3 and Python 3.3.0). The target dimension of the embedding is two and, as it can be seen in the figure, the different word classes form clusters in the two dimensional plane. lisitsyn-tapkee-04b33b5/examples/words/words.py000066400000000000000000000025321463410270200216500ustar00rootroot00000000000000#!/usr/bin/env python import numpy as np import matplotlib.pyplot as plt from modshogun import KernelLocallyLinearEmbedding, CustomKernel import json import random import difflib def word_kernel(words): N = len(words) dist_matrix = np.zeros([N,N]) for i in xrange(N): for j in xrange(i,N): s = difflib.SequenceMatcher(None,words[i],words[j]) dist_matrix[i,j] = s.ratio() dist_matrix = 0.5*(dist_matrix+dist_matrix.T) return CustomKernel(dist_matrix) def embed(filename='words.dat'): print 'loading' words = [] with open(filename) as f: words.extend([str.rstrip() for str in f.readlines()]) print 'loaded', words converter = KernelLocallyLinearEmbedding() converter.set_k(20) converter.set_target_dim(2) converter.parallel.set_num_threads(1) embedding = converter.embed_kernel(word_kernel(words)).get_feature_matrix() return embedding,words def export_json(embedding, words): data = {} N = len(words) data['data'] = [{'string':words[i],'cx':embedding[0,i], 'cy':embedding[1,i]} for i in xrange(N)] json.dump(data, open('words.json', 'w')) def plot_embedding(embedding): fig = plt.figure() ax = fig.add_subplot(1,1,1) ax.scatter(embedding[0,:],embedding[1,:],alpha=0.4,cmap=plt.cm.Spectral) plt.axis('off') plt.show() if __name__ == "__main__": embedding, words = embed() export_json(embedding,words) plot_embedding(embedding) lisitsyn-tapkee-04b33b5/include/000077500000000000000000000000001463410270200166055ustar00rootroot00000000000000lisitsyn-tapkee-04b33b5/include/stichwort/000077500000000000000000000000001463410270200206335ustar00rootroot00000000000000lisitsyn-tapkee-04b33b5/include/stichwort/exceptions.hpp000066400000000000000000000053761463410270200235400ustar00rootroot00000000000000/** Stichwort * * Copyright (c) 2013, Sergey Lisitsyn * All rights reserved. * * Distributed under the BSD 2-clause license: * * Redistribution and use in source and binary forms, with or without modification, * are permitted provided that the following conditions are met: * * * Redistributions of source code must retain the above copyright notice, * this list of conditions and the following disclaimer. * * Redistributions in binary form must reproduce the above copyright notice, * this list of conditions and the following disclaimer in the documentation * and/or other materials provided with the distribution. * * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT * SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, * OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE * POSSIBILITY OF SUCH DAMAGE. */ #pragma once #include #include namespace stichwort { //! An exception type that is thrown in case of missed parameter, //! i.e. when some required parameter is not set. class missed_parameter_error : public std::logic_error { public: /** @param what_msg message of the exception */ explicit missed_parameter_error(const std::string& what_msg) : std::logic_error(what_msg){}; }; //! An exception type that is thrown in case if wrong parameter //! value is passed. class wrong_parameter_error : public std::logic_error { public: /** @param what_msg message of the exception */ explicit wrong_parameter_error(const std::string& what_msg) : std::logic_error(what_msg){}; }; //! An exception type that is thrown in case if wrong parameter //! value is passed. class wrong_parameter_type_error : public std::logic_error { public: /** @param what_msg message of the exception */ explicit wrong_parameter_type_error(const std::string& what_msg) : std::logic_error(what_msg){}; }; //! An exception type that is thrown when some parameter is passed more than once class multiple_parameter_error : public std::runtime_error { public: /** @param what_msg message of the exception */ explicit multiple_parameter_error(const std::string& what_msg) : std::runtime_error(what_msg){}; }; } // namespace stichwort lisitsyn-tapkee-04b33b5/include/stichwort/keywords.hpp000066400000000000000000000064261463410270200232230ustar00rootroot00000000000000/** Stichwort * * Copyright (c) 2013, Sergey Lisitsyn * All rights reserved. * * Distributed under the BSD 2-clause license: * * Redistribution and use in source and binary forms, with or without modification, * are permitted provided that the following conditions are met: * * * Redistributions of source code must retain the above copyright notice, * this list of conditions and the following disclaimer. * * Redistributions in binary form must reproduce the above copyright notice, * this list of conditions and the following disclaimer in the documentation * and/or other materials provided with the distribution. * * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT * SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, * OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE * POSSIBILITY OF SUCH DAMAGE. */ #pragma once #include //! The namespace that contains implementations for the keywords namespace stichwort { /** DefaultValue instance is useful * to set a parameter its default value. * * Once assigned to a keyword it produces a parameter * with the default value assigned to the keyword. */ struct DefaultValue { DefaultValue() { } }; /** ParameterKeyword instance is used to represent * a keyword that is assigned to some value. Such * an assignment results to instance of @ref Parameter * class which can be later checked and casted back * to the value it represents. * * Usage is * @code * ParameterKeyword keyword; * Parameter p = (keyword = 5); * int p_value = p; * @endcode */ template struct ParameterKeyword { typedef std::string Name; typedef T Type; ParameterKeyword(const Name& n, const T& dv) : name(n), default_value(dv) { } ParameterKeyword(const ParameterKeyword& pk); ParameterKeyword operator=(const ParameterKeyword& pk); Parameter operator=(const T& value) const { return Parameter::create(name, value); } Parameter operator=(const DefaultValue&) const { return Parameter::create(name, default_value); } operator Name() const { return name; } Name name; T default_value; }; struct ParametersForwarder { ParametersForwarder() { } ParametersForwarder(const ParametersForwarder&); ParametersForwarder& operator=(const ParametersForwarder&); ParametersSet operator[](ParametersSet parameters) const { return parameters; } }; namespace { /** The default value - assigning any keyword to this * static struct produces a parameter with its default value. */ const DefaultValue by_default; const ParametersForwarder kwargs; } // namespace } // namespace stichwort lisitsyn-tapkee-04b33b5/include/stichwort/parameter.hpp000066400000000000000000000170661463410270200233360ustar00rootroot00000000000000/** Stichwort * * Copyright (c) 2013, Sergey Lisitsyn * All rights reserved. * * Distributed under the BSD 2-clause license: * * Redistribution and use in source and binary forms, with or without modification, * are permitted provided that the following conditions are met: * * * Redistributions of source code must retain the above copyright notice, * this list of conditions and the following disclaimer. * * Redistributions in binary form must reproduce the above copyright notice, * this list of conditions and the following disclaimer in the documentation * and/or other materials provided with the distribution. * * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT * SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, * OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE * POSSIBILITY OF SUCH DAMAGE. */ #pragma once #include #include #include #include #include #include #include namespace stichwort { class ParametersSet; class CheckedParameter; class Parameter { friend class CheckedParameter; typedef std::string ParameterName; private: template Parameter(const ParameterName& pname, const T& value) : valid(true), invalidity_reasons(), parameter_name(pname), keeper(stichwort_internal::ValueKeeper(value)) { } public: template static Parameter create(const std::string& name, const T& value) { return Parameter(name, value); } Parameter() : valid(true), invalidity_reasons(), parameter_name("unknown"), keeper(stichwort_internal::ValueKeeper()) { } Parameter(const Parameter& p) : valid(p.valid), invalidity_reasons(p.invalidity_reasons), parameter_name(p.name()), keeper(p.keeper) { } ~Parameter() { } Parameter& operator=(const Parameter& p) { if (this == &p) { return *this; } this->valid = p.valid; this->invalidity_reasons = p.invalidity_reasons; this->parameter_name = p.parameter_name; this->keeper = p.keeper; return *this; } template inline Parameter withDefault(T value) { if (!isInitialized()) { keeper = stichwort_internal::ValueKeeper(value); } return *this; } template inline operator T() { throwIfInvalid(); try { return getValue(); } catch (const missed_parameter_error&) { throw missed_parameter_error(parameter_name + " is missed"); } } void throwIfInvalid() { if (!valid) { throw wrong_parameter_error(invalidity_reasons); } } operator ParametersSet(); template bool is(T v) { if (!isTypeCorrect()) return false; T kv = keeper.getValue(); if (v == kv) return true; return false; } template bool operator==(T v) const { return is(v); } CheckedParameter checked(); bool isInitialized() const { return keeper.isInitialized(); } template