├── .github
    └── workflows
    │   ├── docker_1604_build.yaml
    │   ├── docker_1804_build.yaml
    │   ├── docker_2004_build.yaml
    │   └── industrial_ci_action.yml.disable
├── .gitignore
├── Dockerfile_ros1_16_04
├── Dockerfile_ros1_18_04
├── Dockerfile_ros1_20_04
├── LICENSE
├── README.md
├── Schweizer-Messer
    ├── numpy_eigen
    │   ├── CMakeLists.txt
    │   ├── cmake
    │   │   ├── add_python_export_library.cmake
    │   │   └── numpy_eigen-extras.cmake.in
    │   ├── include
    │   │   └── numpy_eigen
    │   │   │   ├── NumpyEigenConverter.hpp
    │   │   │   ├── boost_python_headers.hpp
    │   │   │   ├── copy_routines.hpp
    │   │   │   └── type_traits.hpp
    │   ├── mainpage.dox
    │   ├── package.xml
    │   ├── setup.py
    │   ├── src
    │   │   ├── autogen_files.cmake
    │   │   ├── autogen_module
    │   │   │   ├── import_1_1_double.cpp
    │   │   │   ├── import_1_1_float.cpp
    │   │   │   ├── import_1_1_int.cpp
    │   │   │   ├── import_1_1_long.cpp
    │   │   │   ├── import_1_1_uchar.cpp
    │   │   │   ├── import_1_2_double.cpp
    │   │   │   ├── import_1_2_float.cpp
    │   │   │   ├── import_1_2_int.cpp
    │   │   │   ├── import_1_2_long.cpp
    │   │   │   ├── import_1_2_uchar.cpp
    │   │   │   ├── import_1_3_double.cpp
    │   │   │   ├── import_1_3_float.cpp
    │   │   │   ├── import_1_3_int.cpp
    │   │   │   ├── import_1_3_long.cpp
    │   │   │   ├── import_1_3_uchar.cpp
    │   │   │   ├── import_1_4_double.cpp
    │   │   │   ├── import_1_4_float.cpp
    │   │   │   ├── import_1_4_int.cpp
    │   │   │   ├── import_1_4_long.cpp
    │   │   │   ├── import_1_4_uchar.cpp
    │   │   │   ├── import_1_5_double.cpp
    │   │   │   ├── import_1_5_float.cpp
    │   │   │   ├── import_1_5_int.cpp
    │   │   │   ├── import_1_5_long.cpp
    │   │   │   ├── import_1_5_uchar.cpp
    │   │   │   ├── import_1_6_double.cpp
    │   │   │   ├── import_1_6_float.cpp
    │   │   │   ├── import_1_6_int.cpp
    │   │   │   ├── import_1_6_long.cpp
    │   │   │   ├── import_1_6_uchar.cpp
    │   │   │   ├── import_1_D_double.cpp
    │   │   │   ├── import_1_D_float.cpp
    │   │   │   ├── import_1_D_int.cpp
    │   │   │   ├── import_1_D_long.cpp
    │   │   │   ├── import_1_D_uchar.cpp
    │   │   │   ├── import_2_1_double.cpp
    │   │   │   ├── import_2_1_float.cpp
    │   │   │   ├── import_2_1_int.cpp
    │   │   │   ├── import_2_1_long.cpp
    │   │   │   ├── import_2_1_uchar.cpp
    │   │   │   ├── import_2_2_double.cpp
    │   │   │   ├── import_2_2_float.cpp
    │   │   │   ├── import_2_2_int.cpp
    │   │   │   ├── import_2_2_long.cpp
    │   │   │   ├── import_2_2_uchar.cpp
    │   │   │   ├── import_2_3_double.cpp
    │   │   │   ├── import_2_3_float.cpp
    │   │   │   ├── import_2_3_int.cpp
    │   │   │   ├── import_2_3_long.cpp
    │   │   │   ├── import_2_3_uchar.cpp
    │   │   │   ├── import_2_4_double.cpp
    │   │   │   ├── import_2_4_float.cpp
    │   │   │   ├── import_2_4_int.cpp
    │   │   │   ├── import_2_4_long.cpp
    │   │   │   ├── import_2_4_uchar.cpp
    │   │   │   ├── import_2_5_double.cpp
    │   │   │   ├── import_2_5_float.cpp
    │   │   │   ├── import_2_5_int.cpp
    │   │   │   ├── import_2_5_long.cpp
    │   │   │   ├── import_2_5_uchar.cpp
    │   │   │   ├── import_2_6_double.cpp
    │   │   │   ├── import_2_6_float.cpp
    │   │   │   ├── import_2_6_int.cpp
    │   │   │   ├── import_2_6_long.cpp
    │   │   │   ├── import_2_6_uchar.cpp
    │   │   │   ├── import_2_D_double.cpp
    │   │   │   ├── import_2_D_float.cpp
    │   │   │   ├── import_2_D_int.cpp
    │   │   │   ├── import_2_D_long.cpp
    │   │   │   ├── import_2_D_uchar.cpp
    │   │   │   ├── import_3_1_double.cpp
    │   │   │   ├── import_3_1_float.cpp
    │   │   │   ├── import_3_1_int.cpp
    │   │   │   ├── import_3_1_long.cpp
    │   │   │   ├── import_3_1_uchar.cpp
    │   │   │   ├── import_3_2_double.cpp
    │   │   │   ├── import_3_2_float.cpp
    │   │   │   ├── import_3_2_int.cpp
    │   │   │   ├── import_3_2_long.cpp
    │   │   │   ├── import_3_2_uchar.cpp
    │   │   │   ├── import_3_3_double.cpp
    │   │   │   ├── import_3_3_float.cpp
    │   │   │   ├── import_3_3_int.cpp
    │   │   │   ├── import_3_3_long.cpp
    │   │   │   ├── import_3_3_uchar.cpp
    │   │   │   ├── import_3_4_double.cpp
    │   │   │   ├── import_3_4_float.cpp
    │   │   │   ├── import_3_4_int.cpp
    │   │   │   ├── import_3_4_long.cpp
    │   │   │   ├── import_3_4_uchar.cpp
    │   │   │   ├── import_3_5_double.cpp
    │   │   │   ├── import_3_5_float.cpp
    │   │   │   ├── import_3_5_int.cpp
    │   │   │   ├── import_3_5_long.cpp
    │   │   │   ├── import_3_5_uchar.cpp
    │   │   │   ├── import_3_6_double.cpp
    │   │   │   ├── import_3_6_float.cpp
    │   │   │   ├── import_3_6_int.cpp
    │   │   │   ├── import_3_6_long.cpp
    │   │   │   ├── import_3_6_uchar.cpp
    │   │   │   ├── import_3_D_double.cpp
    │   │   │   ├── import_3_D_float.cpp
    │   │   │   ├── import_3_D_int.cpp
    │   │   │   ├── import_3_D_long.cpp
    │   │   │   ├── import_3_D_uchar.cpp
    │   │   │   ├── import_4_1_double.cpp
    │   │   │   ├── import_4_1_float.cpp
    │   │   │   ├── import_4_1_int.cpp
    │   │   │   ├── import_4_1_long.cpp
    │   │   │   ├── import_4_1_uchar.cpp
    │   │   │   ├── import_4_2_double.cpp
    │   │   │   ├── import_4_2_float.cpp
    │   │   │   ├── import_4_2_int.cpp
    │   │   │   ├── import_4_2_long.cpp
    │   │   │   ├── import_4_2_uchar.cpp
    │   │   │   ├── import_4_3_double.cpp
    │   │   │   ├── import_4_3_float.cpp
    │   │   │   ├── import_4_3_int.cpp
    │   │   │   ├── import_4_3_long.cpp
    │   │   │   ├── import_4_3_uchar.cpp
    │   │   │   ├── import_4_4_double.cpp
    │   │   │   ├── import_4_4_float.cpp
    │   │   │   ├── import_4_4_int.cpp
    │   │   │   ├── import_4_4_long.cpp
    │   │   │   ├── import_4_4_uchar.cpp
    │   │   │   ├── import_4_5_double.cpp
    │   │   │   ├── import_4_5_float.cpp
    │   │   │   ├── import_4_5_int.cpp
    │   │   │   ├── import_4_5_long.cpp
    │   │   │   ├── import_4_5_uchar.cpp
    │   │   │   ├── import_4_6_double.cpp
    │   │   │   ├── import_4_6_float.cpp
    │   │   │   ├── import_4_6_int.cpp
    │   │   │   ├── import_4_6_long.cpp
    │   │   │   ├── import_4_6_uchar.cpp
    │   │   │   ├── import_4_D_double.cpp
    │   │   │   ├── import_4_D_float.cpp
    │   │   │   ├── import_4_D_int.cpp
    │   │   │   ├── import_4_D_long.cpp
    │   │   │   ├── import_4_D_uchar.cpp
    │   │   │   ├── import_5_1_double.cpp
    │   │   │   ├── import_5_1_float.cpp
    │   │   │   ├── import_5_1_int.cpp
    │   │   │   ├── import_5_1_long.cpp
    │   │   │   ├── import_5_1_uchar.cpp
    │   │   │   ├── import_5_2_double.cpp
    │   │   │   ├── import_5_2_float.cpp
    │   │   │   ├── import_5_2_int.cpp
    │   │   │   ├── import_5_2_long.cpp
    │   │   │   ├── import_5_2_uchar.cpp
    │   │   │   ├── import_5_3_double.cpp
    │   │   │   ├── import_5_3_float.cpp
    │   │   │   ├── import_5_3_int.cpp
    │   │   │   ├── import_5_3_long.cpp
    │   │   │   ├── import_5_3_uchar.cpp
    │   │   │   ├── import_5_4_double.cpp
    │   │   │   ├── import_5_4_float.cpp
    │   │   │   ├── import_5_4_int.cpp
    │   │   │   ├── import_5_4_long.cpp
    │   │   │   ├── import_5_4_uchar.cpp
    │   │   │   ├── import_5_5_double.cpp
    │   │   │   ├── import_5_5_float.cpp
    │   │   │   ├── import_5_5_int.cpp
    │   │   │   ├── import_5_5_long.cpp
    │   │   │   ├── import_5_5_uchar.cpp
    │   │   │   ├── import_5_6_double.cpp
    │   │   │   ├── import_5_6_float.cpp
    │   │   │   ├── import_5_6_int.cpp
    │   │   │   ├── import_5_6_long.cpp
    │   │   │   ├── import_5_6_uchar.cpp
    │   │   │   ├── import_5_D_double.cpp
    │   │   │   ├── import_5_D_float.cpp
    │   │   │   ├── import_5_D_int.cpp
    │   │   │   ├── import_5_D_long.cpp
    │   │   │   ├── import_5_D_uchar.cpp
    │   │   │   ├── import_6_1_double.cpp
    │   │   │   ├── import_6_1_float.cpp
    │   │   │   ├── import_6_1_int.cpp
    │   │   │   ├── import_6_1_long.cpp
    │   │   │   ├── import_6_1_uchar.cpp
    │   │   │   ├── import_6_2_double.cpp
    │   │   │   ├── import_6_2_float.cpp
    │   │   │   ├── import_6_2_int.cpp
    │   │   │   ├── import_6_2_long.cpp
    │   │   │   ├── import_6_2_uchar.cpp
    │   │   │   ├── import_6_3_double.cpp
    │   │   │   ├── import_6_3_float.cpp
    │   │   │   ├── import_6_3_int.cpp
    │   │   │   ├── import_6_3_long.cpp
    │   │   │   ├── import_6_3_uchar.cpp
    │   │   │   ├── import_6_4_double.cpp
    │   │   │   ├── import_6_4_float.cpp
    │   │   │   ├── import_6_4_int.cpp
    │   │   │   ├── import_6_4_long.cpp
    │   │   │   ├── import_6_4_uchar.cpp
    │   │   │   ├── import_6_5_double.cpp
    │   │   │   ├── import_6_5_float.cpp
    │   │   │   ├── import_6_5_int.cpp
    │   │   │   ├── import_6_5_long.cpp
    │   │   │   ├── import_6_5_uchar.cpp
    │   │   │   ├── import_6_6_double.cpp
    │   │   │   ├── import_6_6_float.cpp
    │   │   │   ├── import_6_6_int.cpp
    │   │   │   ├── import_6_6_long.cpp
    │   │   │   ├── import_6_6_uchar.cpp
    │   │   │   ├── import_6_D_double.cpp
    │   │   │   ├── import_6_D_float.cpp
    │   │   │   ├── import_6_D_int.cpp
    │   │   │   ├── import_6_D_long.cpp
    │   │   │   ├── import_6_D_uchar.cpp
    │   │   │   ├── import_D_1_double.cpp
    │   │   │   ├── import_D_1_float.cpp
    │   │   │   ├── import_D_1_int.cpp
    │   │   │   ├── import_D_1_long.cpp
    │   │   │   ├── import_D_1_uchar.cpp
    │   │   │   ├── import_D_2_double.cpp
    │   │   │   ├── import_D_2_float.cpp
    │   │   │   ├── import_D_2_int.cpp
    │   │   │   ├── import_D_2_long.cpp
    │   │   │   ├── import_D_2_uchar.cpp
    │   │   │   ├── import_D_3_double.cpp
    │   │   │   ├── import_D_3_float.cpp
    │   │   │   ├── import_D_3_int.cpp
    │   │   │   ├── import_D_3_long.cpp
    │   │   │   ├── import_D_3_uchar.cpp
    │   │   │   ├── import_D_4_double.cpp
    │   │   │   ├── import_D_4_float.cpp
    │   │   │   ├── import_D_4_int.cpp
    │   │   │   ├── import_D_4_long.cpp
    │   │   │   ├── import_D_4_uchar.cpp
    │   │   │   ├── import_D_5_double.cpp
    │   │   │   ├── import_D_5_float.cpp
    │   │   │   ├── import_D_5_int.cpp
    │   │   │   ├── import_D_5_long.cpp
    │   │   │   ├── import_D_5_uchar.cpp
    │   │   │   ├── import_D_6_double.cpp
    │   │   │   ├── import_D_6_float.cpp
    │   │   │   ├── import_D_6_int.cpp
    │   │   │   ├── import_D_6_long.cpp
    │   │   │   ├── import_D_6_uchar.cpp
    │   │   │   ├── import_D_D_double.cpp
    │   │   │   ├── import_D_D_float.cpp
    │   │   │   ├── import_D_D_int.cpp
    │   │   │   ├── import_D_D_long.cpp
    │   │   │   ├── import_D_D_uchar.cpp
    │   │   │   └── numpy_eigen_export_module.cpp
    │   │   ├── autogen_test_files.cmake
    │   │   ├── autogen_test_module
    │   │   │   ├── numpy_eigen_test_module.cpp
    │   │   │   ├── test_1_1_double.cpp
    │   │   │   ├── test_1_1_float.cpp
    │   │   │   ├── test_1_1_int.cpp
    │   │   │   ├── test_1_1_long.cpp
    │   │   │   ├── test_1_1_uchar.cpp
    │   │   │   ├── test_1_2_double.cpp
    │   │   │   ├── test_1_2_float.cpp
    │   │   │   ├── test_1_2_int.cpp
    │   │   │   ├── test_1_2_long.cpp
    │   │   │   ├── test_1_2_uchar.cpp
    │   │   │   ├── test_1_3_double.cpp
    │   │   │   ├── test_1_3_float.cpp
    │   │   │   ├── test_1_3_int.cpp
    │   │   │   ├── test_1_3_long.cpp
    │   │   │   ├── test_1_3_uchar.cpp
    │   │   │   ├── test_1_4_double.cpp
    │   │   │   ├── test_1_4_float.cpp
    │   │   │   ├── test_1_4_int.cpp
    │   │   │   ├── test_1_4_long.cpp
    │   │   │   ├── test_1_4_uchar.cpp
    │   │   │   ├── test_1_5_double.cpp
    │   │   │   ├── test_1_5_float.cpp
    │   │   │   ├── test_1_5_int.cpp
    │   │   │   ├── test_1_5_long.cpp
    │   │   │   ├── test_1_5_uchar.cpp
    │   │   │   ├── test_1_6_double.cpp
    │   │   │   ├── test_1_6_float.cpp
    │   │   │   ├── test_1_6_int.cpp
    │   │   │   ├── test_1_6_long.cpp
    │   │   │   ├── test_1_6_uchar.cpp
    │   │   │   ├── test_1_D_double.cpp
    │   │   │   ├── test_1_D_float.cpp
    │   │   │   ├── test_1_D_int.cpp
    │   │   │   ├── test_1_D_long.cpp
    │   │   │   ├── test_1_D_uchar.cpp
    │   │   │   ├── test_2_1_double.cpp
    │   │   │   ├── test_2_1_float.cpp
    │   │   │   ├── test_2_1_int.cpp
    │   │   │   ├── test_2_1_long.cpp
    │   │   │   ├── test_2_1_uchar.cpp
    │   │   │   ├── test_2_2_double.cpp
    │   │   │   ├── test_2_2_float.cpp
    │   │   │   ├── test_2_2_int.cpp
    │   │   │   ├── test_2_2_long.cpp
    │   │   │   ├── test_2_2_uchar.cpp
    │   │   │   ├── test_2_3_double.cpp
    │   │   │   ├── test_2_3_float.cpp
    │   │   │   ├── test_2_3_int.cpp
    │   │   │   ├── test_2_3_long.cpp
    │   │   │   ├── test_2_3_uchar.cpp
    │   │   │   ├── test_2_4_double.cpp
    │   │   │   ├── test_2_4_float.cpp
    │   │   │   ├── test_2_4_int.cpp
    │   │   │   ├── test_2_4_long.cpp
    │   │   │   ├── test_2_4_uchar.cpp
    │   │   │   ├── test_2_5_double.cpp
    │   │   │   ├── test_2_5_float.cpp
    │   │   │   ├── test_2_5_int.cpp
    │   │   │   ├── test_2_5_long.cpp
    │   │   │   ├── test_2_5_uchar.cpp
    │   │   │   ├── test_2_6_double.cpp
    │   │   │   ├── test_2_6_float.cpp
    │   │   │   ├── test_2_6_int.cpp
    │   │   │   ├── test_2_6_long.cpp
    │   │   │   ├── test_2_6_uchar.cpp
    │   │   │   ├── test_2_D_double.cpp
    │   │   │   ├── test_2_D_float.cpp
    │   │   │   ├── test_2_D_int.cpp
    │   │   │   ├── test_2_D_long.cpp
    │   │   │   ├── test_2_D_uchar.cpp
    │   │   │   ├── test_3_1_double.cpp
    │   │   │   ├── test_3_1_float.cpp
    │   │   │   ├── test_3_1_int.cpp
    │   │   │   ├── test_3_1_long.cpp
    │   │   │   ├── test_3_1_uchar.cpp
    │   │   │   ├── test_3_2_double.cpp
    │   │   │   ├── test_3_2_float.cpp
    │   │   │   ├── test_3_2_int.cpp
    │   │   │   ├── test_3_2_long.cpp
    │   │   │   ├── test_3_2_uchar.cpp
    │   │   │   ├── test_3_3_double.cpp
    │   │   │   ├── test_3_3_float.cpp
    │   │   │   ├── test_3_3_int.cpp
    │   │   │   ├── test_3_3_long.cpp
    │   │   │   ├── test_3_3_uchar.cpp
    │   │   │   ├── test_3_4_double.cpp
    │   │   │   ├── test_3_4_float.cpp
    │   │   │   ├── test_3_4_int.cpp
    │   │   │   ├── test_3_4_long.cpp
    │   │   │   ├── test_3_4_uchar.cpp
    │   │   │   ├── test_3_5_double.cpp
    │   │   │   ├── test_3_5_float.cpp
    │   │   │   ├── test_3_5_int.cpp
    │   │   │   ├── test_3_5_long.cpp
    │   │   │   ├── test_3_5_uchar.cpp
    │   │   │   ├── test_3_6_double.cpp
    │   │   │   ├── test_3_6_float.cpp
    │   │   │   ├── test_3_6_int.cpp
    │   │   │   ├── test_3_6_long.cpp
    │   │   │   ├── test_3_6_uchar.cpp
    │   │   │   ├── test_3_D_double.cpp
    │   │   │   ├── test_3_D_float.cpp
    │   │   │   ├── test_3_D_int.cpp
    │   │   │   ├── test_3_D_long.cpp
    │   │   │   ├── test_3_D_uchar.cpp
    │   │   │   ├── test_4_1_double.cpp
    │   │   │   ├── test_4_1_float.cpp
    │   │   │   ├── test_4_1_int.cpp
    │   │   │   ├── test_4_1_long.cpp
    │   │   │   ├── test_4_1_uchar.cpp
    │   │   │   ├── test_4_2_double.cpp
    │   │   │   ├── test_4_2_float.cpp
    │   │   │   ├── test_4_2_int.cpp
    │   │   │   ├── test_4_2_long.cpp
    │   │   │   ├── test_4_2_uchar.cpp
    │   │   │   ├── test_4_3_double.cpp
    │   │   │   ├── test_4_3_float.cpp
    │   │   │   ├── test_4_3_int.cpp
    │   │   │   ├── test_4_3_long.cpp
    │   │   │   ├── test_4_3_uchar.cpp
    │   │   │   ├── test_4_4_double.cpp
    │   │   │   ├── test_4_4_float.cpp
    │   │   │   ├── test_4_4_int.cpp
    │   │   │   ├── test_4_4_long.cpp
    │   │   │   ├── test_4_4_uchar.cpp
    │   │   │   ├── test_4_5_double.cpp
    │   │   │   ├── test_4_5_float.cpp
    │   │   │   ├── test_4_5_int.cpp
    │   │   │   ├── test_4_5_long.cpp
    │   │   │   ├── test_4_5_uchar.cpp
    │   │   │   ├── test_4_6_double.cpp
    │   │   │   ├── test_4_6_float.cpp
    │   │   │   ├── test_4_6_int.cpp
    │   │   │   ├── test_4_6_long.cpp
    │   │   │   ├── test_4_6_uchar.cpp
    │   │   │   ├── test_4_D_double.cpp
    │   │   │   ├── test_4_D_float.cpp
    │   │   │   ├── test_4_D_int.cpp
    │   │   │   ├── test_4_D_long.cpp
    │   │   │   ├── test_4_D_uchar.cpp
    │   │   │   ├── test_5_1_double.cpp
    │   │   │   ├── test_5_1_float.cpp
    │   │   │   ├── test_5_1_int.cpp
    │   │   │   ├── test_5_1_long.cpp
    │   │   │   ├── test_5_1_uchar.cpp
    │   │   │   ├── test_5_2_double.cpp
    │   │   │   ├── test_5_2_float.cpp
    │   │   │   ├── test_5_2_int.cpp
    │   │   │   ├── test_5_2_long.cpp
    │   │   │   ├── test_5_2_uchar.cpp
    │   │   │   ├── test_5_3_double.cpp
    │   │   │   ├── test_5_3_float.cpp
    │   │   │   ├── test_5_3_int.cpp
    │   │   │   ├── test_5_3_long.cpp
    │   │   │   ├── test_5_3_uchar.cpp
    │   │   │   ├── test_5_4_double.cpp
    │   │   │   ├── test_5_4_float.cpp
    │   │   │   ├── test_5_4_int.cpp
    │   │   │   ├── test_5_4_long.cpp
    │   │   │   ├── test_5_4_uchar.cpp
    │   │   │   ├── test_5_5_double.cpp
    │   │   │   ├── test_5_5_float.cpp
    │   │   │   ├── test_5_5_int.cpp
    │   │   │   ├── test_5_5_long.cpp
    │   │   │   ├── test_5_5_uchar.cpp
    │   │   │   ├── test_5_6_double.cpp
    │   │   │   ├── test_5_6_float.cpp
    │   │   │   ├── test_5_6_int.cpp
    │   │   │   ├── test_5_6_long.cpp
    │   │   │   ├── test_5_6_uchar.cpp
    │   │   │   ├── test_5_D_double.cpp
    │   │   │   ├── test_5_D_float.cpp
    │   │   │   ├── test_5_D_int.cpp
    │   │   │   ├── test_5_D_long.cpp
    │   │   │   ├── test_5_D_uchar.cpp
    │   │   │   ├── test_6_1_double.cpp
    │   │   │   ├── test_6_1_float.cpp
    │   │   │   ├── test_6_1_int.cpp
    │   │   │   ├── test_6_1_long.cpp
    │   │   │   ├── test_6_1_uchar.cpp
    │   │   │   ├── test_6_2_double.cpp
    │   │   │   ├── test_6_2_float.cpp
    │   │   │   ├── test_6_2_int.cpp
    │   │   │   ├── test_6_2_long.cpp
    │   │   │   ├── test_6_2_uchar.cpp
    │   │   │   ├── test_6_3_double.cpp
    │   │   │   ├── test_6_3_float.cpp
    │   │   │   ├── test_6_3_int.cpp
    │   │   │   ├── test_6_3_long.cpp
    │   │   │   ├── test_6_3_uchar.cpp
    │   │   │   ├── test_6_4_double.cpp
    │   │   │   ├── test_6_4_float.cpp
    │   │   │   ├── test_6_4_int.cpp
    │   │   │   ├── test_6_4_long.cpp
    │   │   │   ├── test_6_4_uchar.cpp
    │   │   │   ├── test_6_5_double.cpp
    │   │   │   ├── test_6_5_float.cpp
    │   │   │   ├── test_6_5_int.cpp
    │   │   │   ├── test_6_5_long.cpp
    │   │   │   ├── test_6_5_uchar.cpp
    │   │   │   ├── test_6_6_double.cpp
    │   │   │   ├── test_6_6_float.cpp
    │   │   │   ├── test_6_6_int.cpp
    │   │   │   ├── test_6_6_long.cpp
    │   │   │   ├── test_6_6_uchar.cpp
    │   │   │   ├── test_6_D_double.cpp
    │   │   │   ├── test_6_D_float.cpp
    │   │   │   ├── test_6_D_int.cpp
    │   │   │   ├── test_6_D_long.cpp
    │   │   │   ├── test_6_D_uchar.cpp
    │   │   │   ├── test_D_1_double.cpp
    │   │   │   ├── test_D_1_float.cpp
    │   │   │   ├── test_D_1_int.cpp
    │   │   │   ├── test_D_1_long.cpp
    │   │   │   ├── test_D_1_uchar.cpp
    │   │   │   ├── test_D_2_double.cpp
    │   │   │   ├── test_D_2_float.cpp
    │   │   │   ├── test_D_2_int.cpp
    │   │   │   ├── test_D_2_long.cpp
    │   │   │   ├── test_D_2_uchar.cpp
    │   │   │   ├── test_D_3_double.cpp
    │   │   │   ├── test_D_3_float.cpp
    │   │   │   ├── test_D_3_int.cpp
    │   │   │   ├── test_D_3_long.cpp
    │   │   │   ├── test_D_3_uchar.cpp
    │   │   │   ├── test_D_4_double.cpp
    │   │   │   ├── test_D_4_float.cpp
    │   │   │   ├── test_D_4_int.cpp
    │   │   │   ├── test_D_4_long.cpp
    │   │   │   ├── test_D_4_uchar.cpp
    │   │   │   ├── test_D_5_double.cpp
    │   │   │   ├── test_D_5_float.cpp
    │   │   │   ├── test_D_5_int.cpp
    │   │   │   ├── test_D_5_long.cpp
    │   │   │   ├── test_D_5_uchar.cpp
    │   │   │   ├── test_D_6_double.cpp
    │   │   │   ├── test_D_6_float.cpp
    │   │   │   ├── test_D_6_int.cpp
    │   │   │   ├── test_D_6_long.cpp
    │   │   │   ├── test_D_6_uchar.cpp
    │   │   │   ├── test_D_D_double.cpp
    │   │   │   ├── test_D_D_float.cpp
    │   │   │   ├── test_D_D_int.cpp
    │   │   │   ├── test_D_D_long.cpp
    │   │   │   └── test_D_D_uchar.cpp
    │   │   ├── create_export_module.py
    │   │   └── numpy_eigen
    │   │   │   ├── __init__.py
    │   │   │   └── test
    │   │   │       └── __init__.py
    │   └── test
    │   │   └── numpy_eigen_tests.py
    ├── python_module
    │   ├── CMakeLists.txt
    │   ├── cmake
    │   │   └── add_python_export_library.cmake
    │   └── package.xml
    ├── sm_boost
    │   ├── CMakeLists.txt
    │   ├── include
    │   │   ├── boost
    │   │   │   ├── portable_binary_archive.hpp
    │   │   │   ├── portable_binary_iarchive.hpp
    │   │   │   └── portable_binary_oarchive.hpp
    │   │   └── sm
    │   │   │   └── boost
    │   │   │       ├── JobQueue.hpp
    │   │   │       ├── implementation
    │   │   │           └── JobQueue.hpp
    │   │   │       ├── null_deleter.hpp
    │   │   │       ├── ptime.hpp
    │   │   │       └── serialization.hpp
    │   ├── mainpage.dox
    │   ├── package.xml
    │   ├── src
    │   │   ├── JobQueue.cpp
    │   │   ├── portable_binary_iarchive.cpp
    │   │   └── portable_binary_oarchive.cpp
    │   └── test
    │   │   ├── testFuture.cpp
    │   │   └── test_main.cpp
    ├── sm_common
    │   ├── CMakeLists.txt
    │   ├── cmake
    │   │   └── export_flags.cmake
    │   ├── include
    │   │   └── sm
    │   │   │   ├── Id.hpp
    │   │   │   ├── aligned_allocation.h
    │   │   │   ├── assert_macros.hpp
    │   │   │   ├── hash_id.hpp
    │   │   │   ├── is_binary_equal.hpp
    │   │   │   ├── maths.hpp
    │   │   │   ├── numerical_comparisons.hpp
    │   │   │   ├── progress_info.hpp
    │   │   │   ├── round.hpp
    │   │   │   ├── serialization_macros.hpp
    │   │   │   ├── source_file_pos.hpp
    │   │   │   ├── string_routines.hpp
    │   │   │   └── typetraits.hpp
    │   ├── mainpage.dox
    │   ├── package.xml
    │   ├── src
    │   │   └── progress_info.cpp
    │   └── test
    │   │   ├── hash_id.cpp
    │   │   ├── maths.cpp
    │   │   ├── numerical_comparisons.cpp
    │   │   ├── serialization_macros.cpp
    │   │   └── test_main.cpp
    ├── sm_eigen
    │   ├── CMakeLists.txt
    │   ├── cmake
    │   │   └── sm_eigen-extras.cmake.in
    │   ├── include
    │   │   └── sm
    │   │   │   └── eigen
    │   │   │       ├── NumericalDiff.hpp
    │   │   │       ├── assert_macros.hpp
    │   │   │       ├── gtest.hpp
    │   │   │       ├── matrix_sqrt.hpp
    │   │   │       ├── property_tree.hpp
    │   │   │       ├── random.hpp
    │   │   │       ├── serialization.hpp
    │   │   │       ├── static_assert.hpp
    │   │   │       └── traits.hpp
    │   ├── mainpage.dox
    │   ├── package.xml
    │   ├── src
    │   │   └── random.cpp
    │   └── test
    │   │   ├── EigenSerializationTests.cpp
    │   │   ├── MatrixSqrtTest.cpp
    │   │   └── test_main.cpp
    ├── sm_kinematics
    │   ├── CMakeLists.txt
    │   ├── include
    │   │   └── sm
    │   │   │   └── kinematics
    │   │   │       ├── EulerAnglesYawPitchRoll.hpp
    │   │   │       ├── EulerAnglesZXY.h
    │   │   │       ├── EulerAnglesZYX.hpp
    │   │   │       ├── EulerRodriguez.hpp
    │   │   │       ├── HomogeneousPoint.hpp
    │   │   │       ├── RotationVector.hpp
    │   │   │       ├── RotationalKinematics.hpp
    │   │   │       ├── Transformation.hpp
    │   │   │       ├── UncertainHomogeneousPoint.hpp
    │   │   │       ├── UncertainTransformation.hpp
    │   │   │       ├── UncertainVector.hpp
    │   │   │       ├── homogeneous_coordinates.hpp
    │   │   │       ├── implementation
    │   │   │           └── UncertainVector.hpp
    │   │   │       ├── property_tree.hpp
    │   │   │       ├── quaternion_algebra.hpp
    │   │   │       ├── rotations.hpp
    │   │   │       ├── three_point_methods.hpp
    │   │   │       └── transformations.hpp
    │   ├── mainpage.dox
    │   ├── package.xml
    │   ├── src
    │   │   ├── EulerAnglesYawPitchRoll.cpp
    │   │   ├── EulerAnglesZXY.cpp
    │   │   ├── EulerAnglesZYX.cpp
    │   │   ├── EulerRodriguez.cpp
    │   │   ├── HomogeneousPoint.cpp
    │   │   ├── RotationVector.cpp
    │   │   ├── RotationalKinematics.cpp
    │   │   ├── Transformation.cpp
    │   │   ├── UncertainHomogeneousPoint.cpp
    │   │   ├── UncertainTransformation.cpp
    │   │   ├── homogeneous_coordinates.cpp
    │   │   ├── quaternion_algebra.cpp
    │   │   ├── rotations.cpp
    │   │   ├── three_point_methods.cpp
    │   │   └── transformations.cpp
    │   └── test
    │   │   ├── HomogeneousPoint.cpp
    │   │   ├── PointTestHarness.hpp
    │   │   ├── QuaternionTests.cpp
    │   │   ├── RotationalKinematicsTests.cpp
    │   │   ├── TransformationTests.cpp
    │   │   ├── UncertainHomogeneousPoint.cpp
    │   │   ├── UncertainTransformationTests.cpp
    │   │   ├── homogeneous_coordinates.cpp
    │   │   ├── test_main.cpp
    │   │   ├── three_point_methods.cpp
    │   │   └── transformations.cpp
    ├── sm_logging
    │   ├── CMakeLists.txt
    │   ├── include
    │   │   └── sm
    │   │   │   ├── logging.hpp
    │   │   │   └── logging
    │   │   │       ├── Formatter.hpp
    │   │   │       ├── Levels.hpp
    │   │   │       ├── LogLocation.hpp
    │   │   │       ├── Logger.hpp
    │   │   │       ├── LoggingEvent.hpp
    │   │   │       ├── LoggingGlobals.hpp
    │   │   │       ├── StdOutLogger.hpp
    │   │   │       ├── Tokens.hpp
    │   │   │       ├── assert.h
    │   │   │       ├── console.hpp
    │   │   │       ├── macros.h
    │   │   │       └── macros_generated.hpp
    │   ├── mainpage.dox
    │   ├── package.xml
    │   ├── scripts
    │   │   ├── generate_macros.py
    │   │   └── generate_speed_test.py
    │   ├── src
    │   │   ├── Formatter.cpp
    │   │   ├── Logger.cpp
    │   │   ├── LoggingEvent.cpp
    │   │   ├── LoggingGlobals.cpp
    │   │   ├── StdOutLogger.cpp
    │   │   ├── Tokens.cpp
    │   │   └── gettimeofday.hpp
    │   └── test
    │   │   ├── logTest.cpp
    │   │   └── test_main.cpp
    ├── sm_matrix_archive
    │   ├── .gitignore
    │   ├── CMakeLists.txt
    │   ├── include
    │   │   └── sm
    │   │   │   └── MatrixArchive.hpp
    │   ├── mainpage.dox
    │   ├── matlab
    │   │   ├── loadMatrixArchive.m
    │   │   └── saveMatrixArchive.m
    │   ├── package.xml
    │   ├── src
    │   │   └── MatrixArchive.cpp
    │   └── test
    │   │   ├── TestMatrixArchive.cpp
    │   │   └── test_main.cpp
    ├── sm_opencv
    │   ├── CMakeLists.txt
    │   ├── include
    │   │   └── sm
    │   │   │   └── opencv
    │   │   │       └── serialization.hpp
    │   ├── mainpage.dox
    │   └── package.xml
    ├── sm_property_tree
    │   ├── CMakeLists.txt
    │   ├── include
    │   │   └── sm
    │   │   │   ├── BoostPropertyTree.hpp
    │   │   │   ├── BoostPropertyTreeImplementation.hpp
    │   │   │   ├── BoostPropertyTreeSupport.hpp
    │   │   │   ├── PropertyTree.hpp
    │   │   │   └── PropertyTreeImplementation.hpp
    │   ├── mainpage.dox
    │   ├── package.xml
    │   ├── src
    │   │   ├── BoostPropertyTree.cpp
    │   │   ├── BoostPropertyTreeImplementation.cpp
    │   │   ├── BoostPropertyTreeSupport.cpp
    │   │   ├── PropertyTree.cpp
    │   │   └── PropertyTreeImplementation.cpp
    │   └── test
    │   │   ├── BoostPropertyTreeImplementation.cpp
    │   │   └── test_main.cpp
    ├── sm_python
    │   ├── CMakeLists.txt
    │   ├── include
    │   │   └── sm
    │   │   │   └── python
    │   │   │       ├── Id.hpp
    │   │   │       ├── boost_serialization_pickle.hpp
    │   │   │       ├── stl_converters.hpp
    │   │   │       └── unique_register_ptr_to_python.hpp
    │   ├── mainpage.dox
    │   ├── package.xml
    │   ├── python
    │   │   └── sm
    │   │   │   ├── PlotCollection.py
    │   │   │   ├── Progress.py
    │   │   │   ├── __init__.py
    │   │   │   ├── experiments
    │   │   │       └── __init__.py
    │   │   │   ├── plotCoordinateFrame.py
    │   │   │   └── saveFigTight.py
    │   ├── setup.py
    │   └── src
    │   │   ├── Logging.cpp
    │   │   ├── exportEigen.cpp
    │   │   ├── exportHomogeneousPoint.cpp
    │   │   ├── exportMatrixArchive.cpp
    │   │   ├── exportNsecTime.cpp
    │   │   ├── exportPropertyTree.cpp
    │   │   ├── exportTimestampCorrector.cpp
    │   │   ├── exportTransformation.cpp
    │   │   ├── exportUncertainVector.cpp
    │   │   ├── export_eigen_property_tree.cpp
    │   │   ├── export_homogeneous.cpp
    │   │   ├── export_kinematics_property_tree.cpp
    │   │   ├── export_quaternion_algebra.cpp
    │   │   ├── export_rotational_kinematics.cpp
    │   │   ├── export_rotations.cpp
    │   │   ├── export_transformations.cpp
    │   │   ├── module.cpp
    │   │   └── random.cpp
    ├── sm_random
    │   ├── CMakeLists.txt
    │   ├── include
    │   │   └── sm
    │   │   │   └── random.hpp
    │   ├── mainpage.dox
    │   ├── package.xml
    │   └── src
    │   │   └── random.cpp
    └── sm_timing
    │   ├── CMakeLists.txt
    │   ├── include
    │       └── sm
    │       │   └── timing
    │       │       ├── NsecTimeUtilities.hpp
    │       │       ├── Timer.hpp
    │       │       ├── TimestampCorrector.hpp
    │       │       └── implementation
    │       │           └── TimestampCorrector.hpp
    │   ├── mainpage.dox
    │   ├── package.xml
    │   ├── src
    │       ├── NsecTimeUtilities.cpp
    │       └── Timer.cpp
    │   └── test
    │       ├── TestNsecTimeUtilities.cpp
    │       ├── TestTimestampCorrector.cpp
    │       └── test_main.cpp
├── aslam_cv
    ├── aslam_cameras
    │   ├── CMakeLists.txt
    │   ├── include
    │   │   └── aslam
    │   │   │   ├── BackProjection.hpp
    │   │   │   ├── DescriptorBase.hpp
    │   │   │   ├── Frame.hpp
    │   │   │   ├── FrameBase.hpp
    │   │   │   ├── Image.hpp
    │   │   │   ├── Keypoint.hpp
    │   │   │   ├── KeypointBase.hpp
    │   │   │   ├── KeypointIdentifier.hpp
    │   │   │   ├── Landmark.hpp
    │   │   │   ├── cameras.hpp
    │   │   │   ├── cameras
    │   │   │       ├── CameraGeometry.hpp
    │   │   │       ├── CameraGeometryBase.hpp
    │   │   │       ├── DepthProjection.hpp
    │   │   │       ├── DoubleSphereProjection.hpp
    │   │   │       ├── EquidistantDistortion.hpp
    │   │   │       ├── ExtendedUnifiedProjection.hpp
    │   │   │       ├── FiniteDifferences.hpp
    │   │   │       ├── FovDistortion.hpp
    │   │   │       ├── GlobalShutter.hpp
    │   │   │       ├── GridCalibrationTargetBase.hpp
    │   │   │       ├── GridCalibrationTargetCheckerboard.hpp
    │   │   │       ├── GridCalibrationTargetCirclegrid.hpp
    │   │   │       ├── GridCalibrationTargetObservation.hpp
    │   │   │       ├── GridDetector.hpp
    │   │   │       ├── ImageMask.hpp
    │   │   │       ├── NoDistortion.hpp
    │   │   │       ├── NoMask.hpp
    │   │   │       ├── OmniProjection.hpp
    │   │   │       ├── PinholeProjection.hpp
    │   │   │       ├── PinholeProjection.hpp.orig
    │   │   │       ├── RadialTangentialDistortion.hpp
    │   │   │       ├── RollingShutter.hpp
    │   │   │       ├── StaticAssert.hpp
    │   │   │       ├── Triangulation.hpp
    │   │   │       ├── implementation
    │   │   │       │   ├── CameraGeometry.hpp
    │   │   │       │   ├── DepthProjection.hpp
    │   │   │       │   ├── DoubleSphereProjection.hpp
    │   │   │       │   ├── EquidistantDistortion.hpp
    │   │   │       │   ├── ExtendedUnifiedProjection.hpp
    │   │   │       │   ├── FovDistortion.hpp
    │   │   │       │   ├── NoDistortion.hpp
    │   │   │       │   ├── OmniProjection.hpp
    │   │   │       │   ├── PinholeProjection.hpp
    │   │   │       │   └── RadialTangentialDistortion.hpp
    │   │   │       └── test
    │   │   │       │   └── CameraGeometryTestHarness.hpp
    │   │   │   ├── frontend_ids.hpp
    │   │   │   ├── implementation
    │   │   │       ├── Frame.hpp
    │   │   │       ├── Image.hpp
    │   │   │       ├── Keypoint.hpp
    │   │   │       └── utilities.hpp
    │   │   │   ├── targets.hpp
    │   │   │   └── utilities.hpp
    │   ├── package.xml
    │   ├── src
    │   │   ├── BackProjection.cpp
    │   │   ├── CameraGeometryBase.cpp
    │   │   ├── DepthCameraGeometry.cpp
    │   │   ├── DescriptorBase.cpp
    │   │   ├── EquidistantDistortion.cpp
    │   │   ├── FovDistortion.cpp
    │   │   ├── FrameBase.cpp
    │   │   ├── GlobalShutter.cpp
    │   │   ├── GridCalibrationTargetBase.cpp
    │   │   ├── GridCalibrationTargetCheckerboard.cpp
    │   │   ├── GridCalibrationTargetCirclegrid.cpp
    │   │   ├── GridCalibrationTargetObservation.cpp
    │   │   ├── GridDetector.cpp
    │   │   ├── Image.cpp
    │   │   ├── ImageMask.cpp
    │   │   ├── KeypointBase.cpp
    │   │   ├── Landmark.cpp
    │   │   ├── MaskedCameraGeometry.cpp
    │   │   ├── NoDistortion.cpp
    │   │   ├── NoMask.cpp
    │   │   ├── OmniCameraGeometry.cpp
    │   │   ├── PinholeCameraGeometry.cpp
    │   │   ├── PinholeRSCameraGeometry.cpp
    │   │   ├── RadialTangentialDistortion.cpp
    │   │   ├── RollingShutter.cpp
    │   │   ├── SphericalCameraGeometry.cpp
    │   │   └── Triangulation.cpp
    │   ├── test.ba
    │   └── test
    │   │   ├── DepthCameraGeometry.cpp
    │   │   ├── DoubleSphereCameraGeometry.cpp
    │   │   ├── EquidistantDistortion.cpp
    │   │   ├── ExtendedUnifiedCameraGeometry.cpp
    │   │   ├── FovDistortion.cpp
    │   │   ├── GridCalibration.cpp
    │   │   ├── OmniCameraGeometry.cpp
    │   │   ├── PinholeCameraGeometry.cpp
    │   │   ├── PinholeCameraGeometry.cpp.orig
    │   │   ├── RadialTangentialDistortion.cpp
    │   │   ├── Triangulation.cpp
    │   │   ├── testFrame.cpp
    │   │   ├── testImageCheckerboard.jpg
    │   │   ├── testImageCircleGrid.jpg
    │   │   ├── test_etc.cpp
    │   │   └── test_main.cpp
    ├── aslam_cameras_april
    │   ├── CMakeLists.txt
    │   ├── include
    │   │   └── aslam
    │   │   │   └── cameras
    │   │   │       └── GridCalibrationTargetAprilgrid.hpp
    │   ├── package.xml
    │   ├── python
    │   │   └── aslam_cameras_april
    │   │   │   └── __init__.py
    │   ├── setup.py
    │   └── src
    │   │   ├── GridCalibrationTargetAprilgrid.cpp
    │   │   ├── createTargetPDF.py
    │   │   └── module.cpp
    ├── aslam_cv_backend
    │   ├── CMakeLists.txt
    │   ├── include
    │   │   └── aslam
    │   │   │   ├── CameraGeometryDesignVariableContainer.hpp
    │   │   │   ├── GridCalibrationTargetDesignVariableContainer.hpp
    │   │   │   ├── NCameraSystemDesignVariableContainer.hpp
    │   │   │   ├── NCameraSystemEstimation.hpp
    │   │   │   └── backend
    │   │   │       ├── CameraDesignVariable.hpp
    │   │   │       ├── ScalarExpressionNodeKeypointTime.hpp
    │   │   │       └── implementation
    │   │   │           ├── CameraDesignVariable.hpp
    │   │   │           └── ScalarExpressionNodeKeypointTime.hpp
    │   ├── package.xml
    │   ├── src
    │   │   ├── CameraGeometryDesignVariableContainer.cpp
    │   │   ├── GridCalibrationTargetDesignVariableContainer.cpp
    │   │   ├── NCameraSystemDesignVariableContainer.cpp
    │   │   └── NCameraSystemEstimation.cpp
    │   └── test
    │   │   ├── testReprojectionError.cpp
    │   │   └── test_main.cpp
    ├── aslam_cv_backend_python
    │   ├── CMakeLists.txt
    │   ├── include
    │   │   └── aslam
    │   │   │   ├── ExportCameraDesignVariable.hpp
    │   │   │   ├── ExportReprojectionError.hpp
    │   │   │   └── ExportScalarExpressionNodeKeypointTime.hpp
    │   ├── package.xml
    │   ├── python
    │   │   └── aslam_cv_backend
    │   │   │   └── __init__.py
    │   ├── setup.py
    │   └── src
    │   │   ├── CameraGeometryDesignVariableContainer.cpp
    │   │   ├── GridCalibration.cpp
    │   │   ├── NCameraSystemDesignVariableContainer.cpp
    │   │   ├── helpers.hpp
    │   │   └── module.cpp
    ├── aslam_cv_error_terms
    │   ├── CMakeLists.txt
    │   ├── include
    │   │   └── aslam
    │   │   │   └── backend
    │   │   │       ├── BSplineMotionError.hpp
    │   │   │       ├── CovarianceReprojectionError.hpp
    │   │   │       ├── ReprojectionError.hpp
    │   │   │       ├── SimpleReprojectionError.hpp
    │   │   │       └── implementation
    │   │   │           ├── BSplineMotionError.hpp
    │   │   │           ├── CovarianceReprojectionError.hpp
    │   │   │           ├── ReprojectionError.hpp
    │   │   │           └── SimpleReprojectionError.hpp
    │   ├── package.xml
    │   └── test
    │   │   ├── TestReprojectionError.cpp
    │   │   └── test_main.cpp
    ├── aslam_cv_python
    │   ├── CMakeLists.txt
    │   ├── example
    │   │   ├── im_front.jpg
    │   │   ├── im_left.jpg
    │   │   ├── im_rear.jpg
    │   │   ├── im_right.jpg
    │   │   ├── pipeline.info
    │   │   └── prototype.py
    │   ├── include
    │   │   └── aslam
    │   │   │   └── python
    │   │   │       ├── ExportFrame.hpp
    │   │   │       ├── exportOmniUndistorter.hpp
    │   │   │       └── exportPinholeUndistorter.hpp
    │   ├── mainpage.dox
    │   ├── package.xml
    │   ├── python
    │   │   └── aslam_cv
    │   │   │   └── __init__.py
    │   ├── setup.py
    │   └── src
    │   │   ├── CameraGeometries.cpp
    │   │   ├── CameraGeometry.cpp
    │   │   ├── CameraProjections.cpp
    │   │   ├── CameraShutters.cpp
    │   │   ├── CameraSystem.cpp
    │   │   ├── CameraSystemClasses.cpp
    │   │   ├── Descriptors.cpp
    │   │   ├── Frame.cpp
    │   │   ├── FrameBuilder.cpp
    │   │   ├── Frontend.cpp
    │   │   ├── GridCalibration.cpp
    │   │   ├── ImageContainer.cpp
    │   │   ├── ImageSynchronizer.cpp
    │   │   ├── Landmark.cpp
    │   │   ├── MatchingAlgorithms.cpp
    │   │   ├── MultiFrame.cpp
    │   │   ├── MultiFrameFactory.cpp
    │   │   ├── NCameras.cpp
    │   │   ├── OmniUndistorter.cpp
    │   │   ├── PinholeUndistorter.cpp
    │   │   ├── Time.cpp
    │   │   ├── Undistorters.cpp
    │   │   └── module.cpp
    ├── aslam_cv_serialization
    │   ├── .gitignore
    │   ├── CMakeLists.txt
    │   ├── autogen_cameras.cmake
    │   ├── autogen_frames.cmake
    │   ├── gen_files.py
    │   ├── include
    │   │   └── aslam
    │   │   │   ├── FrameBaseSerialization.hpp
    │   │   │   ├── LinkCvSerialization.hpp
    │   │   │   ├── aslam_cv_serialization.hpp
    │   │   │   └── cameras
    │   │   │       └── CameraBaseSerialization.hpp
    │   ├── mainpage.dox
    │   ├── package.xml
    │   ├── src
    │   │   ├── FrameBaseSerialization.cpp
    │   │   ├── FrameSerialization.hpp
    │   │   ├── LinkCvSerialization.cpp
    │   │   └── autogen
    │   │   │   ├── Camera-DepthCameraGeometry.cpp
    │   │   │   ├── Camera-DistortedDepthCameraGeometry.cpp
    │   │   │   ├── Camera-DistortedOmniCameraGeometry.cpp
    │   │   │   ├── Camera-DistortedOmniRsCameraGeometry.cpp
    │   │   │   ├── Camera-DistortedPinholeCameraGeometry.cpp
    │   │   │   ├── Camera-DistortedPinholeRsCameraGeometry.cpp
    │   │   │   ├── Camera-DoubleSphereCameraGeometry.cpp
    │   │   │   ├── Camera-EquidistantDistortedDepthCameraGeometry.cpp
    │   │   │   ├── Camera-EquidistantDistortedOmniCameraGeometry.cpp
    │   │   │   ├── Camera-EquidistantDistortedOmniRsCameraGeometry.cpp
    │   │   │   ├── Camera-EquidistantDistortedPinholeCameraGeometry.cpp
    │   │   │   ├── Camera-EquidistantDistortedPinholeRsCameraGeometry.cpp
    │   │   │   ├── Camera-ExtendedUnifiedCameraGeometry.cpp
    │   │   │   ├── Camera-FovDistortedPinholeCameraGeometry.cpp
    │   │   │   ├── Camera-MaskedDistortedOmniCameraGeometry.cpp
    │   │   │   ├── Camera-MaskedDistortedOmniRsCameraGeometry.cpp
    │   │   │   ├── Camera-MaskedDistortedPinholeCameraGeometry.cpp
    │   │   │   ├── Camera-MaskedDistortedPinholeRsCameraGeometry.cpp
    │   │   │   ├── Camera-MaskedEquidistantDistortedOmniCameraGeometry.cpp
    │   │   │   ├── Camera-MaskedEquidistantDistortedOmniRsCameraGeometry.cpp
    │   │   │   ├── Camera-MaskedEquidistantDistortedPinholeCameraGeometry.cpp
    │   │   │   ├── Camera-MaskedEquidistantDistortedPinholeRsCameraGeometry.cpp
    │   │   │   ├── Camera-MaskedOmniCameraGeometry.cpp
    │   │   │   ├── Camera-MaskedOmniRsCameraGeometry.cpp
    │   │   │   ├── Camera-MaskedPinholeCameraGeometry.cpp
    │   │   │   ├── Camera-MaskedPinholeRsCameraGeometry.cpp
    │   │   │   ├── Camera-OmniCameraGeometry.cpp
    │   │   │   ├── Camera-OmniRsCameraGeometry.cpp
    │   │   │   ├── Camera-PinholeCameraGeometry.cpp
    │   │   │   ├── Camera-PinholeRsCameraGeometry.cpp
    │   │   │   ├── Frame-DepthCameraGeometry.cpp
    │   │   │   ├── Frame-DistortedDepthCameraGeometry.cpp
    │   │   │   ├── Frame-DistortedOmniCameraGeometry.cpp
    │   │   │   ├── Frame-DistortedOmniRsCameraGeometry.cpp
    │   │   │   ├── Frame-DistortedPinholeCameraGeometry.cpp
    │   │   │   ├── Frame-DistortedPinholeRsCameraGeometry.cpp
    │   │   │   ├── Frame-DoubleSphereCameraGeometry.cpp
    │   │   │   ├── Frame-EquidistantDistortedDepthCameraGeometry.cpp
    │   │   │   ├── Frame-EquidistantDistortedOmniCameraGeometry.cpp
    │   │   │   ├── Frame-EquidistantDistortedOmniRsCameraGeometry.cpp
    │   │   │   ├── Frame-EquidistantDistortedPinholeCameraGeometry.cpp
    │   │   │   ├── Frame-EquidistantDistortedPinholeRsCameraGeometry.cpp
    │   │   │   ├── Frame-ExtendedUnifiedCameraGeometry.cpp
    │   │   │   ├── Frame-FovDistortedPinholeCameraGeometry.cpp
    │   │   │   ├── Frame-MaskedDistortedOmniCameraGeometry.cpp
    │   │   │   ├── Frame-MaskedDistortedOmniRsCameraGeometry.cpp
    │   │   │   ├── Frame-MaskedDistortedPinholeCameraGeometry.cpp
    │   │   │   ├── Frame-MaskedDistortedPinholeRsCameraGeometry.cpp
    │   │   │   ├── Frame-MaskedEquidistantDistortedOmniCameraGeometry.cpp
    │   │   │   ├── Frame-MaskedEquidistantDistortedOmniRsCameraGeometry.cpp
    │   │   │   ├── Frame-MaskedEquidistantDistortedPinholeCameraGeometry.cpp
    │   │   │   ├── Frame-MaskedEquidistantDistortedPinholeRsCameraGeometry.cpp
    │   │   │   ├── Frame-MaskedOmniCameraGeometry.cpp
    │   │   │   ├── Frame-MaskedOmniRsCameraGeometry.cpp
    │   │   │   ├── Frame-MaskedPinholeCameraGeometry.cpp
    │   │   │   ├── Frame-MaskedPinholeRsCameraGeometry.cpp
    │   │   │   ├── Frame-OmniCameraGeometry.cpp
    │   │   │   ├── Frame-OmniRsCameraGeometry.cpp
    │   │   │   ├── Frame-PinholeCameraGeometry.cpp
    │   │   │   └── Frame-PinholeRsCameraGeometry.cpp
    │   └── test
    │   │   ├── testMultiFrame.cpp
    │   │   └── test_main.cpp
    ├── aslam_imgproc
    │   ├── CMakeLists.txt
    │   ├── include
    │   │   └── aslam
    │   │   │   ├── NullUndistorter.hpp
    │   │   │   ├── OmniUndistorter.hpp
    │   │   │   ├── PinholeUndistorter.hpp
    │   │   │   ├── UndistorterBase.hpp
    │   │   │   ├── calculateOverlappingFov.hpp
    │   │   │   └── implementation
    │   │   │       ├── NullUndistorter.hpp
    │   │   │       ├── OmniUndistorter.hpp
    │   │   │       ├── PinholeUndistorter.hpp
    │   │   │       ├── aslamcv_helper.hpp
    │   │   │       └── calculateOverlappingFov.hpp
    │   ├── package.xml
    │   ├── src
    │   │   ├── UndistorterBase.cpp
    │   │   └── calculateOverlappingFov.cpp
    │   └── test
    │   │   └── testUndistorter.cpp
    └── aslam_time
    │   ├── CMakeLists.txt
    │   ├── include
    │       └── aslam
    │       │   ├── Duration.hpp
    │       │   ├── Time.hpp
    │       │   └── implementation
    │       │       ├── Duration.hpp
    │       │       └── Time.hpp
    │   ├── package.xml
    │   └── src
    │       ├── duration.cpp
    │       └── time.cpp
├── aslam_incremental_calibration
    ├── incremental_calibration
    │   ├── CMakeLists.txt
    │   ├── conf
    │   │   └── config.xml
    │   ├── include
    │   │   └── aslam
    │   │   │   └── calibration
    │   │   │       ├── algorithms
    │   │   │           ├── linalg.h
    │   │   │           ├── marginalize.h
    │   │   │           ├── matrixOperations.h
    │   │   │           ├── matrixOperations.tpp
    │   │   │           ├── permute.h
    │   │   │           └── permute.tpp
    │   │   │       ├── base
    │   │   │           ├── Condition.h
    │   │   │           ├── Mutex.h
    │   │   │           ├── Serializable.h
    │   │   │           ├── Singleton.h
    │   │   │           ├── Singleton.tpp
    │   │   │           ├── Thread.h
    │   │   │           ├── Threads.h
    │   │   │           ├── Timer.h
    │   │   │           └── Timestamp.h
    │   │   │       ├── core
    │   │   │           ├── IncrementalEstimator.h
    │   │   │           ├── IncrementalOptimizationProblem.h
    │   │   │           ├── LinearSolver.h
    │   │   │           ├── LinearSolverOptions.h
    │   │   │           └── OptimizationProblem.h
    │   │   │       ├── data-structures
    │   │   │           ├── Grid.h
    │   │   │           ├── Grid.tpp
    │   │   │           ├── VectorDesignVariable.h
    │   │   │           └── VectorDesignVariable.tpp
    │   │   │       ├── exceptions
    │   │   │           ├── BadArgumentException.h
    │   │   │           ├── BadArgumentException.tpp
    │   │   │           ├── Exception.h
    │   │   │           ├── InvalidOperationException.h
    │   │   │           ├── NullPointerException.h
    │   │   │           ├── OutOfBoundException.h
    │   │   │           ├── OutOfBoundException.tpp
    │   │   │           ├── SystemException.h
    │   │   │           ├── ThreadsManagerException.h
    │   │   │           └── ThreadsManagerException.tpp
    │   │   │       ├── functions
    │   │   │           ├── ContinuousFunction.h
    │   │   │           ├── ContinuousFunction1v.h
    │   │   │           ├── ContinuousFunction1v.tpp
    │   │   │           ├── ContinuousFunctionMv.h
    │   │   │           ├── ContinuousFunctionMv.tpp
    │   │   │           ├── DigammaFunction.h
    │   │   │           ├── DigammaFunction.tpp
    │   │   │           ├── DiscreteFunction.h
    │   │   │           ├── DiscreteFunction1v.h
    │   │   │           ├── DiscreteFunction1v.tpp
    │   │   │           ├── DiscreteFunctionMv.h
    │   │   │           ├── DiscreteFunctionMv.tpp
    │   │   │           ├── Function.h
    │   │   │           ├── Function.tpp
    │   │   │           ├── IncompleteGammaPFunction.h
    │   │   │           ├── IncompleteGammaQFunction.h
    │   │   │           ├── LogFactorialFunction.h
    │   │   │           ├── LogGammaFunction.h
    │   │   │           └── LogGammaFunction.tpp
    │   │   │       ├── geometry
    │   │   │           ├── Transformation.h
    │   │   │           ├── Transformation2d.h
    │   │   │           ├── Transformation2d.tpp
    │   │   │           ├── Transformation3d.h
    │   │   │           └── Transformation3d.tpp
    │   │   │       ├── statistics
    │   │   │           ├── ChiSquareDistribution.h
    │   │   │           ├── ContinuousDistribution.h
    │   │   │           ├── ContinuousDistribution1v.h
    │   │   │           ├── ContinuousDistribution1v.tpp
    │   │   │           ├── ContinuousDistributionMv.h
    │   │   │           ├── ContinuousDistributionMv.tpp
    │   │   │           ├── DiscreteDistribution.h
    │   │   │           ├── DiscreteDistribution1v.h
    │   │   │           ├── DiscreteDistribution1v.tpp
    │   │   │           ├── DiscreteDistributionMv.h
    │   │   │           ├── DiscreteDistributionMv.tpp
    │   │   │           ├── Distribution.h
    │   │   │           ├── Distribution.tpp
    │   │   │           ├── EstimatorML.h
    │   │   │           ├── EstimatorMLNormal1v.h
    │   │   │           ├── EstimatorMLNormalMv.h
    │   │   │           ├── EstimatorMLNormalMv.tpp
    │   │   │           ├── GammaDistribution.h
    │   │   │           ├── GammaDistribution.tpp
    │   │   │           ├── Histogram.h
    │   │   │           ├── Histogram1v.h
    │   │   │           ├── Histogram1v.tpp
    │   │   │           ├── HistogramMv.h
    │   │   │           ├── HistogramMv.tpp
    │   │   │           ├── NormalDistribution.h
    │   │   │           ├── NormalDistribution1v.h
    │   │   │           ├── NormalDistributionMv.h
    │   │   │           ├── NormalDistributionMv.tpp
    │   │   │           ├── Randomizer.h
    │   │   │           ├── Randomizer.tpp
    │   │   │           ├── SampleDistribution.h
    │   │   │           ├── SampleDistribution.tpp
    │   │   │           ├── UniformDistribution.h
    │   │   │           ├── UniformDistribution1v.h
    │   │   │           ├── UniformDistribution1v.tpp
    │   │   │           ├── UniformDistributionMv.h
    │   │   │           └── UniformDistributionMv.tpp
    │   │   │       ├── tpl
    │   │   │           ├── And.h
    │   │   │           ├── Boolean.h
    │   │   │           ├── Equals.h
    │   │   │           ├── If.h
    │   │   │           ├── IfThenElse.h
    │   │   │           ├── IsInteger.h
    │   │   │           ├── IsNumeric.h
    │   │   │           ├── IsReal.h
    │   │   │           ├── IsVoid.h
    │   │   │           ├── Not.h
    │   │   │           └── Or.h
    │   │   │       └── utils
    │   │   │           ├── OuterProduct.h
    │   │   │           ├── OuterProduct.tpp
    │   │   │           ├── SizeTSupport.h
    │   │   │           └── SsizeTSupport.h
    │   ├── package.xml
    │   ├── src
    │   │   ├── algorithms
    │   │   │   ├── linalg.cpp
    │   │   │   └── marginalize.cpp
    │   │   ├── base
    │   │   │   ├── Condition.cpp
    │   │   │   ├── Mutex.cpp
    │   │   │   ├── Serializable.cpp
    │   │   │   ├── Thread.cpp
    │   │   │   ├── Threads.cpp
    │   │   │   ├── Timer.cpp
    │   │   │   └── Timestamp.cpp
    │   │   ├── core
    │   │   │   ├── IncrementalEstimator.cpp
    │   │   │   ├── IncrementalOptimizationProblem.cpp
    │   │   │   ├── LinearSolver.cpp
    │   │   │   ├── LinearSolverOptions.cpp
    │   │   │   └── OptimizationProblem.cpp
    │   │   ├── exceptions
    │   │   │   ├── Exception.cpp
    │   │   │   ├── InvalidOperationException.cpp
    │   │   │   ├── NullPointerException.cpp
    │   │   │   └── SystemException.cpp
    │   │   ├── functions
    │   │   │   ├── IncompleteGammaPFunction.cpp
    │   │   │   ├── IncompleteGammaQFunction.cpp
    │   │   │   ├── LogFactorialFunction.cpp
    │   │   │   └── LogGammaFunction.cpp
    │   │   └── statistics
    │   │   │   ├── ChiSquareDistribution.cpp
    │   │   │   ├── EstimatorMLNormal1v.cpp
    │   │   │   └── NormalDistribution1v.cpp
    │   └── test
    │   │   ├── AlgorithmsTest.cpp
    │   │   ├── IncrementalOptimizationProblemTest.cpp
    │   │   ├── LinearSolverTest.cpp
    │   │   ├── OptimizationProblemTest.cpp
    │   │   ├── VectorDesignVariableTest.cpp
    │   │   └── test_main.cpp
    └── incremental_calibration_python
    │   ├── CMakeLists.txt
    │   ├── include
    │       └── module.cpp
    │   ├── package.xml
    │   ├── setup.py
    │   └── src
    │       ├── IncrementalEstimator.cpp
    │       ├── LinearSolver.cpp
    │       ├── OptimizationProblem.cpp
    │       ├── VisionDataAssociation.cpp
    │       ├── incremental_calibration
    │           └── __init__.py
    │       └── module.cpp
├── aslam_nonparametric_estimation
    ├── aslam_splines
    │   ├── .gitignore
    │   ├── CMakeLists.txt
    │   ├── include
    │   │   └── aslam
    │   │   │   ├── backend
    │   │   │       ├── BSplineMotionError.hpp
    │   │   │       ├── BSplineMotionErrorFactory.hpp
    │   │   │       ├── QuadraticIntegralError.hpp
    │   │   │       ├── SimpleSplineError.hpp
    │   │   │       └── implementation
    │   │   │       │   ├── BSplineMotionError.hpp
    │   │   │       │   ├── BSplineMotionErrorFactory.hpp
    │   │   │       │   └── SimpleSplineError.hpp
    │   │   │   └── splines
    │   │   │       ├── BSplineDesignVariable.hpp
    │   │   │       ├── BSplineExpressions.hpp
    │   │   │       ├── BSplinePoseDesignVariable.hpp
    │   │   │       ├── EuclideanBSplineDesignVariable.hpp
    │   │   │       └── implementation
    │   │   │           ├── BSplineDesignVariable.hpp
    │   │   │           └── BSplineExpressions.hpp
    │   ├── package.xml
    │   ├── src
    │   │   ├── BSplineExpressions.cpp
    │   │   ├── BSplinePoseDesignVariable.cpp
    │   │   └── EuclideanBSplineDesignVariable.cpp
    │   └── test
    │   │   ├── TestBSplineExpressions.cpp
    │   │   ├── TestErrors.cpp
    │   │   ├── TestOPTBSpline.cpp
    │   │   └── test_main.cpp
    ├── aslam_splines_python
    │   ├── CMakeLists.txt
    │   ├── package.xml
    │   ├── python
    │   │   └── aslam_splines
    │   │   │   └── __init__.py
    │   ├── setup.py
    │   ├── src
    │   │   ├── BSplineMotionError.cpp
    │   │   ├── SimpleSplineError.cpp
    │   │   └── spline_module.cpp
    │   └── test
    │   │   ├── OptBSpline.py
    │   │   └── QuadraticIntegralError.py
    ├── bsplines
    │   ├── .gitignore
    │   ├── .texlipse
    │   ├── CMakeLists.txt
    │   ├── doc
    │   │   ├── doxygen.config.in
    │   │   ├── footer.html
    │   │   └── header.html
    │   ├── include
    │   │   └── bsplines
    │   │   │   ├── BSpline.hpp
    │   │   │   └── BSplinePose.hpp
    │   ├── interp_rotation
    │   │   ├── cummulativeTestPlots.py
    │   │   ├── cumulative.py
    │   │   ├── diffManifoldBSplines
    │   │   │   └── __init__.py
    │   │   ├── diffManifolds
    │   │   │   └── __init__.py
    │   │   ├── invariance.py
    │   │   ├── invariance2.py
    │   │   ├── jacobians.py
    │   │   ├── quaternions
    │   │   │   └── __init__.py
    │   │   ├── testManifoldBSplines.py
    │   │   ├── testThreeManifold.py
    │   │   └── threeManifoldVisual
    │   │   │   └── __init__.py
    │   ├── latex
    │   │   └── orientation
    │   │   │   ├── .gitignore
    │   │   │   ├── figs
    │   │   │       ├── asl.pdf
    │   │   │       ├── asl_black.pdf
    │   │   │       ├── asl_black_logo.pdf
    │   │   │       └── eth_logo_black.pdf
    │   │   │   ├── notation-math-defs.tex
    │   │   │   ├── orientation.tex
    │   │   │   └── thesis.bib
    │   ├── mainpage.dox
    │   ├── package.xml
    │   ├── src
    │   │   ├── BSpline.cpp
    │   │   ├── BSplinePose.cpp
    │   │   └── DiffManifoldBSpline.cpp
    │   └── test
    │   │   ├── BSplinePoseTests.cpp
    │   │   ├── DiffManifoldBSplineTests.cpp
    │   │   ├── DiffManifoldBSplineTests.hpp
    │   │   ├── EuclideanBSplineTests.cpp
    │   │   ├── NodeDistributedCacheTests.cpp
    │   │   ├── NumericIntegratorTests.cpp
    │   │   ├── RotationalKinematicsTests.cpp
    │   │   ├── SplineTests.cpp
    │   │   ├── UnitQuaternionBSplineTests.cpp
    │   │   └── test_main.cpp
    └── bsplines_python
    │   ├── .gitignore
    │   ├── CMakeLists.txt
    │   ├── package.xml
    │   ├── python
    │       └── bsplines
    │       │   ├── __init__.py
    │       │   └── plotPoseSpline.py
    │   ├── setup.py
    │   ├── src
    │       ├── BSplinePosePython.cpp
    │       ├── BSplinePython.cpp
    │       └── SplinePython.cpp
    │   └── test
    │       ├── BSplinePoseTests.py
    │       ├── BSplineTests.py
    │       ├── DiffManifoldBSpline.py
    │       ├── DiffManifoldBSplineFittingExperiments.py
    │       ├── SplineTests.py
    │       └── UnitTests.py
├── aslam_offline_calibration
    ├── ethz_apriltag2
    │   ├── CMakeLists.txt
    │   ├── include
    │   │   └── apriltags
    │   │   │   ├── Edge.h
    │   │   │   ├── FloatImage.h
    │   │   │   ├── GLine2D.h
    │   │   │   ├── GLineSegment2D.h
    │   │   │   ├── Gaussian.h
    │   │   │   ├── GrayModel.h
    │   │   │   ├── Gridder.h
    │   │   │   ├── Homography33.h
    │   │   │   ├── MathUtil.h
    │   │   │   ├── Quad.h
    │   │   │   ├── Segment.h
    │   │   │   ├── Tag16h5.h
    │   │   │   ├── Tag16h5_other.h
    │   │   │   ├── Tag25h7.h
    │   │   │   ├── Tag25h9.h
    │   │   │   ├── Tag36h11.h
    │   │   │   ├── Tag36h11_other.h
    │   │   │   ├── Tag36h9.h
    │   │   │   ├── TagDetection.h
    │   │   │   ├── TagDetector.h
    │   │   │   ├── TagFamily.h
    │   │   │   ├── UnionFindSimple.h
    │   │   │   ├── XYWeight.h
    │   │   │   └── pch.h
    │   ├── package.xml
    │   └── src
    │   │   ├── Edge.cc
    │   │   ├── FloatImage.cc
    │   │   ├── GLine2D.cc
    │   │   ├── GLineSegment2D.cc
    │   │   ├── Gaussian.cc
    │   │   ├── GrayModel.cc
    │   │   ├── Homography33.cc
    │   │   ├── MathUtil.cc
    │   │   ├── Quad.cc
    │   │   ├── Segment.cc
    │   │   ├── TagDetection.cc
    │   │   ├── TagDetector.cc
    │   │   ├── TagFamily.cc
    │   │   ├── UnionFindSimple.cc
    │   │   └── example
    │   │       ├── CMakeLists.txt
    │   │       ├── Serial.cpp
    │   │       ├── Serial.h
    │   │       ├── apriltags_demo.cpp
    │   │       ├── arduino_tags
    │   │           └── arduino_tags.ino
    │   │       └── imu.cpp
    └── kalibr
    │   ├── CMakeLists.txt
    │   ├── include
    │       └── kalibr_errorterms
    │       │   ├── AccelerometerError.hpp
    │       │   ├── EuclideanError.hpp
    │       │   └── GyroscopeError.hpp
    │   ├── package.xml
    │   ├── python
    │       ├── exporters
    │       │   ├── auxiliary_files
    │       │   │   ├── aslam_footer.txt
    │       │   │   ├── msf_footer.txt
    │       │   │   ├── msf_header.txt
    │       │   │   ├── msf_mid.txt
    │       │   │   ├── rovio_footer.txt
    │       │   │   └── rovio_header.txt
    │       │   ├── kalibr_maplab_config
    │       │   ├── kalibr_msf_config
    │       │   ├── kalibr_okvis_config
    │       │   └── kalibr_rovio_config
    │       ├── kalibr_bagcreater
    │       ├── kalibr_bagextractor
    │       ├── kalibr_calibrate_cameras
    │       ├── kalibr_calibrate_imu_camera
    │       ├── kalibr_calibrate_rs_cameras
    │       ├── kalibr_camera_calibration
    │       │   ├── CameraCalibrator.py
    │       │   ├── CameraIntializers.py
    │       │   ├── CameraUtils.py
    │       │   ├── MulticamGraph.py
    │       │   ├── ObsDb.py
    │       │   └── __init__.py
    │       ├── kalibr_camera_focus
    │       ├── kalibr_camera_validator
    │       ├── kalibr_common
    │       │   ├── ConfigReader.py
    │       │   ├── ImageDatasetReader.py
    │       │   ├── ImuDatasetReader.py
    │       │   ├── TargetExtractor.py
    │       │   └── __init__.py
    │       ├── kalibr_create_target_pdf
    │       ├── kalibr_errorterms
    │       │   └── __init__.py
    │       ├── kalibr_imu_camera_calibration
    │       │   ├── IccCalibrator.py
    │       │   ├── IccPlots.py
    │       │   ├── IccSensors.py
    │       │   ├── IccUtil.py
    │       │   └── __init__.py
    │       ├── kalibr_rs_camera_calibration
    │       │   ├── ReprojectionErrorKnotSequenceUpdateStrategy.py
    │       │   ├── RsCalibrator.py
    │       │   ├── RsPlot.py
    │       │   └── __init__.py
    │       ├── kalibr_visualize_calibration
    │       └── kalibr_visualize_distortion
    │   ├── setup.py
    │   ├── src
    │       ├── AccelerometerError.cpp
    │       ├── EuclideanError.cpp
    │       ├── GyroscopeError.cpp
    │       └── module.cpp
    │   └── test
    │       ├── TestErrorTerms.cpp
    │       └── test_main.cpp
├── aslam_optimizer
    ├── aslam_backend
    │   ├── CMakeLists.txt
    │   ├── include
    │   │   └── aslam
    │   │   │   ├── Exceptions.hpp
    │   │   │   └── backend
    │   │   │       ├── BlockCholeskyLinearSolverOptions.h
    │   │   │       ├── BlockCholeskyLinearSystemSolver.hpp
    │   │   │       ├── Cholmod.hpp
    │   │   │       ├── CompressedColumnJacobianTransposeBuilder.hpp
    │   │   │       ├── CompressedColumnMatrix.hpp
    │   │   │       ├── CompressedRowJacobianBuilder.hpp
    │   │   │       ├── DenseMatrix.hpp
    │   │   │       ├── DenseQRLinearSolverOptions.h
    │   │   │       ├── DenseQrLinearSystemSolver.hpp
    │   │   │       ├── DesignVariable.hpp
    │   │   │       ├── DesignVariableAdapter.hpp
    │   │   │       ├── DogLegTrustRegionPolicy.hpp
    │   │   │       ├── ErrorTerm.hpp
    │   │   │       ├── ErrorTermDs.hpp
    │   │   │       ├── GaussNewtonTrustRegionPolicy.hpp
    │   │   │       ├── JacobianBuilder.hpp
    │   │   │       ├── JacobianContainer.hpp
    │   │   │       ├── LevenbergMarquardtTrustRegionPolicy.hpp
    │   │   │       ├── LinearSystemSolver.hpp
    │   │   │       ├── MEstimatorPolicies.hpp
    │   │   │       ├── MarginalizationPriorErrorTerm.hpp
    │   │   │       ├── Marginalizer.hpp
    │   │   │       ├── Matrix.hpp
    │   │   │       ├── OptimizationProblem.hpp
    │   │   │       ├── OptimizationProblemBase.hpp
    │   │   │       ├── Optimizer.hpp
    │   │   │       ├── Optimizer2.hpp
    │   │   │       ├── Optimizer2.tpp
    │   │   │       ├── Optimizer2Options.hpp
    │   │   │       ├── OptimizerOptions.hpp
    │   │   │       ├── SimpleOptimizationProblem.hpp
    │   │   │       ├── SparseBlockMatrixWrapper.hpp
    │   │   │       ├── SparseCholeskyLinearSolverOptions.h
    │   │   │       ├── SparseCholeskyLinearSystemSolver.hpp
    │   │   │       ├── SparseQRLinearSolverOptions.h
    │   │   │       ├── SparseQrLinearSystemSolver.hpp
    │   │   │       ├── TrustRegionPolicy.hpp
    │   │   │       ├── backend.hpp
    │   │   │       ├── implementation
    │   │   │           ├── Cholmod.hpp
    │   │   │           ├── CompressedColumnJacobianTransposeBuilder.hpp
    │   │   │           ├── CompressedColumnMatrix.hpp
    │   │   │           ├── DesignVariableAdapter.hpp
    │   │   │           └── ErrorTerm.hpp
    │   │   │       ├── sparse_matrix_functions.hpp
    │   │   │       └── test
    │   │   │           └── ErrorTermTestHarness.hpp
    │   ├── mainpage.dox
    │   ├── notes.txt
    │   ├── package.xml
    │   ├── src
    │   │   ├── BlockCholeskyLinearSolverOptions.cpp
    │   │   ├── BlockCholeskyLinearSystemSolver.cpp
    │   │   ├── DenseMatrix.cpp
    │   │   ├── DenseQRLinearSolverOptions.cpp
    │   │   ├── DenseQrLinearSystemSolver.cpp
    │   │   ├── DesignVariable.cpp
    │   │   ├── DogLegTrustRegionPolicy.cpp
    │   │   ├── ErrorTerm.cpp
    │   │   ├── ErrorTermDs.cpp
    │   │   ├── GaussNewtonTrustRegionPolicy.cpp
    │   │   ├── JacobianBuilder.cpp
    │   │   ├── JacobianContainer.cpp
    │   │   ├── LevenbergMarquardtTrustRegionPolicy.cpp
    │   │   ├── LinearSystemSolver.cpp
    │   │   ├── MEstimatorPolicies.cpp
    │   │   ├── MarginalizationPriorErrorTerm.cpp
    │   │   ├── Marginalizer.cpp
    │   │   ├── Matrix.cpp
    │   │   ├── OptimizationProblem.cpp
    │   │   ├── OptimizationProblemBase.cpp
    │   │   ├── Optimizer.cpp
    │   │   ├── Optimizer2.cpp
    │   │   ├── QrSolution.hpp
    │   │   ├── SimpleOptimizationProblem.cpp
    │   │   ├── SparseBlockMatrixWrapper.cpp
    │   │   ├── SparseCholeskyLinearSolverOptions.cpp
    │   │   ├── SparseCholeskyLinearSystemSolver.cpp
    │   │   ├── SparseQRLinearSolverOptions.cpp
    │   │   ├── SparseQrLinearSystemSolver.cpp
    │   │   ├── TrustRegionPolicy.cpp
    │   │   └── sparse_matrix_functions.cpp
    │   └── test
    │   │   ├── CompressedColumnMatrixTest.cpp
    │   │   ├── DenseMatrixTest.cpp
    │   │   ├── DummyDesignVariable.hpp
    │   │   ├── ErrorTermTests.cpp
    │   │   ├── JacobianContainer.cpp
    │   │   ├── LinearSolverTests.cpp
    │   │   ├── MatrixTestHarness.cpp
    │   │   ├── MatrixTestHarness.hpp
    │   │   ├── SampleDvAndError.hpp
    │   │   ├── SparseMatrixTest.cpp
    │   │   ├── TestOptimizationProblem.cpp
    │   │   ├── TestOptimizer.cpp
    │   │   ├── test_main.cpp
    │   │   └── test_sparse_matrix_functions.cpp
    ├── aslam_backend_expressions
    │   ├── CMakeLists.txt
    │   ├── include
    │   │   └── aslam
    │   │   │   └── backend
    │   │   │       ├── BasisMatrixFunctor.hpp
    │   │   │       ├── DesignVariableGenericVector.hpp
    │   │   │       ├── DesignVariableMappedVector.hpp
    │   │   │       ├── DesignVariableMinimalDifferenceExpression.hpp
    │   │   │       ├── DesignVariableUnitQuaternion.hpp
    │   │   │       ├── DesignVariableVector.hpp
    │   │   │       ├── Differential.hpp
    │   │   │       ├── ErrorTermEuclidean.hpp
    │   │   │       ├── ErrorTermTransformation.hpp
    │   │   │       ├── EuclideanDirection.hpp
    │   │   │       ├── EuclideanExpression.hpp
    │   │   │       ├── EuclideanExpressionNode.hpp
    │   │   │       ├── EuclideanPoint.hpp
    │   │   │       ├── ExpressionErrorTerm.hpp
    │   │   │       ├── FixedPointNumber.hpp
    │   │   │       ├── GenericMatrixExpression.hpp
    │   │   │       ├── GenericMatrixExpressionNode.hpp
    │   │   │       ├── GenericScalar.hpp
    │   │   │       ├── GenericScalarExpression.hpp
    │   │   │       ├── GenericScalarExpressionNode.hpp
    │   │   │       ├── HomogeneousExpression.hpp
    │   │   │       ├── HomogeneousExpressionNode.hpp
    │   │   │       ├── HomogeneousPoint.hpp
    │   │   │       ├── MapTransformation.hpp
    │   │   │       ├── MappedEuclideanPoint.hpp
    │   │   │       ├── MappedHomogeneousPoint.hpp
    │   │   │       ├── MappedRotationQuaternion.hpp
    │   │   │       ├── MatrixBasic.hpp
    │   │   │       ├── MatrixExpression.hpp
    │   │   │       ├── MatrixExpressionNode.hpp
    │   │   │       ├── MatrixTransformation.hpp
    │   │   │       ├── QuaternionExpression.hpp
    │   │   │       ├── RotationExpression.hpp
    │   │   │       ├── RotationExpressionNode.hpp
    │   │   │       ├── RotationQuaternion.hpp
    │   │   │       ├── Scalar.hpp
    │   │   │       ├── ScalarExpression.hpp
    │   │   │       ├── ScalarExpressionNode.hpp
    │   │   │       ├── TransformationBasic.hpp
    │   │   │       ├── TransformationExpression.hpp
    │   │   │       ├── TransformationExpressionNode.hpp
    │   │   │       ├── Vector2RotationQuaternionExpressionAdapter.hpp
    │   │   │       ├── VectorExpression.hpp
    │   │   │       ├── VectorExpressionNode.hpp
    │   │   │       ├── VectorExpressionToGenericMatrixTraits.hpp
    │   │   │       ├── implementation
    │   │   │           ├── DesignVariableMappedVector.hpp
    │   │   │           ├── DesignVariableVector.hpp
    │   │   │           ├── GenericMatrixExpression.hpp
    │   │   │           ├── GenericScalar.hpp
    │   │   │           ├── GenericScalarExpression.hpp
    │   │   │           ├── GenericScalarExpressionNode.hpp
    │   │   │           ├── QuaternionExpression.hpp
    │   │   │           ├── VectorExpression.hpp
    │   │   │           └── VectorExpressionNode.hpp
    │   │   │       └── test
    │   │   │           ├── DesignVariableTests.hpp
    │   │   │           ├── ExpressionTests.hpp
    │   │   │           ├── GenericScalarExpressionTests.hpp
    │   │   │           ├── RotationExpressionTests.hpp
    │   │   │           └── RotationQuaternionAsVectorExpressionNode.hpp
    │   ├── notes.txt
    │   ├── package.xml
    │   ├── src
    │   │   ├── ErrorTermEuclidean.cpp
    │   │   ├── ErrorTermTransformation.cpp
    │   │   ├── EuclideanDirection.cpp
    │   │   ├── EuclideanExpression.cpp
    │   │   ├── EuclideanExpressionNode.cpp
    │   │   ├── EuclideanPoint.cpp
    │   │   ├── HomogeneousExpression.cpp
    │   │   ├── HomogeneousExpressionNode.cpp
    │   │   ├── HomogeneousPoint.cpp
    │   │   ├── MapTransformation.cpp
    │   │   ├── MappedEuclideanPoint.cpp
    │   │   ├── MappedHomogeneousPoint.cpp
    │   │   ├── MappedRotationQuaternion.cpp
    │   │   ├── MatrixBasic.cpp
    │   │   ├── MatrixExpression.cpp
    │   │   ├── MatrixExpressionNode.cpp
    │   │   ├── MatrixTransformation.cpp
    │   │   ├── RotationExpression.cpp
    │   │   ├── RotationExpressionNode.cpp
    │   │   ├── RotationQuaternion.cpp
    │   │   ├── Scalar.cpp
    │   │   ├── ScalarExpression.cpp
    │   │   ├── ScalarExpressionNode.cpp
    │   │   ├── TransformationBasic.cpp
    │   │   ├── TransformationExpression.cpp
    │   │   ├── TransformationExpressionNode.cpp
    │   │   └── Vector2RotationQuaternionExpressionAdapter.cpp
    │   └── test
    │   │   ├── CameraDesignVariable.cpp
    │   │   ├── ErrorTest_Euclidean.cpp
    │   │   ├── ErrorTest_Transformation.cpp
    │   │   ├── FixedPointNumberTest.cpp
    │   │   ├── GenericMatrixExpression.cpp
    │   │   ├── GenericScalarExpressionTest.cpp
    │   │   ├── HomogeneousExpression.cpp
    │   │   ├── MatrixAndEuclideanExpression.cpp
    │   │   ├── QuaternionExpression.cpp
    │   │   ├── RotationExpression.cpp
    │   │   ├── ScalarExpression.cpp
    │   │   └── test_main.cpp
    ├── aslam_backend_python
    │   ├── CMakeLists.txt
    │   ├── include
    │   │   └── aslam
    │   │   │   └── python
    │   │   │       ├── ExportAPrioriInformationError.hpp
    │   │   │       ├── ExportBackendExpressions.hpp
    │   │   │       ├── ExportDesignVariableAdapter.hpp
    │   │   │       └── ExportFrame.hpp
    │   ├── package.xml
    │   ├── python
    │   │   └── aslam_backend
    │   │   │   └── __init__.py
    │   ├── setup.py
    │   └── src
    │   │   ├── BSplineMotionError.cpp
    │   │   ├── Backend.cpp
    │   │   ├── BackendDesignVariables.cpp
    │   │   ├── BackendExpressions.cpp
    │   │   ├── CompressedColumnMatrix.cpp
    │   │   ├── Descriptors.cpp
    │   │   ├── DesignVariable.cpp
    │   │   ├── ErrorTerm.cpp
    │   │   ├── ErrorTermTransformation.cpp
    │   │   ├── Frontend.cpp
    │   │   ├── JacobianContainer.cpp
    │   │   ├── LinearSystemSolver.cpp
    │   │   ├── MEstimators.cpp
    │   │   ├── OptimizationProblem.cpp
    │   │   ├── Optimizer.cpp
    │   │   ├── OptimizerOptions.cpp
    │   │   ├── SparseBlockMatrix.cpp
    │   │   ├── Time.cpp
    │   │   ├── TrustRegionPolicies.cpp
    │   │   └── module.cpp
    └── sparse_block_matrix
    │   ├── CMakeLists.txt
    │   ├── cmake
    │       ├── FindSuiteSparse.cmake
    │       └── sparse_block_matrix-extras.cmake.in
    │   ├── include
    │       └── sparse_block_matrix
    │       │   ├── implementation
    │       │       ├── linear_solver_pcg.hpp
    │       │       ├── sparse_block_matrix.hpp
    │       │       └── sparse_helper.h
    │       │   ├── linear_solver.h
    │       │   ├── linear_solver_cholmod.h
    │       │   ├── linear_solver_csparse.h
    │       │   ├── linear_solver_dense.h
    │       │   ├── linear_solver_pcg.h
    │       │   ├── linear_solver_spqr.h
    │       │   ├── marginal_covariance_cholesky.h
    │       │   ├── matrix_structure.h
    │       │   ├── sparse_block_matrix.h
    │       │   └── sparse_helper.h
    │   ├── package.xml
    │   ├── src
    │       ├── marginal_covariance_cholesky.cpp
    │       ├── matrix_structure.cpp
    │       ├── solver_cholmod.cpp
    │       ├── solver_csparse.cpp
    │       ├── solver_dense.cpp
    │       ├── solver_pcg.cpp
    │       ├── sparse_block_matrix
    │       │   ├── .gitignore
    │       │   └── __init__.py
    │       └── sparse_helper.cpp
    │   └── test
    │       ├── sbm_gtest.hpp
    │       ├── solver_tests.cpp
    │       ├── sparse_block_matrix_tests.cpp
    │       └── test_main.cpp
├── catkin_simple
    ├── .gitignore
    ├── CMakeLists.txt
    ├── README.md
    ├── cmake
    │   └── catkin_simple-extras.cmake.em
    ├── package.xml
    └── test
    │   └── scenarios
    │       └── hello_world
    │           ├── .gitignore
    │           ├── bar
    │               ├── CMakeLists.txt
    │               ├── include
    │               │   └── bar
    │               │   │   └── hello.h
    │               ├── msg
    │               │   └── HeaderString.msg
    │               ├── package.xml
    │               └── src
    │               │   └── hello.cpp
    │           ├── baz
    │               ├── CMakeLists.txt
    │               ├── include
    │               │   └── baz
    │               │   │   └── world.h
    │               └── package.xml
    │           ├── catkin_simple
    │           └── foo
    │               ├── CMakeLists.txt
    │               ├── package.xml
    │               └── src
    │                   └── main.cpp
└── opencv2_catkin
    ├── .gitignore
    ├── CMakeLists.txt
    ├── README.md
    ├── cmake
        └── opencv2-extras.cmake.in
    └── package.xml


/Schweizer-Messer/numpy_eigen/cmake/add_python_export_library.cmake:
--------------------------------------------------------------------------------
1 | ../../python_module/cmake/add_python_export_library.cmake


--------------------------------------------------------------------------------
/Schweizer-Messer/numpy_eigen/cmake/numpy_eigen-extras.cmake.in:
--------------------------------------------------------------------------------
1 | find_package(Eigen3 REQUIRED)
2 | include_directories(${EIGEN3_INCLUDE_DIRS})
3 | 


--------------------------------------------------------------------------------
/Schweizer-Messer/numpy_eigen/setup.py:
--------------------------------------------------------------------------------
 1 | ## ! DO NOT MANUALLY INVOKE THIS setup.py, USE CATKIN INSTEAD
 2 | 
 3 | from distutils.core import setup
 4 | from catkin_pkg.python_setup import generate_distutils_setup
 5 | 
 6 | # fetch values from package.xml
 7 | setup_args = generate_distutils_setup(
 8 |     packages=['numpy_eigen'],
 9 |     package_dir={'': 'src'})
10 | 
11 | setup(**setup_args)
12 | 


--------------------------------------------------------------------------------
/Schweizer-Messer/numpy_eigen/src/autogen_module/import_1_1_double.cpp:
--------------------------------------------------------------------------------
 1 | // This file automatically generated by create_export_module.py
 2 | #define NO_IMPORT_ARRAY 
 3 | 
 4 | #include <NumpyEigenConverter.hpp>
 5 | 
 6 | #include <boost/cstdint.hpp>
 7 | 
 8 | 
 9 | void import_1_1_double()
10 | {
11 | 	NumpyEigenConverter<Eigen::Matrix< double, 1, 1 > >::register_converter();
12 | }
13 | 
14 | 


--------------------------------------------------------------------------------
/Schweizer-Messer/numpy_eigen/src/autogen_module/import_1_1_float.cpp:
--------------------------------------------------------------------------------
 1 | // This file automatically generated by create_export_module.py
 2 | #define NO_IMPORT_ARRAY 
 3 | 
 4 | #include <NumpyEigenConverter.hpp>
 5 | 
 6 | #include <boost/cstdint.hpp>
 7 | 
 8 | 
 9 | void import_1_1_float()
10 | {
11 | 	NumpyEigenConverter<Eigen::Matrix< float, 1, 1 > >::register_converter();
12 | }
13 | 
14 | 


--------------------------------------------------------------------------------
/Schweizer-Messer/numpy_eigen/src/autogen_module/import_1_1_int.cpp:
--------------------------------------------------------------------------------
 1 | // This file automatically generated by create_export_module.py
 2 | #define NO_IMPORT_ARRAY 
 3 | 
 4 | #include <NumpyEigenConverter.hpp>
 5 | 
 6 | #include <boost/cstdint.hpp>
 7 | 
 8 | 
 9 | void import_1_1_int()
10 | {
11 | 	NumpyEigenConverter<Eigen::Matrix< int, 1, 1 > >::register_converter();
12 | }
13 | 
14 | 


--------------------------------------------------------------------------------
/Schweizer-Messer/numpy_eigen/src/autogen_module/import_1_1_long.cpp:
--------------------------------------------------------------------------------
 1 | // This file automatically generated by create_export_module.py
 2 | #define NO_IMPORT_ARRAY 
 3 | 
 4 | #include <NumpyEigenConverter.hpp>
 5 | 
 6 | #include <boost/cstdint.hpp>
 7 | 
 8 | 
 9 | void import_1_1_long()
10 | {
11 | 	NumpyEigenConverter<Eigen::Matrix< boost::int64_t, 1, 1 > >::register_converter();
12 | }
13 | 
14 | 


--------------------------------------------------------------------------------
/Schweizer-Messer/numpy_eigen/src/autogen_module/import_1_1_uchar.cpp:
--------------------------------------------------------------------------------
 1 | // This file automatically generated by create_export_module.py
 2 | #define NO_IMPORT_ARRAY 
 3 | 
 4 | #include <NumpyEigenConverter.hpp>
 5 | 
 6 | #include <boost/cstdint.hpp>
 7 | 
 8 | 
 9 | void import_1_1_uchar()
10 | {
11 | 	NumpyEigenConverter<Eigen::Matrix< boost::uint8_t, 1, 1 > >::register_converter();
12 | }
13 | 
14 | 


--------------------------------------------------------------------------------
/Schweizer-Messer/numpy_eigen/src/autogen_module/import_1_2_double.cpp:
--------------------------------------------------------------------------------
 1 | // This file automatically generated by create_export_module.py
 2 | #define NO_IMPORT_ARRAY 
 3 | 
 4 | #include <NumpyEigenConverter.hpp>
 5 | 
 6 | #include <boost/cstdint.hpp>
 7 | 
 8 | 
 9 | void import_1_2_double()
10 | {
11 | 	NumpyEigenConverter<Eigen::Matrix< double, 1, 2 > >::register_converter();
12 | }
13 | 
14 | 


--------------------------------------------------------------------------------
/Schweizer-Messer/numpy_eigen/src/autogen_module/import_1_2_float.cpp:
--------------------------------------------------------------------------------
 1 | // This file automatically generated by create_export_module.py
 2 | #define NO_IMPORT_ARRAY 
 3 | 
 4 | #include <NumpyEigenConverter.hpp>
 5 | 
 6 | #include <boost/cstdint.hpp>
 7 | 
 8 | 
 9 | void import_1_2_float()
10 | {
11 | 	NumpyEigenConverter<Eigen::Matrix< float, 1, 2 > >::register_converter();
12 | }
13 | 
14 | 


--------------------------------------------------------------------------------
/Schweizer-Messer/numpy_eigen/src/autogen_module/import_1_2_int.cpp:
--------------------------------------------------------------------------------
 1 | // This file automatically generated by create_export_module.py
 2 | #define NO_IMPORT_ARRAY 
 3 | 
 4 | #include <NumpyEigenConverter.hpp>
 5 | 
 6 | #include <boost/cstdint.hpp>
 7 | 
 8 | 
 9 | void import_1_2_int()
10 | {
11 | 	NumpyEigenConverter<Eigen::Matrix< int, 1, 2 > >::register_converter();
12 | }
13 | 
14 | 


--------------------------------------------------------------------------------
/Schweizer-Messer/numpy_eigen/src/autogen_module/import_1_2_long.cpp:
--------------------------------------------------------------------------------
 1 | // This file automatically generated by create_export_module.py
 2 | #define NO_IMPORT_ARRAY 
 3 | 
 4 | #include <NumpyEigenConverter.hpp>
 5 | 
 6 | #include <boost/cstdint.hpp>
 7 | 
 8 | 
 9 | void import_1_2_long()
10 | {
11 | 	NumpyEigenConverter<Eigen::Matrix< boost::int64_t, 1, 2 > >::register_converter();
12 | }
13 | 
14 | 


--------------------------------------------------------------------------------
/Schweizer-Messer/numpy_eigen/src/autogen_module/import_1_2_uchar.cpp:
--------------------------------------------------------------------------------
 1 | // This file automatically generated by create_export_module.py
 2 | #define NO_IMPORT_ARRAY 
 3 | 
 4 | #include <NumpyEigenConverter.hpp>
 5 | 
 6 | #include <boost/cstdint.hpp>
 7 | 
 8 | 
 9 | void import_1_2_uchar()
10 | {
11 | 	NumpyEigenConverter<Eigen::Matrix< boost::uint8_t, 1, 2 > >::register_converter();
12 | }
13 | 
14 | 


--------------------------------------------------------------------------------
/Schweizer-Messer/numpy_eigen/src/autogen_module/import_1_3_double.cpp:
--------------------------------------------------------------------------------
 1 | // This file automatically generated by create_export_module.py
 2 | #define NO_IMPORT_ARRAY 
 3 | 
 4 | #include <NumpyEigenConverter.hpp>
 5 | 
 6 | #include <boost/cstdint.hpp>
 7 | 
 8 | 
 9 | void import_1_3_double()
10 | {
11 | 	NumpyEigenConverter<Eigen::Matrix< double, 1, 3 > >::register_converter();
12 | }
13 | 
14 | 


--------------------------------------------------------------------------------
/Schweizer-Messer/numpy_eigen/src/autogen_module/import_1_3_float.cpp:
--------------------------------------------------------------------------------
 1 | // This file automatically generated by create_export_module.py
 2 | #define NO_IMPORT_ARRAY 
 3 | 
 4 | #include <NumpyEigenConverter.hpp>
 5 | 
 6 | #include <boost/cstdint.hpp>
 7 | 
 8 | 
 9 | void import_1_3_float()
10 | {
11 | 	NumpyEigenConverter<Eigen::Matrix< float, 1, 3 > >::register_converter();
12 | }
13 | 
14 | 


--------------------------------------------------------------------------------
/Schweizer-Messer/numpy_eigen/src/autogen_module/import_1_3_int.cpp:
--------------------------------------------------------------------------------
 1 | // This file automatically generated by create_export_module.py
 2 | #define NO_IMPORT_ARRAY 
 3 | 
 4 | #include <NumpyEigenConverter.hpp>
 5 | 
 6 | #include <boost/cstdint.hpp>
 7 | 
 8 | 
 9 | void import_1_3_int()
10 | {
11 | 	NumpyEigenConverter<Eigen::Matrix< int, 1, 3 > >::register_converter();
12 | }
13 | 
14 | 


--------------------------------------------------------------------------------
/Schweizer-Messer/numpy_eigen/src/autogen_module/import_1_3_long.cpp:
--------------------------------------------------------------------------------
 1 | // This file automatically generated by create_export_module.py
 2 | #define NO_IMPORT_ARRAY 
 3 | 
 4 | #include <NumpyEigenConverter.hpp>
 5 | 
 6 | #include <boost/cstdint.hpp>
 7 | 
 8 | 
 9 | void import_1_3_long()
10 | {
11 | 	NumpyEigenConverter<Eigen::Matrix< boost::int64_t, 1, 3 > >::register_converter();
12 | }
13 | 
14 | 


--------------------------------------------------------------------------------
/Schweizer-Messer/numpy_eigen/src/autogen_module/import_1_3_uchar.cpp:
--------------------------------------------------------------------------------
 1 | // This file automatically generated by create_export_module.py
 2 | #define NO_IMPORT_ARRAY 
 3 | 
 4 | #include <NumpyEigenConverter.hpp>
 5 | 
 6 | #include <boost/cstdint.hpp>
 7 | 
 8 | 
 9 | void import_1_3_uchar()
10 | {
11 | 	NumpyEigenConverter<Eigen::Matrix< boost::uint8_t, 1, 3 > >::register_converter();
12 | }
13 | 
14 | 


--------------------------------------------------------------------------------
/Schweizer-Messer/numpy_eigen/src/autogen_module/import_1_4_double.cpp:
--------------------------------------------------------------------------------
 1 | // This file automatically generated by create_export_module.py
 2 | #define NO_IMPORT_ARRAY 
 3 | 
 4 | #include <NumpyEigenConverter.hpp>
 5 | 
 6 | #include <boost/cstdint.hpp>
 7 | 
 8 | 
 9 | void import_1_4_double()
10 | {
11 | 	NumpyEigenConverter<Eigen::Matrix< double, 1, 4 > >::register_converter();
12 | }
13 | 
14 | 


--------------------------------------------------------------------------------
/Schweizer-Messer/numpy_eigen/src/autogen_module/import_1_4_float.cpp:
--------------------------------------------------------------------------------
 1 | // This file automatically generated by create_export_module.py
 2 | #define NO_IMPORT_ARRAY 
 3 | 
 4 | #include <NumpyEigenConverter.hpp>
 5 | 
 6 | #include <boost/cstdint.hpp>
 7 | 
 8 | 
 9 | void import_1_4_float()
10 | {
11 | 	NumpyEigenConverter<Eigen::Matrix< float, 1, 4 > >::register_converter();
12 | }
13 | 
14 | 


--------------------------------------------------------------------------------
/Schweizer-Messer/numpy_eigen/src/autogen_module/import_1_4_int.cpp:
--------------------------------------------------------------------------------
 1 | // This file automatically generated by create_export_module.py
 2 | #define NO_IMPORT_ARRAY 
 3 | 
 4 | #include <NumpyEigenConverter.hpp>
 5 | 
 6 | #include <boost/cstdint.hpp>
 7 | 
 8 | 
 9 | void import_1_4_int()
10 | {
11 | 	NumpyEigenConverter<Eigen::Matrix< int, 1, 4 > >::register_converter();
12 | }
13 | 
14 | 


--------------------------------------------------------------------------------
/Schweizer-Messer/numpy_eigen/src/autogen_module/import_1_4_long.cpp:
--------------------------------------------------------------------------------
 1 | // This file automatically generated by create_export_module.py
 2 | #define NO_IMPORT_ARRAY 
 3 | 
 4 | #include <NumpyEigenConverter.hpp>
 5 | 
 6 | #include <boost/cstdint.hpp>
 7 | 
 8 | 
 9 | void import_1_4_long()
10 | {
11 | 	NumpyEigenConverter<Eigen::Matrix< boost::int64_t, 1, 4 > >::register_converter();
12 | }
13 | 
14 | 


--------------------------------------------------------------------------------
/Schweizer-Messer/numpy_eigen/src/autogen_module/import_1_4_uchar.cpp:
--------------------------------------------------------------------------------
 1 | // This file automatically generated by create_export_module.py
 2 | #define NO_IMPORT_ARRAY 
 3 | 
 4 | #include <NumpyEigenConverter.hpp>
 5 | 
 6 | #include <boost/cstdint.hpp>
 7 | 
 8 | 
 9 | void import_1_4_uchar()
10 | {
11 | 	NumpyEigenConverter<Eigen::Matrix< boost::uint8_t, 1, 4 > >::register_converter();
12 | }
13 | 
14 | 


--------------------------------------------------------------------------------
/Schweizer-Messer/numpy_eigen/src/autogen_module/import_1_5_double.cpp:
--------------------------------------------------------------------------------
 1 | // This file automatically generated by create_export_module.py
 2 | #define NO_IMPORT_ARRAY 
 3 | 
 4 | #include <NumpyEigenConverter.hpp>
 5 | 
 6 | #include <boost/cstdint.hpp>
 7 | 
 8 | 
 9 | void import_1_5_double()
10 | {
11 | 	NumpyEigenConverter<Eigen::Matrix< double, 1, 5 > >::register_converter();
12 | }
13 | 
14 | 


--------------------------------------------------------------------------------
/Schweizer-Messer/numpy_eigen/src/autogen_module/import_1_5_float.cpp:
--------------------------------------------------------------------------------
 1 | // This file automatically generated by create_export_module.py
 2 | #define NO_IMPORT_ARRAY 
 3 | 
 4 | #include <NumpyEigenConverter.hpp>
 5 | 
 6 | #include <boost/cstdint.hpp>
 7 | 
 8 | 
 9 | void import_1_5_float()
10 | {
11 | 	NumpyEigenConverter<Eigen::Matrix< float, 1, 5 > >::register_converter();
12 | }
13 | 
14 | 


--------------------------------------------------------------------------------
/Schweizer-Messer/numpy_eigen/src/autogen_module/import_1_5_int.cpp:
--------------------------------------------------------------------------------
 1 | // This file automatically generated by create_export_module.py
 2 | #define NO_IMPORT_ARRAY 
 3 | 
 4 | #include <NumpyEigenConverter.hpp>
 5 | 
 6 | #include <boost/cstdint.hpp>
 7 | 
 8 | 
 9 | void import_1_5_int()
10 | {
11 | 	NumpyEigenConverter<Eigen::Matrix< int, 1, 5 > >::register_converter();
12 | }
13 | 
14 | 


--------------------------------------------------------------------------------
/Schweizer-Messer/numpy_eigen/src/autogen_module/import_1_5_long.cpp:
--------------------------------------------------------------------------------
 1 | // This file automatically generated by create_export_module.py
 2 | #define NO_IMPORT_ARRAY 
 3 | 
 4 | #include <NumpyEigenConverter.hpp>
 5 | 
 6 | #include <boost/cstdint.hpp>
 7 | 
 8 | 
 9 | void import_1_5_long()
10 | {
11 | 	NumpyEigenConverter<Eigen::Matrix< boost::int64_t, 1, 5 > >::register_converter();
12 | }
13 | 
14 | 


--------------------------------------------------------------------------------
/Schweizer-Messer/numpy_eigen/src/autogen_module/import_1_5_uchar.cpp:
--------------------------------------------------------------------------------
 1 | // This file automatically generated by create_export_module.py
 2 | #define NO_IMPORT_ARRAY 
 3 | 
 4 | #include <NumpyEigenConverter.hpp>
 5 | 
 6 | #include <boost/cstdint.hpp>
 7 | 
 8 | 
 9 | void import_1_5_uchar()
10 | {
11 | 	NumpyEigenConverter<Eigen::Matrix< boost::uint8_t, 1, 5 > >::register_converter();
12 | }
13 | 
14 | 


--------------------------------------------------------------------------------
/Schweizer-Messer/numpy_eigen/src/autogen_module/import_1_6_double.cpp:
--------------------------------------------------------------------------------
 1 | // This file automatically generated by create_export_module.py
 2 | #define NO_IMPORT_ARRAY 
 3 | 
 4 | #include <NumpyEigenConverter.hpp>
 5 | 
 6 | #include <boost/cstdint.hpp>
 7 | 
 8 | 
 9 | void import_1_6_double()
10 | {
11 | 	NumpyEigenConverter<Eigen::Matrix< double, 1, 6 > >::register_converter();
12 | }
13 | 
14 | 


--------------------------------------------------------------------------------
/Schweizer-Messer/numpy_eigen/src/autogen_module/import_1_6_float.cpp:
--------------------------------------------------------------------------------
 1 | // This file automatically generated by create_export_module.py
 2 | #define NO_IMPORT_ARRAY 
 3 | 
 4 | #include <NumpyEigenConverter.hpp>
 5 | 
 6 | #include <boost/cstdint.hpp>
 7 | 
 8 | 
 9 | void import_1_6_float()
10 | {
11 | 	NumpyEigenConverter<Eigen::Matrix< float, 1, 6 > >::register_converter();
12 | }
13 | 
14 | 


--------------------------------------------------------------------------------
/Schweizer-Messer/numpy_eigen/src/autogen_module/import_1_6_int.cpp:
--------------------------------------------------------------------------------
 1 | // This file automatically generated by create_export_module.py
 2 | #define NO_IMPORT_ARRAY 
 3 | 
 4 | #include <NumpyEigenConverter.hpp>
 5 | 
 6 | #include <boost/cstdint.hpp>
 7 | 
 8 | 
 9 | void import_1_6_int()
10 | {
11 | 	NumpyEigenConverter<Eigen::Matrix< int, 1, 6 > >::register_converter();
12 | }
13 | 
14 | 


--------------------------------------------------------------------------------
/Schweizer-Messer/numpy_eigen/src/autogen_module/import_1_6_long.cpp:
--------------------------------------------------------------------------------
 1 | // This file automatically generated by create_export_module.py
 2 | #define NO_IMPORT_ARRAY 
 3 | 
 4 | #include <NumpyEigenConverter.hpp>
 5 | 
 6 | #include <boost/cstdint.hpp>
 7 | 
 8 | 
 9 | void import_1_6_long()
10 | {
11 | 	NumpyEigenConverter<Eigen::Matrix< boost::int64_t, 1, 6 > >::register_converter();
12 | }
13 | 
14 | 


--------------------------------------------------------------------------------
/Schweizer-Messer/numpy_eigen/src/autogen_module/import_1_6_uchar.cpp:
--------------------------------------------------------------------------------
 1 | // This file automatically generated by create_export_module.py
 2 | #define NO_IMPORT_ARRAY 
 3 | 
 4 | #include <NumpyEigenConverter.hpp>
 5 | 
 6 | #include <boost/cstdint.hpp>
 7 | 
 8 | 
 9 | void import_1_6_uchar()
10 | {
11 | 	NumpyEigenConverter<Eigen::Matrix< boost::uint8_t, 1, 6 > >::register_converter();
12 | }
13 | 
14 | 


--------------------------------------------------------------------------------
/Schweizer-Messer/numpy_eigen/src/autogen_module/import_1_D_float.cpp:
--------------------------------------------------------------------------------
 1 | // This file automatically generated by create_export_module.py
 2 | #define NO_IMPORT_ARRAY 
 3 | 
 4 | #include <NumpyEigenConverter.hpp>
 5 | 
 6 | #include <boost/cstdint.hpp>
 7 | 
 8 | 
 9 | void import_1_D_float()
10 | {
11 | 	NumpyEigenConverter<Eigen::Matrix< float, 1, Eigen::Dynamic > >::register_converter();
12 | }
13 | 
14 | 


--------------------------------------------------------------------------------
/Schweizer-Messer/numpy_eigen/src/autogen_module/import_1_D_int.cpp:
--------------------------------------------------------------------------------
 1 | // This file automatically generated by create_export_module.py
 2 | #define NO_IMPORT_ARRAY 
 3 | 
 4 | #include <NumpyEigenConverter.hpp>
 5 | 
 6 | #include <boost/cstdint.hpp>
 7 | 
 8 | 
 9 | void import_1_D_int()
10 | {
11 | 	NumpyEigenConverter<Eigen::Matrix< int, 1, Eigen::Dynamic > >::register_converter();
12 | }
13 | 
14 | 


--------------------------------------------------------------------------------
/Schweizer-Messer/numpy_eigen/src/autogen_module/import_2_1_double.cpp:
--------------------------------------------------------------------------------
 1 | // This file automatically generated by create_export_module.py
 2 | #define NO_IMPORT_ARRAY 
 3 | 
 4 | #include <NumpyEigenConverter.hpp>
 5 | 
 6 | #include <boost/cstdint.hpp>
 7 | 
 8 | 
 9 | void import_2_1_double()
10 | {
11 | 	NumpyEigenConverter<Eigen::Matrix< double, 2, 1 > >::register_converter();
12 | }
13 | 
14 | 


--------------------------------------------------------------------------------
/Schweizer-Messer/numpy_eigen/src/autogen_module/import_2_1_float.cpp:
--------------------------------------------------------------------------------
 1 | // This file automatically generated by create_export_module.py
 2 | #define NO_IMPORT_ARRAY 
 3 | 
 4 | #include <NumpyEigenConverter.hpp>
 5 | 
 6 | #include <boost/cstdint.hpp>
 7 | 
 8 | 
 9 | void import_2_1_float()
10 | {
11 | 	NumpyEigenConverter<Eigen::Matrix< float, 2, 1 > >::register_converter();
12 | }
13 | 
14 | 


--------------------------------------------------------------------------------
/Schweizer-Messer/numpy_eigen/src/autogen_module/import_2_1_int.cpp:
--------------------------------------------------------------------------------
 1 | // This file automatically generated by create_export_module.py
 2 | #define NO_IMPORT_ARRAY 
 3 | 
 4 | #include <NumpyEigenConverter.hpp>
 5 | 
 6 | #include <boost/cstdint.hpp>
 7 | 
 8 | 
 9 | void import_2_1_int()
10 | {
11 | 	NumpyEigenConverter<Eigen::Matrix< int, 2, 1 > >::register_converter();
12 | }
13 | 
14 | 


--------------------------------------------------------------------------------
/Schweizer-Messer/numpy_eigen/src/autogen_module/import_2_1_long.cpp:
--------------------------------------------------------------------------------
 1 | // This file automatically generated by create_export_module.py
 2 | #define NO_IMPORT_ARRAY 
 3 | 
 4 | #include <NumpyEigenConverter.hpp>
 5 | 
 6 | #include <boost/cstdint.hpp>
 7 | 
 8 | 
 9 | void import_2_1_long()
10 | {
11 | 	NumpyEigenConverter<Eigen::Matrix< boost::int64_t, 2, 1 > >::register_converter();
12 | }
13 | 
14 | 


--------------------------------------------------------------------------------
/Schweizer-Messer/numpy_eigen/src/autogen_module/import_2_1_uchar.cpp:
--------------------------------------------------------------------------------
 1 | // This file automatically generated by create_export_module.py
 2 | #define NO_IMPORT_ARRAY 
 3 | 
 4 | #include <NumpyEigenConverter.hpp>
 5 | 
 6 | #include <boost/cstdint.hpp>
 7 | 
 8 | 
 9 | void import_2_1_uchar()
10 | {
11 | 	NumpyEigenConverter<Eigen::Matrix< boost::uint8_t, 2, 1 > >::register_converter();
12 | }
13 | 
14 | 


--------------------------------------------------------------------------------
/Schweizer-Messer/numpy_eigen/src/autogen_module/import_2_2_double.cpp:
--------------------------------------------------------------------------------
 1 | // This file automatically generated by create_export_module.py
 2 | #define NO_IMPORT_ARRAY 
 3 | 
 4 | #include <NumpyEigenConverter.hpp>
 5 | 
 6 | #include <boost/cstdint.hpp>
 7 | 
 8 | 
 9 | void import_2_2_double()
10 | {
11 | 	NumpyEigenConverter<Eigen::Matrix< double, 2, 2 > >::register_converter();
12 | }
13 | 
14 | 


--------------------------------------------------------------------------------
/Schweizer-Messer/numpy_eigen/src/autogen_module/import_2_2_float.cpp:
--------------------------------------------------------------------------------
 1 | // This file automatically generated by create_export_module.py
 2 | #define NO_IMPORT_ARRAY 
 3 | 
 4 | #include <NumpyEigenConverter.hpp>
 5 | 
 6 | #include <boost/cstdint.hpp>
 7 | 
 8 | 
 9 | void import_2_2_float()
10 | {
11 | 	NumpyEigenConverter<Eigen::Matrix< float, 2, 2 > >::register_converter();
12 | }
13 | 
14 | 


--------------------------------------------------------------------------------
/Schweizer-Messer/numpy_eigen/src/autogen_module/import_2_2_int.cpp:
--------------------------------------------------------------------------------
 1 | // This file automatically generated by create_export_module.py
 2 | #define NO_IMPORT_ARRAY 
 3 | 
 4 | #include <NumpyEigenConverter.hpp>
 5 | 
 6 | #include <boost/cstdint.hpp>
 7 | 
 8 | 
 9 | void import_2_2_int()
10 | {
11 | 	NumpyEigenConverter<Eigen::Matrix< int, 2, 2 > >::register_converter();
12 | }
13 | 
14 | 


--------------------------------------------------------------------------------
/Schweizer-Messer/numpy_eigen/src/autogen_module/import_2_2_long.cpp:
--------------------------------------------------------------------------------
 1 | // This file automatically generated by create_export_module.py
 2 | #define NO_IMPORT_ARRAY 
 3 | 
 4 | #include <NumpyEigenConverter.hpp>
 5 | 
 6 | #include <boost/cstdint.hpp>
 7 | 
 8 | 
 9 | void import_2_2_long()
10 | {
11 | 	NumpyEigenConverter<Eigen::Matrix< boost::int64_t, 2, 2 > >::register_converter();
12 | }
13 | 
14 | 


--------------------------------------------------------------------------------
/Schweizer-Messer/numpy_eigen/src/autogen_module/import_2_2_uchar.cpp:
--------------------------------------------------------------------------------
 1 | // This file automatically generated by create_export_module.py
 2 | #define NO_IMPORT_ARRAY 
 3 | 
 4 | #include <NumpyEigenConverter.hpp>
 5 | 
 6 | #include <boost/cstdint.hpp>
 7 | 
 8 | 
 9 | void import_2_2_uchar()
10 | {
11 | 	NumpyEigenConverter<Eigen::Matrix< boost::uint8_t, 2, 2 > >::register_converter();
12 | }
13 | 
14 | 


--------------------------------------------------------------------------------
/Schweizer-Messer/numpy_eigen/src/autogen_module/import_2_3_double.cpp:
--------------------------------------------------------------------------------
 1 | // This file automatically generated by create_export_module.py
 2 | #define NO_IMPORT_ARRAY 
 3 | 
 4 | #include <NumpyEigenConverter.hpp>
 5 | 
 6 | #include <boost/cstdint.hpp>
 7 | 
 8 | 
 9 | void import_2_3_double()
10 | {
11 | 	NumpyEigenConverter<Eigen::Matrix< double, 2, 3 > >::register_converter();
12 | }
13 | 
14 | 


--------------------------------------------------------------------------------
/Schweizer-Messer/numpy_eigen/src/autogen_module/import_2_3_float.cpp:
--------------------------------------------------------------------------------
 1 | // This file automatically generated by create_export_module.py
 2 | #define NO_IMPORT_ARRAY 
 3 | 
 4 | #include <NumpyEigenConverter.hpp>
 5 | 
 6 | #include <boost/cstdint.hpp>
 7 | 
 8 | 
 9 | void import_2_3_float()
10 | {
11 | 	NumpyEigenConverter<Eigen::Matrix< float, 2, 3 > >::register_converter();
12 | }
13 | 
14 | 


--------------------------------------------------------------------------------
/Schweizer-Messer/numpy_eigen/src/autogen_module/import_2_3_int.cpp:
--------------------------------------------------------------------------------
 1 | // This file automatically generated by create_export_module.py
 2 | #define NO_IMPORT_ARRAY 
 3 | 
 4 | #include <NumpyEigenConverter.hpp>
 5 | 
 6 | #include <boost/cstdint.hpp>
 7 | 
 8 | 
 9 | void import_2_3_int()
10 | {
11 | 	NumpyEigenConverter<Eigen::Matrix< int, 2, 3 > >::register_converter();
12 | }
13 | 
14 | 


--------------------------------------------------------------------------------
/Schweizer-Messer/numpy_eigen/src/autogen_module/import_2_3_long.cpp:
--------------------------------------------------------------------------------
 1 | // This file automatically generated by create_export_module.py
 2 | #define NO_IMPORT_ARRAY 
 3 | 
 4 | #include <NumpyEigenConverter.hpp>
 5 | 
 6 | #include <boost/cstdint.hpp>
 7 | 
 8 | 
 9 | void import_2_3_long()
10 | {
11 | 	NumpyEigenConverter<Eigen::Matrix< boost::int64_t, 2, 3 > >::register_converter();
12 | }
13 | 
14 | 


--------------------------------------------------------------------------------
/Schweizer-Messer/numpy_eigen/src/autogen_module/import_2_3_uchar.cpp:
--------------------------------------------------------------------------------
 1 | // This file automatically generated by create_export_module.py
 2 | #define NO_IMPORT_ARRAY 
 3 | 
 4 | #include <NumpyEigenConverter.hpp>
 5 | 
 6 | #include <boost/cstdint.hpp>
 7 | 
 8 | 
 9 | void import_2_3_uchar()
10 | {
11 | 	NumpyEigenConverter<Eigen::Matrix< boost::uint8_t, 2, 3 > >::register_converter();
12 | }
13 | 
14 | 


--------------------------------------------------------------------------------
/Schweizer-Messer/numpy_eigen/src/autogen_module/import_2_4_double.cpp:
--------------------------------------------------------------------------------
 1 | // This file automatically generated by create_export_module.py
 2 | #define NO_IMPORT_ARRAY 
 3 | 
 4 | #include <NumpyEigenConverter.hpp>
 5 | 
 6 | #include <boost/cstdint.hpp>
 7 | 
 8 | 
 9 | void import_2_4_double()
10 | {
11 | 	NumpyEigenConverter<Eigen::Matrix< double, 2, 4 > >::register_converter();
12 | }
13 | 
14 | 


--------------------------------------------------------------------------------
/Schweizer-Messer/numpy_eigen/src/autogen_module/import_2_4_float.cpp:
--------------------------------------------------------------------------------
 1 | // This file automatically generated by create_export_module.py
 2 | #define NO_IMPORT_ARRAY 
 3 | 
 4 | #include <NumpyEigenConverter.hpp>
 5 | 
 6 | #include <boost/cstdint.hpp>
 7 | 
 8 | 
 9 | void import_2_4_float()
10 | {
11 | 	NumpyEigenConverter<Eigen::Matrix< float, 2, 4 > >::register_converter();
12 | }
13 | 
14 | 


--------------------------------------------------------------------------------
/Schweizer-Messer/numpy_eigen/src/autogen_module/import_2_4_int.cpp:
--------------------------------------------------------------------------------
 1 | // This file automatically generated by create_export_module.py
 2 | #define NO_IMPORT_ARRAY 
 3 | 
 4 | #include <NumpyEigenConverter.hpp>
 5 | 
 6 | #include <boost/cstdint.hpp>
 7 | 
 8 | 
 9 | void import_2_4_int()
10 | {
11 | 	NumpyEigenConverter<Eigen::Matrix< int, 2, 4 > >::register_converter();
12 | }
13 | 
14 | 


--------------------------------------------------------------------------------
/Schweizer-Messer/numpy_eigen/src/autogen_module/import_2_4_long.cpp:
--------------------------------------------------------------------------------
 1 | // This file automatically generated by create_export_module.py
 2 | #define NO_IMPORT_ARRAY 
 3 | 
 4 | #include <NumpyEigenConverter.hpp>
 5 | 
 6 | #include <boost/cstdint.hpp>
 7 | 
 8 | 
 9 | void import_2_4_long()
10 | {
11 | 	NumpyEigenConverter<Eigen::Matrix< boost::int64_t, 2, 4 > >::register_converter();
12 | }
13 | 
14 | 


--------------------------------------------------------------------------------
/Schweizer-Messer/numpy_eigen/src/autogen_module/import_2_4_uchar.cpp:
--------------------------------------------------------------------------------
 1 | // This file automatically generated by create_export_module.py
 2 | #define NO_IMPORT_ARRAY 
 3 | 
 4 | #include <NumpyEigenConverter.hpp>
 5 | 
 6 | #include <boost/cstdint.hpp>
 7 | 
 8 | 
 9 | void import_2_4_uchar()
10 | {
11 | 	NumpyEigenConverter<Eigen::Matrix< boost::uint8_t, 2, 4 > >::register_converter();
12 | }
13 | 
14 | 


--------------------------------------------------------------------------------
/Schweizer-Messer/numpy_eigen/src/autogen_module/import_2_5_double.cpp:
--------------------------------------------------------------------------------
 1 | // This file automatically generated by create_export_module.py
 2 | #define NO_IMPORT_ARRAY 
 3 | 
 4 | #include <NumpyEigenConverter.hpp>
 5 | 
 6 | #include <boost/cstdint.hpp>
 7 | 
 8 | 
 9 | void import_2_5_double()
10 | {
11 | 	NumpyEigenConverter<Eigen::Matrix< double, 2, 5 > >::register_converter();
12 | }
13 | 
14 | 


--------------------------------------------------------------------------------
/Schweizer-Messer/numpy_eigen/src/autogen_module/import_2_5_float.cpp:
--------------------------------------------------------------------------------
 1 | // This file automatically generated by create_export_module.py
 2 | #define NO_IMPORT_ARRAY 
 3 | 
 4 | #include <NumpyEigenConverter.hpp>
 5 | 
 6 | #include <boost/cstdint.hpp>
 7 | 
 8 | 
 9 | void import_2_5_float()
10 | {
11 | 	NumpyEigenConverter<Eigen::Matrix< float, 2, 5 > >::register_converter();
12 | }
13 | 
14 | 


--------------------------------------------------------------------------------
/Schweizer-Messer/numpy_eigen/src/autogen_module/import_2_5_int.cpp:
--------------------------------------------------------------------------------
 1 | // This file automatically generated by create_export_module.py
 2 | #define NO_IMPORT_ARRAY 
 3 | 
 4 | #include <NumpyEigenConverter.hpp>
 5 | 
 6 | #include <boost/cstdint.hpp>
 7 | 
 8 | 
 9 | void import_2_5_int()
10 | {
11 | 	NumpyEigenConverter<Eigen::Matrix< int, 2, 5 > >::register_converter();
12 | }
13 | 
14 | 


--------------------------------------------------------------------------------
/Schweizer-Messer/numpy_eigen/src/autogen_module/import_2_5_long.cpp:
--------------------------------------------------------------------------------
 1 | // This file automatically generated by create_export_module.py
 2 | #define NO_IMPORT_ARRAY 
 3 | 
 4 | #include <NumpyEigenConverter.hpp>
 5 | 
 6 | #include <boost/cstdint.hpp>
 7 | 
 8 | 
 9 | void import_2_5_long()
10 | {
11 | 	NumpyEigenConverter<Eigen::Matrix< boost::int64_t, 2, 5 > >::register_converter();
12 | }
13 | 
14 | 


--------------------------------------------------------------------------------
/Schweizer-Messer/numpy_eigen/src/autogen_module/import_2_5_uchar.cpp:
--------------------------------------------------------------------------------
 1 | // This file automatically generated by create_export_module.py
 2 | #define NO_IMPORT_ARRAY 
 3 | 
 4 | #include <NumpyEigenConverter.hpp>
 5 | 
 6 | #include <boost/cstdint.hpp>
 7 | 
 8 | 
 9 | void import_2_5_uchar()
10 | {
11 | 	NumpyEigenConverter<Eigen::Matrix< boost::uint8_t, 2, 5 > >::register_converter();
12 | }
13 | 
14 | 


--------------------------------------------------------------------------------
/Schweizer-Messer/numpy_eigen/src/autogen_module/import_2_6_double.cpp:
--------------------------------------------------------------------------------
 1 | // This file automatically generated by create_export_module.py
 2 | #define NO_IMPORT_ARRAY 
 3 | 
 4 | #include <NumpyEigenConverter.hpp>
 5 | 
 6 | #include <boost/cstdint.hpp>
 7 | 
 8 | 
 9 | void import_2_6_double()
10 | {
11 | 	NumpyEigenConverter<Eigen::Matrix< double, 2, 6 > >::register_converter();
12 | }
13 | 
14 | 


--------------------------------------------------------------------------------
/Schweizer-Messer/numpy_eigen/src/autogen_module/import_2_6_float.cpp:
--------------------------------------------------------------------------------
 1 | // This file automatically generated by create_export_module.py
 2 | #define NO_IMPORT_ARRAY 
 3 | 
 4 | #include <NumpyEigenConverter.hpp>
 5 | 
 6 | #include <boost/cstdint.hpp>
 7 | 
 8 | 
 9 | void import_2_6_float()
10 | {
11 | 	NumpyEigenConverter<Eigen::Matrix< float, 2, 6 > >::register_converter();
12 | }
13 | 
14 | 


--------------------------------------------------------------------------------
/Schweizer-Messer/numpy_eigen/src/autogen_module/import_2_6_int.cpp:
--------------------------------------------------------------------------------
 1 | // This file automatically generated by create_export_module.py
 2 | #define NO_IMPORT_ARRAY 
 3 | 
 4 | #include <NumpyEigenConverter.hpp>
 5 | 
 6 | #include <boost/cstdint.hpp>
 7 | 
 8 | 
 9 | void import_2_6_int()
10 | {
11 | 	NumpyEigenConverter<Eigen::Matrix< int, 2, 6 > >::register_converter();
12 | }
13 | 
14 | 


--------------------------------------------------------------------------------
/Schweizer-Messer/numpy_eigen/src/autogen_module/import_2_6_long.cpp:
--------------------------------------------------------------------------------
 1 | // This file automatically generated by create_export_module.py
 2 | #define NO_IMPORT_ARRAY 
 3 | 
 4 | #include <NumpyEigenConverter.hpp>
 5 | 
 6 | #include <boost/cstdint.hpp>
 7 | 
 8 | 
 9 | void import_2_6_long()
10 | {
11 | 	NumpyEigenConverter<Eigen::Matrix< boost::int64_t, 2, 6 > >::register_converter();
12 | }
13 | 
14 | 


--------------------------------------------------------------------------------
/Schweizer-Messer/numpy_eigen/src/autogen_module/import_2_6_uchar.cpp:
--------------------------------------------------------------------------------
 1 | // This file automatically generated by create_export_module.py
 2 | #define NO_IMPORT_ARRAY 
 3 | 
 4 | #include <NumpyEigenConverter.hpp>
 5 | 
 6 | #include <boost/cstdint.hpp>
 7 | 
 8 | 
 9 | void import_2_6_uchar()
10 | {
11 | 	NumpyEigenConverter<Eigen::Matrix< boost::uint8_t, 2, 6 > >::register_converter();
12 | }
13 | 
14 | 


--------------------------------------------------------------------------------
/Schweizer-Messer/numpy_eigen/src/autogen_module/import_2_D_float.cpp:
--------------------------------------------------------------------------------
 1 | // This file automatically generated by create_export_module.py
 2 | #define NO_IMPORT_ARRAY 
 3 | 
 4 | #include <NumpyEigenConverter.hpp>
 5 | 
 6 | #include <boost/cstdint.hpp>
 7 | 
 8 | 
 9 | void import_2_D_float()
10 | {
11 | 	NumpyEigenConverter<Eigen::Matrix< float, 2, Eigen::Dynamic > >::register_converter();
12 | }
13 | 
14 | 


--------------------------------------------------------------------------------
/Schweizer-Messer/numpy_eigen/src/autogen_module/import_2_D_int.cpp:
--------------------------------------------------------------------------------
 1 | // This file automatically generated by create_export_module.py
 2 | #define NO_IMPORT_ARRAY 
 3 | 
 4 | #include <NumpyEigenConverter.hpp>
 5 | 
 6 | #include <boost/cstdint.hpp>
 7 | 
 8 | 
 9 | void import_2_D_int()
10 | {
11 | 	NumpyEigenConverter<Eigen::Matrix< int, 2, Eigen::Dynamic > >::register_converter();
12 | }
13 | 
14 | 


--------------------------------------------------------------------------------
/Schweizer-Messer/numpy_eigen/src/autogen_module/import_3_1_double.cpp:
--------------------------------------------------------------------------------
 1 | // This file automatically generated by create_export_module.py
 2 | #define NO_IMPORT_ARRAY 
 3 | 
 4 | #include <NumpyEigenConverter.hpp>
 5 | 
 6 | #include <boost/cstdint.hpp>
 7 | 
 8 | 
 9 | void import_3_1_double()
10 | {
11 | 	NumpyEigenConverter<Eigen::Matrix< double, 3, 1 > >::register_converter();
12 | }
13 | 
14 | 


--------------------------------------------------------------------------------
/Schweizer-Messer/numpy_eigen/src/autogen_module/import_3_1_float.cpp:
--------------------------------------------------------------------------------
 1 | // This file automatically generated by create_export_module.py
 2 | #define NO_IMPORT_ARRAY 
 3 | 
 4 | #include <NumpyEigenConverter.hpp>
 5 | 
 6 | #include <boost/cstdint.hpp>
 7 | 
 8 | 
 9 | void import_3_1_float()
10 | {
11 | 	NumpyEigenConverter<Eigen::Matrix< float, 3, 1 > >::register_converter();
12 | }
13 | 
14 | 


--------------------------------------------------------------------------------
/Schweizer-Messer/numpy_eigen/src/autogen_module/import_3_1_int.cpp:
--------------------------------------------------------------------------------
 1 | // This file automatically generated by create_export_module.py
 2 | #define NO_IMPORT_ARRAY 
 3 | 
 4 | #include <NumpyEigenConverter.hpp>
 5 | 
 6 | #include <boost/cstdint.hpp>
 7 | 
 8 | 
 9 | void import_3_1_int()
10 | {
11 | 	NumpyEigenConverter<Eigen::Matrix< int, 3, 1 > >::register_converter();
12 | }
13 | 
14 | 


--------------------------------------------------------------------------------
/Schweizer-Messer/numpy_eigen/src/autogen_module/import_3_1_long.cpp:
--------------------------------------------------------------------------------
 1 | // This file automatically generated by create_export_module.py
 2 | #define NO_IMPORT_ARRAY 
 3 | 
 4 | #include <NumpyEigenConverter.hpp>
 5 | 
 6 | #include <boost/cstdint.hpp>
 7 | 
 8 | 
 9 | void import_3_1_long()
10 | {
11 | 	NumpyEigenConverter<Eigen::Matrix< boost::int64_t, 3, 1 > >::register_converter();
12 | }
13 | 
14 | 


--------------------------------------------------------------------------------
/Schweizer-Messer/numpy_eigen/src/autogen_module/import_3_1_uchar.cpp:
--------------------------------------------------------------------------------
 1 | // This file automatically generated by create_export_module.py
 2 | #define NO_IMPORT_ARRAY 
 3 | 
 4 | #include <NumpyEigenConverter.hpp>
 5 | 
 6 | #include <boost/cstdint.hpp>
 7 | 
 8 | 
 9 | void import_3_1_uchar()
10 | {
11 | 	NumpyEigenConverter<Eigen::Matrix< boost::uint8_t, 3, 1 > >::register_converter();
12 | }
13 | 
14 | 


--------------------------------------------------------------------------------
/Schweizer-Messer/numpy_eigen/src/autogen_module/import_3_2_double.cpp:
--------------------------------------------------------------------------------
 1 | // This file automatically generated by create_export_module.py
 2 | #define NO_IMPORT_ARRAY 
 3 | 
 4 | #include <NumpyEigenConverter.hpp>
 5 | 
 6 | #include <boost/cstdint.hpp>
 7 | 
 8 | 
 9 | void import_3_2_double()
10 | {
11 | 	NumpyEigenConverter<Eigen::Matrix< double, 3, 2 > >::register_converter();
12 | }
13 | 
14 | 


--------------------------------------------------------------------------------
/Schweizer-Messer/numpy_eigen/src/autogen_module/import_3_2_float.cpp:
--------------------------------------------------------------------------------
 1 | // This file automatically generated by create_export_module.py
 2 | #define NO_IMPORT_ARRAY 
 3 | 
 4 | #include <NumpyEigenConverter.hpp>
 5 | 
 6 | #include <boost/cstdint.hpp>
 7 | 
 8 | 
 9 | void import_3_2_float()
10 | {
11 | 	NumpyEigenConverter<Eigen::Matrix< float, 3, 2 > >::register_converter();
12 | }
13 | 
14 | 


--------------------------------------------------------------------------------
/Schweizer-Messer/numpy_eigen/src/autogen_module/import_3_2_int.cpp:
--------------------------------------------------------------------------------
 1 | // This file automatically generated by create_export_module.py
 2 | #define NO_IMPORT_ARRAY 
 3 | 
 4 | #include <NumpyEigenConverter.hpp>
 5 | 
 6 | #include <boost/cstdint.hpp>
 7 | 
 8 | 
 9 | void import_3_2_int()
10 | {
11 | 	NumpyEigenConverter<Eigen::Matrix< int, 3, 2 > >::register_converter();
12 | }
13 | 
14 | 


--------------------------------------------------------------------------------
/Schweizer-Messer/numpy_eigen/src/autogen_module/import_3_2_long.cpp:
--------------------------------------------------------------------------------
 1 | // This file automatically generated by create_export_module.py
 2 | #define NO_IMPORT_ARRAY 
 3 | 
 4 | #include <NumpyEigenConverter.hpp>
 5 | 
 6 | #include <boost/cstdint.hpp>
 7 | 
 8 | 
 9 | void import_3_2_long()
10 | {
11 | 	NumpyEigenConverter<Eigen::Matrix< boost::int64_t, 3, 2 > >::register_converter();
12 | }
13 | 
14 | 


--------------------------------------------------------------------------------
/Schweizer-Messer/numpy_eigen/src/autogen_module/import_3_2_uchar.cpp:
--------------------------------------------------------------------------------
 1 | // This file automatically generated by create_export_module.py
 2 | #define NO_IMPORT_ARRAY 
 3 | 
 4 | #include <NumpyEigenConverter.hpp>
 5 | 
 6 | #include <boost/cstdint.hpp>
 7 | 
 8 | 
 9 | void import_3_2_uchar()
10 | {
11 | 	NumpyEigenConverter<Eigen::Matrix< boost::uint8_t, 3, 2 > >::register_converter();
12 | }
13 | 
14 | 


--------------------------------------------------------------------------------
/Schweizer-Messer/numpy_eigen/src/autogen_module/import_3_3_double.cpp:
--------------------------------------------------------------------------------
 1 | // This file automatically generated by create_export_module.py
 2 | #define NO_IMPORT_ARRAY 
 3 | 
 4 | #include <NumpyEigenConverter.hpp>
 5 | 
 6 | #include <boost/cstdint.hpp>
 7 | 
 8 | 
 9 | void import_3_3_double()
10 | {
11 | 	NumpyEigenConverter<Eigen::Matrix< double, 3, 3 > >::register_converter();
12 | }
13 | 
14 | 


--------------------------------------------------------------------------------
/Schweizer-Messer/numpy_eigen/src/autogen_module/import_3_3_float.cpp:
--------------------------------------------------------------------------------
 1 | // This file automatically generated by create_export_module.py
 2 | #define NO_IMPORT_ARRAY 
 3 | 
 4 | #include <NumpyEigenConverter.hpp>
 5 | 
 6 | #include <boost/cstdint.hpp>
 7 | 
 8 | 
 9 | void import_3_3_float()
10 | {
11 | 	NumpyEigenConverter<Eigen::Matrix< float, 3, 3 > >::register_converter();
12 | }
13 | 
14 | 


--------------------------------------------------------------------------------
/Schweizer-Messer/numpy_eigen/src/autogen_module/import_3_3_int.cpp:
--------------------------------------------------------------------------------
 1 | // This file automatically generated by create_export_module.py
 2 | #define NO_IMPORT_ARRAY 
 3 | 
 4 | #include <NumpyEigenConverter.hpp>
 5 | 
 6 | #include <boost/cstdint.hpp>
 7 | 
 8 | 
 9 | void import_3_3_int()
10 | {
11 | 	NumpyEigenConverter<Eigen::Matrix< int, 3, 3 > >::register_converter();
12 | }
13 | 
14 | 


--------------------------------------------------------------------------------
/Schweizer-Messer/numpy_eigen/src/autogen_module/import_3_3_long.cpp:
--------------------------------------------------------------------------------
 1 | // This file automatically generated by create_export_module.py
 2 | #define NO_IMPORT_ARRAY 
 3 | 
 4 | #include <NumpyEigenConverter.hpp>
 5 | 
 6 | #include <boost/cstdint.hpp>
 7 | 
 8 | 
 9 | void import_3_3_long()
10 | {
11 | 	NumpyEigenConverter<Eigen::Matrix< boost::int64_t, 3, 3 > >::register_converter();
12 | }
13 | 
14 | 


--------------------------------------------------------------------------------
/Schweizer-Messer/numpy_eigen/src/autogen_module/import_3_3_uchar.cpp:
--------------------------------------------------------------------------------
 1 | // This file automatically generated by create_export_module.py
 2 | #define NO_IMPORT_ARRAY 
 3 | 
 4 | #include <NumpyEigenConverter.hpp>
 5 | 
 6 | #include <boost/cstdint.hpp>
 7 | 
 8 | 
 9 | void import_3_3_uchar()
10 | {
11 | 	NumpyEigenConverter<Eigen::Matrix< boost::uint8_t, 3, 3 > >::register_converter();
12 | }
13 | 
14 | 


--------------------------------------------------------------------------------
/Schweizer-Messer/numpy_eigen/src/autogen_module/import_3_4_double.cpp:
--------------------------------------------------------------------------------
 1 | // This file automatically generated by create_export_module.py
 2 | #define NO_IMPORT_ARRAY 
 3 | 
 4 | #include <NumpyEigenConverter.hpp>
 5 | 
 6 | #include <boost/cstdint.hpp>
 7 | 
 8 | 
 9 | void import_3_4_double()
10 | {
11 | 	NumpyEigenConverter<Eigen::Matrix< double, 3, 4 > >::register_converter();
12 | }
13 | 
14 | 


--------------------------------------------------------------------------------
/Schweizer-Messer/numpy_eigen/src/autogen_module/import_3_4_float.cpp:
--------------------------------------------------------------------------------
 1 | // This file automatically generated by create_export_module.py
 2 | #define NO_IMPORT_ARRAY 
 3 | 
 4 | #include <NumpyEigenConverter.hpp>
 5 | 
 6 | #include <boost/cstdint.hpp>
 7 | 
 8 | 
 9 | void import_3_4_float()
10 | {
11 | 	NumpyEigenConverter<Eigen::Matrix< float, 3, 4 > >::register_converter();
12 | }
13 | 
14 | 


--------------------------------------------------------------------------------
/Schweizer-Messer/numpy_eigen/src/autogen_module/import_3_4_int.cpp:
--------------------------------------------------------------------------------
 1 | // This file automatically generated by create_export_module.py
 2 | #define NO_IMPORT_ARRAY 
 3 | 
 4 | #include <NumpyEigenConverter.hpp>
 5 | 
 6 | #include <boost/cstdint.hpp>
 7 | 
 8 | 
 9 | void import_3_4_int()
10 | {
11 | 	NumpyEigenConverter<Eigen::Matrix< int, 3, 4 > >::register_converter();
12 | }
13 | 
14 | 


--------------------------------------------------------------------------------
/Schweizer-Messer/numpy_eigen/src/autogen_module/import_3_4_long.cpp:
--------------------------------------------------------------------------------
 1 | // This file automatically generated by create_export_module.py
 2 | #define NO_IMPORT_ARRAY 
 3 | 
 4 | #include <NumpyEigenConverter.hpp>
 5 | 
 6 | #include <boost/cstdint.hpp>
 7 | 
 8 | 
 9 | void import_3_4_long()
10 | {
11 | 	NumpyEigenConverter<Eigen::Matrix< boost::int64_t, 3, 4 > >::register_converter();
12 | }
13 | 
14 | 


--------------------------------------------------------------------------------
/Schweizer-Messer/numpy_eigen/src/autogen_module/import_3_5_double.cpp:
--------------------------------------------------------------------------------
 1 | // This file automatically generated by create_export_module.py
 2 | #define NO_IMPORT_ARRAY 
 3 | 
 4 | #include <NumpyEigenConverter.hpp>
 5 | 
 6 | #include <boost/cstdint.hpp>
 7 | 
 8 | 
 9 | void import_3_5_double()
10 | {
11 | 	NumpyEigenConverter<Eigen::Matrix< double, 3, 5 > >::register_converter();
12 | }
13 | 
14 | 


--------------------------------------------------------------------------------
/Schweizer-Messer/numpy_eigen/src/autogen_module/import_3_5_float.cpp:
--------------------------------------------------------------------------------
 1 | // This file automatically generated by create_export_module.py
 2 | #define NO_IMPORT_ARRAY 
 3 | 
 4 | #include <NumpyEigenConverter.hpp>
 5 | 
 6 | #include <boost/cstdint.hpp>
 7 | 
 8 | 
 9 | void import_3_5_float()
10 | {
11 | 	NumpyEigenConverter<Eigen::Matrix< float, 3, 5 > >::register_converter();
12 | }
13 | 
14 | 


--------------------------------------------------------------------------------
/Schweizer-Messer/numpy_eigen/src/autogen_module/import_3_5_int.cpp:
--------------------------------------------------------------------------------
 1 | // This file automatically generated by create_export_module.py
 2 | #define NO_IMPORT_ARRAY 
 3 | 
 4 | #include <NumpyEigenConverter.hpp>
 5 | 
 6 | #include <boost/cstdint.hpp>
 7 | 
 8 | 
 9 | void import_3_5_int()
10 | {
11 | 	NumpyEigenConverter<Eigen::Matrix< int, 3, 5 > >::register_converter();
12 | }
13 | 
14 | 


--------------------------------------------------------------------------------
/Schweizer-Messer/numpy_eigen/src/autogen_module/import_3_5_long.cpp:
--------------------------------------------------------------------------------
 1 | // This file automatically generated by create_export_module.py
 2 | #define NO_IMPORT_ARRAY 
 3 | 
 4 | #include <NumpyEigenConverter.hpp>
 5 | 
 6 | #include <boost/cstdint.hpp>
 7 | 
 8 | 
 9 | void import_3_5_long()
10 | {
11 | 	NumpyEigenConverter<Eigen::Matrix< boost::int64_t, 3, 5 > >::register_converter();
12 | }
13 | 
14 | 


--------------------------------------------------------------------------------
/Schweizer-Messer/numpy_eigen/src/autogen_module/import_3_6_double.cpp:
--------------------------------------------------------------------------------
 1 | // This file automatically generated by create_export_module.py
 2 | #define NO_IMPORT_ARRAY 
 3 | 
 4 | #include <NumpyEigenConverter.hpp>
 5 | 
 6 | #include <boost/cstdint.hpp>
 7 | 
 8 | 
 9 | void import_3_6_double()
10 | {
11 | 	NumpyEigenConverter<Eigen::Matrix< double, 3, 6 > >::register_converter();
12 | }
13 | 
14 | 


--------------------------------------------------------------------------------
/Schweizer-Messer/numpy_eigen/src/autogen_module/import_3_6_float.cpp:
--------------------------------------------------------------------------------
 1 | // This file automatically generated by create_export_module.py
 2 | #define NO_IMPORT_ARRAY 
 3 | 
 4 | #include <NumpyEigenConverter.hpp>
 5 | 
 6 | #include <boost/cstdint.hpp>
 7 | 
 8 | 
 9 | void import_3_6_float()
10 | {
11 | 	NumpyEigenConverter<Eigen::Matrix< float, 3, 6 > >::register_converter();
12 | }
13 | 
14 | 


--------------------------------------------------------------------------------
/Schweizer-Messer/numpy_eigen/src/autogen_module/import_3_6_int.cpp:
--------------------------------------------------------------------------------
 1 | // This file automatically generated by create_export_module.py
 2 | #define NO_IMPORT_ARRAY 
 3 | 
 4 | #include <NumpyEigenConverter.hpp>
 5 | 
 6 | #include <boost/cstdint.hpp>
 7 | 
 8 | 
 9 | void import_3_6_int()
10 | {
11 | 	NumpyEigenConverter<Eigen::Matrix< int, 3, 6 > >::register_converter();
12 | }
13 | 
14 | 


--------------------------------------------------------------------------------
/Schweizer-Messer/numpy_eigen/src/autogen_module/import_3_6_long.cpp:
--------------------------------------------------------------------------------
 1 | // This file automatically generated by create_export_module.py
 2 | #define NO_IMPORT_ARRAY 
 3 | 
 4 | #include <NumpyEigenConverter.hpp>
 5 | 
 6 | #include <boost/cstdint.hpp>
 7 | 
 8 | 
 9 | void import_3_6_long()
10 | {
11 | 	NumpyEigenConverter<Eigen::Matrix< boost::int64_t, 3, 6 > >::register_converter();
12 | }
13 | 
14 | 


--------------------------------------------------------------------------------
/Schweizer-Messer/numpy_eigen/src/autogen_module/import_3_D_int.cpp:
--------------------------------------------------------------------------------
 1 | // This file automatically generated by create_export_module.py
 2 | #define NO_IMPORT_ARRAY 
 3 | 
 4 | #include <NumpyEigenConverter.hpp>
 5 | 
 6 | #include <boost/cstdint.hpp>
 7 | 
 8 | 
 9 | void import_3_D_int()
10 | {
11 | 	NumpyEigenConverter<Eigen::Matrix< int, 3, Eigen::Dynamic > >::register_converter();
12 | }
13 | 
14 | 


--------------------------------------------------------------------------------
/Schweizer-Messer/numpy_eigen/src/autogen_module/import_4_1_double.cpp:
--------------------------------------------------------------------------------
 1 | // This file automatically generated by create_export_module.py
 2 | #define NO_IMPORT_ARRAY 
 3 | 
 4 | #include <NumpyEigenConverter.hpp>
 5 | 
 6 | #include <boost/cstdint.hpp>
 7 | 
 8 | 
 9 | void import_4_1_double()
10 | {
11 | 	NumpyEigenConverter<Eigen::Matrix< double, 4, 1 > >::register_converter();
12 | }
13 | 
14 | 


--------------------------------------------------------------------------------
/Schweizer-Messer/numpy_eigen/src/autogen_module/import_4_1_float.cpp:
--------------------------------------------------------------------------------
 1 | // This file automatically generated by create_export_module.py
 2 | #define NO_IMPORT_ARRAY 
 3 | 
 4 | #include <NumpyEigenConverter.hpp>
 5 | 
 6 | #include <boost/cstdint.hpp>
 7 | 
 8 | 
 9 | void import_4_1_float()
10 | {
11 | 	NumpyEigenConverter<Eigen::Matrix< float, 4, 1 > >::register_converter();
12 | }
13 | 
14 | 


--------------------------------------------------------------------------------
/Schweizer-Messer/numpy_eigen/src/autogen_module/import_4_1_int.cpp:
--------------------------------------------------------------------------------
 1 | // This file automatically generated by create_export_module.py
 2 | #define NO_IMPORT_ARRAY 
 3 | 
 4 | #include <NumpyEigenConverter.hpp>
 5 | 
 6 | #include <boost/cstdint.hpp>
 7 | 
 8 | 
 9 | void import_4_1_int()
10 | {
11 | 	NumpyEigenConverter<Eigen::Matrix< int, 4, 1 > >::register_converter();
12 | }
13 | 
14 | 


--------------------------------------------------------------------------------
/Schweizer-Messer/numpy_eigen/src/autogen_module/import_4_1_long.cpp:
--------------------------------------------------------------------------------
 1 | // This file automatically generated by create_export_module.py
 2 | #define NO_IMPORT_ARRAY 
 3 | 
 4 | #include <NumpyEigenConverter.hpp>
 5 | 
 6 | #include <boost/cstdint.hpp>
 7 | 
 8 | 
 9 | void import_4_1_long()
10 | {
11 | 	NumpyEigenConverter<Eigen::Matrix< boost::int64_t, 4, 1 > >::register_converter();
12 | }
13 | 
14 | 


--------------------------------------------------------------------------------
/Schweizer-Messer/numpy_eigen/src/autogen_module/import_4_2_double.cpp:
--------------------------------------------------------------------------------
 1 | // This file automatically generated by create_export_module.py
 2 | #define NO_IMPORT_ARRAY 
 3 | 
 4 | #include <NumpyEigenConverter.hpp>
 5 | 
 6 | #include <boost/cstdint.hpp>
 7 | 
 8 | 
 9 | void import_4_2_double()
10 | {
11 | 	NumpyEigenConverter<Eigen::Matrix< double, 4, 2 > >::register_converter();
12 | }
13 | 
14 | 


--------------------------------------------------------------------------------
/Schweizer-Messer/numpy_eigen/src/autogen_module/import_4_2_float.cpp:
--------------------------------------------------------------------------------
 1 | // This file automatically generated by create_export_module.py
 2 | #define NO_IMPORT_ARRAY 
 3 | 
 4 | #include <NumpyEigenConverter.hpp>
 5 | 
 6 | #include <boost/cstdint.hpp>
 7 | 
 8 | 
 9 | void import_4_2_float()
10 | {
11 | 	NumpyEigenConverter<Eigen::Matrix< float, 4, 2 > >::register_converter();
12 | }
13 | 
14 | 


--------------------------------------------------------------------------------
/Schweizer-Messer/numpy_eigen/src/autogen_module/import_4_2_int.cpp:
--------------------------------------------------------------------------------
 1 | // This file automatically generated by create_export_module.py
 2 | #define NO_IMPORT_ARRAY 
 3 | 
 4 | #include <NumpyEigenConverter.hpp>
 5 | 
 6 | #include <boost/cstdint.hpp>
 7 | 
 8 | 
 9 | void import_4_2_int()
10 | {
11 | 	NumpyEigenConverter<Eigen::Matrix< int, 4, 2 > >::register_converter();
12 | }
13 | 
14 | 


--------------------------------------------------------------------------------
/Schweizer-Messer/numpy_eigen/src/autogen_module/import_4_2_long.cpp:
--------------------------------------------------------------------------------
 1 | // This file automatically generated by create_export_module.py
 2 | #define NO_IMPORT_ARRAY 
 3 | 
 4 | #include <NumpyEigenConverter.hpp>
 5 | 
 6 | #include <boost/cstdint.hpp>
 7 | 
 8 | 
 9 | void import_4_2_long()
10 | {
11 | 	NumpyEigenConverter<Eigen::Matrix< boost::int64_t, 4, 2 > >::register_converter();
12 | }
13 | 
14 | 


--------------------------------------------------------------------------------
/Schweizer-Messer/numpy_eigen/src/autogen_module/import_4_3_double.cpp:
--------------------------------------------------------------------------------
 1 | // This file automatically generated by create_export_module.py
 2 | #define NO_IMPORT_ARRAY 
 3 | 
 4 | #include <NumpyEigenConverter.hpp>
 5 | 
 6 | #include <boost/cstdint.hpp>
 7 | 
 8 | 
 9 | void import_4_3_double()
10 | {
11 | 	NumpyEigenConverter<Eigen::Matrix< double, 4, 3 > >::register_converter();
12 | }
13 | 
14 | 


--------------------------------------------------------------------------------
/Schweizer-Messer/numpy_eigen/src/autogen_module/import_4_3_float.cpp:
--------------------------------------------------------------------------------
 1 | // This file automatically generated by create_export_module.py
 2 | #define NO_IMPORT_ARRAY 
 3 | 
 4 | #include <NumpyEigenConverter.hpp>
 5 | 
 6 | #include <boost/cstdint.hpp>
 7 | 
 8 | 
 9 | void import_4_3_float()
10 | {
11 | 	NumpyEigenConverter<Eigen::Matrix< float, 4, 3 > >::register_converter();
12 | }
13 | 
14 | 


--------------------------------------------------------------------------------
/Schweizer-Messer/numpy_eigen/src/autogen_module/import_4_3_int.cpp:
--------------------------------------------------------------------------------
 1 | // This file automatically generated by create_export_module.py
 2 | #define NO_IMPORT_ARRAY 
 3 | 
 4 | #include <NumpyEigenConverter.hpp>
 5 | 
 6 | #include <boost/cstdint.hpp>
 7 | 
 8 | 
 9 | void import_4_3_int()
10 | {
11 | 	NumpyEigenConverter<Eigen::Matrix< int, 4, 3 > >::register_converter();
12 | }
13 | 
14 | 


--------------------------------------------------------------------------------
/Schweizer-Messer/numpy_eigen/src/autogen_module/import_4_3_long.cpp:
--------------------------------------------------------------------------------
 1 | // This file automatically generated by create_export_module.py
 2 | #define NO_IMPORT_ARRAY 
 3 | 
 4 | #include <NumpyEigenConverter.hpp>
 5 | 
 6 | #include <boost/cstdint.hpp>
 7 | 
 8 | 
 9 | void import_4_3_long()
10 | {
11 | 	NumpyEigenConverter<Eigen::Matrix< boost::int64_t, 4, 3 > >::register_converter();
12 | }
13 | 
14 | 


--------------------------------------------------------------------------------
/Schweizer-Messer/numpy_eigen/src/autogen_module/import_4_4_double.cpp:
--------------------------------------------------------------------------------
 1 | // This file automatically generated by create_export_module.py
 2 | #define NO_IMPORT_ARRAY 
 3 | 
 4 | #include <NumpyEigenConverter.hpp>
 5 | 
 6 | #include <boost/cstdint.hpp>
 7 | 
 8 | 
 9 | void import_4_4_double()
10 | {
11 | 	NumpyEigenConverter<Eigen::Matrix< double, 4, 4 > >::register_converter();
12 | }
13 | 
14 | 


--------------------------------------------------------------------------------
/Schweizer-Messer/numpy_eigen/src/autogen_module/import_4_4_float.cpp:
--------------------------------------------------------------------------------
 1 | // This file automatically generated by create_export_module.py
 2 | #define NO_IMPORT_ARRAY 
 3 | 
 4 | #include <NumpyEigenConverter.hpp>
 5 | 
 6 | #include <boost/cstdint.hpp>
 7 | 
 8 | 
 9 | void import_4_4_float()
10 | {
11 | 	NumpyEigenConverter<Eigen::Matrix< float, 4, 4 > >::register_converter();
12 | }
13 | 
14 | 


--------------------------------------------------------------------------------
/Schweizer-Messer/numpy_eigen/src/autogen_module/import_4_4_int.cpp:
--------------------------------------------------------------------------------
 1 | // This file automatically generated by create_export_module.py
 2 | #define NO_IMPORT_ARRAY 
 3 | 
 4 | #include <NumpyEigenConverter.hpp>
 5 | 
 6 | #include <boost/cstdint.hpp>
 7 | 
 8 | 
 9 | void import_4_4_int()
10 | {
11 | 	NumpyEigenConverter<Eigen::Matrix< int, 4, 4 > >::register_converter();
12 | }
13 | 
14 | 


--------------------------------------------------------------------------------
/Schweizer-Messer/numpy_eigen/src/autogen_module/import_4_4_long.cpp:
--------------------------------------------------------------------------------
 1 | // This file automatically generated by create_export_module.py
 2 | #define NO_IMPORT_ARRAY 
 3 | 
 4 | #include <NumpyEigenConverter.hpp>
 5 | 
 6 | #include <boost/cstdint.hpp>
 7 | 
 8 | 
 9 | void import_4_4_long()
10 | {
11 | 	NumpyEigenConverter<Eigen::Matrix< boost::int64_t, 4, 4 > >::register_converter();
12 | }
13 | 
14 | 


--------------------------------------------------------------------------------
/Schweizer-Messer/numpy_eigen/src/autogen_module/import_4_5_double.cpp:
--------------------------------------------------------------------------------
 1 | // This file automatically generated by create_export_module.py
 2 | #define NO_IMPORT_ARRAY 
 3 | 
 4 | #include <NumpyEigenConverter.hpp>
 5 | 
 6 | #include <boost/cstdint.hpp>
 7 | 
 8 | 
 9 | void import_4_5_double()
10 | {
11 | 	NumpyEigenConverter<Eigen::Matrix< double, 4, 5 > >::register_converter();
12 | }
13 | 
14 | 


--------------------------------------------------------------------------------
/Schweizer-Messer/numpy_eigen/src/autogen_module/import_4_5_float.cpp:
--------------------------------------------------------------------------------
 1 | // This file automatically generated by create_export_module.py
 2 | #define NO_IMPORT_ARRAY 
 3 | 
 4 | #include <NumpyEigenConverter.hpp>
 5 | 
 6 | #include <boost/cstdint.hpp>
 7 | 
 8 | 
 9 | void import_4_5_float()
10 | {
11 | 	NumpyEigenConverter<Eigen::Matrix< float, 4, 5 > >::register_converter();
12 | }
13 | 
14 | 


--------------------------------------------------------------------------------
/Schweizer-Messer/numpy_eigen/src/autogen_module/import_4_5_int.cpp:
--------------------------------------------------------------------------------
 1 | // This file automatically generated by create_export_module.py
 2 | #define NO_IMPORT_ARRAY 
 3 | 
 4 | #include <NumpyEigenConverter.hpp>
 5 | 
 6 | #include <boost/cstdint.hpp>
 7 | 
 8 | 
 9 | void import_4_5_int()
10 | {
11 | 	NumpyEigenConverter<Eigen::Matrix< int, 4, 5 > >::register_converter();
12 | }
13 | 
14 | 


--------------------------------------------------------------------------------
/Schweizer-Messer/numpy_eigen/src/autogen_module/import_4_5_long.cpp:
--------------------------------------------------------------------------------
 1 | // This file automatically generated by create_export_module.py
 2 | #define NO_IMPORT_ARRAY 
 3 | 
 4 | #include <NumpyEigenConverter.hpp>
 5 | 
 6 | #include <boost/cstdint.hpp>
 7 | 
 8 | 
 9 | void import_4_5_long()
10 | {
11 | 	NumpyEigenConverter<Eigen::Matrix< boost::int64_t, 4, 5 > >::register_converter();
12 | }
13 | 
14 | 


--------------------------------------------------------------------------------
/Schweizer-Messer/numpy_eigen/src/autogen_module/import_4_6_double.cpp:
--------------------------------------------------------------------------------
 1 | // This file automatically generated by create_export_module.py
 2 | #define NO_IMPORT_ARRAY 
 3 | 
 4 | #include <NumpyEigenConverter.hpp>
 5 | 
 6 | #include <boost/cstdint.hpp>
 7 | 
 8 | 
 9 | void import_4_6_double()
10 | {
11 | 	NumpyEigenConverter<Eigen::Matrix< double, 4, 6 > >::register_converter();
12 | }
13 | 
14 | 


--------------------------------------------------------------------------------
/Schweizer-Messer/numpy_eigen/src/autogen_module/import_4_6_float.cpp:
--------------------------------------------------------------------------------
 1 | // This file automatically generated by create_export_module.py
 2 | #define NO_IMPORT_ARRAY 
 3 | 
 4 | #include <NumpyEigenConverter.hpp>
 5 | 
 6 | #include <boost/cstdint.hpp>
 7 | 
 8 | 
 9 | void import_4_6_float()
10 | {
11 | 	NumpyEigenConverter<Eigen::Matrix< float, 4, 6 > >::register_converter();
12 | }
13 | 
14 | 


--------------------------------------------------------------------------------
/Schweizer-Messer/numpy_eigen/src/autogen_module/import_4_6_int.cpp:
--------------------------------------------------------------------------------
 1 | // This file automatically generated by create_export_module.py
 2 | #define NO_IMPORT_ARRAY 
 3 | 
 4 | #include <NumpyEigenConverter.hpp>
 5 | 
 6 | #include <boost/cstdint.hpp>
 7 | 
 8 | 
 9 | void import_4_6_int()
10 | {
11 | 	NumpyEigenConverter<Eigen::Matrix< int, 4, 6 > >::register_converter();
12 | }
13 | 
14 | 


--------------------------------------------------------------------------------
/Schweizer-Messer/numpy_eigen/src/autogen_module/import_4_6_long.cpp:
--------------------------------------------------------------------------------
 1 | // This file automatically generated by create_export_module.py
 2 | #define NO_IMPORT_ARRAY 
 3 | 
 4 | #include <NumpyEigenConverter.hpp>
 5 | 
 6 | #include <boost/cstdint.hpp>
 7 | 
 8 | 
 9 | void import_4_6_long()
10 | {
11 | 	NumpyEigenConverter<Eigen::Matrix< boost::int64_t, 4, 6 > >::register_converter();
12 | }
13 | 
14 | 


--------------------------------------------------------------------------------
/Schweizer-Messer/numpy_eigen/src/autogen_module/import_4_D_int.cpp:
--------------------------------------------------------------------------------
 1 | // This file automatically generated by create_export_module.py
 2 | #define NO_IMPORT_ARRAY 
 3 | 
 4 | #include <NumpyEigenConverter.hpp>
 5 | 
 6 | #include <boost/cstdint.hpp>
 7 | 
 8 | 
 9 | void import_4_D_int()
10 | {
11 | 	NumpyEigenConverter<Eigen::Matrix< int, 4, Eigen::Dynamic > >::register_converter();
12 | }
13 | 
14 | 


--------------------------------------------------------------------------------
/Schweizer-Messer/numpy_eigen/src/autogen_module/import_5_1_double.cpp:
--------------------------------------------------------------------------------
 1 | // This file automatically generated by create_export_module.py
 2 | #define NO_IMPORT_ARRAY 
 3 | 
 4 | #include <NumpyEigenConverter.hpp>
 5 | 
 6 | #include <boost/cstdint.hpp>
 7 | 
 8 | 
 9 | void import_5_1_double()
10 | {
11 | 	NumpyEigenConverter<Eigen::Matrix< double, 5, 1 > >::register_converter();
12 | }
13 | 
14 | 


--------------------------------------------------------------------------------
/Schweizer-Messer/numpy_eigen/src/autogen_module/import_5_1_float.cpp:
--------------------------------------------------------------------------------
 1 | // This file automatically generated by create_export_module.py
 2 | #define NO_IMPORT_ARRAY 
 3 | 
 4 | #include <NumpyEigenConverter.hpp>
 5 | 
 6 | #include <boost/cstdint.hpp>
 7 | 
 8 | 
 9 | void import_5_1_float()
10 | {
11 | 	NumpyEigenConverter<Eigen::Matrix< float, 5, 1 > >::register_converter();
12 | }
13 | 
14 | 


--------------------------------------------------------------------------------
/Schweizer-Messer/numpy_eigen/src/autogen_module/import_5_1_int.cpp:
--------------------------------------------------------------------------------
 1 | // This file automatically generated by create_export_module.py
 2 | #define NO_IMPORT_ARRAY 
 3 | 
 4 | #include <NumpyEigenConverter.hpp>
 5 | 
 6 | #include <boost/cstdint.hpp>
 7 | 
 8 | 
 9 | void import_5_1_int()
10 | {
11 | 	NumpyEigenConverter<Eigen::Matrix< int, 5, 1 > >::register_converter();
12 | }
13 | 
14 | 


--------------------------------------------------------------------------------
/Schweizer-Messer/numpy_eigen/src/autogen_module/import_5_1_long.cpp:
--------------------------------------------------------------------------------
 1 | // This file automatically generated by create_export_module.py
 2 | #define NO_IMPORT_ARRAY 
 3 | 
 4 | #include <NumpyEigenConverter.hpp>
 5 | 
 6 | #include <boost/cstdint.hpp>
 7 | 
 8 | 
 9 | void import_5_1_long()
10 | {
11 | 	NumpyEigenConverter<Eigen::Matrix< boost::int64_t, 5, 1 > >::register_converter();
12 | }
13 | 
14 | 


--------------------------------------------------------------------------------
/Schweizer-Messer/numpy_eigen/src/autogen_module/import_5_2_double.cpp:
--------------------------------------------------------------------------------
 1 | // This file automatically generated by create_export_module.py
 2 | #define NO_IMPORT_ARRAY 
 3 | 
 4 | #include <NumpyEigenConverter.hpp>
 5 | 
 6 | #include <boost/cstdint.hpp>
 7 | 
 8 | 
 9 | void import_5_2_double()
10 | {
11 | 	NumpyEigenConverter<Eigen::Matrix< double, 5, 2 > >::register_converter();
12 | }
13 | 
14 | 


--------------------------------------------------------------------------------
/Schweizer-Messer/numpy_eigen/src/autogen_module/import_5_2_float.cpp:
--------------------------------------------------------------------------------
 1 | // This file automatically generated by create_export_module.py
 2 | #define NO_IMPORT_ARRAY 
 3 | 
 4 | #include <NumpyEigenConverter.hpp>
 5 | 
 6 | #include <boost/cstdint.hpp>
 7 | 
 8 | 
 9 | void import_5_2_float()
10 | {
11 | 	NumpyEigenConverter<Eigen::Matrix< float, 5, 2 > >::register_converter();
12 | }
13 | 
14 | 


--------------------------------------------------------------------------------
/Schweizer-Messer/numpy_eigen/src/autogen_module/import_5_2_int.cpp:
--------------------------------------------------------------------------------
 1 | // This file automatically generated by create_export_module.py
 2 | #define NO_IMPORT_ARRAY 
 3 | 
 4 | #include <NumpyEigenConverter.hpp>
 5 | 
 6 | #include <boost/cstdint.hpp>
 7 | 
 8 | 
 9 | void import_5_2_int()
10 | {
11 | 	NumpyEigenConverter<Eigen::Matrix< int, 5, 2 > >::register_converter();
12 | }
13 | 
14 | 


--------------------------------------------------------------------------------
/Schweizer-Messer/numpy_eigen/src/autogen_module/import_5_2_long.cpp:
--------------------------------------------------------------------------------
 1 | // This file automatically generated by create_export_module.py
 2 | #define NO_IMPORT_ARRAY 
 3 | 
 4 | #include <NumpyEigenConverter.hpp>
 5 | 
 6 | #include <boost/cstdint.hpp>
 7 | 
 8 | 
 9 | void import_5_2_long()
10 | {
11 | 	NumpyEigenConverter<Eigen::Matrix< boost::int64_t, 5, 2 > >::register_converter();
12 | }
13 | 
14 | 


--------------------------------------------------------------------------------
/Schweizer-Messer/numpy_eigen/src/autogen_module/import_5_3_double.cpp:
--------------------------------------------------------------------------------
 1 | // This file automatically generated by create_export_module.py
 2 | #define NO_IMPORT_ARRAY 
 3 | 
 4 | #include <NumpyEigenConverter.hpp>
 5 | 
 6 | #include <boost/cstdint.hpp>
 7 | 
 8 | 
 9 | void import_5_3_double()
10 | {
11 | 	NumpyEigenConverter<Eigen::Matrix< double, 5, 3 > >::register_converter();
12 | }
13 | 
14 | 


--------------------------------------------------------------------------------
/Schweizer-Messer/numpy_eigen/src/autogen_module/import_5_3_float.cpp:
--------------------------------------------------------------------------------
 1 | // This file automatically generated by create_export_module.py
 2 | #define NO_IMPORT_ARRAY 
 3 | 
 4 | #include <NumpyEigenConverter.hpp>
 5 | 
 6 | #include <boost/cstdint.hpp>
 7 | 
 8 | 
 9 | void import_5_3_float()
10 | {
11 | 	NumpyEigenConverter<Eigen::Matrix< float, 5, 3 > >::register_converter();
12 | }
13 | 
14 | 


--------------------------------------------------------------------------------
/Schweizer-Messer/numpy_eigen/src/autogen_module/import_5_3_int.cpp:
--------------------------------------------------------------------------------
 1 | // This file automatically generated by create_export_module.py
 2 | #define NO_IMPORT_ARRAY 
 3 | 
 4 | #include <NumpyEigenConverter.hpp>
 5 | 
 6 | #include <boost/cstdint.hpp>
 7 | 
 8 | 
 9 | void import_5_3_int()
10 | {
11 | 	NumpyEigenConverter<Eigen::Matrix< int, 5, 3 > >::register_converter();
12 | }
13 | 
14 | 


--------------------------------------------------------------------------------
/Schweizer-Messer/numpy_eigen/src/autogen_module/import_5_3_long.cpp:
--------------------------------------------------------------------------------
 1 | // This file automatically generated by create_export_module.py
 2 | #define NO_IMPORT_ARRAY 
 3 | 
 4 | #include <NumpyEigenConverter.hpp>
 5 | 
 6 | #include <boost/cstdint.hpp>
 7 | 
 8 | 
 9 | void import_5_3_long()
10 | {
11 | 	NumpyEigenConverter<Eigen::Matrix< boost::int64_t, 5, 3 > >::register_converter();
12 | }
13 | 
14 | 


--------------------------------------------------------------------------------
/Schweizer-Messer/numpy_eigen/src/autogen_module/import_5_4_double.cpp:
--------------------------------------------------------------------------------
 1 | // This file automatically generated by create_export_module.py
 2 | #define NO_IMPORT_ARRAY 
 3 | 
 4 | #include <NumpyEigenConverter.hpp>
 5 | 
 6 | #include <boost/cstdint.hpp>
 7 | 
 8 | 
 9 | void import_5_4_double()
10 | {
11 | 	NumpyEigenConverter<Eigen::Matrix< double, 5, 4 > >::register_converter();
12 | }
13 | 
14 | 


--------------------------------------------------------------------------------
/Schweizer-Messer/numpy_eigen/src/autogen_module/import_5_4_float.cpp:
--------------------------------------------------------------------------------
 1 | // This file automatically generated by create_export_module.py
 2 | #define NO_IMPORT_ARRAY 
 3 | 
 4 | #include <NumpyEigenConverter.hpp>
 5 | 
 6 | #include <boost/cstdint.hpp>
 7 | 
 8 | 
 9 | void import_5_4_float()
10 | {
11 | 	NumpyEigenConverter<Eigen::Matrix< float, 5, 4 > >::register_converter();
12 | }
13 | 
14 | 


--------------------------------------------------------------------------------
/Schweizer-Messer/numpy_eigen/src/autogen_module/import_5_4_int.cpp:
--------------------------------------------------------------------------------
 1 | // This file automatically generated by create_export_module.py
 2 | #define NO_IMPORT_ARRAY 
 3 | 
 4 | #include <NumpyEigenConverter.hpp>
 5 | 
 6 | #include <boost/cstdint.hpp>
 7 | 
 8 | 
 9 | void import_5_4_int()
10 | {
11 | 	NumpyEigenConverter<Eigen::Matrix< int, 5, 4 > >::register_converter();
12 | }
13 | 
14 | 


--------------------------------------------------------------------------------
/Schweizer-Messer/numpy_eigen/src/autogen_module/import_5_4_long.cpp:
--------------------------------------------------------------------------------
 1 | // This file automatically generated by create_export_module.py
 2 | #define NO_IMPORT_ARRAY 
 3 | 
 4 | #include <NumpyEigenConverter.hpp>
 5 | 
 6 | #include <boost/cstdint.hpp>
 7 | 
 8 | 
 9 | void import_5_4_long()
10 | {
11 | 	NumpyEigenConverter<Eigen::Matrix< boost::int64_t, 5, 4 > >::register_converter();
12 | }
13 | 
14 | 


--------------------------------------------------------------------------------
/Schweizer-Messer/numpy_eigen/src/autogen_module/import_5_5_double.cpp:
--------------------------------------------------------------------------------
 1 | // This file automatically generated by create_export_module.py
 2 | #define NO_IMPORT_ARRAY 
 3 | 
 4 | #include <NumpyEigenConverter.hpp>
 5 | 
 6 | #include <boost/cstdint.hpp>
 7 | 
 8 | 
 9 | void import_5_5_double()
10 | {
11 | 	NumpyEigenConverter<Eigen::Matrix< double, 5, 5 > >::register_converter();
12 | }
13 | 
14 | 


--------------------------------------------------------------------------------
/Schweizer-Messer/numpy_eigen/src/autogen_module/import_5_5_float.cpp:
--------------------------------------------------------------------------------
 1 | // This file automatically generated by create_export_module.py
 2 | #define NO_IMPORT_ARRAY 
 3 | 
 4 | #include <NumpyEigenConverter.hpp>
 5 | 
 6 | #include <boost/cstdint.hpp>
 7 | 
 8 | 
 9 | void import_5_5_float()
10 | {
11 | 	NumpyEigenConverter<Eigen::Matrix< float, 5, 5 > >::register_converter();
12 | }
13 | 
14 | 


--------------------------------------------------------------------------------
/Schweizer-Messer/numpy_eigen/src/autogen_module/import_5_5_int.cpp:
--------------------------------------------------------------------------------
 1 | // This file automatically generated by create_export_module.py
 2 | #define NO_IMPORT_ARRAY 
 3 | 
 4 | #include <NumpyEigenConverter.hpp>
 5 | 
 6 | #include <boost/cstdint.hpp>
 7 | 
 8 | 
 9 | void import_5_5_int()
10 | {
11 | 	NumpyEigenConverter<Eigen::Matrix< int, 5, 5 > >::register_converter();
12 | }
13 | 
14 | 


--------------------------------------------------------------------------------
/Schweizer-Messer/numpy_eigen/src/autogen_module/import_5_5_long.cpp:
--------------------------------------------------------------------------------
 1 | // This file automatically generated by create_export_module.py
 2 | #define NO_IMPORT_ARRAY 
 3 | 
 4 | #include <NumpyEigenConverter.hpp>
 5 | 
 6 | #include <boost/cstdint.hpp>
 7 | 
 8 | 
 9 | void import_5_5_long()
10 | {
11 | 	NumpyEigenConverter<Eigen::Matrix< boost::int64_t, 5, 5 > >::register_converter();
12 | }
13 | 
14 | 


--------------------------------------------------------------------------------
/Schweizer-Messer/numpy_eigen/src/autogen_module/import_5_6_double.cpp:
--------------------------------------------------------------------------------
 1 | // This file automatically generated by create_export_module.py
 2 | #define NO_IMPORT_ARRAY 
 3 | 
 4 | #include <NumpyEigenConverter.hpp>
 5 | 
 6 | #include <boost/cstdint.hpp>
 7 | 
 8 | 
 9 | void import_5_6_double()
10 | {
11 | 	NumpyEigenConverter<Eigen::Matrix< double, 5, 6 > >::register_converter();
12 | }
13 | 
14 | 


--------------------------------------------------------------------------------
/Schweizer-Messer/numpy_eigen/src/autogen_module/import_5_6_float.cpp:
--------------------------------------------------------------------------------
 1 | // This file automatically generated by create_export_module.py
 2 | #define NO_IMPORT_ARRAY 
 3 | 
 4 | #include <NumpyEigenConverter.hpp>
 5 | 
 6 | #include <boost/cstdint.hpp>
 7 | 
 8 | 
 9 | void import_5_6_float()
10 | {
11 | 	NumpyEigenConverter<Eigen::Matrix< float, 5, 6 > >::register_converter();
12 | }
13 | 
14 | 


--------------------------------------------------------------------------------
/Schweizer-Messer/numpy_eigen/src/autogen_module/import_5_6_int.cpp:
--------------------------------------------------------------------------------
 1 | // This file automatically generated by create_export_module.py
 2 | #define NO_IMPORT_ARRAY 
 3 | 
 4 | #include <NumpyEigenConverter.hpp>
 5 | 
 6 | #include <boost/cstdint.hpp>
 7 | 
 8 | 
 9 | void import_5_6_int()
10 | {
11 | 	NumpyEigenConverter<Eigen::Matrix< int, 5, 6 > >::register_converter();
12 | }
13 | 
14 | 


--------------------------------------------------------------------------------
/Schweizer-Messer/numpy_eigen/src/autogen_module/import_5_6_long.cpp:
--------------------------------------------------------------------------------
 1 | // This file automatically generated by create_export_module.py
 2 | #define NO_IMPORT_ARRAY 
 3 | 
 4 | #include <NumpyEigenConverter.hpp>
 5 | 
 6 | #include <boost/cstdint.hpp>
 7 | 
 8 | 
 9 | void import_5_6_long()
10 | {
11 | 	NumpyEigenConverter<Eigen::Matrix< boost::int64_t, 5, 6 > >::register_converter();
12 | }
13 | 
14 | 


--------------------------------------------------------------------------------
/Schweizer-Messer/numpy_eigen/src/autogen_module/import_5_D_int.cpp:
--------------------------------------------------------------------------------
 1 | // This file automatically generated by create_export_module.py
 2 | #define NO_IMPORT_ARRAY 
 3 | 
 4 | #include <NumpyEigenConverter.hpp>
 5 | 
 6 | #include <boost/cstdint.hpp>
 7 | 
 8 | 
 9 | void import_5_D_int()
10 | {
11 | 	NumpyEigenConverter<Eigen::Matrix< int, 5, Eigen::Dynamic > >::register_converter();
12 | }
13 | 
14 | 


--------------------------------------------------------------------------------
/Schweizer-Messer/numpy_eigen/src/autogen_module/import_6_1_double.cpp:
--------------------------------------------------------------------------------
 1 | // This file automatically generated by create_export_module.py
 2 | #define NO_IMPORT_ARRAY 
 3 | 
 4 | #include <NumpyEigenConverter.hpp>
 5 | 
 6 | #include <boost/cstdint.hpp>
 7 | 
 8 | 
 9 | void import_6_1_double()
10 | {
11 | 	NumpyEigenConverter<Eigen::Matrix< double, 6, 1 > >::register_converter();
12 | }
13 | 
14 | 


--------------------------------------------------------------------------------
/Schweizer-Messer/numpy_eigen/src/autogen_module/import_6_1_float.cpp:
--------------------------------------------------------------------------------
 1 | // This file automatically generated by create_export_module.py
 2 | #define NO_IMPORT_ARRAY 
 3 | 
 4 | #include <NumpyEigenConverter.hpp>
 5 | 
 6 | #include <boost/cstdint.hpp>
 7 | 
 8 | 
 9 | void import_6_1_float()
10 | {
11 | 	NumpyEigenConverter<Eigen::Matrix< float, 6, 1 > >::register_converter();
12 | }
13 | 
14 | 


--------------------------------------------------------------------------------
/Schweizer-Messer/numpy_eigen/src/autogen_module/import_6_1_int.cpp:
--------------------------------------------------------------------------------
 1 | // This file automatically generated by create_export_module.py
 2 | #define NO_IMPORT_ARRAY 
 3 | 
 4 | #include <NumpyEigenConverter.hpp>
 5 | 
 6 | #include <boost/cstdint.hpp>
 7 | 
 8 | 
 9 | void import_6_1_int()
10 | {
11 | 	NumpyEigenConverter<Eigen::Matrix< int, 6, 1 > >::register_converter();
12 | }
13 | 
14 | 


--------------------------------------------------------------------------------
/Schweizer-Messer/numpy_eigen/src/autogen_module/import_6_1_long.cpp:
--------------------------------------------------------------------------------
 1 | // This file automatically generated by create_export_module.py
 2 | #define NO_IMPORT_ARRAY 
 3 | 
 4 | #include <NumpyEigenConverter.hpp>
 5 | 
 6 | #include <boost/cstdint.hpp>
 7 | 
 8 | 
 9 | void import_6_1_long()
10 | {
11 | 	NumpyEigenConverter<Eigen::Matrix< boost::int64_t, 6, 1 > >::register_converter();
12 | }
13 | 
14 | 


--------------------------------------------------------------------------------
/Schweizer-Messer/numpy_eigen/src/autogen_module/import_6_2_double.cpp:
--------------------------------------------------------------------------------
 1 | // This file automatically generated by create_export_module.py
 2 | #define NO_IMPORT_ARRAY 
 3 | 
 4 | #include <NumpyEigenConverter.hpp>
 5 | 
 6 | #include <boost/cstdint.hpp>
 7 | 
 8 | 
 9 | void import_6_2_double()
10 | {
11 | 	NumpyEigenConverter<Eigen::Matrix< double, 6, 2 > >::register_converter();
12 | }
13 | 
14 | 


--------------------------------------------------------------------------------
/Schweizer-Messer/numpy_eigen/src/autogen_module/import_6_2_float.cpp:
--------------------------------------------------------------------------------
 1 | // This file automatically generated by create_export_module.py
 2 | #define NO_IMPORT_ARRAY 
 3 | 
 4 | #include <NumpyEigenConverter.hpp>
 5 | 
 6 | #include <boost/cstdint.hpp>
 7 | 
 8 | 
 9 | void import_6_2_float()
10 | {
11 | 	NumpyEigenConverter<Eigen::Matrix< float, 6, 2 > >::register_converter();
12 | }
13 | 
14 | 


--------------------------------------------------------------------------------
/Schweizer-Messer/numpy_eigen/src/autogen_module/import_6_2_int.cpp:
--------------------------------------------------------------------------------
 1 | // This file automatically generated by create_export_module.py
 2 | #define NO_IMPORT_ARRAY 
 3 | 
 4 | #include <NumpyEigenConverter.hpp>
 5 | 
 6 | #include <boost/cstdint.hpp>
 7 | 
 8 | 
 9 | void import_6_2_int()
10 | {
11 | 	NumpyEigenConverter<Eigen::Matrix< int, 6, 2 > >::register_converter();
12 | }
13 | 
14 | 


--------------------------------------------------------------------------------
/Schweizer-Messer/numpy_eigen/src/autogen_module/import_6_2_long.cpp:
--------------------------------------------------------------------------------
 1 | // This file automatically generated by create_export_module.py
 2 | #define NO_IMPORT_ARRAY 
 3 | 
 4 | #include <NumpyEigenConverter.hpp>
 5 | 
 6 | #include <boost/cstdint.hpp>
 7 | 
 8 | 
 9 | void import_6_2_long()
10 | {
11 | 	NumpyEigenConverter<Eigen::Matrix< boost::int64_t, 6, 2 > >::register_converter();
12 | }
13 | 
14 | 


--------------------------------------------------------------------------------
/Schweizer-Messer/numpy_eigen/src/autogen_module/import_6_3_double.cpp:
--------------------------------------------------------------------------------
 1 | // This file automatically generated by create_export_module.py
 2 | #define NO_IMPORT_ARRAY 
 3 | 
 4 | #include <NumpyEigenConverter.hpp>
 5 | 
 6 | #include <boost/cstdint.hpp>
 7 | 
 8 | 
 9 | void import_6_3_double()
10 | {
11 | 	NumpyEigenConverter<Eigen::Matrix< double, 6, 3 > >::register_converter();
12 | }
13 | 
14 | 


--------------------------------------------------------------------------------
/Schweizer-Messer/numpy_eigen/src/autogen_module/import_6_3_float.cpp:
--------------------------------------------------------------------------------
 1 | // This file automatically generated by create_export_module.py
 2 | #define NO_IMPORT_ARRAY 
 3 | 
 4 | #include <NumpyEigenConverter.hpp>
 5 | 
 6 | #include <boost/cstdint.hpp>
 7 | 
 8 | 
 9 | void import_6_3_float()
10 | {
11 | 	NumpyEigenConverter<Eigen::Matrix< float, 6, 3 > >::register_converter();
12 | }
13 | 
14 | 


--------------------------------------------------------------------------------
/Schweizer-Messer/numpy_eigen/src/autogen_module/import_6_3_int.cpp:
--------------------------------------------------------------------------------
 1 | // This file automatically generated by create_export_module.py
 2 | #define NO_IMPORT_ARRAY 
 3 | 
 4 | #include <NumpyEigenConverter.hpp>
 5 | 
 6 | #include <boost/cstdint.hpp>
 7 | 
 8 | 
 9 | void import_6_3_int()
10 | {
11 | 	NumpyEigenConverter<Eigen::Matrix< int, 6, 3 > >::register_converter();
12 | }
13 | 
14 | 


--------------------------------------------------------------------------------
/Schweizer-Messer/numpy_eigen/src/autogen_module/import_6_3_long.cpp:
--------------------------------------------------------------------------------
 1 | // This file automatically generated by create_export_module.py
 2 | #define NO_IMPORT_ARRAY 
 3 | 
 4 | #include <NumpyEigenConverter.hpp>
 5 | 
 6 | #include <boost/cstdint.hpp>
 7 | 
 8 | 
 9 | void import_6_3_long()
10 | {
11 | 	NumpyEigenConverter<Eigen::Matrix< boost::int64_t, 6, 3 > >::register_converter();
12 | }
13 | 
14 | 


--------------------------------------------------------------------------------
/Schweizer-Messer/numpy_eigen/src/autogen_module/import_6_4_double.cpp:
--------------------------------------------------------------------------------
 1 | // This file automatically generated by create_export_module.py
 2 | #define NO_IMPORT_ARRAY 
 3 | 
 4 | #include <NumpyEigenConverter.hpp>
 5 | 
 6 | #include <boost/cstdint.hpp>
 7 | 
 8 | 
 9 | void import_6_4_double()
10 | {
11 | 	NumpyEigenConverter<Eigen::Matrix< double, 6, 4 > >::register_converter();
12 | }
13 | 
14 | 


--------------------------------------------------------------------------------
/Schweizer-Messer/numpy_eigen/src/autogen_module/import_6_4_float.cpp:
--------------------------------------------------------------------------------
 1 | // This file automatically generated by create_export_module.py
 2 | #define NO_IMPORT_ARRAY 
 3 | 
 4 | #include <NumpyEigenConverter.hpp>
 5 | 
 6 | #include <boost/cstdint.hpp>
 7 | 
 8 | 
 9 | void import_6_4_float()
10 | {
11 | 	NumpyEigenConverter<Eigen::Matrix< float, 6, 4 > >::register_converter();
12 | }
13 | 
14 | 


--------------------------------------------------------------------------------
/Schweizer-Messer/numpy_eigen/src/autogen_module/import_6_4_int.cpp:
--------------------------------------------------------------------------------
 1 | // This file automatically generated by create_export_module.py
 2 | #define NO_IMPORT_ARRAY 
 3 | 
 4 | #include <NumpyEigenConverter.hpp>
 5 | 
 6 | #include <boost/cstdint.hpp>
 7 | 
 8 | 
 9 | void import_6_4_int()
10 | {
11 | 	NumpyEigenConverter<Eigen::Matrix< int, 6, 4 > >::register_converter();
12 | }
13 | 
14 | 


--------------------------------------------------------------------------------
/Schweizer-Messer/numpy_eigen/src/autogen_module/import_6_4_long.cpp:
--------------------------------------------------------------------------------
 1 | // This file automatically generated by create_export_module.py
 2 | #define NO_IMPORT_ARRAY 
 3 | 
 4 | #include <NumpyEigenConverter.hpp>
 5 | 
 6 | #include <boost/cstdint.hpp>
 7 | 
 8 | 
 9 | void import_6_4_long()
10 | {
11 | 	NumpyEigenConverter<Eigen::Matrix< boost::int64_t, 6, 4 > >::register_converter();
12 | }
13 | 
14 | 


--------------------------------------------------------------------------------
/Schweizer-Messer/numpy_eigen/src/autogen_module/import_6_5_double.cpp:
--------------------------------------------------------------------------------
 1 | // This file automatically generated by create_export_module.py
 2 | #define NO_IMPORT_ARRAY 
 3 | 
 4 | #include <NumpyEigenConverter.hpp>
 5 | 
 6 | #include <boost/cstdint.hpp>
 7 | 
 8 | 
 9 | void import_6_5_double()
10 | {
11 | 	NumpyEigenConverter<Eigen::Matrix< double, 6, 5 > >::register_converter();
12 | }
13 | 
14 | 


--------------------------------------------------------------------------------
/Schweizer-Messer/numpy_eigen/src/autogen_module/import_6_5_float.cpp:
--------------------------------------------------------------------------------
 1 | // This file automatically generated by create_export_module.py
 2 | #define NO_IMPORT_ARRAY 
 3 | 
 4 | #include <NumpyEigenConverter.hpp>
 5 | 
 6 | #include <boost/cstdint.hpp>
 7 | 
 8 | 
 9 | void import_6_5_float()
10 | {
11 | 	NumpyEigenConverter<Eigen::Matrix< float, 6, 5 > >::register_converter();
12 | }
13 | 
14 | 


--------------------------------------------------------------------------------
/Schweizer-Messer/numpy_eigen/src/autogen_module/import_6_5_int.cpp:
--------------------------------------------------------------------------------
 1 | // This file automatically generated by create_export_module.py
 2 | #define NO_IMPORT_ARRAY 
 3 | 
 4 | #include <NumpyEigenConverter.hpp>
 5 | 
 6 | #include <boost/cstdint.hpp>
 7 | 
 8 | 
 9 | void import_6_5_int()
10 | {
11 | 	NumpyEigenConverter<Eigen::Matrix< int, 6, 5 > >::register_converter();
12 | }
13 | 
14 | 


--------------------------------------------------------------------------------
/Schweizer-Messer/numpy_eigen/src/autogen_module/import_6_5_long.cpp:
--------------------------------------------------------------------------------
 1 | // This file automatically generated by create_export_module.py
 2 | #define NO_IMPORT_ARRAY 
 3 | 
 4 | #include <NumpyEigenConverter.hpp>
 5 | 
 6 | #include <boost/cstdint.hpp>
 7 | 
 8 | 
 9 | void import_6_5_long()
10 | {
11 | 	NumpyEigenConverter<Eigen::Matrix< boost::int64_t, 6, 5 > >::register_converter();
12 | }
13 | 
14 | 


--------------------------------------------------------------------------------
/Schweizer-Messer/numpy_eigen/src/autogen_module/import_6_6_double.cpp:
--------------------------------------------------------------------------------
 1 | // This file automatically generated by create_export_module.py
 2 | #define NO_IMPORT_ARRAY 
 3 | 
 4 | #include <NumpyEigenConverter.hpp>
 5 | 
 6 | #include <boost/cstdint.hpp>
 7 | 
 8 | 
 9 | void import_6_6_double()
10 | {
11 | 	NumpyEigenConverter<Eigen::Matrix< double, 6, 6 > >::register_converter();
12 | }
13 | 
14 | 


--------------------------------------------------------------------------------
/Schweizer-Messer/numpy_eigen/src/autogen_module/import_6_6_float.cpp:
--------------------------------------------------------------------------------
 1 | // This file automatically generated by create_export_module.py
 2 | #define NO_IMPORT_ARRAY 
 3 | 
 4 | #include <NumpyEigenConverter.hpp>
 5 | 
 6 | #include <boost/cstdint.hpp>
 7 | 
 8 | 
 9 | void import_6_6_float()
10 | {
11 | 	NumpyEigenConverter<Eigen::Matrix< float, 6, 6 > >::register_converter();
12 | }
13 | 
14 | 


--------------------------------------------------------------------------------
/Schweizer-Messer/numpy_eigen/src/autogen_module/import_6_6_int.cpp:
--------------------------------------------------------------------------------
 1 | // This file automatically generated by create_export_module.py
 2 | #define NO_IMPORT_ARRAY 
 3 | 
 4 | #include <NumpyEigenConverter.hpp>
 5 | 
 6 | #include <boost/cstdint.hpp>
 7 | 
 8 | 
 9 | void import_6_6_int()
10 | {
11 | 	NumpyEigenConverter<Eigen::Matrix< int, 6, 6 > >::register_converter();
12 | }
13 | 
14 | 


--------------------------------------------------------------------------------
/Schweizer-Messer/numpy_eigen/src/autogen_module/import_6_6_long.cpp:
--------------------------------------------------------------------------------
 1 | // This file automatically generated by create_export_module.py
 2 | #define NO_IMPORT_ARRAY 
 3 | 
 4 | #include <NumpyEigenConverter.hpp>
 5 | 
 6 | #include <boost/cstdint.hpp>
 7 | 
 8 | 
 9 | void import_6_6_long()
10 | {
11 | 	NumpyEigenConverter<Eigen::Matrix< boost::int64_t, 6, 6 > >::register_converter();
12 | }
13 | 
14 | 


--------------------------------------------------------------------------------
/Schweizer-Messer/numpy_eigen/src/autogen_module/import_6_D_int.cpp:
--------------------------------------------------------------------------------
 1 | // This file automatically generated by create_export_module.py
 2 | #define NO_IMPORT_ARRAY 
 3 | 
 4 | #include <NumpyEigenConverter.hpp>
 5 | 
 6 | #include <boost/cstdint.hpp>
 7 | 
 8 | 
 9 | void import_6_D_int()
10 | {
11 | 	NumpyEigenConverter<Eigen::Matrix< int, 6, Eigen::Dynamic > >::register_converter();
12 | }
13 | 
14 | 


--------------------------------------------------------------------------------
/Schweizer-Messer/numpy_eigen/src/autogen_module/import_D_1_int.cpp:
--------------------------------------------------------------------------------
 1 | // This file automatically generated by create_export_module.py
 2 | #define NO_IMPORT_ARRAY 
 3 | 
 4 | #include <NumpyEigenConverter.hpp>
 5 | 
 6 | #include <boost/cstdint.hpp>
 7 | 
 8 | 
 9 | void import_D_1_int()
10 | {
11 | 	NumpyEigenConverter<Eigen::Matrix< int, Eigen::Dynamic, 1 > >::register_converter();
12 | }
13 | 
14 | 


--------------------------------------------------------------------------------
/Schweizer-Messer/numpy_eigen/src/autogen_module/import_D_2_int.cpp:
--------------------------------------------------------------------------------
 1 | // This file automatically generated by create_export_module.py
 2 | #define NO_IMPORT_ARRAY 
 3 | 
 4 | #include <NumpyEigenConverter.hpp>
 5 | 
 6 | #include <boost/cstdint.hpp>
 7 | 
 8 | 
 9 | void import_D_2_int()
10 | {
11 | 	NumpyEigenConverter<Eigen::Matrix< int, Eigen::Dynamic, 2 > >::register_converter();
12 | }
13 | 
14 | 


--------------------------------------------------------------------------------
/Schweizer-Messer/numpy_eigen/src/autogen_module/import_D_3_int.cpp:
--------------------------------------------------------------------------------
 1 | // This file automatically generated by create_export_module.py
 2 | #define NO_IMPORT_ARRAY 
 3 | 
 4 | #include <NumpyEigenConverter.hpp>
 5 | 
 6 | #include <boost/cstdint.hpp>
 7 | 
 8 | 
 9 | void import_D_3_int()
10 | {
11 | 	NumpyEigenConverter<Eigen::Matrix< int, Eigen::Dynamic, 3 > >::register_converter();
12 | }
13 | 
14 | 


--------------------------------------------------------------------------------
/Schweizer-Messer/numpy_eigen/src/autogen_module/import_D_4_int.cpp:
--------------------------------------------------------------------------------
 1 | // This file automatically generated by create_export_module.py
 2 | #define NO_IMPORT_ARRAY 
 3 | 
 4 | #include <NumpyEigenConverter.hpp>
 5 | 
 6 | #include <boost/cstdint.hpp>
 7 | 
 8 | 
 9 | void import_D_4_int()
10 | {
11 | 	NumpyEigenConverter<Eigen::Matrix< int, Eigen::Dynamic, 4 > >::register_converter();
12 | }
13 | 
14 | 


--------------------------------------------------------------------------------
/Schweizer-Messer/numpy_eigen/src/autogen_module/import_D_5_int.cpp:
--------------------------------------------------------------------------------
 1 | // This file automatically generated by create_export_module.py
 2 | #define NO_IMPORT_ARRAY 
 3 | 
 4 | #include <NumpyEigenConverter.hpp>
 5 | 
 6 | #include <boost/cstdint.hpp>
 7 | 
 8 | 
 9 | void import_D_5_int()
10 | {
11 | 	NumpyEigenConverter<Eigen::Matrix< int, Eigen::Dynamic, 5 > >::register_converter();
12 | }
13 | 
14 | 


--------------------------------------------------------------------------------
/Schweizer-Messer/numpy_eigen/src/autogen_module/import_D_6_int.cpp:
--------------------------------------------------------------------------------
 1 | // This file automatically generated by create_export_module.py
 2 | #define NO_IMPORT_ARRAY 
 3 | 
 4 | #include <NumpyEigenConverter.hpp>
 5 | 
 6 | #include <boost/cstdint.hpp>
 7 | 
 8 | 
 9 | void import_D_6_int()
10 | {
11 | 	NumpyEigenConverter<Eigen::Matrix< int, Eigen::Dynamic, 6 > >::register_converter();
12 | }
13 | 
14 | 


--------------------------------------------------------------------------------
/Schweizer-Messer/numpy_eigen/src/autogen_test_module/test_1_1_double.cpp:
--------------------------------------------------------------------------------
 1 | #include <Eigen/Core>
 2 | 
 3 | #include <numpy_eigen/boost_python_headers.hpp>
 4 | Eigen::Matrix<double, 1, 1> test_double_1_1(const Eigen::Matrix<double, 1, 1> & M)
 5 | {
 6 | 	return M;
 7 | }
 8 | void export_double_1_1()
 9 | {
10 | 	boost::python::def("test_double_1_1",test_double_1_1);
11 | }
12 | 
13 | 


--------------------------------------------------------------------------------
/Schweizer-Messer/numpy_eigen/src/autogen_test_module/test_1_1_float.cpp:
--------------------------------------------------------------------------------
 1 | #include <Eigen/Core>
 2 | 
 3 | #include <numpy_eigen/boost_python_headers.hpp>
 4 | Eigen::Matrix<float, 1, 1> test_float_1_1(const Eigen::Matrix<float, 1, 1> & M)
 5 | {
 6 | 	return M;
 7 | }
 8 | void export_float_1_1()
 9 | {
10 | 	boost::python::def("test_float_1_1",test_float_1_1);
11 | }
12 | 
13 | 


--------------------------------------------------------------------------------
/Schweizer-Messer/numpy_eigen/src/autogen_test_module/test_1_1_int.cpp:
--------------------------------------------------------------------------------
 1 | #include <Eigen/Core>
 2 | 
 3 | #include <numpy_eigen/boost_python_headers.hpp>
 4 | Eigen::Matrix<int, 1, 1> test_int_1_1(const Eigen::Matrix<int, 1, 1> & M)
 5 | {
 6 | 	return M;
 7 | }
 8 | void export_int_1_1()
 9 | {
10 | 	boost::python::def("test_int_1_1",test_int_1_1);
11 | }
12 | 
13 | 


--------------------------------------------------------------------------------
/Schweizer-Messer/numpy_eigen/src/autogen_test_module/test_1_1_long.cpp:
--------------------------------------------------------------------------------
 1 | #include <Eigen/Core>
 2 | 
 3 | #include <numpy_eigen/boost_python_headers.hpp>
 4 | Eigen::Matrix<boost::int64_t, 1, 1> test_long_1_1(const Eigen::Matrix<boost::int64_t, 1, 1> & M)
 5 | {
 6 | 	return M;
 7 | }
 8 | void export_long_1_1()
 9 | {
10 | 	boost::python::def("test_long_1_1",test_long_1_1);
11 | }
12 | 
13 | 


--------------------------------------------------------------------------------
/Schweizer-Messer/numpy_eigen/src/autogen_test_module/test_1_1_uchar.cpp:
--------------------------------------------------------------------------------
 1 | #include <Eigen/Core>
 2 | 
 3 | #include <numpy_eigen/boost_python_headers.hpp>
 4 | Eigen::Matrix<boost::uint8_t, 1, 1> test_uchar_1_1(const Eigen::Matrix<boost::uint8_t, 1, 1> & M)
 5 | {
 6 | 	return M;
 7 | }
 8 | void export_uchar_1_1()
 9 | {
10 | 	boost::python::def("test_uchar_1_1",test_uchar_1_1);
11 | }
12 | 
13 | 


--------------------------------------------------------------------------------
/Schweizer-Messer/numpy_eigen/src/autogen_test_module/test_1_2_double.cpp:
--------------------------------------------------------------------------------
 1 | #include <Eigen/Core>
 2 | 
 3 | #include <numpy_eigen/boost_python_headers.hpp>
 4 | Eigen::Matrix<double, 1, 2> test_double_1_2(const Eigen::Matrix<double, 1, 2> & M)
 5 | {
 6 | 	return M;
 7 | }
 8 | void export_double_1_2()
 9 | {
10 | 	boost::python::def("test_double_1_2",test_double_1_2);
11 | }
12 | 
13 | 


--------------------------------------------------------------------------------
/Schweizer-Messer/numpy_eigen/src/autogen_test_module/test_1_2_float.cpp:
--------------------------------------------------------------------------------
 1 | #include <Eigen/Core>
 2 | 
 3 | #include <numpy_eigen/boost_python_headers.hpp>
 4 | Eigen::Matrix<float, 1, 2> test_float_1_2(const Eigen::Matrix<float, 1, 2> & M)
 5 | {
 6 | 	return M;
 7 | }
 8 | void export_float_1_2()
 9 | {
10 | 	boost::python::def("test_float_1_2",test_float_1_2);
11 | }
12 | 
13 | 


--------------------------------------------------------------------------------
/Schweizer-Messer/numpy_eigen/src/autogen_test_module/test_1_2_int.cpp:
--------------------------------------------------------------------------------
 1 | #include <Eigen/Core>
 2 | 
 3 | #include <numpy_eigen/boost_python_headers.hpp>
 4 | Eigen::Matrix<int, 1, 2> test_int_1_2(const Eigen::Matrix<int, 1, 2> & M)
 5 | {
 6 | 	return M;
 7 | }
 8 | void export_int_1_2()
 9 | {
10 | 	boost::python::def("test_int_1_2",test_int_1_2);
11 | }
12 | 
13 | 


--------------------------------------------------------------------------------
/Schweizer-Messer/numpy_eigen/src/autogen_test_module/test_1_2_long.cpp:
--------------------------------------------------------------------------------
 1 | #include <Eigen/Core>
 2 | 
 3 | #include <numpy_eigen/boost_python_headers.hpp>
 4 | Eigen::Matrix<boost::int64_t, 1, 2> test_long_1_2(const Eigen::Matrix<boost::int64_t, 1, 2> & M)
 5 | {
 6 | 	return M;
 7 | }
 8 | void export_long_1_2()
 9 | {
10 | 	boost::python::def("test_long_1_2",test_long_1_2);
11 | }
12 | 
13 | 


--------------------------------------------------------------------------------
/Schweizer-Messer/numpy_eigen/src/autogen_test_module/test_1_2_uchar.cpp:
--------------------------------------------------------------------------------
 1 | #include <Eigen/Core>
 2 | 
 3 | #include <numpy_eigen/boost_python_headers.hpp>
 4 | Eigen::Matrix<boost::uint8_t, 1, 2> test_uchar_1_2(const Eigen::Matrix<boost::uint8_t, 1, 2> & M)
 5 | {
 6 | 	return M;
 7 | }
 8 | void export_uchar_1_2()
 9 | {
10 | 	boost::python::def("test_uchar_1_2",test_uchar_1_2);
11 | }
12 | 
13 | 


--------------------------------------------------------------------------------
/Schweizer-Messer/numpy_eigen/src/autogen_test_module/test_1_3_double.cpp:
--------------------------------------------------------------------------------
 1 | #include <Eigen/Core>
 2 | 
 3 | #include <numpy_eigen/boost_python_headers.hpp>
 4 | Eigen::Matrix<double, 1, 3> test_double_1_3(const Eigen::Matrix<double, 1, 3> & M)
 5 | {
 6 | 	return M;
 7 | }
 8 | void export_double_1_3()
 9 | {
10 | 	boost::python::def("test_double_1_3",test_double_1_3);
11 | }
12 | 
13 | 


--------------------------------------------------------------------------------
/Schweizer-Messer/numpy_eigen/src/autogen_test_module/test_1_3_float.cpp:
--------------------------------------------------------------------------------
 1 | #include <Eigen/Core>
 2 | 
 3 | #include <numpy_eigen/boost_python_headers.hpp>
 4 | Eigen::Matrix<float, 1, 3> test_float_1_3(const Eigen::Matrix<float, 1, 3> & M)
 5 | {
 6 | 	return M;
 7 | }
 8 | void export_float_1_3()
 9 | {
10 | 	boost::python::def("test_float_1_3",test_float_1_3);
11 | }
12 | 
13 | 


--------------------------------------------------------------------------------
/Schweizer-Messer/numpy_eigen/src/autogen_test_module/test_1_3_int.cpp:
--------------------------------------------------------------------------------
 1 | #include <Eigen/Core>
 2 | 
 3 | #include <numpy_eigen/boost_python_headers.hpp>
 4 | Eigen::Matrix<int, 1, 3> test_int_1_3(const Eigen::Matrix<int, 1, 3> & M)
 5 | {
 6 | 	return M;
 7 | }
 8 | void export_int_1_3()
 9 | {
10 | 	boost::python::def("test_int_1_3",test_int_1_3);
11 | }
12 | 
13 | 


--------------------------------------------------------------------------------
/Schweizer-Messer/numpy_eigen/src/autogen_test_module/test_1_3_long.cpp:
--------------------------------------------------------------------------------
 1 | #include <Eigen/Core>
 2 | 
 3 | #include <numpy_eigen/boost_python_headers.hpp>
 4 | Eigen::Matrix<boost::int64_t, 1, 3> test_long_1_3(const Eigen::Matrix<boost::int64_t, 1, 3> & M)
 5 | {
 6 | 	return M;
 7 | }
 8 | void export_long_1_3()
 9 | {
10 | 	boost::python::def("test_long_1_3",test_long_1_3);
11 | }
12 | 
13 | 


--------------------------------------------------------------------------------
/Schweizer-Messer/numpy_eigen/src/autogen_test_module/test_1_3_uchar.cpp:
--------------------------------------------------------------------------------
 1 | #include <Eigen/Core>
 2 | 
 3 | #include <numpy_eigen/boost_python_headers.hpp>
 4 | Eigen::Matrix<boost::uint8_t, 1, 3> test_uchar_1_3(const Eigen::Matrix<boost::uint8_t, 1, 3> & M)
 5 | {
 6 | 	return M;
 7 | }
 8 | void export_uchar_1_3()
 9 | {
10 | 	boost::python::def("test_uchar_1_3",test_uchar_1_3);
11 | }
12 | 
13 | 


--------------------------------------------------------------------------------
/Schweizer-Messer/numpy_eigen/src/autogen_test_module/test_1_4_double.cpp:
--------------------------------------------------------------------------------
 1 | #include <Eigen/Core>
 2 | 
 3 | #include <numpy_eigen/boost_python_headers.hpp>
 4 | Eigen::Matrix<double, 1, 4> test_double_1_4(const Eigen::Matrix<double, 1, 4> & M)
 5 | {
 6 | 	return M;
 7 | }
 8 | void export_double_1_4()
 9 | {
10 | 	boost::python::def("test_double_1_4",test_double_1_4);
11 | }
12 | 
13 | 


--------------------------------------------------------------------------------
/Schweizer-Messer/numpy_eigen/src/autogen_test_module/test_1_4_float.cpp:
--------------------------------------------------------------------------------
 1 | #include <Eigen/Core>
 2 | 
 3 | #include <numpy_eigen/boost_python_headers.hpp>
 4 | Eigen::Matrix<float, 1, 4> test_float_1_4(const Eigen::Matrix<float, 1, 4> & M)
 5 | {
 6 | 	return M;
 7 | }
 8 | void export_float_1_4()
 9 | {
10 | 	boost::python::def("test_float_1_4",test_float_1_4);
11 | }
12 | 
13 | 


--------------------------------------------------------------------------------
/Schweizer-Messer/numpy_eigen/src/autogen_test_module/test_1_4_int.cpp:
--------------------------------------------------------------------------------
 1 | #include <Eigen/Core>
 2 | 
 3 | #include <numpy_eigen/boost_python_headers.hpp>
 4 | Eigen::Matrix<int, 1, 4> test_int_1_4(const Eigen::Matrix<int, 1, 4> & M)
 5 | {
 6 | 	return M;
 7 | }
 8 | void export_int_1_4()
 9 | {
10 | 	boost::python::def("test_int_1_4",test_int_1_4);
11 | }
12 | 
13 | 


--------------------------------------------------------------------------------
/Schweizer-Messer/numpy_eigen/src/autogen_test_module/test_1_4_long.cpp:
--------------------------------------------------------------------------------
 1 | #include <Eigen/Core>
 2 | 
 3 | #include <numpy_eigen/boost_python_headers.hpp>
 4 | Eigen::Matrix<boost::int64_t, 1, 4> test_long_1_4(const Eigen::Matrix<boost::int64_t, 1, 4> & M)
 5 | {
 6 | 	return M;
 7 | }
 8 | void export_long_1_4()
 9 | {
10 | 	boost::python::def("test_long_1_4",test_long_1_4);
11 | }
12 | 
13 | 


--------------------------------------------------------------------------------
/Schweizer-Messer/numpy_eigen/src/autogen_test_module/test_1_4_uchar.cpp:
--------------------------------------------------------------------------------
 1 | #include <Eigen/Core>
 2 | 
 3 | #include <numpy_eigen/boost_python_headers.hpp>
 4 | Eigen::Matrix<boost::uint8_t, 1, 4> test_uchar_1_4(const Eigen::Matrix<boost::uint8_t, 1, 4> & M)
 5 | {
 6 | 	return M;
 7 | }
 8 | void export_uchar_1_4()
 9 | {
10 | 	boost::python::def("test_uchar_1_4",test_uchar_1_4);
11 | }
12 | 
13 | 


--------------------------------------------------------------------------------
/Schweizer-Messer/numpy_eigen/src/autogen_test_module/test_1_5_double.cpp:
--------------------------------------------------------------------------------
 1 | #include <Eigen/Core>
 2 | 
 3 | #include <numpy_eigen/boost_python_headers.hpp>
 4 | Eigen::Matrix<double, 1, 5> test_double_1_5(const Eigen::Matrix<double, 1, 5> & M)
 5 | {
 6 | 	return M;
 7 | }
 8 | void export_double_1_5()
 9 | {
10 | 	boost::python::def("test_double_1_5",test_double_1_5);
11 | }
12 | 
13 | 


--------------------------------------------------------------------------------
/Schweizer-Messer/numpy_eigen/src/autogen_test_module/test_1_5_float.cpp:
--------------------------------------------------------------------------------
 1 | #include <Eigen/Core>
 2 | 
 3 | #include <numpy_eigen/boost_python_headers.hpp>
 4 | Eigen::Matrix<float, 1, 5> test_float_1_5(const Eigen::Matrix<float, 1, 5> & M)
 5 | {
 6 | 	return M;
 7 | }
 8 | void export_float_1_5()
 9 | {
10 | 	boost::python::def("test_float_1_5",test_float_1_5);
11 | }
12 | 
13 | 


--------------------------------------------------------------------------------
/Schweizer-Messer/numpy_eigen/src/autogen_test_module/test_1_5_int.cpp:
--------------------------------------------------------------------------------
 1 | #include <Eigen/Core>
 2 | 
 3 | #include <numpy_eigen/boost_python_headers.hpp>
 4 | Eigen::Matrix<int, 1, 5> test_int_1_5(const Eigen::Matrix<int, 1, 5> & M)
 5 | {
 6 | 	return M;
 7 | }
 8 | void export_int_1_5()
 9 | {
10 | 	boost::python::def("test_int_1_5",test_int_1_5);
11 | }
12 | 
13 | 


--------------------------------------------------------------------------------
/Schweizer-Messer/numpy_eigen/src/autogen_test_module/test_1_5_long.cpp:
--------------------------------------------------------------------------------
 1 | #include <Eigen/Core>
 2 | 
 3 | #include <numpy_eigen/boost_python_headers.hpp>
 4 | Eigen::Matrix<boost::int64_t, 1, 5> test_long_1_5(const Eigen::Matrix<boost::int64_t, 1, 5> & M)
 5 | {
 6 | 	return M;
 7 | }
 8 | void export_long_1_5()
 9 | {
10 | 	boost::python::def("test_long_1_5",test_long_1_5);
11 | }
12 | 
13 | 


--------------------------------------------------------------------------------
/Schweizer-Messer/numpy_eigen/src/autogen_test_module/test_1_5_uchar.cpp:
--------------------------------------------------------------------------------
 1 | #include <Eigen/Core>
 2 | 
 3 | #include <numpy_eigen/boost_python_headers.hpp>
 4 | Eigen::Matrix<boost::uint8_t, 1, 5> test_uchar_1_5(const Eigen::Matrix<boost::uint8_t, 1, 5> & M)
 5 | {
 6 | 	return M;
 7 | }
 8 | void export_uchar_1_5()
 9 | {
10 | 	boost::python::def("test_uchar_1_5",test_uchar_1_5);
11 | }
12 | 
13 | 


--------------------------------------------------------------------------------
/Schweizer-Messer/numpy_eigen/src/autogen_test_module/test_1_6_double.cpp:
--------------------------------------------------------------------------------
 1 | #include <Eigen/Core>
 2 | 
 3 | #include <numpy_eigen/boost_python_headers.hpp>
 4 | Eigen::Matrix<double, 1, 6> test_double_1_6(const Eigen::Matrix<double, 1, 6> & M)
 5 | {
 6 | 	return M;
 7 | }
 8 | void export_double_1_6()
 9 | {
10 | 	boost::python::def("test_double_1_6",test_double_1_6);
11 | }
12 | 
13 | 


--------------------------------------------------------------------------------
/Schweizer-Messer/numpy_eigen/src/autogen_test_module/test_1_6_float.cpp:
--------------------------------------------------------------------------------
 1 | #include <Eigen/Core>
 2 | 
 3 | #include <numpy_eigen/boost_python_headers.hpp>
 4 | Eigen::Matrix<float, 1, 6> test_float_1_6(const Eigen::Matrix<float, 1, 6> & M)
 5 | {
 6 | 	return M;
 7 | }
 8 | void export_float_1_6()
 9 | {
10 | 	boost::python::def("test_float_1_6",test_float_1_6);
11 | }
12 | 
13 | 


--------------------------------------------------------------------------------
/Schweizer-Messer/numpy_eigen/src/autogen_test_module/test_1_6_int.cpp:
--------------------------------------------------------------------------------
 1 | #include <Eigen/Core>
 2 | 
 3 | #include <numpy_eigen/boost_python_headers.hpp>
 4 | Eigen::Matrix<int, 1, 6> test_int_1_6(const Eigen::Matrix<int, 1, 6> & M)
 5 | {
 6 | 	return M;
 7 | }
 8 | void export_int_1_6()
 9 | {
10 | 	boost::python::def("test_int_1_6",test_int_1_6);
11 | }
12 | 
13 | 


--------------------------------------------------------------------------------
/Schweizer-Messer/numpy_eigen/src/autogen_test_module/test_1_6_long.cpp:
--------------------------------------------------------------------------------
 1 | #include <Eigen/Core>
 2 | 
 3 | #include <numpy_eigen/boost_python_headers.hpp>
 4 | Eigen::Matrix<boost::int64_t, 1, 6> test_long_1_6(const Eigen::Matrix<boost::int64_t, 1, 6> & M)
 5 | {
 6 | 	return M;
 7 | }
 8 | void export_long_1_6()
 9 | {
10 | 	boost::python::def("test_long_1_6",test_long_1_6);
11 | }
12 | 
13 | 


--------------------------------------------------------------------------------
/Schweizer-Messer/numpy_eigen/src/autogen_test_module/test_1_6_uchar.cpp:
--------------------------------------------------------------------------------
 1 | #include <Eigen/Core>
 2 | 
 3 | #include <numpy_eigen/boost_python_headers.hpp>
 4 | Eigen::Matrix<boost::uint8_t, 1, 6> test_uchar_1_6(const Eigen::Matrix<boost::uint8_t, 1, 6> & M)
 5 | {
 6 | 	return M;
 7 | }
 8 | void export_uchar_1_6()
 9 | {
10 | 	boost::python::def("test_uchar_1_6",test_uchar_1_6);
11 | }
12 | 
13 | 


--------------------------------------------------------------------------------
/Schweizer-Messer/numpy_eigen/src/autogen_test_module/test_1_D_int.cpp:
--------------------------------------------------------------------------------
 1 | #include <Eigen/Core>
 2 | 
 3 | #include <numpy_eigen/boost_python_headers.hpp>
 4 | Eigen::Matrix<int, 1, Eigen::Dynamic> test_int_1_D(const Eigen::Matrix<int, 1, Eigen::Dynamic> & M)
 5 | {
 6 | 	return M;
 7 | }
 8 | void export_int_1_D()
 9 | {
10 | 	boost::python::def("test_int_1_D",test_int_1_D);
11 | }
12 | 
13 | 


--------------------------------------------------------------------------------
/Schweizer-Messer/numpy_eigen/src/autogen_test_module/test_2_1_double.cpp:
--------------------------------------------------------------------------------
 1 | #include <Eigen/Core>
 2 | 
 3 | #include <numpy_eigen/boost_python_headers.hpp>
 4 | Eigen::Matrix<double, 2, 1> test_double_2_1(const Eigen::Matrix<double, 2, 1> & M)
 5 | {
 6 | 	return M;
 7 | }
 8 | void export_double_2_1()
 9 | {
10 | 	boost::python::def("test_double_2_1",test_double_2_1);
11 | }
12 | 
13 | 


--------------------------------------------------------------------------------
/Schweizer-Messer/numpy_eigen/src/autogen_test_module/test_2_1_float.cpp:
--------------------------------------------------------------------------------
 1 | #include <Eigen/Core>
 2 | 
 3 | #include <numpy_eigen/boost_python_headers.hpp>
 4 | Eigen::Matrix<float, 2, 1> test_float_2_1(const Eigen::Matrix<float, 2, 1> & M)
 5 | {
 6 | 	return M;
 7 | }
 8 | void export_float_2_1()
 9 | {
10 | 	boost::python::def("test_float_2_1",test_float_2_1);
11 | }
12 | 
13 | 


--------------------------------------------------------------------------------
/Schweizer-Messer/numpy_eigen/src/autogen_test_module/test_2_1_int.cpp:
--------------------------------------------------------------------------------
 1 | #include <Eigen/Core>
 2 | 
 3 | #include <numpy_eigen/boost_python_headers.hpp>
 4 | Eigen::Matrix<int, 2, 1> test_int_2_1(const Eigen::Matrix<int, 2, 1> & M)
 5 | {
 6 | 	return M;
 7 | }
 8 | void export_int_2_1()
 9 | {
10 | 	boost::python::def("test_int_2_1",test_int_2_1);
11 | }
12 | 
13 | 


--------------------------------------------------------------------------------
/Schweizer-Messer/numpy_eigen/src/autogen_test_module/test_2_1_long.cpp:
--------------------------------------------------------------------------------
 1 | #include <Eigen/Core>
 2 | 
 3 | #include <numpy_eigen/boost_python_headers.hpp>
 4 | Eigen::Matrix<boost::int64_t, 2, 1> test_long_2_1(const Eigen::Matrix<boost::int64_t, 2, 1> & M)
 5 | {
 6 | 	return M;
 7 | }
 8 | void export_long_2_1()
 9 | {
10 | 	boost::python::def("test_long_2_1",test_long_2_1);
11 | }
12 | 
13 | 


--------------------------------------------------------------------------------
/Schweizer-Messer/numpy_eigen/src/autogen_test_module/test_2_1_uchar.cpp:
--------------------------------------------------------------------------------
 1 | #include <Eigen/Core>
 2 | 
 3 | #include <numpy_eigen/boost_python_headers.hpp>
 4 | Eigen::Matrix<boost::uint8_t, 2, 1> test_uchar_2_1(const Eigen::Matrix<boost::uint8_t, 2, 1> & M)
 5 | {
 6 | 	return M;
 7 | }
 8 | void export_uchar_2_1()
 9 | {
10 | 	boost::python::def("test_uchar_2_1",test_uchar_2_1);
11 | }
12 | 
13 | 


--------------------------------------------------------------------------------
/Schweizer-Messer/numpy_eigen/src/autogen_test_module/test_2_2_double.cpp:
--------------------------------------------------------------------------------
 1 | #include <Eigen/Core>
 2 | 
 3 | #include <numpy_eigen/boost_python_headers.hpp>
 4 | Eigen::Matrix<double, 2, 2> test_double_2_2(const Eigen::Matrix<double, 2, 2> & M)
 5 | {
 6 | 	return M;
 7 | }
 8 | void export_double_2_2()
 9 | {
10 | 	boost::python::def("test_double_2_2",test_double_2_2);
11 | }
12 | 
13 | 


--------------------------------------------------------------------------------
/Schweizer-Messer/numpy_eigen/src/autogen_test_module/test_2_2_float.cpp:
--------------------------------------------------------------------------------
 1 | #include <Eigen/Core>
 2 | 
 3 | #include <numpy_eigen/boost_python_headers.hpp>
 4 | Eigen::Matrix<float, 2, 2> test_float_2_2(const Eigen::Matrix<float, 2, 2> & M)
 5 | {
 6 | 	return M;
 7 | }
 8 | void export_float_2_2()
 9 | {
10 | 	boost::python::def("test_float_2_2",test_float_2_2);
11 | }
12 | 
13 | 


--------------------------------------------------------------------------------
/Schweizer-Messer/numpy_eigen/src/autogen_test_module/test_2_2_int.cpp:
--------------------------------------------------------------------------------
 1 | #include <Eigen/Core>
 2 | 
 3 | #include <numpy_eigen/boost_python_headers.hpp>
 4 | Eigen::Matrix<int, 2, 2> test_int_2_2(const Eigen::Matrix<int, 2, 2> & M)
 5 | {
 6 | 	return M;
 7 | }
 8 | void export_int_2_2()
 9 | {
10 | 	boost::python::def("test_int_2_2",test_int_2_2);
11 | }
12 | 
13 | 


--------------------------------------------------------------------------------
/Schweizer-Messer/numpy_eigen/src/autogen_test_module/test_2_2_long.cpp:
--------------------------------------------------------------------------------
 1 | #include <Eigen/Core>
 2 | 
 3 | #include <numpy_eigen/boost_python_headers.hpp>
 4 | Eigen::Matrix<boost::int64_t, 2, 2> test_long_2_2(const Eigen::Matrix<boost::int64_t, 2, 2> & M)
 5 | {
 6 | 	return M;
 7 | }
 8 | void export_long_2_2()
 9 | {
10 | 	boost::python::def("test_long_2_2",test_long_2_2);
11 | }
12 | 
13 | 


--------------------------------------------------------------------------------
/Schweizer-Messer/numpy_eigen/src/autogen_test_module/test_2_2_uchar.cpp:
--------------------------------------------------------------------------------
 1 | #include <Eigen/Core>
 2 | 
 3 | #include <numpy_eigen/boost_python_headers.hpp>
 4 | Eigen::Matrix<boost::uint8_t, 2, 2> test_uchar_2_2(const Eigen::Matrix<boost::uint8_t, 2, 2> & M)
 5 | {
 6 | 	return M;
 7 | }
 8 | void export_uchar_2_2()
 9 | {
10 | 	boost::python::def("test_uchar_2_2",test_uchar_2_2);
11 | }
12 | 
13 | 


--------------------------------------------------------------------------------
/Schweizer-Messer/numpy_eigen/src/autogen_test_module/test_2_3_double.cpp:
--------------------------------------------------------------------------------
 1 | #include <Eigen/Core>
 2 | 
 3 | #include <numpy_eigen/boost_python_headers.hpp>
 4 | Eigen::Matrix<double, 2, 3> test_double_2_3(const Eigen::Matrix<double, 2, 3> & M)
 5 | {
 6 | 	return M;
 7 | }
 8 | void export_double_2_3()
 9 | {
10 | 	boost::python::def("test_double_2_3",test_double_2_3);
11 | }
12 | 
13 | 


--------------------------------------------------------------------------------
/Schweizer-Messer/numpy_eigen/src/autogen_test_module/test_2_3_float.cpp:
--------------------------------------------------------------------------------
 1 | #include <Eigen/Core>
 2 | 
 3 | #include <numpy_eigen/boost_python_headers.hpp>
 4 | Eigen::Matrix<float, 2, 3> test_float_2_3(const Eigen::Matrix<float, 2, 3> & M)
 5 | {
 6 | 	return M;
 7 | }
 8 | void export_float_2_3()
 9 | {
10 | 	boost::python::def("test_float_2_3",test_float_2_3);
11 | }
12 | 
13 | 


--------------------------------------------------------------------------------
/Schweizer-Messer/numpy_eigen/src/autogen_test_module/test_2_3_int.cpp:
--------------------------------------------------------------------------------
 1 | #include <Eigen/Core>
 2 | 
 3 | #include <numpy_eigen/boost_python_headers.hpp>
 4 | Eigen::Matrix<int, 2, 3> test_int_2_3(const Eigen::Matrix<int, 2, 3> & M)
 5 | {
 6 | 	return M;
 7 | }
 8 | void export_int_2_3()
 9 | {
10 | 	boost::python::def("test_int_2_3",test_int_2_3);
11 | }
12 | 
13 | 


--------------------------------------------------------------------------------
/Schweizer-Messer/numpy_eigen/src/autogen_test_module/test_2_3_long.cpp:
--------------------------------------------------------------------------------
 1 | #include <Eigen/Core>
 2 | 
 3 | #include <numpy_eigen/boost_python_headers.hpp>
 4 | Eigen::Matrix<boost::int64_t, 2, 3> test_long_2_3(const Eigen::Matrix<boost::int64_t, 2, 3> & M)
 5 | {
 6 | 	return M;
 7 | }
 8 | void export_long_2_3()
 9 | {
10 | 	boost::python::def("test_long_2_3",test_long_2_3);
11 | }
12 | 
13 | 


--------------------------------------------------------------------------------
/Schweizer-Messer/numpy_eigen/src/autogen_test_module/test_2_3_uchar.cpp:
--------------------------------------------------------------------------------
 1 | #include <Eigen/Core>
 2 | 
 3 | #include <numpy_eigen/boost_python_headers.hpp>
 4 | Eigen::Matrix<boost::uint8_t, 2, 3> test_uchar_2_3(const Eigen::Matrix<boost::uint8_t, 2, 3> & M)
 5 | {
 6 | 	return M;
 7 | }
 8 | void export_uchar_2_3()
 9 | {
10 | 	boost::python::def("test_uchar_2_3",test_uchar_2_3);
11 | }
12 | 
13 | 


--------------------------------------------------------------------------------
/Schweizer-Messer/numpy_eigen/src/autogen_test_module/test_2_4_double.cpp:
--------------------------------------------------------------------------------
 1 | #include <Eigen/Core>
 2 | 
 3 | #include <numpy_eigen/boost_python_headers.hpp>
 4 | Eigen::Matrix<double, 2, 4> test_double_2_4(const Eigen::Matrix<double, 2, 4> & M)
 5 | {
 6 | 	return M;
 7 | }
 8 | void export_double_2_4()
 9 | {
10 | 	boost::python::def("test_double_2_4",test_double_2_4);
11 | }
12 | 
13 | 


--------------------------------------------------------------------------------
/Schweizer-Messer/numpy_eigen/src/autogen_test_module/test_2_4_float.cpp:
--------------------------------------------------------------------------------
 1 | #include <Eigen/Core>
 2 | 
 3 | #include <numpy_eigen/boost_python_headers.hpp>
 4 | Eigen::Matrix<float, 2, 4> test_float_2_4(const Eigen::Matrix<float, 2, 4> & M)
 5 | {
 6 | 	return M;
 7 | }
 8 | void export_float_2_4()
 9 | {
10 | 	boost::python::def("test_float_2_4",test_float_2_4);
11 | }
12 | 
13 | 


--------------------------------------------------------------------------------
/Schweizer-Messer/numpy_eigen/src/autogen_test_module/test_2_4_int.cpp:
--------------------------------------------------------------------------------
 1 | #include <Eigen/Core>
 2 | 
 3 | #include <numpy_eigen/boost_python_headers.hpp>
 4 | Eigen::Matrix<int, 2, 4> test_int_2_4(const Eigen::Matrix<int, 2, 4> & M)
 5 | {
 6 | 	return M;
 7 | }
 8 | void export_int_2_4()
 9 | {
10 | 	boost::python::def("test_int_2_4",test_int_2_4);
11 | }
12 | 
13 | 


--------------------------------------------------------------------------------
/Schweizer-Messer/numpy_eigen/src/autogen_test_module/test_2_4_long.cpp:
--------------------------------------------------------------------------------
 1 | #include <Eigen/Core>
 2 | 
 3 | #include <numpy_eigen/boost_python_headers.hpp>
 4 | Eigen::Matrix<boost::int64_t, 2, 4> test_long_2_4(const Eigen::Matrix<boost::int64_t, 2, 4> & M)
 5 | {
 6 | 	return M;
 7 | }
 8 | void export_long_2_4()
 9 | {
10 | 	boost::python::def("test_long_2_4",test_long_2_4);
11 | }
12 | 
13 | 


--------------------------------------------------------------------------------
/Schweizer-Messer/numpy_eigen/src/autogen_test_module/test_2_4_uchar.cpp:
--------------------------------------------------------------------------------
 1 | #include <Eigen/Core>
 2 | 
 3 | #include <numpy_eigen/boost_python_headers.hpp>
 4 | Eigen::Matrix<boost::uint8_t, 2, 4> test_uchar_2_4(const Eigen::Matrix<boost::uint8_t, 2, 4> & M)
 5 | {
 6 | 	return M;
 7 | }
 8 | void export_uchar_2_4()
 9 | {
10 | 	boost::python::def("test_uchar_2_4",test_uchar_2_4);
11 | }
12 | 
13 | 


--------------------------------------------------------------------------------
/Schweizer-Messer/numpy_eigen/src/autogen_test_module/test_2_5_double.cpp:
--------------------------------------------------------------------------------
 1 | #include <Eigen/Core>
 2 | 
 3 | #include <numpy_eigen/boost_python_headers.hpp>
 4 | Eigen::Matrix<double, 2, 5> test_double_2_5(const Eigen::Matrix<double, 2, 5> & M)
 5 | {
 6 | 	return M;
 7 | }
 8 | void export_double_2_5()
 9 | {
10 | 	boost::python::def("test_double_2_5",test_double_2_5);
11 | }
12 | 
13 | 


--------------------------------------------------------------------------------
/Schweizer-Messer/numpy_eigen/src/autogen_test_module/test_2_5_float.cpp:
--------------------------------------------------------------------------------
 1 | #include <Eigen/Core>
 2 | 
 3 | #include <numpy_eigen/boost_python_headers.hpp>
 4 | Eigen::Matrix<float, 2, 5> test_float_2_5(const Eigen::Matrix<float, 2, 5> & M)
 5 | {
 6 | 	return M;
 7 | }
 8 | void export_float_2_5()
 9 | {
10 | 	boost::python::def("test_float_2_5",test_float_2_5);
11 | }
12 | 
13 | 


--------------------------------------------------------------------------------
/Schweizer-Messer/numpy_eigen/src/autogen_test_module/test_2_5_int.cpp:
--------------------------------------------------------------------------------
 1 | #include <Eigen/Core>
 2 | 
 3 | #include <numpy_eigen/boost_python_headers.hpp>
 4 | Eigen::Matrix<int, 2, 5> test_int_2_5(const Eigen::Matrix<int, 2, 5> & M)
 5 | {
 6 | 	return M;
 7 | }
 8 | void export_int_2_5()
 9 | {
10 | 	boost::python::def("test_int_2_5",test_int_2_5);
11 | }
12 | 
13 | 


--------------------------------------------------------------------------------
/Schweizer-Messer/numpy_eigen/src/autogen_test_module/test_2_5_long.cpp:
--------------------------------------------------------------------------------
 1 | #include <Eigen/Core>
 2 | 
 3 | #include <numpy_eigen/boost_python_headers.hpp>
 4 | Eigen::Matrix<boost::int64_t, 2, 5> test_long_2_5(const Eigen::Matrix<boost::int64_t, 2, 5> & M)
 5 | {
 6 | 	return M;
 7 | }
 8 | void export_long_2_5()
 9 | {
10 | 	boost::python::def("test_long_2_5",test_long_2_5);
11 | }
12 | 
13 | 


--------------------------------------------------------------------------------
/Schweizer-Messer/numpy_eigen/src/autogen_test_module/test_2_5_uchar.cpp:
--------------------------------------------------------------------------------
 1 | #include <Eigen/Core>
 2 | 
 3 | #include <numpy_eigen/boost_python_headers.hpp>
 4 | Eigen::Matrix<boost::uint8_t, 2, 5> test_uchar_2_5(const Eigen::Matrix<boost::uint8_t, 2, 5> & M)
 5 | {
 6 | 	return M;
 7 | }
 8 | void export_uchar_2_5()
 9 | {
10 | 	boost::python::def("test_uchar_2_5",test_uchar_2_5);
11 | }
12 | 
13 | 


--------------------------------------------------------------------------------
/Schweizer-Messer/numpy_eigen/src/autogen_test_module/test_2_6_double.cpp:
--------------------------------------------------------------------------------
 1 | #include <Eigen/Core>
 2 | 
 3 | #include <numpy_eigen/boost_python_headers.hpp>
 4 | Eigen::Matrix<double, 2, 6> test_double_2_6(const Eigen::Matrix<double, 2, 6> & M)
 5 | {
 6 | 	return M;
 7 | }
 8 | void export_double_2_6()
 9 | {
10 | 	boost::python::def("test_double_2_6",test_double_2_6);
11 | }
12 | 
13 | 


--------------------------------------------------------------------------------
/Schweizer-Messer/numpy_eigen/src/autogen_test_module/test_2_6_float.cpp:
--------------------------------------------------------------------------------
 1 | #include <Eigen/Core>
 2 | 
 3 | #include <numpy_eigen/boost_python_headers.hpp>
 4 | Eigen::Matrix<float, 2, 6> test_float_2_6(const Eigen::Matrix<float, 2, 6> & M)
 5 | {
 6 | 	return M;
 7 | }
 8 | void export_float_2_6()
 9 | {
10 | 	boost::python::def("test_float_2_6",test_float_2_6);
11 | }
12 | 
13 | 


--------------------------------------------------------------------------------
/Schweizer-Messer/numpy_eigen/src/autogen_test_module/test_2_6_int.cpp:
--------------------------------------------------------------------------------
 1 | #include <Eigen/Core>
 2 | 
 3 | #include <numpy_eigen/boost_python_headers.hpp>
 4 | Eigen::Matrix<int, 2, 6> test_int_2_6(const Eigen::Matrix<int, 2, 6> & M)
 5 | {
 6 | 	return M;
 7 | }
 8 | void export_int_2_6()
 9 | {
10 | 	boost::python::def("test_int_2_6",test_int_2_6);
11 | }
12 | 
13 | 


--------------------------------------------------------------------------------
/Schweizer-Messer/numpy_eigen/src/autogen_test_module/test_2_6_long.cpp:
--------------------------------------------------------------------------------
 1 | #include <Eigen/Core>
 2 | 
 3 | #include <numpy_eigen/boost_python_headers.hpp>
 4 | Eigen::Matrix<boost::int64_t, 2, 6> test_long_2_6(const Eigen::Matrix<boost::int64_t, 2, 6> & M)
 5 | {
 6 | 	return M;
 7 | }
 8 | void export_long_2_6()
 9 | {
10 | 	boost::python::def("test_long_2_6",test_long_2_6);
11 | }
12 | 
13 | 


--------------------------------------------------------------------------------
/Schweizer-Messer/numpy_eigen/src/autogen_test_module/test_2_6_uchar.cpp:
--------------------------------------------------------------------------------
 1 | #include <Eigen/Core>
 2 | 
 3 | #include <numpy_eigen/boost_python_headers.hpp>
 4 | Eigen::Matrix<boost::uint8_t, 2, 6> test_uchar_2_6(const Eigen::Matrix<boost::uint8_t, 2, 6> & M)
 5 | {
 6 | 	return M;
 7 | }
 8 | void export_uchar_2_6()
 9 | {
10 | 	boost::python::def("test_uchar_2_6",test_uchar_2_6);
11 | }
12 | 
13 | 


--------------------------------------------------------------------------------
/Schweizer-Messer/numpy_eigen/src/autogen_test_module/test_2_D_int.cpp:
--------------------------------------------------------------------------------
 1 | #include <Eigen/Core>
 2 | 
 3 | #include <numpy_eigen/boost_python_headers.hpp>
 4 | Eigen::Matrix<int, 2, Eigen::Dynamic> test_int_2_D(const Eigen::Matrix<int, 2, Eigen::Dynamic> & M)
 5 | {
 6 | 	return M;
 7 | }
 8 | void export_int_2_D()
 9 | {
10 | 	boost::python::def("test_int_2_D",test_int_2_D);
11 | }
12 | 
13 | 


--------------------------------------------------------------------------------
/Schweizer-Messer/numpy_eigen/src/autogen_test_module/test_3_1_double.cpp:
--------------------------------------------------------------------------------
 1 | #include <Eigen/Core>
 2 | 
 3 | #include <numpy_eigen/boost_python_headers.hpp>
 4 | Eigen::Matrix<double, 3, 1> test_double_3_1(const Eigen::Matrix<double, 3, 1> & M)
 5 | {
 6 | 	return M;
 7 | }
 8 | void export_double_3_1()
 9 | {
10 | 	boost::python::def("test_double_3_1",test_double_3_1);
11 | }
12 | 
13 | 


--------------------------------------------------------------------------------
/Schweizer-Messer/numpy_eigen/src/autogen_test_module/test_3_1_float.cpp:
--------------------------------------------------------------------------------
 1 | #include <Eigen/Core>
 2 | 
 3 | #include <numpy_eigen/boost_python_headers.hpp>
 4 | Eigen::Matrix<float, 3, 1> test_float_3_1(const Eigen::Matrix<float, 3, 1> & M)
 5 | {
 6 | 	return M;
 7 | }
 8 | void export_float_3_1()
 9 | {
10 | 	boost::python::def("test_float_3_1",test_float_3_1);
11 | }
12 | 
13 | 


--------------------------------------------------------------------------------
/Schweizer-Messer/numpy_eigen/src/autogen_test_module/test_3_1_int.cpp:
--------------------------------------------------------------------------------
 1 | #include <Eigen/Core>
 2 | 
 3 | #include <numpy_eigen/boost_python_headers.hpp>
 4 | Eigen::Matrix<int, 3, 1> test_int_3_1(const Eigen::Matrix<int, 3, 1> & M)
 5 | {
 6 | 	return M;
 7 | }
 8 | void export_int_3_1()
 9 | {
10 | 	boost::python::def("test_int_3_1",test_int_3_1);
11 | }
12 | 
13 | 


--------------------------------------------------------------------------------
/Schweizer-Messer/numpy_eigen/src/autogen_test_module/test_3_1_long.cpp:
--------------------------------------------------------------------------------
 1 | #include <Eigen/Core>
 2 | 
 3 | #include <numpy_eigen/boost_python_headers.hpp>
 4 | Eigen::Matrix<boost::int64_t, 3, 1> test_long_3_1(const Eigen::Matrix<boost::int64_t, 3, 1> & M)
 5 | {
 6 | 	return M;
 7 | }
 8 | void export_long_3_1()
 9 | {
10 | 	boost::python::def("test_long_3_1",test_long_3_1);
11 | }
12 | 
13 | 


--------------------------------------------------------------------------------
/Schweizer-Messer/numpy_eigen/src/autogen_test_module/test_3_1_uchar.cpp:
--------------------------------------------------------------------------------
 1 | #include <Eigen/Core>
 2 | 
 3 | #include <numpy_eigen/boost_python_headers.hpp>
 4 | Eigen::Matrix<boost::uint8_t, 3, 1> test_uchar_3_1(const Eigen::Matrix<boost::uint8_t, 3, 1> & M)
 5 | {
 6 | 	return M;
 7 | }
 8 | void export_uchar_3_1()
 9 | {
10 | 	boost::python::def("test_uchar_3_1",test_uchar_3_1);
11 | }
12 | 
13 | 


--------------------------------------------------------------------------------
/Schweizer-Messer/numpy_eigen/src/autogen_test_module/test_3_2_double.cpp:
--------------------------------------------------------------------------------
 1 | #include <Eigen/Core>
 2 | 
 3 | #include <numpy_eigen/boost_python_headers.hpp>
 4 | Eigen::Matrix<double, 3, 2> test_double_3_2(const Eigen::Matrix<double, 3, 2> & M)
 5 | {
 6 | 	return M;
 7 | }
 8 | void export_double_3_2()
 9 | {
10 | 	boost::python::def("test_double_3_2",test_double_3_2);
11 | }
12 | 
13 | 


--------------------------------------------------------------------------------
/Schweizer-Messer/numpy_eigen/src/autogen_test_module/test_3_2_float.cpp:
--------------------------------------------------------------------------------
 1 | #include <Eigen/Core>
 2 | 
 3 | #include <numpy_eigen/boost_python_headers.hpp>
 4 | Eigen::Matrix<float, 3, 2> test_float_3_2(const Eigen::Matrix<float, 3, 2> & M)
 5 | {
 6 | 	return M;
 7 | }
 8 | void export_float_3_2()
 9 | {
10 | 	boost::python::def("test_float_3_2",test_float_3_2);
11 | }
12 | 
13 | 


--------------------------------------------------------------------------------
/Schweizer-Messer/numpy_eigen/src/autogen_test_module/test_3_2_int.cpp:
--------------------------------------------------------------------------------
 1 | #include <Eigen/Core>
 2 | 
 3 | #include <numpy_eigen/boost_python_headers.hpp>
 4 | Eigen::Matrix<int, 3, 2> test_int_3_2(const Eigen::Matrix<int, 3, 2> & M)
 5 | {
 6 | 	return M;
 7 | }
 8 | void export_int_3_2()
 9 | {
10 | 	boost::python::def("test_int_3_2",test_int_3_2);
11 | }
12 | 
13 | 


--------------------------------------------------------------------------------
/Schweizer-Messer/numpy_eigen/src/autogen_test_module/test_3_2_long.cpp:
--------------------------------------------------------------------------------
 1 | #include <Eigen/Core>
 2 | 
 3 | #include <numpy_eigen/boost_python_headers.hpp>
 4 | Eigen::Matrix<boost::int64_t, 3, 2> test_long_3_2(const Eigen::Matrix<boost::int64_t, 3, 2> & M)
 5 | {
 6 | 	return M;
 7 | }
 8 | void export_long_3_2()
 9 | {
10 | 	boost::python::def("test_long_3_2",test_long_3_2);
11 | }
12 | 
13 | 


--------------------------------------------------------------------------------
/Schweizer-Messer/numpy_eigen/src/autogen_test_module/test_3_2_uchar.cpp:
--------------------------------------------------------------------------------
 1 | #include <Eigen/Core>
 2 | 
 3 | #include <numpy_eigen/boost_python_headers.hpp>
 4 | Eigen::Matrix<boost::uint8_t, 3, 2> test_uchar_3_2(const Eigen::Matrix<boost::uint8_t, 3, 2> & M)
 5 | {
 6 | 	return M;
 7 | }
 8 | void export_uchar_3_2()
 9 | {
10 | 	boost::python::def("test_uchar_3_2",test_uchar_3_2);
11 | }
12 | 
13 | 


--------------------------------------------------------------------------------
/Schweizer-Messer/numpy_eigen/src/autogen_test_module/test_3_3_double.cpp:
--------------------------------------------------------------------------------
 1 | #include <Eigen/Core>
 2 | 
 3 | #include <numpy_eigen/boost_python_headers.hpp>
 4 | Eigen::Matrix<double, 3, 3> test_double_3_3(const Eigen::Matrix<double, 3, 3> & M)
 5 | {
 6 | 	return M;
 7 | }
 8 | void export_double_3_3()
 9 | {
10 | 	boost::python::def("test_double_3_3",test_double_3_3);
11 | }
12 | 
13 | 


--------------------------------------------------------------------------------
/Schweizer-Messer/numpy_eigen/src/autogen_test_module/test_3_3_float.cpp:
--------------------------------------------------------------------------------
 1 | #include <Eigen/Core>
 2 | 
 3 | #include <numpy_eigen/boost_python_headers.hpp>
 4 | Eigen::Matrix<float, 3, 3> test_float_3_3(const Eigen::Matrix<float, 3, 3> & M)
 5 | {
 6 | 	return M;
 7 | }
 8 | void export_float_3_3()
 9 | {
10 | 	boost::python::def("test_float_3_3",test_float_3_3);
11 | }
12 | 
13 | 


--------------------------------------------------------------------------------
/Schweizer-Messer/numpy_eigen/src/autogen_test_module/test_3_3_int.cpp:
--------------------------------------------------------------------------------
 1 | #include <Eigen/Core>
 2 | 
 3 | #include <numpy_eigen/boost_python_headers.hpp>
 4 | Eigen::Matrix<int, 3, 3> test_int_3_3(const Eigen::Matrix<int, 3, 3> & M)
 5 | {
 6 | 	return M;
 7 | }
 8 | void export_int_3_3()
 9 | {
10 | 	boost::python::def("test_int_3_3",test_int_3_3);
11 | }
12 | 
13 | 


--------------------------------------------------------------------------------
/Schweizer-Messer/numpy_eigen/src/autogen_test_module/test_3_3_long.cpp:
--------------------------------------------------------------------------------
 1 | #include <Eigen/Core>
 2 | 
 3 | #include <numpy_eigen/boost_python_headers.hpp>
 4 | Eigen::Matrix<boost::int64_t, 3, 3> test_long_3_3(const Eigen::Matrix<boost::int64_t, 3, 3> & M)
 5 | {
 6 | 	return M;
 7 | }
 8 | void export_long_3_3()
 9 | {
10 | 	boost::python::def("test_long_3_3",test_long_3_3);
11 | }
12 | 
13 | 


--------------------------------------------------------------------------------
/Schweizer-Messer/numpy_eigen/src/autogen_test_module/test_3_3_uchar.cpp:
--------------------------------------------------------------------------------
 1 | #include <Eigen/Core>
 2 | 
 3 | #include <numpy_eigen/boost_python_headers.hpp>
 4 | Eigen::Matrix<boost::uint8_t, 3, 3> test_uchar_3_3(const Eigen::Matrix<boost::uint8_t, 3, 3> & M)
 5 | {
 6 | 	return M;
 7 | }
 8 | void export_uchar_3_3()
 9 | {
10 | 	boost::python::def("test_uchar_3_3",test_uchar_3_3);
11 | }
12 | 
13 | 


--------------------------------------------------------------------------------
/Schweizer-Messer/numpy_eigen/src/autogen_test_module/test_3_4_double.cpp:
--------------------------------------------------------------------------------
 1 | #include <Eigen/Core>
 2 | 
 3 | #include <numpy_eigen/boost_python_headers.hpp>
 4 | Eigen::Matrix<double, 3, 4> test_double_3_4(const Eigen::Matrix<double, 3, 4> & M)
 5 | {
 6 | 	return M;
 7 | }
 8 | void export_double_3_4()
 9 | {
10 | 	boost::python::def("test_double_3_4",test_double_3_4);
11 | }
12 | 
13 | 


--------------------------------------------------------------------------------
/Schweizer-Messer/numpy_eigen/src/autogen_test_module/test_3_4_float.cpp:
--------------------------------------------------------------------------------
 1 | #include <Eigen/Core>
 2 | 
 3 | #include <numpy_eigen/boost_python_headers.hpp>
 4 | Eigen::Matrix<float, 3, 4> test_float_3_4(const Eigen::Matrix<float, 3, 4> & M)
 5 | {
 6 | 	return M;
 7 | }
 8 | void export_float_3_4()
 9 | {
10 | 	boost::python::def("test_float_3_4",test_float_3_4);
11 | }
12 | 
13 | 


--------------------------------------------------------------------------------
/Schweizer-Messer/numpy_eigen/src/autogen_test_module/test_3_4_int.cpp:
--------------------------------------------------------------------------------
 1 | #include <Eigen/Core>
 2 | 
 3 | #include <numpy_eigen/boost_python_headers.hpp>
 4 | Eigen::Matrix<int, 3, 4> test_int_3_4(const Eigen::Matrix<int, 3, 4> & M)
 5 | {
 6 | 	return M;
 7 | }
 8 | void export_int_3_4()
 9 | {
10 | 	boost::python::def("test_int_3_4",test_int_3_4);
11 | }
12 | 
13 | 


--------------------------------------------------------------------------------
/Schweizer-Messer/numpy_eigen/src/autogen_test_module/test_3_4_long.cpp:
--------------------------------------------------------------------------------
 1 | #include <Eigen/Core>
 2 | 
 3 | #include <numpy_eigen/boost_python_headers.hpp>
 4 | Eigen::Matrix<boost::int64_t, 3, 4> test_long_3_4(const Eigen::Matrix<boost::int64_t, 3, 4> & M)
 5 | {
 6 | 	return M;
 7 | }
 8 | void export_long_3_4()
 9 | {
10 | 	boost::python::def("test_long_3_4",test_long_3_4);
11 | }
12 | 
13 | 


--------------------------------------------------------------------------------
/Schweizer-Messer/numpy_eigen/src/autogen_test_module/test_3_4_uchar.cpp:
--------------------------------------------------------------------------------
 1 | #include <Eigen/Core>
 2 | 
 3 | #include <numpy_eigen/boost_python_headers.hpp>
 4 | Eigen::Matrix<boost::uint8_t, 3, 4> test_uchar_3_4(const Eigen::Matrix<boost::uint8_t, 3, 4> & M)
 5 | {
 6 | 	return M;
 7 | }
 8 | void export_uchar_3_4()
 9 | {
10 | 	boost::python::def("test_uchar_3_4",test_uchar_3_4);
11 | }
12 | 
13 | 


--------------------------------------------------------------------------------
/Schweizer-Messer/numpy_eigen/src/autogen_test_module/test_3_5_double.cpp:
--------------------------------------------------------------------------------
 1 | #include <Eigen/Core>
 2 | 
 3 | #include <numpy_eigen/boost_python_headers.hpp>
 4 | Eigen::Matrix<double, 3, 5> test_double_3_5(const Eigen::Matrix<double, 3, 5> & M)
 5 | {
 6 | 	return M;
 7 | }
 8 | void export_double_3_5()
 9 | {
10 | 	boost::python::def("test_double_3_5",test_double_3_5);
11 | }
12 | 
13 | 


--------------------------------------------------------------------------------
/Schweizer-Messer/numpy_eigen/src/autogen_test_module/test_3_5_float.cpp:
--------------------------------------------------------------------------------
 1 | #include <Eigen/Core>
 2 | 
 3 | #include <numpy_eigen/boost_python_headers.hpp>
 4 | Eigen::Matrix<float, 3, 5> test_float_3_5(const Eigen::Matrix<float, 3, 5> & M)
 5 | {
 6 | 	return M;
 7 | }
 8 | void export_float_3_5()
 9 | {
10 | 	boost::python::def("test_float_3_5",test_float_3_5);
11 | }
12 | 
13 | 


--------------------------------------------------------------------------------
/Schweizer-Messer/numpy_eigen/src/autogen_test_module/test_3_5_int.cpp:
--------------------------------------------------------------------------------
 1 | #include <Eigen/Core>
 2 | 
 3 | #include <numpy_eigen/boost_python_headers.hpp>
 4 | Eigen::Matrix<int, 3, 5> test_int_3_5(const Eigen::Matrix<int, 3, 5> & M)
 5 | {
 6 | 	return M;
 7 | }
 8 | void export_int_3_5()
 9 | {
10 | 	boost::python::def("test_int_3_5",test_int_3_5);
11 | }
12 | 
13 | 


--------------------------------------------------------------------------------
/Schweizer-Messer/numpy_eigen/src/autogen_test_module/test_3_5_long.cpp:
--------------------------------------------------------------------------------
 1 | #include <Eigen/Core>
 2 | 
 3 | #include <numpy_eigen/boost_python_headers.hpp>
 4 | Eigen::Matrix<boost::int64_t, 3, 5> test_long_3_5(const Eigen::Matrix<boost::int64_t, 3, 5> & M)
 5 | {
 6 | 	return M;
 7 | }
 8 | void export_long_3_5()
 9 | {
10 | 	boost::python::def("test_long_3_5",test_long_3_5);
11 | }
12 | 
13 | 


--------------------------------------------------------------------------------
/Schweizer-Messer/numpy_eigen/src/autogen_test_module/test_3_5_uchar.cpp:
--------------------------------------------------------------------------------
 1 | #include <Eigen/Core>
 2 | 
 3 | #include <numpy_eigen/boost_python_headers.hpp>
 4 | Eigen::Matrix<boost::uint8_t, 3, 5> test_uchar_3_5(const Eigen::Matrix<boost::uint8_t, 3, 5> & M)
 5 | {
 6 | 	return M;
 7 | }
 8 | void export_uchar_3_5()
 9 | {
10 | 	boost::python::def("test_uchar_3_5",test_uchar_3_5);
11 | }
12 | 
13 | 


--------------------------------------------------------------------------------
/Schweizer-Messer/numpy_eigen/src/autogen_test_module/test_3_6_double.cpp:
--------------------------------------------------------------------------------
 1 | #include <Eigen/Core>
 2 | 
 3 | #include <numpy_eigen/boost_python_headers.hpp>
 4 | Eigen::Matrix<double, 3, 6> test_double_3_6(const Eigen::Matrix<double, 3, 6> & M)
 5 | {
 6 | 	return M;
 7 | }
 8 | void export_double_3_6()
 9 | {
10 | 	boost::python::def("test_double_3_6",test_double_3_6);
11 | }
12 | 
13 | 


--------------------------------------------------------------------------------
/Schweizer-Messer/numpy_eigen/src/autogen_test_module/test_3_6_float.cpp:
--------------------------------------------------------------------------------
 1 | #include <Eigen/Core>
 2 | 
 3 | #include <numpy_eigen/boost_python_headers.hpp>
 4 | Eigen::Matrix<float, 3, 6> test_float_3_6(const Eigen::Matrix<float, 3, 6> & M)
 5 | {
 6 | 	return M;
 7 | }
 8 | void export_float_3_6()
 9 | {
10 | 	boost::python::def("test_float_3_6",test_float_3_6);
11 | }
12 | 
13 | 


--------------------------------------------------------------------------------
/Schweizer-Messer/numpy_eigen/src/autogen_test_module/test_3_6_int.cpp:
--------------------------------------------------------------------------------
 1 | #include <Eigen/Core>
 2 | 
 3 | #include <numpy_eigen/boost_python_headers.hpp>
 4 | Eigen::Matrix<int, 3, 6> test_int_3_6(const Eigen::Matrix<int, 3, 6> & M)
 5 | {
 6 | 	return M;
 7 | }
 8 | void export_int_3_6()
 9 | {
10 | 	boost::python::def("test_int_3_6",test_int_3_6);
11 | }
12 | 
13 | 


--------------------------------------------------------------------------------
/Schweizer-Messer/numpy_eigen/src/autogen_test_module/test_3_6_long.cpp:
--------------------------------------------------------------------------------
 1 | #include <Eigen/Core>
 2 | 
 3 | #include <numpy_eigen/boost_python_headers.hpp>
 4 | Eigen::Matrix<boost::int64_t, 3, 6> test_long_3_6(const Eigen::Matrix<boost::int64_t, 3, 6> & M)
 5 | {
 6 | 	return M;
 7 | }
 8 | void export_long_3_6()
 9 | {
10 | 	boost::python::def("test_long_3_6",test_long_3_6);
11 | }
12 | 
13 | 


--------------------------------------------------------------------------------
/Schweizer-Messer/numpy_eigen/src/autogen_test_module/test_3_6_uchar.cpp:
--------------------------------------------------------------------------------
 1 | #include <Eigen/Core>
 2 | 
 3 | #include <numpy_eigen/boost_python_headers.hpp>
 4 | Eigen::Matrix<boost::uint8_t, 3, 6> test_uchar_3_6(const Eigen::Matrix<boost::uint8_t, 3, 6> & M)
 5 | {
 6 | 	return M;
 7 | }
 8 | void export_uchar_3_6()
 9 | {
10 | 	boost::python::def("test_uchar_3_6",test_uchar_3_6);
11 | }
12 | 
13 | 


--------------------------------------------------------------------------------
/Schweizer-Messer/numpy_eigen/src/autogen_test_module/test_3_D_int.cpp:
--------------------------------------------------------------------------------
 1 | #include <Eigen/Core>
 2 | 
 3 | #include <numpy_eigen/boost_python_headers.hpp>
 4 | Eigen::Matrix<int, 3, Eigen::Dynamic> test_int_3_D(const Eigen::Matrix<int, 3, Eigen::Dynamic> & M)
 5 | {
 6 | 	return M;
 7 | }
 8 | void export_int_3_D()
 9 | {
10 | 	boost::python::def("test_int_3_D",test_int_3_D);
11 | }
12 | 
13 | 


--------------------------------------------------------------------------------
/Schweizer-Messer/numpy_eigen/src/autogen_test_module/test_4_1_double.cpp:
--------------------------------------------------------------------------------
 1 | #include <Eigen/Core>
 2 | 
 3 | #include <numpy_eigen/boost_python_headers.hpp>
 4 | Eigen::Matrix<double, 4, 1> test_double_4_1(const Eigen::Matrix<double, 4, 1> & M)
 5 | {
 6 | 	return M;
 7 | }
 8 | void export_double_4_1()
 9 | {
10 | 	boost::python::def("test_double_4_1",test_double_4_1);
11 | }
12 | 
13 | 


--------------------------------------------------------------------------------
/Schweizer-Messer/numpy_eigen/src/autogen_test_module/test_4_1_float.cpp:
--------------------------------------------------------------------------------
 1 | #include <Eigen/Core>
 2 | 
 3 | #include <numpy_eigen/boost_python_headers.hpp>
 4 | Eigen::Matrix<float, 4, 1> test_float_4_1(const Eigen::Matrix<float, 4, 1> & M)
 5 | {
 6 | 	return M;
 7 | }
 8 | void export_float_4_1()
 9 | {
10 | 	boost::python::def("test_float_4_1",test_float_4_1);
11 | }
12 | 
13 | 


--------------------------------------------------------------------------------
/Schweizer-Messer/numpy_eigen/src/autogen_test_module/test_4_1_int.cpp:
--------------------------------------------------------------------------------
 1 | #include <Eigen/Core>
 2 | 
 3 | #include <numpy_eigen/boost_python_headers.hpp>
 4 | Eigen::Matrix<int, 4, 1> test_int_4_1(const Eigen::Matrix<int, 4, 1> & M)
 5 | {
 6 | 	return M;
 7 | }
 8 | void export_int_4_1()
 9 | {
10 | 	boost::python::def("test_int_4_1",test_int_4_1);
11 | }
12 | 
13 | 


--------------------------------------------------------------------------------
/Schweizer-Messer/numpy_eigen/src/autogen_test_module/test_4_1_long.cpp:
--------------------------------------------------------------------------------
 1 | #include <Eigen/Core>
 2 | 
 3 | #include <numpy_eigen/boost_python_headers.hpp>
 4 | Eigen::Matrix<boost::int64_t, 4, 1> test_long_4_1(const Eigen::Matrix<boost::int64_t, 4, 1> & M)
 5 | {
 6 | 	return M;
 7 | }
 8 | void export_long_4_1()
 9 | {
10 | 	boost::python::def("test_long_4_1",test_long_4_1);
11 | }
12 | 
13 | 


--------------------------------------------------------------------------------
/Schweizer-Messer/numpy_eigen/src/autogen_test_module/test_4_1_uchar.cpp:
--------------------------------------------------------------------------------
 1 | #include <Eigen/Core>
 2 | 
 3 | #include <numpy_eigen/boost_python_headers.hpp>
 4 | Eigen::Matrix<boost::uint8_t, 4, 1> test_uchar_4_1(const Eigen::Matrix<boost::uint8_t, 4, 1> & M)
 5 | {
 6 | 	return M;
 7 | }
 8 | void export_uchar_4_1()
 9 | {
10 | 	boost::python::def("test_uchar_4_1",test_uchar_4_1);
11 | }
12 | 
13 | 


--------------------------------------------------------------------------------
/Schweizer-Messer/numpy_eigen/src/autogen_test_module/test_4_2_double.cpp:
--------------------------------------------------------------------------------
 1 | #include <Eigen/Core>
 2 | 
 3 | #include <numpy_eigen/boost_python_headers.hpp>
 4 | Eigen::Matrix<double, 4, 2> test_double_4_2(const Eigen::Matrix<double, 4, 2> & M)
 5 | {
 6 | 	return M;
 7 | }
 8 | void export_double_4_2()
 9 | {
10 | 	boost::python::def("test_double_4_2",test_double_4_2);
11 | }
12 | 
13 | 


--------------------------------------------------------------------------------
/Schweizer-Messer/numpy_eigen/src/autogen_test_module/test_4_2_float.cpp:
--------------------------------------------------------------------------------
 1 | #include <Eigen/Core>
 2 | 
 3 | #include <numpy_eigen/boost_python_headers.hpp>
 4 | Eigen::Matrix<float, 4, 2> test_float_4_2(const Eigen::Matrix<float, 4, 2> & M)
 5 | {
 6 | 	return M;
 7 | }
 8 | void export_float_4_2()
 9 | {
10 | 	boost::python::def("test_float_4_2",test_float_4_2);
11 | }
12 | 
13 | 


--------------------------------------------------------------------------------
/Schweizer-Messer/numpy_eigen/src/autogen_test_module/test_4_2_int.cpp:
--------------------------------------------------------------------------------
 1 | #include <Eigen/Core>
 2 | 
 3 | #include <numpy_eigen/boost_python_headers.hpp>
 4 | Eigen::Matrix<int, 4, 2> test_int_4_2(const Eigen::Matrix<int, 4, 2> & M)
 5 | {
 6 | 	return M;
 7 | }
 8 | void export_int_4_2()
 9 | {
10 | 	boost::python::def("test_int_4_2",test_int_4_2);
11 | }
12 | 
13 | 


--------------------------------------------------------------------------------
/Schweizer-Messer/numpy_eigen/src/autogen_test_module/test_4_2_long.cpp:
--------------------------------------------------------------------------------
 1 | #include <Eigen/Core>
 2 | 
 3 | #include <numpy_eigen/boost_python_headers.hpp>
 4 | Eigen::Matrix<boost::int64_t, 4, 2> test_long_4_2(const Eigen::Matrix<boost::int64_t, 4, 2> & M)
 5 | {
 6 | 	return M;
 7 | }
 8 | void export_long_4_2()
 9 | {
10 | 	boost::python::def("test_long_4_2",test_long_4_2);
11 | }
12 | 
13 | 


--------------------------------------------------------------------------------
/Schweizer-Messer/numpy_eigen/src/autogen_test_module/test_4_2_uchar.cpp:
--------------------------------------------------------------------------------
 1 | #include <Eigen/Core>
 2 | 
 3 | #include <numpy_eigen/boost_python_headers.hpp>
 4 | Eigen::Matrix<boost::uint8_t, 4, 2> test_uchar_4_2(const Eigen::Matrix<boost::uint8_t, 4, 2> & M)
 5 | {
 6 | 	return M;
 7 | }
 8 | void export_uchar_4_2()
 9 | {
10 | 	boost::python::def("test_uchar_4_2",test_uchar_4_2);
11 | }
12 | 
13 | 


--------------------------------------------------------------------------------
/Schweizer-Messer/numpy_eigen/src/autogen_test_module/test_4_3_double.cpp:
--------------------------------------------------------------------------------
 1 | #include <Eigen/Core>
 2 | 
 3 | #include <numpy_eigen/boost_python_headers.hpp>
 4 | Eigen::Matrix<double, 4, 3> test_double_4_3(const Eigen::Matrix<double, 4, 3> & M)
 5 | {
 6 | 	return M;
 7 | }
 8 | void export_double_4_3()
 9 | {
10 | 	boost::python::def("test_double_4_3",test_double_4_3);
11 | }
12 | 
13 | 


--------------------------------------------------------------------------------
/Schweizer-Messer/numpy_eigen/src/autogen_test_module/test_4_3_float.cpp:
--------------------------------------------------------------------------------
 1 | #include <Eigen/Core>
 2 | 
 3 | #include <numpy_eigen/boost_python_headers.hpp>
 4 | Eigen::Matrix<float, 4, 3> test_float_4_3(const Eigen::Matrix<float, 4, 3> & M)
 5 | {
 6 | 	return M;
 7 | }
 8 | void export_float_4_3()
 9 | {
10 | 	boost::python::def("test_float_4_3",test_float_4_3);
11 | }
12 | 
13 | 


--------------------------------------------------------------------------------
/Schweizer-Messer/numpy_eigen/src/autogen_test_module/test_4_3_int.cpp:
--------------------------------------------------------------------------------
 1 | #include <Eigen/Core>
 2 | 
 3 | #include <numpy_eigen/boost_python_headers.hpp>
 4 | Eigen::Matrix<int, 4, 3> test_int_4_3(const Eigen::Matrix<int, 4, 3> & M)
 5 | {
 6 | 	return M;
 7 | }
 8 | void export_int_4_3()
 9 | {
10 | 	boost::python::def("test_int_4_3",test_int_4_3);
11 | }
12 | 
13 | 


--------------------------------------------------------------------------------
/Schweizer-Messer/numpy_eigen/src/autogen_test_module/test_4_3_long.cpp:
--------------------------------------------------------------------------------
 1 | #include <Eigen/Core>
 2 | 
 3 | #include <numpy_eigen/boost_python_headers.hpp>
 4 | Eigen::Matrix<boost::int64_t, 4, 3> test_long_4_3(const Eigen::Matrix<boost::int64_t, 4, 3> & M)
 5 | {
 6 | 	return M;
 7 | }
 8 | void export_long_4_3()
 9 | {
10 | 	boost::python::def("test_long_4_3",test_long_4_3);
11 | }
12 | 
13 | 


--------------------------------------------------------------------------------
/Schweizer-Messer/numpy_eigen/src/autogen_test_module/test_4_3_uchar.cpp:
--------------------------------------------------------------------------------
 1 | #include <Eigen/Core>
 2 | 
 3 | #include <numpy_eigen/boost_python_headers.hpp>
 4 | Eigen::Matrix<boost::uint8_t, 4, 3> test_uchar_4_3(const Eigen::Matrix<boost::uint8_t, 4, 3> & M)
 5 | {
 6 | 	return M;
 7 | }
 8 | void export_uchar_4_3()
 9 | {
10 | 	boost::python::def("test_uchar_4_3",test_uchar_4_3);
11 | }
12 | 
13 | 


--------------------------------------------------------------------------------
/Schweizer-Messer/numpy_eigen/src/autogen_test_module/test_4_4_double.cpp:
--------------------------------------------------------------------------------
 1 | #include <Eigen/Core>
 2 | 
 3 | #include <numpy_eigen/boost_python_headers.hpp>
 4 | Eigen::Matrix<double, 4, 4> test_double_4_4(const Eigen::Matrix<double, 4, 4> & M)
 5 | {
 6 | 	return M;
 7 | }
 8 | void export_double_4_4()
 9 | {
10 | 	boost::python::def("test_double_4_4",test_double_4_4);
11 | }
12 | 
13 | 


--------------------------------------------------------------------------------
/Schweizer-Messer/numpy_eigen/src/autogen_test_module/test_4_4_float.cpp:
--------------------------------------------------------------------------------
 1 | #include <Eigen/Core>
 2 | 
 3 | #include <numpy_eigen/boost_python_headers.hpp>
 4 | Eigen::Matrix<float, 4, 4> test_float_4_4(const Eigen::Matrix<float, 4, 4> & M)
 5 | {
 6 | 	return M;
 7 | }
 8 | void export_float_4_4()
 9 | {
10 | 	boost::python::def("test_float_4_4",test_float_4_4);
11 | }
12 | 
13 | 


--------------------------------------------------------------------------------
/Schweizer-Messer/numpy_eigen/src/autogen_test_module/test_4_4_int.cpp:
--------------------------------------------------------------------------------
 1 | #include <Eigen/Core>
 2 | 
 3 | #include <numpy_eigen/boost_python_headers.hpp>
 4 | Eigen::Matrix<int, 4, 4> test_int_4_4(const Eigen::Matrix<int, 4, 4> & M)
 5 | {
 6 | 	return M;
 7 | }
 8 | void export_int_4_4()
 9 | {
10 | 	boost::python::def("test_int_4_4",test_int_4_4);
11 | }
12 | 
13 | 


--------------------------------------------------------------------------------
/Schweizer-Messer/numpy_eigen/src/autogen_test_module/test_4_4_long.cpp:
--------------------------------------------------------------------------------
 1 | #include <Eigen/Core>
 2 | 
 3 | #include <numpy_eigen/boost_python_headers.hpp>
 4 | Eigen::Matrix<boost::int64_t, 4, 4> test_long_4_4(const Eigen::Matrix<boost::int64_t, 4, 4> & M)
 5 | {
 6 | 	return M;
 7 | }
 8 | void export_long_4_4()
 9 | {
10 | 	boost::python::def("test_long_4_4",test_long_4_4);
11 | }
12 | 
13 | 


--------------------------------------------------------------------------------
/Schweizer-Messer/numpy_eigen/src/autogen_test_module/test_4_4_uchar.cpp:
--------------------------------------------------------------------------------
 1 | #include <Eigen/Core>
 2 | 
 3 | #include <numpy_eigen/boost_python_headers.hpp>
 4 | Eigen::Matrix<boost::uint8_t, 4, 4> test_uchar_4_4(const Eigen::Matrix<boost::uint8_t, 4, 4> & M)
 5 | {
 6 | 	return M;
 7 | }
 8 | void export_uchar_4_4()
 9 | {
10 | 	boost::python::def("test_uchar_4_4",test_uchar_4_4);
11 | }
12 | 
13 | 


--------------------------------------------------------------------------------
/Schweizer-Messer/numpy_eigen/src/autogen_test_module/test_4_5_double.cpp:
--------------------------------------------------------------------------------
 1 | #include <Eigen/Core>
 2 | 
 3 | #include <numpy_eigen/boost_python_headers.hpp>
 4 | Eigen::Matrix<double, 4, 5> test_double_4_5(const Eigen::Matrix<double, 4, 5> & M)
 5 | {
 6 | 	return M;
 7 | }
 8 | void export_double_4_5()
 9 | {
10 | 	boost::python::def("test_double_4_5",test_double_4_5);
11 | }
12 | 
13 | 


--------------------------------------------------------------------------------
/Schweizer-Messer/numpy_eigen/src/autogen_test_module/test_4_5_float.cpp:
--------------------------------------------------------------------------------
 1 | #include <Eigen/Core>
 2 | 
 3 | #include <numpy_eigen/boost_python_headers.hpp>
 4 | Eigen::Matrix<float, 4, 5> test_float_4_5(const Eigen::Matrix<float, 4, 5> & M)
 5 | {
 6 | 	return M;
 7 | }
 8 | void export_float_4_5()
 9 | {
10 | 	boost::python::def("test_float_4_5",test_float_4_5);
11 | }
12 | 
13 | 


--------------------------------------------------------------------------------
/Schweizer-Messer/numpy_eigen/src/autogen_test_module/test_4_5_int.cpp:
--------------------------------------------------------------------------------
 1 | #include <Eigen/Core>
 2 | 
 3 | #include <numpy_eigen/boost_python_headers.hpp>
 4 | Eigen::Matrix<int, 4, 5> test_int_4_5(const Eigen::Matrix<int, 4, 5> & M)
 5 | {
 6 | 	return M;
 7 | }
 8 | void export_int_4_5()
 9 | {
10 | 	boost::python::def("test_int_4_5",test_int_4_5);
11 | }
12 | 
13 | 


--------------------------------------------------------------------------------
/Schweizer-Messer/numpy_eigen/src/autogen_test_module/test_4_5_long.cpp:
--------------------------------------------------------------------------------
 1 | #include <Eigen/Core>
 2 | 
 3 | #include <numpy_eigen/boost_python_headers.hpp>
 4 | Eigen::Matrix<boost::int64_t, 4, 5> test_long_4_5(const Eigen::Matrix<boost::int64_t, 4, 5> & M)
 5 | {
 6 | 	return M;
 7 | }
 8 | void export_long_4_5()
 9 | {
10 | 	boost::python::def("test_long_4_5",test_long_4_5);
11 | }
12 | 
13 | 


--------------------------------------------------------------------------------
/Schweizer-Messer/numpy_eigen/src/autogen_test_module/test_4_5_uchar.cpp:
--------------------------------------------------------------------------------
 1 | #include <Eigen/Core>
 2 | 
 3 | #include <numpy_eigen/boost_python_headers.hpp>
 4 | Eigen::Matrix<boost::uint8_t, 4, 5> test_uchar_4_5(const Eigen::Matrix<boost::uint8_t, 4, 5> & M)
 5 | {
 6 | 	return M;
 7 | }
 8 | void export_uchar_4_5()
 9 | {
10 | 	boost::python::def("test_uchar_4_5",test_uchar_4_5);
11 | }
12 | 
13 | 


--------------------------------------------------------------------------------
/Schweizer-Messer/numpy_eigen/src/autogen_test_module/test_4_6_double.cpp:
--------------------------------------------------------------------------------
 1 | #include <Eigen/Core>
 2 | 
 3 | #include <numpy_eigen/boost_python_headers.hpp>
 4 | Eigen::Matrix<double, 4, 6> test_double_4_6(const Eigen::Matrix<double, 4, 6> & M)
 5 | {
 6 | 	return M;
 7 | }
 8 | void export_double_4_6()
 9 | {
10 | 	boost::python::def("test_double_4_6",test_double_4_6);
11 | }
12 | 
13 | 


--------------------------------------------------------------------------------
/Schweizer-Messer/numpy_eigen/src/autogen_test_module/test_4_6_float.cpp:
--------------------------------------------------------------------------------
 1 | #include <Eigen/Core>
 2 | 
 3 | #include <numpy_eigen/boost_python_headers.hpp>
 4 | Eigen::Matrix<float, 4, 6> test_float_4_6(const Eigen::Matrix<float, 4, 6> & M)
 5 | {
 6 | 	return M;
 7 | }
 8 | void export_float_4_6()
 9 | {
10 | 	boost::python::def("test_float_4_6",test_float_4_6);
11 | }
12 | 
13 | 


--------------------------------------------------------------------------------
/Schweizer-Messer/numpy_eigen/src/autogen_test_module/test_4_6_int.cpp:
--------------------------------------------------------------------------------
 1 | #include <Eigen/Core>
 2 | 
 3 | #include <numpy_eigen/boost_python_headers.hpp>
 4 | Eigen::Matrix<int, 4, 6> test_int_4_6(const Eigen::Matrix<int, 4, 6> & M)
 5 | {
 6 | 	return M;
 7 | }
 8 | void export_int_4_6()
 9 | {
10 | 	boost::python::def("test_int_4_6",test_int_4_6);
11 | }
12 | 
13 | 


--------------------------------------------------------------------------------
/Schweizer-Messer/numpy_eigen/src/autogen_test_module/test_4_6_long.cpp:
--------------------------------------------------------------------------------
 1 | #include <Eigen/Core>
 2 | 
 3 | #include <numpy_eigen/boost_python_headers.hpp>
 4 | Eigen::Matrix<boost::int64_t, 4, 6> test_long_4_6(const Eigen::Matrix<boost::int64_t, 4, 6> & M)
 5 | {
 6 | 	return M;
 7 | }
 8 | void export_long_4_6()
 9 | {
10 | 	boost::python::def("test_long_4_6",test_long_4_6);
11 | }
12 | 
13 | 


--------------------------------------------------------------------------------
/Schweizer-Messer/numpy_eigen/src/autogen_test_module/test_4_6_uchar.cpp:
--------------------------------------------------------------------------------
 1 | #include <Eigen/Core>
 2 | 
 3 | #include <numpy_eigen/boost_python_headers.hpp>
 4 | Eigen::Matrix<boost::uint8_t, 4, 6> test_uchar_4_6(const Eigen::Matrix<boost::uint8_t, 4, 6> & M)
 5 | {
 6 | 	return M;
 7 | }
 8 | void export_uchar_4_6()
 9 | {
10 | 	boost::python::def("test_uchar_4_6",test_uchar_4_6);
11 | }
12 | 
13 | 


--------------------------------------------------------------------------------
/Schweizer-Messer/numpy_eigen/src/autogen_test_module/test_4_D_int.cpp:
--------------------------------------------------------------------------------
 1 | #include <Eigen/Core>
 2 | 
 3 | #include <numpy_eigen/boost_python_headers.hpp>
 4 | Eigen::Matrix<int, 4, Eigen::Dynamic> test_int_4_D(const Eigen::Matrix<int, 4, Eigen::Dynamic> & M)
 5 | {
 6 | 	return M;
 7 | }
 8 | void export_int_4_D()
 9 | {
10 | 	boost::python::def("test_int_4_D",test_int_4_D);
11 | }
12 | 
13 | 


--------------------------------------------------------------------------------
/Schweizer-Messer/numpy_eigen/src/autogen_test_module/test_5_1_double.cpp:
--------------------------------------------------------------------------------
 1 | #include <Eigen/Core>
 2 | 
 3 | #include <numpy_eigen/boost_python_headers.hpp>
 4 | Eigen::Matrix<double, 5, 1> test_double_5_1(const Eigen::Matrix<double, 5, 1> & M)
 5 | {
 6 | 	return M;
 7 | }
 8 | void export_double_5_1()
 9 | {
10 | 	boost::python::def("test_double_5_1",test_double_5_1);
11 | }
12 | 
13 | 


--------------------------------------------------------------------------------
/Schweizer-Messer/numpy_eigen/src/autogen_test_module/test_5_1_float.cpp:
--------------------------------------------------------------------------------
 1 | #include <Eigen/Core>
 2 | 
 3 | #include <numpy_eigen/boost_python_headers.hpp>
 4 | Eigen::Matrix<float, 5, 1> test_float_5_1(const Eigen::Matrix<float, 5, 1> & M)
 5 | {
 6 | 	return M;
 7 | }
 8 | void export_float_5_1()
 9 | {
10 | 	boost::python::def("test_float_5_1",test_float_5_1);
11 | }
12 | 
13 | 


--------------------------------------------------------------------------------
/Schweizer-Messer/numpy_eigen/src/autogen_test_module/test_5_1_int.cpp:
--------------------------------------------------------------------------------
 1 | #include <Eigen/Core>
 2 | 
 3 | #include <numpy_eigen/boost_python_headers.hpp>
 4 | Eigen::Matrix<int, 5, 1> test_int_5_1(const Eigen::Matrix<int, 5, 1> & M)
 5 | {
 6 | 	return M;
 7 | }
 8 | void export_int_5_1()
 9 | {
10 | 	boost::python::def("test_int_5_1",test_int_5_1);
11 | }
12 | 
13 | 


--------------------------------------------------------------------------------
/Schweizer-Messer/numpy_eigen/src/autogen_test_module/test_5_1_long.cpp:
--------------------------------------------------------------------------------
 1 | #include <Eigen/Core>
 2 | 
 3 | #include <numpy_eigen/boost_python_headers.hpp>
 4 | Eigen::Matrix<boost::int64_t, 5, 1> test_long_5_1(const Eigen::Matrix<boost::int64_t, 5, 1> & M)
 5 | {
 6 | 	return M;
 7 | }
 8 | void export_long_5_1()
 9 | {
10 | 	boost::python::def("test_long_5_1",test_long_5_1);
11 | }
12 | 
13 | 


--------------------------------------------------------------------------------
/Schweizer-Messer/numpy_eigen/src/autogen_test_module/test_5_1_uchar.cpp:
--------------------------------------------------------------------------------
 1 | #include <Eigen/Core>
 2 | 
 3 | #include <numpy_eigen/boost_python_headers.hpp>
 4 | Eigen::Matrix<boost::uint8_t, 5, 1> test_uchar_5_1(const Eigen::Matrix<boost::uint8_t, 5, 1> & M)
 5 | {
 6 | 	return M;
 7 | }
 8 | void export_uchar_5_1()
 9 | {
10 | 	boost::python::def("test_uchar_5_1",test_uchar_5_1);
11 | }
12 | 
13 | 


--------------------------------------------------------------------------------
/Schweizer-Messer/numpy_eigen/src/autogen_test_module/test_5_2_double.cpp:
--------------------------------------------------------------------------------
 1 | #include <Eigen/Core>
 2 | 
 3 | #include <numpy_eigen/boost_python_headers.hpp>
 4 | Eigen::Matrix<double, 5, 2> test_double_5_2(const Eigen::Matrix<double, 5, 2> & M)
 5 | {
 6 | 	return M;
 7 | }
 8 | void export_double_5_2()
 9 | {
10 | 	boost::python::def("test_double_5_2",test_double_5_2);
11 | }
12 | 
13 | 


--------------------------------------------------------------------------------
/Schweizer-Messer/numpy_eigen/src/autogen_test_module/test_5_2_float.cpp:
--------------------------------------------------------------------------------
 1 | #include <Eigen/Core>
 2 | 
 3 | #include <numpy_eigen/boost_python_headers.hpp>
 4 | Eigen::Matrix<float, 5, 2> test_float_5_2(const Eigen::Matrix<float, 5, 2> & M)
 5 | {
 6 | 	return M;
 7 | }
 8 | void export_float_5_2()
 9 | {
10 | 	boost::python::def("test_float_5_2",test_float_5_2);
11 | }
12 | 
13 | 


--------------------------------------------------------------------------------
/Schweizer-Messer/numpy_eigen/src/autogen_test_module/test_5_2_int.cpp:
--------------------------------------------------------------------------------
 1 | #include <Eigen/Core>
 2 | 
 3 | #include <numpy_eigen/boost_python_headers.hpp>
 4 | Eigen::Matrix<int, 5, 2> test_int_5_2(const Eigen::Matrix<int, 5, 2> & M)
 5 | {
 6 | 	return M;
 7 | }
 8 | void export_int_5_2()
 9 | {
10 | 	boost::python::def("test_int_5_2",test_int_5_2);
11 | }
12 | 
13 | 


--------------------------------------------------------------------------------
/Schweizer-Messer/numpy_eigen/src/autogen_test_module/test_5_2_long.cpp:
--------------------------------------------------------------------------------
 1 | #include <Eigen/Core>
 2 | 
 3 | #include <numpy_eigen/boost_python_headers.hpp>
 4 | Eigen::Matrix<boost::int64_t, 5, 2> test_long_5_2(const Eigen::Matrix<boost::int64_t, 5, 2> & M)
 5 | {
 6 | 	return M;
 7 | }
 8 | void export_long_5_2()
 9 | {
10 | 	boost::python::def("test_long_5_2",test_long_5_2);
11 | }
12 | 
13 | 


--------------------------------------------------------------------------------
/Schweizer-Messer/numpy_eigen/src/autogen_test_module/test_5_2_uchar.cpp:
--------------------------------------------------------------------------------
 1 | #include <Eigen/Core>
 2 | 
 3 | #include <numpy_eigen/boost_python_headers.hpp>
 4 | Eigen::Matrix<boost::uint8_t, 5, 2> test_uchar_5_2(const Eigen::Matrix<boost::uint8_t, 5, 2> & M)
 5 | {
 6 | 	return M;
 7 | }
 8 | void export_uchar_5_2()
 9 | {
10 | 	boost::python::def("test_uchar_5_2",test_uchar_5_2);
11 | }
12 | 
13 | 


--------------------------------------------------------------------------------
/Schweizer-Messer/numpy_eigen/src/autogen_test_module/test_5_3_double.cpp:
--------------------------------------------------------------------------------
 1 | #include <Eigen/Core>
 2 | 
 3 | #include <numpy_eigen/boost_python_headers.hpp>
 4 | Eigen::Matrix<double, 5, 3> test_double_5_3(const Eigen::Matrix<double, 5, 3> & M)
 5 | {
 6 | 	return M;
 7 | }
 8 | void export_double_5_3()
 9 | {
10 | 	boost::python::def("test_double_5_3",test_double_5_3);
11 | }
12 | 
13 | 


--------------------------------------------------------------------------------
/Schweizer-Messer/numpy_eigen/src/autogen_test_module/test_5_3_float.cpp:
--------------------------------------------------------------------------------
 1 | #include <Eigen/Core>
 2 | 
 3 | #include <numpy_eigen/boost_python_headers.hpp>
 4 | Eigen::Matrix<float, 5, 3> test_float_5_3(const Eigen::Matrix<float, 5, 3> & M)
 5 | {
 6 | 	return M;
 7 | }
 8 | void export_float_5_3()
 9 | {
10 | 	boost::python::def("test_float_5_3",test_float_5_3);
11 | }
12 | 
13 | 


--------------------------------------------------------------------------------
/Schweizer-Messer/numpy_eigen/src/autogen_test_module/test_5_3_int.cpp:
--------------------------------------------------------------------------------
 1 | #include <Eigen/Core>
 2 | 
 3 | #include <numpy_eigen/boost_python_headers.hpp>
 4 | Eigen::Matrix<int, 5, 3> test_int_5_3(const Eigen::Matrix<int, 5, 3> & M)
 5 | {
 6 | 	return M;
 7 | }
 8 | void export_int_5_3()
 9 | {
10 | 	boost::python::def("test_int_5_3",test_int_5_3);
11 | }
12 | 
13 | 


--------------------------------------------------------------------------------
/Schweizer-Messer/numpy_eigen/src/autogen_test_module/test_5_3_long.cpp:
--------------------------------------------------------------------------------
 1 | #include <Eigen/Core>
 2 | 
 3 | #include <numpy_eigen/boost_python_headers.hpp>
 4 | Eigen::Matrix<boost::int64_t, 5, 3> test_long_5_3(const Eigen::Matrix<boost::int64_t, 5, 3> & M)
 5 | {
 6 | 	return M;
 7 | }
 8 | void export_long_5_3()
 9 | {
10 | 	boost::python::def("test_long_5_3",test_long_5_3);
11 | }
12 | 
13 | 


--------------------------------------------------------------------------------
/Schweizer-Messer/numpy_eigen/src/autogen_test_module/test_5_3_uchar.cpp:
--------------------------------------------------------------------------------
 1 | #include <Eigen/Core>
 2 | 
 3 | #include <numpy_eigen/boost_python_headers.hpp>
 4 | Eigen::Matrix<boost::uint8_t, 5, 3> test_uchar_5_3(const Eigen::Matrix<boost::uint8_t, 5, 3> & M)
 5 | {
 6 | 	return M;
 7 | }
 8 | void export_uchar_5_3()
 9 | {
10 | 	boost::python::def("test_uchar_5_3",test_uchar_5_3);
11 | }
12 | 
13 | 


--------------------------------------------------------------------------------
/Schweizer-Messer/numpy_eigen/src/autogen_test_module/test_5_4_double.cpp:
--------------------------------------------------------------------------------
 1 | #include <Eigen/Core>
 2 | 
 3 | #include <numpy_eigen/boost_python_headers.hpp>
 4 | Eigen::Matrix<double, 5, 4> test_double_5_4(const Eigen::Matrix<double, 5, 4> & M)
 5 | {
 6 | 	return M;
 7 | }
 8 | void export_double_5_4()
 9 | {
10 | 	boost::python::def("test_double_5_4",test_double_5_4);
11 | }
12 | 
13 | 


--------------------------------------------------------------------------------
/Schweizer-Messer/numpy_eigen/src/autogen_test_module/test_5_4_float.cpp:
--------------------------------------------------------------------------------
 1 | #include <Eigen/Core>
 2 | 
 3 | #include <numpy_eigen/boost_python_headers.hpp>
 4 | Eigen::Matrix<float, 5, 4> test_float_5_4(const Eigen::Matrix<float, 5, 4> & M)
 5 | {
 6 | 	return M;
 7 | }
 8 | void export_float_5_4()
 9 | {
10 | 	boost::python::def("test_float_5_4",test_float_5_4);
11 | }
12 | 
13 | 


--------------------------------------------------------------------------------
/Schweizer-Messer/numpy_eigen/src/autogen_test_module/test_5_4_int.cpp:
--------------------------------------------------------------------------------
 1 | #include <Eigen/Core>
 2 | 
 3 | #include <numpy_eigen/boost_python_headers.hpp>
 4 | Eigen::Matrix<int, 5, 4> test_int_5_4(const Eigen::Matrix<int, 5, 4> & M)
 5 | {
 6 | 	return M;
 7 | }
 8 | void export_int_5_4()
 9 | {
10 | 	boost::python::def("test_int_5_4",test_int_5_4);
11 | }
12 | 
13 | 


--------------------------------------------------------------------------------
/Schweizer-Messer/numpy_eigen/src/autogen_test_module/test_5_4_long.cpp:
--------------------------------------------------------------------------------
 1 | #include <Eigen/Core>
 2 | 
 3 | #include <numpy_eigen/boost_python_headers.hpp>
 4 | Eigen::Matrix<boost::int64_t, 5, 4> test_long_5_4(const Eigen::Matrix<boost::int64_t, 5, 4> & M)
 5 | {
 6 | 	return M;
 7 | }
 8 | void export_long_5_4()
 9 | {
10 | 	boost::python::def("test_long_5_4",test_long_5_4);
11 | }
12 | 
13 | 


--------------------------------------------------------------------------------
/Schweizer-Messer/numpy_eigen/src/autogen_test_module/test_5_4_uchar.cpp:
--------------------------------------------------------------------------------
 1 | #include <Eigen/Core>
 2 | 
 3 | #include <numpy_eigen/boost_python_headers.hpp>
 4 | Eigen::Matrix<boost::uint8_t, 5, 4> test_uchar_5_4(const Eigen::Matrix<boost::uint8_t, 5, 4> & M)
 5 | {
 6 | 	return M;
 7 | }
 8 | void export_uchar_5_4()
 9 | {
10 | 	boost::python::def("test_uchar_5_4",test_uchar_5_4);
11 | }
12 | 
13 | 


--------------------------------------------------------------------------------
/Schweizer-Messer/numpy_eigen/src/autogen_test_module/test_5_5_double.cpp:
--------------------------------------------------------------------------------
 1 | #include <Eigen/Core>
 2 | 
 3 | #include <numpy_eigen/boost_python_headers.hpp>
 4 | Eigen::Matrix<double, 5, 5> test_double_5_5(const Eigen::Matrix<double, 5, 5> & M)
 5 | {
 6 | 	return M;
 7 | }
 8 | void export_double_5_5()
 9 | {
10 | 	boost::python::def("test_double_5_5",test_double_5_5);
11 | }
12 | 
13 | 


--------------------------------------------------------------------------------
/Schweizer-Messer/numpy_eigen/src/autogen_test_module/test_5_5_float.cpp:
--------------------------------------------------------------------------------
 1 | #include <Eigen/Core>
 2 | 
 3 | #include <numpy_eigen/boost_python_headers.hpp>
 4 | Eigen::Matrix<float, 5, 5> test_float_5_5(const Eigen::Matrix<float, 5, 5> & M)
 5 | {
 6 | 	return M;
 7 | }
 8 | void export_float_5_5()
 9 | {
10 | 	boost::python::def("test_float_5_5",test_float_5_5);
11 | }
12 | 
13 | 


--------------------------------------------------------------------------------
/Schweizer-Messer/numpy_eigen/src/autogen_test_module/test_5_5_int.cpp:
--------------------------------------------------------------------------------
 1 | #include <Eigen/Core>
 2 | 
 3 | #include <numpy_eigen/boost_python_headers.hpp>
 4 | Eigen::Matrix<int, 5, 5> test_int_5_5(const Eigen::Matrix<int, 5, 5> & M)
 5 | {
 6 | 	return M;
 7 | }
 8 | void export_int_5_5()
 9 | {
10 | 	boost::python::def("test_int_5_5",test_int_5_5);
11 | }
12 | 
13 | 


--------------------------------------------------------------------------------
/Schweizer-Messer/numpy_eigen/src/autogen_test_module/test_5_5_long.cpp:
--------------------------------------------------------------------------------
 1 | #include <Eigen/Core>
 2 | 
 3 | #include <numpy_eigen/boost_python_headers.hpp>
 4 | Eigen::Matrix<boost::int64_t, 5, 5> test_long_5_5(const Eigen::Matrix<boost::int64_t, 5, 5> & M)
 5 | {
 6 | 	return M;
 7 | }
 8 | void export_long_5_5()
 9 | {
10 | 	boost::python::def("test_long_5_5",test_long_5_5);
11 | }
12 | 
13 | 


--------------------------------------------------------------------------------
/Schweizer-Messer/numpy_eigen/src/autogen_test_module/test_5_5_uchar.cpp:
--------------------------------------------------------------------------------
 1 | #include <Eigen/Core>
 2 | 
 3 | #include <numpy_eigen/boost_python_headers.hpp>
 4 | Eigen::Matrix<boost::uint8_t, 5, 5> test_uchar_5_5(const Eigen::Matrix<boost::uint8_t, 5, 5> & M)
 5 | {
 6 | 	return M;
 7 | }
 8 | void export_uchar_5_5()
 9 | {
10 | 	boost::python::def("test_uchar_5_5",test_uchar_5_5);
11 | }
12 | 
13 | 


--------------------------------------------------------------------------------
/Schweizer-Messer/numpy_eigen/src/autogen_test_module/test_5_6_double.cpp:
--------------------------------------------------------------------------------
 1 | #include <Eigen/Core>
 2 | 
 3 | #include <numpy_eigen/boost_python_headers.hpp>
 4 | Eigen::Matrix<double, 5, 6> test_double_5_6(const Eigen::Matrix<double, 5, 6> & M)
 5 | {
 6 | 	return M;
 7 | }
 8 | void export_double_5_6()
 9 | {
10 | 	boost::python::def("test_double_5_6",test_double_5_6);
11 | }
12 | 
13 | 


--------------------------------------------------------------------------------
/Schweizer-Messer/numpy_eigen/src/autogen_test_module/test_5_6_float.cpp:
--------------------------------------------------------------------------------
 1 | #include <Eigen/Core>
 2 | 
 3 | #include <numpy_eigen/boost_python_headers.hpp>
 4 | Eigen::Matrix<float, 5, 6> test_float_5_6(const Eigen::Matrix<float, 5, 6> & M)
 5 | {
 6 | 	return M;
 7 | }
 8 | void export_float_5_6()
 9 | {
10 | 	boost::python::def("test_float_5_6",test_float_5_6);
11 | }
12 | 
13 | 


--------------------------------------------------------------------------------
/Schweizer-Messer/numpy_eigen/src/autogen_test_module/test_5_6_int.cpp:
--------------------------------------------------------------------------------
 1 | #include <Eigen/Core>
 2 | 
 3 | #include <numpy_eigen/boost_python_headers.hpp>
 4 | Eigen::Matrix<int, 5, 6> test_int_5_6(const Eigen::Matrix<int, 5, 6> & M)
 5 | {
 6 | 	return M;
 7 | }
 8 | void export_int_5_6()
 9 | {
10 | 	boost::python::def("test_int_5_6",test_int_5_6);
11 | }
12 | 
13 | 


--------------------------------------------------------------------------------
/Schweizer-Messer/numpy_eigen/src/autogen_test_module/test_5_6_long.cpp:
--------------------------------------------------------------------------------
 1 | #include <Eigen/Core>
 2 | 
 3 | #include <numpy_eigen/boost_python_headers.hpp>
 4 | Eigen::Matrix<boost::int64_t, 5, 6> test_long_5_6(const Eigen::Matrix<boost::int64_t, 5, 6> & M)
 5 | {
 6 | 	return M;
 7 | }
 8 | void export_long_5_6()
 9 | {
10 | 	boost::python::def("test_long_5_6",test_long_5_6);
11 | }
12 | 
13 | 


--------------------------------------------------------------------------------
/Schweizer-Messer/numpy_eigen/src/autogen_test_module/test_5_6_uchar.cpp:
--------------------------------------------------------------------------------
 1 | #include <Eigen/Core>
 2 | 
 3 | #include <numpy_eigen/boost_python_headers.hpp>
 4 | Eigen::Matrix<boost::uint8_t, 5, 6> test_uchar_5_6(const Eigen::Matrix<boost::uint8_t, 5, 6> & M)
 5 | {
 6 | 	return M;
 7 | }
 8 | void export_uchar_5_6()
 9 | {
10 | 	boost::python::def("test_uchar_5_6",test_uchar_5_6);
11 | }
12 | 
13 | 


--------------------------------------------------------------------------------
/Schweizer-Messer/numpy_eigen/src/autogen_test_module/test_5_D_int.cpp:
--------------------------------------------------------------------------------
 1 | #include <Eigen/Core>
 2 | 
 3 | #include <numpy_eigen/boost_python_headers.hpp>
 4 | Eigen::Matrix<int, 5, Eigen::Dynamic> test_int_5_D(const Eigen::Matrix<int, 5, Eigen::Dynamic> & M)
 5 | {
 6 | 	return M;
 7 | }
 8 | void export_int_5_D()
 9 | {
10 | 	boost::python::def("test_int_5_D",test_int_5_D);
11 | }
12 | 
13 | 


--------------------------------------------------------------------------------
/Schweizer-Messer/numpy_eigen/src/autogen_test_module/test_6_1_double.cpp:
--------------------------------------------------------------------------------
 1 | #include <Eigen/Core>
 2 | 
 3 | #include <numpy_eigen/boost_python_headers.hpp>
 4 | Eigen::Matrix<double, 6, 1> test_double_6_1(const Eigen::Matrix<double, 6, 1> & M)
 5 | {
 6 | 	return M;
 7 | }
 8 | void export_double_6_1()
 9 | {
10 | 	boost::python::def("test_double_6_1",test_double_6_1);
11 | }
12 | 
13 | 


--------------------------------------------------------------------------------
/Schweizer-Messer/numpy_eigen/src/autogen_test_module/test_6_1_float.cpp:
--------------------------------------------------------------------------------
 1 | #include <Eigen/Core>
 2 | 
 3 | #include <numpy_eigen/boost_python_headers.hpp>
 4 | Eigen::Matrix<float, 6, 1> test_float_6_1(const Eigen::Matrix<float, 6, 1> & M)
 5 | {
 6 | 	return M;
 7 | }
 8 | void export_float_6_1()
 9 | {
10 | 	boost::python::def("test_float_6_1",test_float_6_1);
11 | }
12 | 
13 | 


--------------------------------------------------------------------------------
/Schweizer-Messer/numpy_eigen/src/autogen_test_module/test_6_1_int.cpp:
--------------------------------------------------------------------------------
 1 | #include <Eigen/Core>
 2 | 
 3 | #include <numpy_eigen/boost_python_headers.hpp>
 4 | Eigen::Matrix<int, 6, 1> test_int_6_1(const Eigen::Matrix<int, 6, 1> & M)
 5 | {
 6 | 	return M;
 7 | }
 8 | void export_int_6_1()
 9 | {
10 | 	boost::python::def("test_int_6_1",test_int_6_1);
11 | }
12 | 
13 | 


--------------------------------------------------------------------------------
/Schweizer-Messer/numpy_eigen/src/autogen_test_module/test_6_1_long.cpp:
--------------------------------------------------------------------------------
 1 | #include <Eigen/Core>
 2 | 
 3 | #include <numpy_eigen/boost_python_headers.hpp>
 4 | Eigen::Matrix<boost::int64_t, 6, 1> test_long_6_1(const Eigen::Matrix<boost::int64_t, 6, 1> & M)
 5 | {
 6 | 	return M;
 7 | }
 8 | void export_long_6_1()
 9 | {
10 | 	boost::python::def("test_long_6_1",test_long_6_1);
11 | }
12 | 
13 | 


--------------------------------------------------------------------------------
/Schweizer-Messer/numpy_eigen/src/autogen_test_module/test_6_1_uchar.cpp:
--------------------------------------------------------------------------------
 1 | #include <Eigen/Core>
 2 | 
 3 | #include <numpy_eigen/boost_python_headers.hpp>
 4 | Eigen::Matrix<boost::uint8_t, 6, 1> test_uchar_6_1(const Eigen::Matrix<boost::uint8_t, 6, 1> & M)
 5 | {
 6 | 	return M;
 7 | }
 8 | void export_uchar_6_1()
 9 | {
10 | 	boost::python::def("test_uchar_6_1",test_uchar_6_1);
11 | }
12 | 
13 | 


--------------------------------------------------------------------------------
/Schweizer-Messer/numpy_eigen/src/autogen_test_module/test_6_2_double.cpp:
--------------------------------------------------------------------------------
 1 | #include <Eigen/Core>
 2 | 
 3 | #include <numpy_eigen/boost_python_headers.hpp>
 4 | Eigen::Matrix<double, 6, 2> test_double_6_2(const Eigen::Matrix<double, 6, 2> & M)
 5 | {
 6 | 	return M;
 7 | }
 8 | void export_double_6_2()
 9 | {
10 | 	boost::python::def("test_double_6_2",test_double_6_2);
11 | }
12 | 
13 | 


--------------------------------------------------------------------------------
/Schweizer-Messer/numpy_eigen/src/autogen_test_module/test_6_2_float.cpp:
--------------------------------------------------------------------------------
 1 | #include <Eigen/Core>
 2 | 
 3 | #include <numpy_eigen/boost_python_headers.hpp>
 4 | Eigen::Matrix<float, 6, 2> test_float_6_2(const Eigen::Matrix<float, 6, 2> & M)
 5 | {
 6 | 	return M;
 7 | }
 8 | void export_float_6_2()
 9 | {
10 | 	boost::python::def("test_float_6_2",test_float_6_2);
11 | }
12 | 
13 | 


--------------------------------------------------------------------------------
/Schweizer-Messer/numpy_eigen/src/autogen_test_module/test_6_2_int.cpp:
--------------------------------------------------------------------------------
 1 | #include <Eigen/Core>
 2 | 
 3 | #include <numpy_eigen/boost_python_headers.hpp>
 4 | Eigen::Matrix<int, 6, 2> test_int_6_2(const Eigen::Matrix<int, 6, 2> & M)
 5 | {
 6 | 	return M;
 7 | }
 8 | void export_int_6_2()
 9 | {
10 | 	boost::python::def("test_int_6_2",test_int_6_2);
11 | }
12 | 
13 | 


--------------------------------------------------------------------------------
/Schweizer-Messer/numpy_eigen/src/autogen_test_module/test_6_2_long.cpp:
--------------------------------------------------------------------------------
 1 | #include <Eigen/Core>
 2 | 
 3 | #include <numpy_eigen/boost_python_headers.hpp>
 4 | Eigen::Matrix<boost::int64_t, 6, 2> test_long_6_2(const Eigen::Matrix<boost::int64_t, 6, 2> & M)
 5 | {
 6 | 	return M;
 7 | }
 8 | void export_long_6_2()
 9 | {
10 | 	boost::python::def("test_long_6_2",test_long_6_2);
11 | }
12 | 
13 | 


--------------------------------------------------------------------------------
/Schweizer-Messer/numpy_eigen/src/autogen_test_module/test_6_2_uchar.cpp:
--------------------------------------------------------------------------------
 1 | #include <Eigen/Core>
 2 | 
 3 | #include <numpy_eigen/boost_python_headers.hpp>
 4 | Eigen::Matrix<boost::uint8_t, 6, 2> test_uchar_6_2(const Eigen::Matrix<boost::uint8_t, 6, 2> & M)
 5 | {
 6 | 	return M;
 7 | }
 8 | void export_uchar_6_2()
 9 | {
10 | 	boost::python::def("test_uchar_6_2",test_uchar_6_2);
11 | }
12 | 
13 | 


--------------------------------------------------------------------------------
/Schweizer-Messer/numpy_eigen/src/autogen_test_module/test_6_3_double.cpp:
--------------------------------------------------------------------------------
 1 | #include <Eigen/Core>
 2 | 
 3 | #include <numpy_eigen/boost_python_headers.hpp>
 4 | Eigen::Matrix<double, 6, 3> test_double_6_3(const Eigen::Matrix<double, 6, 3> & M)
 5 | {
 6 | 	return M;
 7 | }
 8 | void export_double_6_3()
 9 | {
10 | 	boost::python::def("test_double_6_3",test_double_6_3);
11 | }
12 | 
13 | 


--------------------------------------------------------------------------------
/Schweizer-Messer/numpy_eigen/src/autogen_test_module/test_6_3_float.cpp:
--------------------------------------------------------------------------------
 1 | #include <Eigen/Core>
 2 | 
 3 | #include <numpy_eigen/boost_python_headers.hpp>
 4 | Eigen::Matrix<float, 6, 3> test_float_6_3(const Eigen::Matrix<float, 6, 3> & M)
 5 | {
 6 | 	return M;
 7 | }
 8 | void export_float_6_3()
 9 | {
10 | 	boost::python::def("test_float_6_3",test_float_6_3);
11 | }
12 | 
13 | 


--------------------------------------------------------------------------------
/Schweizer-Messer/numpy_eigen/src/autogen_test_module/test_6_3_int.cpp:
--------------------------------------------------------------------------------
 1 | #include <Eigen/Core>
 2 | 
 3 | #include <numpy_eigen/boost_python_headers.hpp>
 4 | Eigen::Matrix<int, 6, 3> test_int_6_3(const Eigen::Matrix<int, 6, 3> & M)
 5 | {
 6 | 	return M;
 7 | }
 8 | void export_int_6_3()
 9 | {
10 | 	boost::python::def("test_int_6_3",test_int_6_3);
11 | }
12 | 
13 | 


--------------------------------------------------------------------------------
/Schweizer-Messer/numpy_eigen/src/autogen_test_module/test_6_3_long.cpp:
--------------------------------------------------------------------------------
 1 | #include <Eigen/Core>
 2 | 
 3 | #include <numpy_eigen/boost_python_headers.hpp>
 4 | Eigen::Matrix<boost::int64_t, 6, 3> test_long_6_3(const Eigen::Matrix<boost::int64_t, 6, 3> & M)
 5 | {
 6 | 	return M;
 7 | }
 8 | void export_long_6_3()
 9 | {
10 | 	boost::python::def("test_long_6_3",test_long_6_3);
11 | }
12 | 
13 | 


--------------------------------------------------------------------------------
/Schweizer-Messer/numpy_eigen/src/autogen_test_module/test_6_3_uchar.cpp:
--------------------------------------------------------------------------------
 1 | #include <Eigen/Core>
 2 | 
 3 | #include <numpy_eigen/boost_python_headers.hpp>
 4 | Eigen::Matrix<boost::uint8_t, 6, 3> test_uchar_6_3(const Eigen::Matrix<boost::uint8_t, 6, 3> & M)
 5 | {
 6 | 	return M;
 7 | }
 8 | void export_uchar_6_3()
 9 | {
10 | 	boost::python::def("test_uchar_6_3",test_uchar_6_3);
11 | }
12 | 
13 | 


--------------------------------------------------------------------------------
/Schweizer-Messer/numpy_eigen/src/autogen_test_module/test_6_4_double.cpp:
--------------------------------------------------------------------------------
 1 | #include <Eigen/Core>
 2 | 
 3 | #include <numpy_eigen/boost_python_headers.hpp>
 4 | Eigen::Matrix<double, 6, 4> test_double_6_4(const Eigen::Matrix<double, 6, 4> & M)
 5 | {
 6 | 	return M;
 7 | }
 8 | void export_double_6_4()
 9 | {
10 | 	boost::python::def("test_double_6_4",test_double_6_4);
11 | }
12 | 
13 | 


--------------------------------------------------------------------------------
/Schweizer-Messer/numpy_eigen/src/autogen_test_module/test_6_4_float.cpp:
--------------------------------------------------------------------------------
 1 | #include <Eigen/Core>
 2 | 
 3 | #include <numpy_eigen/boost_python_headers.hpp>
 4 | Eigen::Matrix<float, 6, 4> test_float_6_4(const Eigen::Matrix<float, 6, 4> & M)
 5 | {
 6 | 	return M;
 7 | }
 8 | void export_float_6_4()
 9 | {
10 | 	boost::python::def("test_float_6_4",test_float_6_4);
11 | }
12 | 
13 | 


--------------------------------------------------------------------------------
/Schweizer-Messer/numpy_eigen/src/autogen_test_module/test_6_4_int.cpp:
--------------------------------------------------------------------------------
 1 | #include <Eigen/Core>
 2 | 
 3 | #include <numpy_eigen/boost_python_headers.hpp>
 4 | Eigen::Matrix<int, 6, 4> test_int_6_4(const Eigen::Matrix<int, 6, 4> & M)
 5 | {
 6 | 	return M;
 7 | }
 8 | void export_int_6_4()
 9 | {
10 | 	boost::python::def("test_int_6_4",test_int_6_4);
11 | }
12 | 
13 | 


--------------------------------------------------------------------------------
/Schweizer-Messer/numpy_eigen/src/autogen_test_module/test_6_4_long.cpp:
--------------------------------------------------------------------------------
 1 | #include <Eigen/Core>
 2 | 
 3 | #include <numpy_eigen/boost_python_headers.hpp>
 4 | Eigen::Matrix<boost::int64_t, 6, 4> test_long_6_4(const Eigen::Matrix<boost::int64_t, 6, 4> & M)
 5 | {
 6 | 	return M;
 7 | }
 8 | void export_long_6_4()
 9 | {
10 | 	boost::python::def("test_long_6_4",test_long_6_4);
11 | }
12 | 
13 | 


--------------------------------------------------------------------------------
/Schweizer-Messer/numpy_eigen/src/autogen_test_module/test_6_4_uchar.cpp:
--------------------------------------------------------------------------------
 1 | #include <Eigen/Core>
 2 | 
 3 | #include <numpy_eigen/boost_python_headers.hpp>
 4 | Eigen::Matrix<boost::uint8_t, 6, 4> test_uchar_6_4(const Eigen::Matrix<boost::uint8_t, 6, 4> & M)
 5 | {
 6 | 	return M;
 7 | }
 8 | void export_uchar_6_4()
 9 | {
10 | 	boost::python::def("test_uchar_6_4",test_uchar_6_4);
11 | }
12 | 
13 | 


--------------------------------------------------------------------------------
/Schweizer-Messer/numpy_eigen/src/autogen_test_module/test_6_5_double.cpp:
--------------------------------------------------------------------------------
 1 | #include <Eigen/Core>
 2 | 
 3 | #include <numpy_eigen/boost_python_headers.hpp>
 4 | Eigen::Matrix<double, 6, 5> test_double_6_5(const Eigen::Matrix<double, 6, 5> & M)
 5 | {
 6 | 	return M;
 7 | }
 8 | void export_double_6_5()
 9 | {
10 | 	boost::python::def("test_double_6_5",test_double_6_5);
11 | }
12 | 
13 | 


--------------------------------------------------------------------------------
/Schweizer-Messer/numpy_eigen/src/autogen_test_module/test_6_5_float.cpp:
--------------------------------------------------------------------------------
 1 | #include <Eigen/Core>
 2 | 
 3 | #include <numpy_eigen/boost_python_headers.hpp>
 4 | Eigen::Matrix<float, 6, 5> test_float_6_5(const Eigen::Matrix<float, 6, 5> & M)
 5 | {
 6 | 	return M;
 7 | }
 8 | void export_float_6_5()
 9 | {
10 | 	boost::python::def("test_float_6_5",test_float_6_5);
11 | }
12 | 
13 | 


--------------------------------------------------------------------------------
/Schweizer-Messer/numpy_eigen/src/autogen_test_module/test_6_5_int.cpp:
--------------------------------------------------------------------------------
 1 | #include <Eigen/Core>
 2 | 
 3 | #include <numpy_eigen/boost_python_headers.hpp>
 4 | Eigen::Matrix<int, 6, 5> test_int_6_5(const Eigen::Matrix<int, 6, 5> & M)
 5 | {
 6 | 	return M;
 7 | }
 8 | void export_int_6_5()
 9 | {
10 | 	boost::python::def("test_int_6_5",test_int_6_5);
11 | }
12 | 
13 | 


--------------------------------------------------------------------------------
/Schweizer-Messer/numpy_eigen/src/autogen_test_module/test_6_5_long.cpp:
--------------------------------------------------------------------------------
 1 | #include <Eigen/Core>
 2 | 
 3 | #include <numpy_eigen/boost_python_headers.hpp>
 4 | Eigen::Matrix<boost::int64_t, 6, 5> test_long_6_5(const Eigen::Matrix<boost::int64_t, 6, 5> & M)
 5 | {
 6 | 	return M;
 7 | }
 8 | void export_long_6_5()
 9 | {
10 | 	boost::python::def("test_long_6_5",test_long_6_5);
11 | }
12 | 
13 | 


--------------------------------------------------------------------------------
/Schweizer-Messer/numpy_eigen/src/autogen_test_module/test_6_5_uchar.cpp:
--------------------------------------------------------------------------------
 1 | #include <Eigen/Core>
 2 | 
 3 | #include <numpy_eigen/boost_python_headers.hpp>
 4 | Eigen::Matrix<boost::uint8_t, 6, 5> test_uchar_6_5(const Eigen::Matrix<boost::uint8_t, 6, 5> & M)
 5 | {
 6 | 	return M;
 7 | }
 8 | void export_uchar_6_5()
 9 | {
10 | 	boost::python::def("test_uchar_6_5",test_uchar_6_5);
11 | }
12 | 
13 | 


--------------------------------------------------------------------------------
/Schweizer-Messer/numpy_eigen/src/autogen_test_module/test_6_6_double.cpp:
--------------------------------------------------------------------------------
 1 | #include <Eigen/Core>
 2 | 
 3 | #include <numpy_eigen/boost_python_headers.hpp>
 4 | Eigen::Matrix<double, 6, 6> test_double_6_6(const Eigen::Matrix<double, 6, 6> & M)
 5 | {
 6 | 	return M;
 7 | }
 8 | void export_double_6_6()
 9 | {
10 | 	boost::python::def("test_double_6_6",test_double_6_6);
11 | }
12 | 
13 | 


--------------------------------------------------------------------------------
/Schweizer-Messer/numpy_eigen/src/autogen_test_module/test_6_6_float.cpp:
--------------------------------------------------------------------------------
 1 | #include <Eigen/Core>
 2 | 
 3 | #include <numpy_eigen/boost_python_headers.hpp>
 4 | Eigen::Matrix<float, 6, 6> test_float_6_6(const Eigen::Matrix<float, 6, 6> & M)
 5 | {
 6 | 	return M;
 7 | }
 8 | void export_float_6_6()
 9 | {
10 | 	boost::python::def("test_float_6_6",test_float_6_6);
11 | }
12 | 
13 | 


--------------------------------------------------------------------------------
/Schweizer-Messer/numpy_eigen/src/autogen_test_module/test_6_6_int.cpp:
--------------------------------------------------------------------------------
 1 | #include <Eigen/Core>
 2 | 
 3 | #include <numpy_eigen/boost_python_headers.hpp>
 4 | Eigen::Matrix<int, 6, 6> test_int_6_6(const Eigen::Matrix<int, 6, 6> & M)
 5 | {
 6 | 	return M;
 7 | }
 8 | void export_int_6_6()
 9 | {
10 | 	boost::python::def("test_int_6_6",test_int_6_6);
11 | }
12 | 
13 | 


--------------------------------------------------------------------------------
/Schweizer-Messer/numpy_eigen/src/autogen_test_module/test_6_6_long.cpp:
--------------------------------------------------------------------------------
 1 | #include <Eigen/Core>
 2 | 
 3 | #include <numpy_eigen/boost_python_headers.hpp>
 4 | Eigen::Matrix<boost::int64_t, 6, 6> test_long_6_6(const Eigen::Matrix<boost::int64_t, 6, 6> & M)
 5 | {
 6 | 	return M;
 7 | }
 8 | void export_long_6_6()
 9 | {
10 | 	boost::python::def("test_long_6_6",test_long_6_6);
11 | }
12 | 
13 | 


--------------------------------------------------------------------------------
/Schweizer-Messer/numpy_eigen/src/autogen_test_module/test_6_6_uchar.cpp:
--------------------------------------------------------------------------------
 1 | #include <Eigen/Core>
 2 | 
 3 | #include <numpy_eigen/boost_python_headers.hpp>
 4 | Eigen::Matrix<boost::uint8_t, 6, 6> test_uchar_6_6(const Eigen::Matrix<boost::uint8_t, 6, 6> & M)
 5 | {
 6 | 	return M;
 7 | }
 8 | void export_uchar_6_6()
 9 | {
10 | 	boost::python::def("test_uchar_6_6",test_uchar_6_6);
11 | }
12 | 
13 | 


--------------------------------------------------------------------------------
/Schweizer-Messer/numpy_eigen/src/autogen_test_module/test_6_D_int.cpp:
--------------------------------------------------------------------------------
 1 | #include <Eigen/Core>
 2 | 
 3 | #include <numpy_eigen/boost_python_headers.hpp>
 4 | Eigen::Matrix<int, 6, Eigen::Dynamic> test_int_6_D(const Eigen::Matrix<int, 6, Eigen::Dynamic> & M)
 5 | {
 6 | 	return M;
 7 | }
 8 | void export_int_6_D()
 9 | {
10 | 	boost::python::def("test_int_6_D",test_int_6_D);
11 | }
12 | 
13 | 


--------------------------------------------------------------------------------
/Schweizer-Messer/numpy_eigen/src/autogen_test_module/test_D_1_int.cpp:
--------------------------------------------------------------------------------
 1 | #include <Eigen/Core>
 2 | 
 3 | #include <numpy_eigen/boost_python_headers.hpp>
 4 | Eigen::Matrix<int, Eigen::Dynamic, 1> test_int_D_1(const Eigen::Matrix<int, Eigen::Dynamic, 1> & M)
 5 | {
 6 | 	return M;
 7 | }
 8 | void export_int_D_1()
 9 | {
10 | 	boost::python::def("test_int_D_1",test_int_D_1);
11 | }
12 | 
13 | 


--------------------------------------------------------------------------------
/Schweizer-Messer/numpy_eigen/src/autogen_test_module/test_D_2_int.cpp:
--------------------------------------------------------------------------------
 1 | #include <Eigen/Core>
 2 | 
 3 | #include <numpy_eigen/boost_python_headers.hpp>
 4 | Eigen::Matrix<int, Eigen::Dynamic, 2> test_int_D_2(const Eigen::Matrix<int, Eigen::Dynamic, 2> & M)
 5 | {
 6 | 	return M;
 7 | }
 8 | void export_int_D_2()
 9 | {
10 | 	boost::python::def("test_int_D_2",test_int_D_2);
11 | }
12 | 
13 | 


--------------------------------------------------------------------------------
/Schweizer-Messer/numpy_eigen/src/autogen_test_module/test_D_3_int.cpp:
--------------------------------------------------------------------------------
 1 | #include <Eigen/Core>
 2 | 
 3 | #include <numpy_eigen/boost_python_headers.hpp>
 4 | Eigen::Matrix<int, Eigen::Dynamic, 3> test_int_D_3(const Eigen::Matrix<int, Eigen::Dynamic, 3> & M)
 5 | {
 6 | 	return M;
 7 | }
 8 | void export_int_D_3()
 9 | {
10 | 	boost::python::def("test_int_D_3",test_int_D_3);
11 | }
12 | 
13 | 


--------------------------------------------------------------------------------
/Schweizer-Messer/numpy_eigen/src/autogen_test_module/test_D_4_int.cpp:
--------------------------------------------------------------------------------
 1 | #include <Eigen/Core>
 2 | 
 3 | #include <numpy_eigen/boost_python_headers.hpp>
 4 | Eigen::Matrix<int, Eigen::Dynamic, 4> test_int_D_4(const Eigen::Matrix<int, Eigen::Dynamic, 4> & M)
 5 | {
 6 | 	return M;
 7 | }
 8 | void export_int_D_4()
 9 | {
10 | 	boost::python::def("test_int_D_4",test_int_D_4);
11 | }
12 | 
13 | 


--------------------------------------------------------------------------------
/Schweizer-Messer/numpy_eigen/src/autogen_test_module/test_D_5_int.cpp:
--------------------------------------------------------------------------------
 1 | #include <Eigen/Core>
 2 | 
 3 | #include <numpy_eigen/boost_python_headers.hpp>
 4 | Eigen::Matrix<int, Eigen::Dynamic, 5> test_int_D_5(const Eigen::Matrix<int, Eigen::Dynamic, 5> & M)
 5 | {
 6 | 	return M;
 7 | }
 8 | void export_int_D_5()
 9 | {
10 | 	boost::python::def("test_int_D_5",test_int_D_5);
11 | }
12 | 
13 | 


--------------------------------------------------------------------------------
/Schweizer-Messer/numpy_eigen/src/autogen_test_module/test_D_6_int.cpp:
--------------------------------------------------------------------------------
 1 | #include <Eigen/Core>
 2 | 
 3 | #include <numpy_eigen/boost_python_headers.hpp>
 4 | Eigen::Matrix<int, Eigen::Dynamic, 6> test_int_D_6(const Eigen::Matrix<int, Eigen::Dynamic, 6> & M)
 5 | {
 6 | 	return M;
 7 | }
 8 | void export_int_D_6()
 9 | {
10 | 	boost::python::def("test_int_D_6",test_int_D_6);
11 | }
12 | 
13 | 


--------------------------------------------------------------------------------
/Schweizer-Messer/numpy_eigen/src/numpy_eigen/__init__.py:
--------------------------------------------------------------------------------
1 | import os
2 | 
3 | from .libnumpy_eigen import *
4 | 


--------------------------------------------------------------------------------
/Schweizer-Messer/numpy_eigen/src/numpy_eigen/test/__init__.py:
--------------------------------------------------------------------------------
1 | import os
2 | print('Importing numpy_test ', os.path.realpath(__file__))
3 | from ..libnumpy_eigen_test import *
4 | 


--------------------------------------------------------------------------------
/Schweizer-Messer/python_module/CMakeLists.txt:
--------------------------------------------------------------------------------
1 | cmake_minimum_required(VERSION 3.0.2)
2 | project(python_module)
3 | 
4 | find_package(catkin REQUIRED)
5 | 
6 | catkin_package(
7 |   CFG_EXTRAS add_python_export_library.cmake
8 | )


--------------------------------------------------------------------------------
/Schweizer-Messer/sm_boost/include/sm/boost/null_deleter.hpp:
--------------------------------------------------------------------------------
 1 | #ifndef SM_BOOST_NULL_DELETER_HPP
 2 | #define SM_BOOST_NULL_DELETER_HPP
 3 | 
 4 | namespace sm {
 5 | 
 6 |     struct null_deleter
 7 |     {
 8 |       template<typename T>
 9 |       void operator()(const T * ){}
10 |     };
11 | 
12 | } // namespace sm
13 | 
14 | 
15 | #endif /* SM_BOOST_NULL_DELETER_HPP */
16 | 


--------------------------------------------------------------------------------
/Schweizer-Messer/sm_boost/test/test_main.cpp:
--------------------------------------------------------------------------------
1 | #include <gtest/gtest.h>
2 | 
3 | /// Run all the tests that were declared with TEST()
4 | int main(int argc, char **argv){
5 |   testing::InitGoogleTest(&argc, argv);
6 |   return RUN_ALL_TESTS();
7 | }
8 | 


--------------------------------------------------------------------------------
/Schweizer-Messer/sm_common/cmake/export_flags.cmake:
--------------------------------------------------------------------------------
1 | SET(CMAKE_CXX_STANDARD 14)
2 | SET(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wall -Wextra")
3 | 


--------------------------------------------------------------------------------
/Schweizer-Messer/sm_common/test/test_main.cpp:
--------------------------------------------------------------------------------
1 | #include <gtest/gtest.h>
2 | 
3 | /// Run all the tests that were declared with TEST()
4 | int main(int argc, char **argv){
5 |   testing::InitGoogleTest(&argc, argv);
6 |   return RUN_ALL_TESTS();
7 | }
8 | 


--------------------------------------------------------------------------------
/Schweizer-Messer/sm_eigen/cmake/sm_eigen-extras.cmake.in:
--------------------------------------------------------------------------------
1 | find_package(Eigen3 REQUIRED)
2 | include_directories(${EIGEN3_INCLUDE_DIRS})
3 | 


--------------------------------------------------------------------------------
/Schweizer-Messer/sm_eigen/include/sm/eigen/random.hpp:
--------------------------------------------------------------------------------
 1 | #ifndef SM_EIGEN_RANDOM_HPP
 2 | #define SM_EIGEN_RANDOM_HPP
 3 | #include <Eigen/Core>
 4 | 
 5 | namespace sm {
 6 | namespace eigen {
 7 | 
 8 | Eigen::VectorXd randn(unsigned dim);
 9 | 
10 | } // namespace eigen
11 | } // namespace sm
12 | 
13 | 
14 | #endif /* SM_EIGEN_RANDOM_HPP */
15 | 


--------------------------------------------------------------------------------
/Schweizer-Messer/sm_eigen/test/test_main.cpp:
--------------------------------------------------------------------------------
1 | #include <gtest/gtest.h>
2 | 
3 | /// Run all the tests that were declared with TEST()
4 | int main(int argc, char **argv){
5 |   testing::InitGoogleTest(&argc, argv);
6 |   return RUN_ALL_TESTS();
7 | }
8 | 


--------------------------------------------------------------------------------
/Schweizer-Messer/sm_kinematics/src/RotationalKinematics.cpp:
--------------------------------------------------------------------------------
 1 | #include <sm/kinematics/RotationalKinematics.hpp>
 2 | 
 3 | namespace sm { namespace kinematics {
 4 | 
 5 | 
 6 |     RotationalKinematics::~RotationalKinematics()
 7 |     {
 8 | 
 9 |     }
10 | 
11 | 
12 |   }} // sm::kinematics
13 | 


--------------------------------------------------------------------------------
/Schweizer-Messer/sm_kinematics/test/HomogeneousPoint.cpp:
--------------------------------------------------------------------------------
 1 | #include <sm/eigen/gtest.hpp>
 2 | #include <sm/kinematics/HomogeneousPoint.hpp>
 3 | 
 4 | #include "PointTestHarness.hpp"
 5 | 
 6 | TEST(HomogeneousPointTestSuite, testHpoints)
 7 | {
 8 |   sm::PointTestHarness<sm::kinematics::HomogeneousPoint> harness(1e-6);
 9 |   harness.testAll();
10 | }
11 | 


--------------------------------------------------------------------------------
/Schweizer-Messer/sm_kinematics/test/test_main.cpp:
--------------------------------------------------------------------------------
1 | #include <gtest/gtest.h>
2 | 
3 | /// Run all the tests that were declared with TEST()
4 | int main(int argc, char **argv){
5 |   testing::InitGoogleTest(&argc, argv);
6 |   return RUN_ALL_TESTS();
7 | }
8 | 


--------------------------------------------------------------------------------
/Schweizer-Messer/sm_logging/src/LoggingEvent.cpp:
--------------------------------------------------------------------------------
 1 | #include <sm/logging/LoggingEvent.hpp>
 2 | 
 3 | namespace sm {
 4 |     namespace logging {
 5 |         
 6 | 
 7 | 
 8 |     } // namespace logging
 9 | } // namespace sm
10 | 


--------------------------------------------------------------------------------
/Schweizer-Messer/sm_logging/src/Tokens.cpp:
--------------------------------------------------------------------------------
 1 | #include <sm/logging/Tokens.hpp>
 2 | 
 3 | namespace sm {
 4 |     namespace logging {
 5 |         
 6 |         
 7 | 
 8 |     } // namespace logging
 9 | } // namespace sm
10 | 


--------------------------------------------------------------------------------
/Schweizer-Messer/sm_logging/test/test_main.cpp:
--------------------------------------------------------------------------------
1 | #include <gtest/gtest.h>
2 | 
3 | /// Run all the tests that were declared with TEST()
4 | int main(int argc, char **argv){
5 |   testing::InitGoogleTest(&argc, argv);
6 |   return RUN_ALL_TESTS();
7 | }
8 | 


--------------------------------------------------------------------------------
/Schweizer-Messer/sm_matrix_archive/.gitignore:
--------------------------------------------------------------------------------
1 | /bin
2 | 


--------------------------------------------------------------------------------
/Schweizer-Messer/sm_matrix_archive/test/test_main.cpp:
--------------------------------------------------------------------------------
1 | #include <gtest/gtest.h>
2 | 
3 | /// Run all the tests that were declared with TEST()
4 | int main(int argc, char **argv){
5 |   testing::InitGoogleTest(&argc, argv);
6 |   return RUN_ALL_TESTS();
7 | }
8 | 


--------------------------------------------------------------------------------
/Schweizer-Messer/sm_property_tree/src/PropertyTreeImplementation.cpp:
--------------------------------------------------------------------------------
 1 | #include <sm/PropertyTreeImplementation.hpp>
 2 | 
 3 | namespace sm {
 4 |   
 5 |   PropertyTreeImplementation::PropertyTreeImplementation()
 6 |   {
 7 | 
 8 |   }
 9 |   PropertyTreeImplementation::~PropertyTreeImplementation()
10 |   {
11 | 
12 |   }
13 | 
14 |   
15 | } // namespace sm
16 | 


--------------------------------------------------------------------------------
/Schweizer-Messer/sm_property_tree/test/test_main.cpp:
--------------------------------------------------------------------------------
1 | #include <gtest/gtest.h>
2 | 
3 | /// Run all the tests that were declared with TEST()
4 | int main(int argc, char **argv){
5 |   testing::InitGoogleTest(&argc, argv);
6 |   return RUN_ALL_TESTS();
7 | }
8 | 


--------------------------------------------------------------------------------
/Schweizer-Messer/sm_python/python/sm/experiments/__init__.py:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/ethz-asl/kalibr/1f60227442d25e36365ef5f72cd80b9666d73467/Schweizer-Messer/sm_python/python/sm/experiments/__init__.py


--------------------------------------------------------------------------------
/Schweizer-Messer/sm_python/python/sm/saveFigTight.py:
--------------------------------------------------------------------------------
1 | 
2 | def saveFigTight(fig, filename):
3 |     ax = fig.gca()
4 |     extent = ax.get_window_extent().transformed(fig.dpi_scale_trans.inverted())
5 |     fig.savefig(filename, bbox_inches=extent)
6 | 


--------------------------------------------------------------------------------
/Schweizer-Messer/sm_python/setup.py:
--------------------------------------------------------------------------------
 1 | 
 2 | ## ! DO NOT MANUALLY INVOKE THIS setup.py, USE CATKIN INSTEAD
 3 | 
 4 | from distutils.core import setup
 5 | from catkin_pkg.python_setup import generate_distutils_setup
 6 | 
 7 | # fetch values from package.xml
 8 | setup_args = generate_distutils_setup(
 9 |     packages=['sm'],
10 |     package_dir={'':'python'})
11 | 
12 | setup(**setup_args)
13 | 


--------------------------------------------------------------------------------
/Schweizer-Messer/sm_python/src/export_eigen_property_tree.cpp:
--------------------------------------------------------------------------------
1 | #include <numpy_eigen/boost_python_headers.hpp>
2 | #include <sm/eigen/property_tree.hpp>
3 | 
4 | void export_eigen_property_tree()
5 | {
6 |     boost::python::def("vector3FromPropertyTree", &sm::eigen::vector3FromPropertyTree);
7 |     boost::python::def("quaternionFromPropertyTree", &sm::eigen::quaternionFromPropertyTree);
8 | }
9 | 


--------------------------------------------------------------------------------
/Schweizer-Messer/sm_python/src/export_kinematics_property_tree.cpp:
--------------------------------------------------------------------------------
1 | #include <numpy_eigen/boost_python_headers.hpp>
2 | #include <sm/kinematics/property_tree.hpp>
3 | 
4 | void export_kinematics_property_tree()
5 | {
6 |     boost::python::def("transformationFromPropertyTree", &sm::kinematics::transformationFromPropertyTree);
7 | }
8 | 


--------------------------------------------------------------------------------
/Schweizer-Messer/sm_timing/test/test_main.cpp:
--------------------------------------------------------------------------------
1 | #include <gtest/gtest.h>
2 | 
3 | /// Run all the tests that were declared with TEST()
4 | int main(int argc, char **argv){
5 |   testing::InitGoogleTest(&argc, argv);
6 |   return RUN_ALL_TESTS();
7 | }
8 | 


--------------------------------------------------------------------------------
/aslam_cv/aslam_cameras/include/aslam/cameras/StaticAssert.hpp:
--------------------------------------------------------------------------------
1 | #ifndef ASLAM_EIGEN_STATIC_ASSERT_HPP
2 | #define ASLAM_EIGEN_STATIC_ASSERT_HPP
3 | 
4 | #include <sm/eigen/static_assert.hpp>
5 | 
6 | #endif /* SM_EIGEN_STATIC_ASSERT_HPP */
7 | 


--------------------------------------------------------------------------------
/aslam_cv/aslam_cameras/include/aslam/targets.hpp:
--------------------------------------------------------------------------------
 1 | #ifndef ASLAM_TARGETS_HPP
 2 | #define ASLAM_TARGETS_HPP
 3 | 
 4 | // Calibration targets
 5 | #include <aslam/cameras/GridCalibrationTargetCheckerboard.hpp>
 6 | #include <aslam/cameras/GridCalibrationTargetCirclegrid.hpp>
 7 | 
 8 | 
 9 | #endif /* ASLAM_TARGETS_HPP */
10 | 


--------------------------------------------------------------------------------
/aslam_cv/aslam_cameras/src/MaskedCameraGeometry.cpp:
--------------------------------------------------------------------------------
1 | #include <aslam/cameras/MaskedCameraGeometry.hpp>
2 | 
3 | namespace aslam {
4 | namespace cameras {
5 | }
6 | }
7 | 


--------------------------------------------------------------------------------
/aslam_cv/aslam_cameras/src/NoMask.cpp:
--------------------------------------------------------------------------------
 1 | #include<aslam/cameras/NoMask.hpp>
 2 | 
 3 | namespace aslam {
 4 | namespace cameras {
 5 | 
 6 | NoMask::NoMask() {
 7 | }
 8 | NoMask::NoMask(const sm::PropertyTree &) {
 9 | }
10 | NoMask::~NoMask() {
11 | }
12 | 
13 | }  // namespace cameras
14 | }  // namespace aslam
15 | 


--------------------------------------------------------------------------------
/aslam_cv/aslam_cameras/test.ba:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/ethz-asl/kalibr/1f60227442d25e36365ef5f72cd80b9666d73467/aslam_cv/aslam_cameras/test.ba


--------------------------------------------------------------------------------
/aslam_cv/aslam_cameras/test/testImageCheckerboard.jpg:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/ethz-asl/kalibr/1f60227442d25e36365ef5f72cd80b9666d73467/aslam_cv/aslam_cameras/test/testImageCheckerboard.jpg


--------------------------------------------------------------------------------
/aslam_cv/aslam_cameras/test/testImageCircleGrid.jpg:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/ethz-asl/kalibr/1f60227442d25e36365ef5f72cd80b9666d73467/aslam_cv/aslam_cameras/test/testImageCircleGrid.jpg


--------------------------------------------------------------------------------
/aslam_cv/aslam_cameras/test/test_main.cpp:
--------------------------------------------------------------------------------
1 | #include <gtest/gtest.h>
2 | 
3 | /// Run all the tests that were declared with TEST()
4 | int main(int argc, char **argv) {
5 |   testing::InitGoogleTest(&argc, argv);
6 |   return RUN_ALL_TESTS();
7 | }
8 | 


--------------------------------------------------------------------------------
/aslam_cv/aslam_cv_backend/src/NCameraSystemEstimation.cpp:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/ethz-asl/kalibr/1f60227442d25e36365ef5f72cd80b9666d73467/aslam_cv/aslam_cv_backend/src/NCameraSystemEstimation.cpp


--------------------------------------------------------------------------------
/aslam_cv/aslam_cv_backend/test/test_main.cpp:
--------------------------------------------------------------------------------
1 | #include <gtest/gtest.h>
2 | 
3 | /// Run all the tests that were declared with TEST()
4 | int main(int argc, char **argv) {
5 |   testing::InitGoogleTest(&argc, argv);
6 |   return RUN_ALL_TESTS();
7 | }
8 | 


--------------------------------------------------------------------------------
/aslam_cv/aslam_cv_error_terms/test/test_main.cpp:
--------------------------------------------------------------------------------
1 | #include <gtest/gtest.h>
2 | 
3 | /// Run all the tests that were declared with TEST()
4 | int main(int argc, char **argv) {
5 |   testing::InitGoogleTest(&argc, argv);
6 |   return RUN_ALL_TESTS();
7 | }
8 | 
9 | 


--------------------------------------------------------------------------------
/aslam_cv/aslam_cv_python/example/im_front.jpg:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/ethz-asl/kalibr/1f60227442d25e36365ef5f72cd80b9666d73467/aslam_cv/aslam_cv_python/example/im_front.jpg


--------------------------------------------------------------------------------
/aslam_cv/aslam_cv_python/example/im_left.jpg:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/ethz-asl/kalibr/1f60227442d25e36365ef5f72cd80b9666d73467/aslam_cv/aslam_cv_python/example/im_left.jpg


--------------------------------------------------------------------------------
/aslam_cv/aslam_cv_python/example/im_rear.jpg:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/ethz-asl/kalibr/1f60227442d25e36365ef5f72cd80b9666d73467/aslam_cv/aslam_cv_python/example/im_rear.jpg


--------------------------------------------------------------------------------
/aslam_cv/aslam_cv_python/example/im_right.jpg:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/ethz-asl/kalibr/1f60227442d25e36365ef5f72cd80b9666d73467/aslam_cv/aslam_cv_python/example/im_right.jpg


--------------------------------------------------------------------------------
/aslam_cv/aslam_cv_python/setup.py:
--------------------------------------------------------------------------------
 1 | 
 2 | ## ! DO NOT MANUALLY INVOKE THIS setup.py, USE CATKIN INSTEAD
 3 | 
 4 | from distutils.core import setup
 5 | from catkin_pkg.python_setup import generate_distutils_setup
 6 | 
 7 | # fetch values from package.xml
 8 | setup_args = generate_distutils_setup(
 9 |     packages=['aslam_cv'],
10 |     package_dir={'':'python'})
11 | 
12 | setup(**setup_args)
13 | 


--------------------------------------------------------------------------------
/aslam_cv/aslam_cv_python/src/CameraSystemClasses.cpp:
--------------------------------------------------------------------------------
 1 | void exportCameraSystem();
 2 | void exportMultiFrame();
 3 | void exportImageSynchronizer();
 4 | void exportFrameBuilder();
 5 | 
 6 | void exportCameraSystemClasses() {
 7 |   exportCameraSystem();
 8 |   exportMultiFrame();
 9 |   exportImageSynchronizer();
10 |   exportFrameBuilder();
11 | }
12 | 


--------------------------------------------------------------------------------
/aslam_cv/aslam_cv_python/src/Frontend.cpp:
--------------------------------------------------------------------------------
 1 | #include <numpy_eigen/boost_python_headers.hpp>
 2 | 
 3 | void exportFrame();
 4 | //void exportDescriptors();
 5 | 
 6 | void exportFrontend() {
 7 |   exportFrame();
 8 | //  exportDescriptors();
 9 | }
10 | 


--------------------------------------------------------------------------------
/aslam_cv/aslam_cv_serialization/.gitignore:
--------------------------------------------------------------------------------
1 | test.ba
2 | 


--------------------------------------------------------------------------------
/aslam_cv/aslam_cv_serialization/include/aslam/aslam_cv_serialization.hpp:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/ethz-asl/kalibr/1f60227442d25e36365ef5f72cd80b9666d73467/aslam_cv/aslam_cv_serialization/include/aslam/aslam_cv_serialization.hpp


--------------------------------------------------------------------------------
/aslam_cv/aslam_cv_serialization/mainpage.dox:
--------------------------------------------------------------------------------
 1 | /**
 2 | \mainpage
 3 | \htmlinclude manifest.html
 4 | 
 5 | \b aslam_cv_serialization 
 6 | 
 7 | <!-- 
 8 | Provide an overview of your package.
 9 | -->
10 | 
11 | -->
12 | 
13 | 
14 | */
15 | 


--------------------------------------------------------------------------------
/aslam_cv/aslam_cv_serialization/src/FrameSerialization.hpp:
--------------------------------------------------------------------------------
1 | namespace aslam {
2 | 
3 | }  // namespace aslam
4 | 


--------------------------------------------------------------------------------
/aslam_cv/aslam_cv_serialization/src/LinkCvSerialization.cpp:
--------------------------------------------------------------------------------
1 | #include <aslam/LinkCvSerialization.hpp>
2 | 


--------------------------------------------------------------------------------
/aslam_cv/aslam_cv_serialization/test/test_main.cpp:
--------------------------------------------------------------------------------
1 | #include <gtest/gtest.h>
2 | 
3 | /// Run all the tests that were declared with TEST()
4 | int main(int argc, char **argv) {
5 |   testing::InitGoogleTest(&argc, argv);
6 |   return RUN_ALL_TESTS();
7 | }
8 | 


--------------------------------------------------------------------------------
/aslam_cv/aslam_imgproc/test/testUndistorter.cpp:
--------------------------------------------------------------------------------
1 | #include <aslam/PinholeUndistorter.hpp>
2 | #include <aslam/OmniUndistorter.hpp>
3 | #include <aslam/NullUndistorter.hpp>
4 | #include <aslam/calculateOverlappingFov.hpp>
5 | 
6 | int main(int argc, char **argv) {
7 |   return 1;
8 | }
9 | 


--------------------------------------------------------------------------------
/aslam_incremental_calibration/incremental_calibration_python/include/module.cpp:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/ethz-asl/kalibr/1f60227442d25e36365ef5f72cd80b9666d73467/aslam_incremental_calibration/incremental_calibration_python/include/module.cpp


--------------------------------------------------------------------------------
/aslam_nonparametric_estimation/aslam_splines/.gitignore:
--------------------------------------------------------------------------------
1 | python/aslam_splines/libaslam_splines_python.so
2 | /LocalBuildType.cmake
3 | 


--------------------------------------------------------------------------------
/aslam_nonparametric_estimation/aslam_splines/test/test_main.cpp:
--------------------------------------------------------------------------------
1 | #include <gtest/gtest.h>
2 | 
3 | /// Run all the tests that were declared with TEST()
4 | int main(int argc, char **argv){
5 |   testing::InitGoogleTest(&argc, argv);
6 |   return RUN_ALL_TESTS();
7 | }
8 | 


--------------------------------------------------------------------------------
/aslam_nonparametric_estimation/aslam_splines_python/python/aslam_splines/__init__.py:
--------------------------------------------------------------------------------
1 | # Import the numpy to Eigen type conversion.
2 | import numpy_eigen
3 | import os
4 | import aslam_backend
5 | import bsplines
6 | from .libaslam_splines_python import *
7 | 
8 | 
9 | 


--------------------------------------------------------------------------------
/aslam_nonparametric_estimation/bsplines/.gitignore:
--------------------------------------------------------------------------------
1 | python/bsplines/libbsplines.so
2 | *.pyc
3 | /LocalBuildType.cmake
4 | 


--------------------------------------------------------------------------------
/aslam_nonparametric_estimation/bsplines/doc/footer.html:
--------------------------------------------------------------------------------
1 | <hr size="1"/><address style="text-align: right;"><small>
2 | Generated on $datetime for $projectname by&nbsp;<a href="http://www.doxygen.org/index.html"><img class="footer" src="doxygen.png" alt="doxygen"/></a> $doxygenversion</small></address>
3 | </td>
4 | </tr>
5 | </table>
6 | 
7 | </body>
8 | </html>
9 | 


--------------------------------------------------------------------------------
/aslam_nonparametric_estimation/bsplines/interp_rotation/quaternions/__init__.py:
--------------------------------------------------------------------------------
 1 | import sm
 2 | import numpy
 3 | 
 4 | 
 5 | def qdot(q1,q2):
 6 |     return numpy.dot(sm.quatPlus(q1),q2)
 7 | 
 8 | def qinv(q):
 9 |     return sm.quatInv(q)
10 | 
11 | def qlog(q):
12 |     return sm.quat2AxisAngle(q)
13 | 
14 | def qexp(a):
15 |     return sm.axisAngle2quat(a)


--------------------------------------------------------------------------------
/aslam_nonparametric_estimation/bsplines/latex/orientation/.gitignore:
--------------------------------------------------------------------------------
1 | /orientation.log
2 | /orientation.pdf
3 | /orientation.synctex.gz
4 | /orientation.aux
5 | /orientation.out
6 | /orientation.bbl
7 | /orientation.blg
8 | 


--------------------------------------------------------------------------------
/aslam_nonparametric_estimation/bsplines/latex/orientation/figs/asl.pdf:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/ethz-asl/kalibr/1f60227442d25e36365ef5f72cd80b9666d73467/aslam_nonparametric_estimation/bsplines/latex/orientation/figs/asl.pdf


--------------------------------------------------------------------------------
/aslam_nonparametric_estimation/bsplines/latex/orientation/figs/asl_black.pdf:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/ethz-asl/kalibr/1f60227442d25e36365ef5f72cd80b9666d73467/aslam_nonparametric_estimation/bsplines/latex/orientation/figs/asl_black.pdf


--------------------------------------------------------------------------------
/aslam_nonparametric_estimation/bsplines/latex/orientation/figs/asl_black_logo.pdf:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/ethz-asl/kalibr/1f60227442d25e36365ef5f72cd80b9666d73467/aslam_nonparametric_estimation/bsplines/latex/orientation/figs/asl_black_logo.pdf


--------------------------------------------------------------------------------
/aslam_nonparametric_estimation/bsplines/latex/orientation/figs/eth_logo_black.pdf:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/ethz-asl/kalibr/1f60227442d25e36365ef5f72cd80b9666d73467/aslam_nonparametric_estimation/bsplines/latex/orientation/figs/eth_logo_black.pdf


--------------------------------------------------------------------------------
/aslam_nonparametric_estimation/bsplines/src/DiffManifoldBSpline.cpp:
--------------------------------------------------------------------------------
 1 | /*
 2 |  * DiffManifoldBSpline.cpp
 3 |  *
 4 |  *  Created on: 05.08.2012
 5 |  *      Author: hannes
 6 |  *
 7 |  * this file only supplies the eclipse C-Indexer with a canonical context for the included header
 8 |  */
 9 | 
10 | 
11 | 
12 | 
13 | #include <bsplines/DiffManifoldBSpline.hpp>
14 | 


--------------------------------------------------------------------------------
/aslam_nonparametric_estimation/bsplines/test/test_main.cpp:
--------------------------------------------------------------------------------
1 | #include <gtest/gtest.h>
2 | 
3 | /// Run all the tests that were declared with TEST()
4 | int main(int argc, char **argv){
5 |   testing::InitGoogleTest(&argc, argv);
6 |   return RUN_ALL_TESTS();
7 | }
8 | 


--------------------------------------------------------------------------------
/aslam_nonparametric_estimation/bsplines_python/.gitignore:
--------------------------------------------------------------------------------
1 | python/bsplines/libbsplines.so
2 | *.pyc
3 | /LocalBuildType.cmake
4 | 


--------------------------------------------------------------------------------
/aslam_nonparametric_estimation/bsplines_python/python/bsplines/__init__.py:
--------------------------------------------------------------------------------
1 | # Import the numpy to Eigen type conversion.
2 | import numpy_eigen
3 | # Import the Spline C++ library.
4 | from .libbsplines_python import *
5 | from .plotPoseSpline import *
6 | 


--------------------------------------------------------------------------------
/aslam_offline_calibration/ethz_apriltag2/src/MathUtil.cc:
--------------------------------------------------------------------------------
 1 | #include "apriltags/MathUtil.h"
 2 | 
 3 | namespace AprilTags{
 4 | 
 5 | // Output operator for std::pair<float,float>, useful for debugging
 6 | std::ostream& operator<<(std::ostream &os, const std::pair<float,float> &pt) {
 7 |   os << pt.first << "," << pt.second;
 8 |   return os;
 9 | }
10 | 
11 | } // namespace
12 | 


--------------------------------------------------------------------------------
/aslam_offline_calibration/ethz_apriltag2/src/example/CMakeLists.txt:
--------------------------------------------------------------------------------
 1 | cmake_minimum_required (VERSION 2.6)
 2 | 
 3 | link_libraries(apriltags)
 4 | 
 5 | add_executable(apriltags_demo apriltags_demo.cpp Serial.cpp)
 6 | pods_install_executables(apriltags_demo)
 7 | 
 8 | add_executable(imu imu.cpp Serial.cpp)
 9 | pods_install_executables(imu)
10 | 


--------------------------------------------------------------------------------
/aslam_offline_calibration/kalibr/python/exporters/auxiliary_files/msf_mid.txt:
--------------------------------------------------------------------------------
1 | pose_sensor/pose_noise_meas_p: 0.002
2 | pose_sensor/pose_noise_meas_q: 0.005
3 | 
4 | 


--------------------------------------------------------------------------------
/aslam_offline_calibration/kalibr/python/kalibr_camera_calibration/__init__.py:
--------------------------------------------------------------------------------
1 | # Import the numpy to Eigen type conversion.
2 | import numpy_eigen
3 | from .CameraCalibrator import *
4 | from .ObsDb import *
5 | from .MulticamGraph import *
6 | from .CameraIntializers import *
7 | from .CameraUtils import *
8 | 


--------------------------------------------------------------------------------
/aslam_offline_calibration/kalibr/python/kalibr_common/__init__.py:
--------------------------------------------------------------------------------
1 | # Import the numpy to Eigen type conversion.
2 | import numpy_eigen
3 | from .ConfigReader import *
4 | from .ImageDatasetReader import *
5 | from .ImuDatasetReader import *
6 | from .TargetExtractor import *
7 | 


--------------------------------------------------------------------------------
/aslam_offline_calibration/kalibr/python/kalibr_errorterms/__init__.py:
--------------------------------------------------------------------------------
1 | import aslam_cv_backend #needed for errorterm base class wrapper
2 | 
3 | # NB: We import these bindings from the global path as we have to
4 | # hack the installation due to multiple Python packages in one
5 | # catkin package.
6 | from libkalibr_errorterms_python import * 
7 | 


--------------------------------------------------------------------------------
/aslam_offline_calibration/kalibr/python/kalibr_imu_camera_calibration/__init__.py:
--------------------------------------------------------------------------------
1 | from .IccCalibrator import *
2 | from . import IccUtil as util
3 | from . import IccPlots as plots
4 | from . import IccSensors as sens
5 | 


--------------------------------------------------------------------------------
/aslam_offline_calibration/kalibr/python/kalibr_rs_camera_calibration/__init__.py:
--------------------------------------------------------------------------------
1 | from .RsCalibrator import *
2 | 


--------------------------------------------------------------------------------
/aslam_offline_calibration/kalibr/test/test_main.cpp:
--------------------------------------------------------------------------------
1 | #include <gtest/gtest.h>
2 | 
3 | /// Run all the tests that were declared with TEST()
4 | int main(int argc, char **argv){
5 |   testing::InitGoogleTest(&argc, argv);
6 |   return RUN_ALL_TESTS();
7 | }
8 | 
9 | 


--------------------------------------------------------------------------------
/aslam_optimizer/aslam_backend/src/JacobianBuilder.cpp:
--------------------------------------------------------------------------------
 1 | #include <aslam/backend/JacobianBuilder.hpp>
 2 | 
 3 | namespace aslam {
 4 |   namespace backend {
 5 | 
 6 |     JacobianBuilder::JacobianBuilder()
 7 |     {
 8 |     }
 9 | 
10 |     JacobianBuilder::~JacobianBuilder()
11 |     {
12 |     }
13 | 
14 | 
15 |   } // namespace backend
16 | } // namespace aslam
17 | 


--------------------------------------------------------------------------------
/aslam_optimizer/aslam_backend/test/test_main.cpp:
--------------------------------------------------------------------------------
 1 | #include <gtest/gtest.h>
 2 | 
 3 | /// Run all the tests that were declared with TEST()
 4 | int main(int argc, char** argv)
 5 | {
 6 |   testing::InitGoogleTest(&argc, argv);
 7 |   return RUN_ALL_TESTS();
 8 | }
 9 | 
10 | 


--------------------------------------------------------------------------------
/aslam_optimizer/aslam_backend_expressions/include/aslam/backend/implementation/GenericScalarExpressionNode.hpp:
--------------------------------------------------------------------------------
1 | #include <aslam/backend/GenericScalarExpressionNode.hpp>
2 | #include <sm/kinematics/rotations.hpp>
3 | 
4 | namespace aslam {
5 | namespace backend {
6 | 
7 | }  // namespace backend
8 | }  // namespace aslam
9 | 


--------------------------------------------------------------------------------
/aslam_optimizer/aslam_backend_expressions/test/test_main.cpp:
--------------------------------------------------------------------------------
1 | #include <gtest/gtest.h>
2 | 
3 | /// Run all the tests that were declared with TEST()
4 | int main(int argc, char **argv){
5 |   testing::InitGoogleTest(&argc, argv);
6 |   return RUN_ALL_TESTS();
7 | }
8 | 
9 | 


--------------------------------------------------------------------------------
/aslam_optimizer/aslam_backend_python/src/BackendDesignVariables.cpp:
--------------------------------------------------------------------------------
 1 | #include <numpy_eigen/boost_python_headers.hpp>
 2 | 
 3 | 
 4 | void exportPinholeCameraDesignVariable();
 5 | void exportPinholeRSCameraDesignVariable();
 6 | 
 7 | 
 8 | void exportBackendDesignVariables()
 9 | {
10 |   //exportPinholeRSCameraDesignVariable();
11 |   //exportPinholeCameraDesignVariable();
12 | }
13 | 
14 | 


--------------------------------------------------------------------------------
/aslam_optimizer/aslam_backend_python/src/Frontend.cpp:
--------------------------------------------------------------------------------
 1 | #include <numpy_eigen/boost_python_headers.hpp>
 2 | 
 3 | 
 4 | 
 5 | void exportFrame();
 6 | void exportDescriptors();
 7 | 
 8 | void exportFrontend()
 9 | {
10 |   exportFrame();
11 |   exportDescriptors();
12 | }
13 | 


--------------------------------------------------------------------------------
/aslam_optimizer/sparse_block_matrix/cmake/sparse_block_matrix-extras.cmake.in:
--------------------------------------------------------------------------------
1 | # The first CFG_EXTRAS runs the FindSuiteSparse, now we just need to add the include directories:
2 | include_directories(${CHOLMOD_INCLUDE_DIR})


--------------------------------------------------------------------------------
/aslam_optimizer/sparse_block_matrix/src/solver_cholmod.cpp:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/ethz-asl/kalibr/1f60227442d25e36365ef5f72cd80b9666d73467/aslam_optimizer/sparse_block_matrix/src/solver_cholmod.cpp


--------------------------------------------------------------------------------
/aslam_optimizer/sparse_block_matrix/src/sparse_block_matrix/.gitignore:
--------------------------------------------------------------------------------
1 | libsparse_block_matrix_python.so
2 | 


--------------------------------------------------------------------------------
/aslam_optimizer/sparse_block_matrix/src/sparse_block_matrix/__init__.py:
--------------------------------------------------------------------------------
1 | # Import the numpy to Eigen type conversion.
2 | import numpy_eigen
3 | # Import the the C++ exports from your package library.
4 | from .libsparse_block_matrix_python import *
5 | # Import other files in the directory
6 | # from mypyfile import *
7 | 


--------------------------------------------------------------------------------
/aslam_optimizer/sparse_block_matrix/test/test_main.cpp:
--------------------------------------------------------------------------------
1 | #include <gtest/gtest.h>
2 | 
3 | /// Run all the tests that were declared with TEST()
4 | int main(int argc, char **argv){
5 |   testing::InitGoogleTest(&argc, argv);
6 |   return RUN_ALL_TESTS();
7 | }
8 | 


--------------------------------------------------------------------------------
/catkin_simple/.gitignore:
--------------------------------------------------------------------------------
1 | *.pyc
2 | 


--------------------------------------------------------------------------------
/catkin_simple/CMakeLists.txt:
--------------------------------------------------------------------------------
 1 | cmake_minimum_required(VERSION 3.0.2)
 2 | project(catkin_simple)
 3 | 
 4 | find_package(catkin REQUIRED)
 5 | 
 6 | catkin_package(
 7 |   CATKIN_DEPENDS catkin
 8 |   CFG_EXTRAS catkin_simple-extras.cmake
 9 | )
10 | 


--------------------------------------------------------------------------------
/catkin_simple/test/scenarios/hello_world/.gitignore:
--------------------------------------------------------------------------------
1 | CMakeLists.txt
2 | 


--------------------------------------------------------------------------------
/catkin_simple/test/scenarios/hello_world/bar/include/bar/hello.h:
--------------------------------------------------------------------------------
1 | void hello();
2 | 


--------------------------------------------------------------------------------
/catkin_simple/test/scenarios/hello_world/bar/msg/HeaderString.msg:
--------------------------------------------------------------------------------
1 | Header header
2 | string data
3 | 


--------------------------------------------------------------------------------
/catkin_simple/test/scenarios/hello_world/bar/src/hello.cpp:
--------------------------------------------------------------------------------
 1 | #include <bar/hello.h>
 2 | #include <bar/HeaderString.h>
 3 | 
 4 | #include <iostream>
 5 | 
 6 | #include <boost/thread.hpp>
 7 | 
 8 | 
 9 | inline void print_hello() {
10 |     std::cout << "Hello ";
11 | }
12 | 
13 | void hello() {
14 |     boost::thread t(print_hello);
15 |     t.join();
16 | }
17 | 


--------------------------------------------------------------------------------
/catkin_simple/test/scenarios/hello_world/baz/CMakeLists.txt:
--------------------------------------------------------------------------------
1 | cmake_minimum_required(VERSION 2.8.3)
2 | project(baz)
3 | 
4 | find_package(catkin REQUIRED)
5 | 
6 | catkin_package(
7 |   INCLUDE_DIRS include
8 | )
9 | 


--------------------------------------------------------------------------------
/catkin_simple/test/scenarios/hello_world/baz/include/baz/world.h:
--------------------------------------------------------------------------------
 1 | #include <iostream>
 2 | 
 3 | #include <boost/thread.hpp>
 4 | 
 5 | void print_world() {
 6 |     std::cout << "world!" << std::endl;
 7 | }
 8 | 
 9 | void world() {
10 |     boost::thread t(print_world);
11 |     t.join();
12 | }
13 | 


--------------------------------------------------------------------------------
/catkin_simple/test/scenarios/hello_world/catkin_simple:
--------------------------------------------------------------------------------
1 | ../../..


--------------------------------------------------------------------------------
/catkin_simple/test/scenarios/hello_world/foo/CMakeLists.txt:
--------------------------------------------------------------------------------
 1 | cmake_minimum_required(VERSION 2.8.3)
 2 | project(foo)
 3 | 
 4 | find_package(catkin_simple REQUIRED)
 5 | 
 6 | catkin_simple()
 7 | 
 8 | cs_add_executable(my_exec src/main.cpp)
 9 | 
10 | cs_install()
11 | 
12 | cs_export()
13 | 


--------------------------------------------------------------------------------
/catkin_simple/test/scenarios/hello_world/foo/src/main.cpp:
--------------------------------------------------------------------------------
1 | #include <bar/hello.h>
2 | #include <baz/world.h>
3 | 
4 | int main(void) {
5 |     hello();
6 |     world();
7 | 
8 |     return 0;
9 | }


--------------------------------------------------------------------------------
/opencv2_catkin/.gitignore:
--------------------------------------------------------------------------------
1 | *~
2 | 


--------------------------------------------------------------------------------
/opencv2_catkin/CMakeLists.txt:
--------------------------------------------------------------------------------
 1 | cmake_minimum_required(VERSION 3.0.2)
 2 | project(opencv2_catkin)
 3 | 
 4 | find_package(catkin_simple REQUIRED)
 5 | 
 6 | catkin_simple()
 7 | 
 8 | 
 9 | cs_install()
10 | cs_export(CFG_EXTRAS opencv2-extras.cmake)
11 | 


--------------------------------------------------------------------------------
/opencv2_catkin/README.md:
--------------------------------------------------------------------------------
1 | A convenience wrapper that handles the include and link for opencv automatically for catkin packages.
2 | 
3 | Make sure that the ROS catkin package "opencv2" is somewhere in your workspace, then add 
4 | ```
5 | <build_depend>opencv2_catkin</build_depend>
6 | ```
7 | to your package. OpenCV will be automatically found and linked.
8 | 


--------------------------------------------------------------------------------