Copy disabled (too large)
Download .txt
Showing preview only (107,986K chars total). Download the full file to get everything.
Repository: numenta/nupic.core
Branch: master
Commit: aafcbb92e391
Files: 12933
Total size: 113.2 MB
Directory structure:
gitextract_vbrl680u/
├── .circleci/
│ └── config.yml
├── .clang-format
├── .gitignore
├── .travis.yml
├── CHANGELOG.md
├── CMakeLists.txt
├── CONTRIBUTING.md
├── CommonCompilerConfig.cmake
├── DEPENDENCIES.md
├── Dockerfile
├── LICENSE.txt
├── README.md
├── RELEASE.md
├── VERSION
├── appveyor.yml
├── bindings/
│ └── py/
│ ├── dummy.c
│ ├── requirements.txt
│ ├── setup.py
│ ├── src/
│ │ └── nupic/
│ │ ├── __init__.py
│ │ ├── bindings/
│ │ │ ├── regions/
│ │ │ │ ├── PyRegion.py
│ │ │ │ ├── TestNode.py
│ │ │ │ └── __init__.py
│ │ │ └── tools/
│ │ │ ├── SerializationTestPyRegionProto.capnp
│ │ │ ├── __init__.py
│ │ │ ├── cyclical_serialization_perf.py
│ │ │ ├── random_serialization_perf.py
│ │ │ └── serialization_test_py_region.py
│ │ └── proto/
│ │ ├── .gitignore
│ │ └── __init__.py
│ └── tests/
│ ├── __init__.py
│ ├── algorithms/
│ │ ├── cells4_test.py
│ │ └── svm_test.py
│ ├── array_algorithms_test.py
│ ├── cast_mode_test.py
│ ├── check_test.py
│ ├── connections_test.py
│ ├── network_test.py
│ ├── nupic_random_test.py
│ ├── pyregion_test.py
│ ├── segment_sparse_matrix_test.py
│ ├── sparse_binary_matrix_test.py
│ ├── sparse_link_test.py
│ ├── sparse_matrix_test.py
│ └── temporal_memory_test.py
├── ci/
│ ├── appveyor/
│ │ └── install_python_pip.ps1
│ ├── bamboo/
│ │ ├── build-linux-debug.sh
│ │ ├── build-linux-release.sh
│ │ ├── build-manylinux-debug.sh
│ │ ├── build-manylinux-release.sh
│ │ ├── build-osx.sh
│ │ ├── build-windows.ps1
│ │ ├── check-style.sh
│ │ ├── fetch_remote.py
│ │ ├── manylinux-build-env.rc
│ │ └── setup-dependencies-linux.sh
│ ├── build-and-test-nupic-bindings.sh
│ ├── deploy-wheel-to-s3.py
│ └── travis/
│ ├── README.md
│ ├── before_deploy.sh
│ └── before_install-osx.sh
├── docs/
│ ├── .gitignore
│ ├── Doxyfile
│ ├── Makefile
│ ├── make.bat
│ ├── source/
│ │ ├── algorithms.rst
│ │ ├── classifiers.rst
│ │ ├── conf.py
│ │ ├── connections.rst
│ │ ├── encoders.rst
│ │ ├── engine.rst
│ │ ├── index.rst
│ │ ├── math.rst
│ │ ├── network-io.rst
│ │ ├── network-links.rst
│ │ ├── network-network.rst
│ │ ├── network-regions.rst
│ │ ├── network-sensors.rst
│ │ ├── network.rst
│ │ ├── spatial-pooler.rst
│ │ ├── temporal-memory.rst
│ │ ├── types.rst
│ │ └── utils.rst
│ └── xunit.xslt
├── external/
│ ├── Apr1Lib.cmake
│ ├── AprUtil1Lib.cmake
│ ├── CMakeLists.txt
│ ├── CapnProto.cmake
│ ├── MoveFilesToNewDir.cmake
│ ├── README.md
│ ├── Swig.cmake
│ ├── YamlCppLib.cmake
│ ├── YamlLib.cmake
│ ├── Zlib.cmake
│ ├── common/
│ │ ├── include/
│ │ │ ├── CSV_README.md
│ │ │ ├── boost/
│ │ │ │ ├── accumulators/
│ │ │ │ │ ├── accumulators.hpp
│ │ │ │ │ ├── accumulators_fwd.hpp
│ │ │ │ │ ├── framework/
│ │ │ │ │ │ ├── accumulator_base.hpp
│ │ │ │ │ │ ├── accumulator_concept.hpp
│ │ │ │ │ │ ├── accumulator_set.hpp
│ │ │ │ │ │ ├── accumulators/
│ │ │ │ │ │ │ ├── droppable_accumulator.hpp
│ │ │ │ │ │ │ ├── external_accumulator.hpp
│ │ │ │ │ │ │ ├── reference_accumulator.hpp
│ │ │ │ │ │ │ └── value_accumulator.hpp
│ │ │ │ │ │ ├── depends_on.hpp
│ │ │ │ │ │ ├── external.hpp
│ │ │ │ │ │ ├── extractor.hpp
│ │ │ │ │ │ ├── features.hpp
│ │ │ │ │ │ └── parameters/
│ │ │ │ │ │ ├── accumulator.hpp
│ │ │ │ │ │ ├── sample.hpp
│ │ │ │ │ │ ├── weight.hpp
│ │ │ │ │ │ └── weights.hpp
│ │ │ │ │ ├── numeric/
│ │ │ │ │ │ ├── detail/
│ │ │ │ │ │ │ ├── function1.hpp
│ │ │ │ │ │ │ ├── function2.hpp
│ │ │ │ │ │ │ ├── function3.hpp
│ │ │ │ │ │ │ ├── function4.hpp
│ │ │ │ │ │ │ ├── function_n.hpp
│ │ │ │ │ │ │ └── pod_singleton.hpp
│ │ │ │ │ │ ├── functional/
│ │ │ │ │ │ │ ├── complex.hpp
│ │ │ │ │ │ │ ├── valarray.hpp
│ │ │ │ │ │ │ └── vector.hpp
│ │ │ │ │ │ ├── functional.hpp
│ │ │ │ │ │ └── functional_fwd.hpp
│ │ │ │ │ ├── statistics/
│ │ │ │ │ │ ├── count.hpp
│ │ │ │ │ │ ├── covariance.hpp
│ │ │ │ │ │ ├── density.hpp
│ │ │ │ │ │ ├── error_of.hpp
│ │ │ │ │ │ ├── error_of_mean.hpp
│ │ │ │ │ │ ├── extended_p_square.hpp
│ │ │ │ │ │ ├── extended_p_square_quantile.hpp
│ │ │ │ │ │ ├── kurtosis.hpp
│ │ │ │ │ │ ├── max.hpp
│ │ │ │ │ │ ├── mean.hpp
│ │ │ │ │ │ ├── median.hpp
│ │ │ │ │ │ ├── min.hpp
│ │ │ │ │ │ ├── moment.hpp
│ │ │ │ │ │ ├── p_square_cumul_dist.hpp
│ │ │ │ │ │ ├── p_square_cumulative_distribution.hpp
│ │ │ │ │ │ ├── p_square_quantile.hpp
│ │ │ │ │ │ ├── parameters/
│ │ │ │ │ │ │ └── quantile_probability.hpp
│ │ │ │ │ │ ├── peaks_over_threshold.hpp
│ │ │ │ │ │ ├── pot_quantile.hpp
│ │ │ │ │ │ ├── pot_tail_mean.hpp
│ │ │ │ │ │ ├── rolling_count.hpp
│ │ │ │ │ │ ├── rolling_mean.hpp
│ │ │ │ │ │ ├── rolling_moment.hpp
│ │ │ │ │ │ ├── rolling_sum.hpp
│ │ │ │ │ │ ├── rolling_variance.hpp
│ │ │ │ │ │ ├── rolling_window.hpp
│ │ │ │ │ │ ├── skewness.hpp
│ │ │ │ │ │ ├── stats.hpp
│ │ │ │ │ │ ├── sum.hpp
│ │ │ │ │ │ ├── sum_kahan.hpp
│ │ │ │ │ │ ├── tail.hpp
│ │ │ │ │ │ ├── tail_mean.hpp
│ │ │ │ │ │ ├── tail_quantile.hpp
│ │ │ │ │ │ ├── tail_variate.hpp
│ │ │ │ │ │ ├── tail_variate_means.hpp
│ │ │ │ │ │ ├── times2_iterator.hpp
│ │ │ │ │ │ ├── variance.hpp
│ │ │ │ │ │ ├── variates/
│ │ │ │ │ │ │ └── covariate.hpp
│ │ │ │ │ │ ├── weighted_covariance.hpp
│ │ │ │ │ │ ├── weighted_density.hpp
│ │ │ │ │ │ ├── weighted_extended_p_square.hpp
│ │ │ │ │ │ ├── weighted_kurtosis.hpp
│ │ │ │ │ │ ├── weighted_mean.hpp
│ │ │ │ │ │ ├── weighted_median.hpp
│ │ │ │ │ │ ├── weighted_moment.hpp
│ │ │ │ │ │ ├── weighted_p_square_cumul_dist.hpp
│ │ │ │ │ │ ├── weighted_p_square_cumulative_distribution.hpp
│ │ │ │ │ │ ├── weighted_p_square_quantile.hpp
│ │ │ │ │ │ ├── weighted_peaks_over_threshold.hpp
│ │ │ │ │ │ ├── weighted_skewness.hpp
│ │ │ │ │ │ ├── weighted_sum.hpp
│ │ │ │ │ │ ├── weighted_sum_kahan.hpp
│ │ │ │ │ │ ├── weighted_tail_mean.hpp
│ │ │ │ │ │ ├── weighted_tail_quantile.hpp
│ │ │ │ │ │ ├── weighted_tail_variate_means.hpp
│ │ │ │ │ │ ├── weighted_variance.hpp
│ │ │ │ │ │ └── with_error.hpp
│ │ │ │ │ ├── statistics.hpp
│ │ │ │ │ └── statistics_fwd.hpp
│ │ │ │ ├── algorithm/
│ │ │ │ │ ├── algorithm.hpp
│ │ │ │ │ ├── clamp.hpp
│ │ │ │ │ ├── cxx11/
│ │ │ │ │ │ ├── all_of.hpp
│ │ │ │ │ │ ├── any_of.hpp
│ │ │ │ │ │ ├── copy_if.hpp
│ │ │ │ │ │ ├── copy_n.hpp
│ │ │ │ │ │ ├── find_if_not.hpp
│ │ │ │ │ │ ├── iota.hpp
│ │ │ │ │ │ ├── is_partitioned.hpp
│ │ │ │ │ │ ├── is_permutation.hpp
│ │ │ │ │ │ ├── is_sorted.hpp
│ │ │ │ │ │ ├── none_of.hpp
│ │ │ │ │ │ ├── one_of.hpp
│ │ │ │ │ │ ├── partition_copy.hpp
│ │ │ │ │ │ └── partition_point.hpp
│ │ │ │ │ ├── cxx14/
│ │ │ │ │ │ ├── equal.hpp
│ │ │ │ │ │ ├── is_permutation.hpp
│ │ │ │ │ │ └── mismatch.hpp
│ │ │ │ │ ├── gather.hpp
│ │ │ │ │ ├── hex.hpp
│ │ │ │ │ ├── is_palindrome.hpp
│ │ │ │ │ ├── minmax.hpp
│ │ │ │ │ ├── minmax_element.hpp
│ │ │ │ │ ├── searching/
│ │ │ │ │ │ ├── boyer_moore.hpp
│ │ │ │ │ │ ├── boyer_moore_horspool.hpp
│ │ │ │ │ │ ├── detail/
│ │ │ │ │ │ │ ├── bm_traits.hpp
│ │ │ │ │ │ │ └── debugging.hpp
│ │ │ │ │ │ └── knuth_morris_pratt.hpp
│ │ │ │ │ ├── sort_subrange.hpp
│ │ │ │ │ ├── string/
│ │ │ │ │ │ ├── case_conv.hpp
│ │ │ │ │ │ ├── classification.hpp
│ │ │ │ │ │ ├── compare.hpp
│ │ │ │ │ │ ├── concept.hpp
│ │ │ │ │ │ ├── config.hpp
│ │ │ │ │ │ ├── constants.hpp
│ │ │ │ │ │ ├── detail/
│ │ │ │ │ │ │ ├── case_conv.hpp
│ │ │ │ │ │ │ ├── classification.hpp
│ │ │ │ │ │ │ ├── find_format.hpp
│ │ │ │ │ │ │ ├── find_format_all.hpp
│ │ │ │ │ │ │ ├── find_format_store.hpp
│ │ │ │ │ │ │ ├── find_iterator.hpp
│ │ │ │ │ │ │ ├── finder.hpp
│ │ │ │ │ │ │ ├── finder_regex.hpp
│ │ │ │ │ │ │ ├── formatter.hpp
│ │ │ │ │ │ │ ├── formatter_regex.hpp
│ │ │ │ │ │ │ ├── predicate.hpp
│ │ │ │ │ │ │ ├── replace_storage.hpp
│ │ │ │ │ │ │ ├── sequence.hpp
│ │ │ │ │ │ │ ├── trim.hpp
│ │ │ │ │ │ │ └── util.hpp
│ │ │ │ │ │ ├── erase.hpp
│ │ │ │ │ │ ├── find.hpp
│ │ │ │ │ │ ├── find_format.hpp
│ │ │ │ │ │ ├── find_iterator.hpp
│ │ │ │ │ │ ├── finder.hpp
│ │ │ │ │ │ ├── formatter.hpp
│ │ │ │ │ │ ├── iter_find.hpp
│ │ │ │ │ │ ├── join.hpp
│ │ │ │ │ │ ├── predicate.hpp
│ │ │ │ │ │ ├── predicate_facade.hpp
│ │ │ │ │ │ ├── regex.hpp
│ │ │ │ │ │ ├── regex_find_format.hpp
│ │ │ │ │ │ ├── replace.hpp
│ │ │ │ │ │ ├── sequence_traits.hpp
│ │ │ │ │ │ ├── split.hpp
│ │ │ │ │ │ ├── std/
│ │ │ │ │ │ │ ├── list_traits.hpp
│ │ │ │ │ │ │ ├── rope_traits.hpp
│ │ │ │ │ │ │ ├── slist_traits.hpp
│ │ │ │ │ │ │ └── string_traits.hpp
│ │ │ │ │ │ ├── std_containers_traits.hpp
│ │ │ │ │ │ ├── trim.hpp
│ │ │ │ │ │ ├── trim_all.hpp
│ │ │ │ │ │ └── yes_no_type.hpp
│ │ │ │ │ ├── string.hpp
│ │ │ │ │ └── string_regex.hpp
│ │ │ │ ├── align/
│ │ │ │ │ ├── align.hpp
│ │ │ │ │ ├── align_down.hpp
│ │ │ │ │ ├── align_up.hpp
│ │ │ │ │ ├── aligned_alloc.hpp
│ │ │ │ │ ├── aligned_allocator.hpp
│ │ │ │ │ ├── aligned_allocator_adaptor.hpp
│ │ │ │ │ ├── aligned_allocator_adaptor_forward.hpp
│ │ │ │ │ ├── aligned_allocator_forward.hpp
│ │ │ │ │ ├── aligned_delete.hpp
│ │ │ │ │ ├── aligned_delete_forward.hpp
│ │ │ │ │ ├── alignment_of.hpp
│ │ │ │ │ ├── alignment_of_forward.hpp
│ │ │ │ │ ├── assume_aligned.hpp
│ │ │ │ │ ├── detail/
│ │ │ │ │ │ ├── addressof.hpp
│ │ │ │ │ │ ├── align.hpp
│ │ │ │ │ │ ├── align_cxx11.hpp
│ │ │ │ │ │ ├── align_down.hpp
│ │ │ │ │ │ ├── align_up.hpp
│ │ │ │ │ │ ├── aligned_alloc.hpp
│ │ │ │ │ │ ├── aligned_alloc_android.hpp
│ │ │ │ │ │ ├── aligned_alloc_macos.hpp
│ │ │ │ │ │ ├── aligned_alloc_msvc.hpp
│ │ │ │ │ │ ├── aligned_alloc_posix.hpp
│ │ │ │ │ │ ├── aligned_alloc_sunos.hpp
│ │ │ │ │ │ ├── alignment_of.hpp
│ │ │ │ │ │ ├── alignment_of_clang.hpp
│ │ │ │ │ │ ├── alignment_of_codegear.hpp
│ │ │ │ │ │ ├── alignment_of_cxx11.hpp
│ │ │ │ │ │ ├── alignment_of_gcc.hpp
│ │ │ │ │ │ ├── alignment_of_msvc.hpp
│ │ │ │ │ │ ├── assume_aligned.hpp
│ │ │ │ │ │ ├── assume_aligned_clang.hpp
│ │ │ │ │ │ ├── assume_aligned_gcc.hpp
│ │ │ │ │ │ ├── assume_aligned_intel.hpp
│ │ │ │ │ │ ├── assume_aligned_msvc.hpp
│ │ │ │ │ │ ├── element_type.hpp
│ │ │ │ │ │ ├── integral_constant.hpp
│ │ │ │ │ │ ├── is_aligned.hpp
│ │ │ │ │ │ ├── is_alignment.hpp
│ │ │ │ │ │ ├── is_alignment_constant.hpp
│ │ │ │ │ │ ├── max_align.hpp
│ │ │ │ │ │ ├── max_objects.hpp
│ │ │ │ │ │ ├── max_size.hpp
│ │ │ │ │ │ └── min_size.hpp
│ │ │ │ │ └── is_aligned.hpp
│ │ │ │ ├── align.hpp
│ │ │ │ ├── aligned_storage.hpp
│ │ │ │ ├── any.hpp
│ │ │ │ ├── archive/
│ │ │ │ │ ├── archive_exception.hpp
│ │ │ │ │ ├── basic_archive.hpp
│ │ │ │ │ ├── basic_binary_iarchive.hpp
│ │ │ │ │ ├── basic_binary_iprimitive.hpp
│ │ │ │ │ ├── basic_binary_oarchive.hpp
│ │ │ │ │ ├── basic_binary_oprimitive.hpp
│ │ │ │ │ ├── basic_streambuf_locale_saver.hpp
│ │ │ │ │ ├── basic_text_iarchive.hpp
│ │ │ │ │ ├── basic_text_iprimitive.hpp
│ │ │ │ │ ├── basic_text_oarchive.hpp
│ │ │ │ │ ├── basic_text_oprimitive.hpp
│ │ │ │ │ ├── basic_xml_archive.hpp
│ │ │ │ │ ├── basic_xml_iarchive.hpp
│ │ │ │ │ ├── basic_xml_oarchive.hpp
│ │ │ │ │ ├── binary_iarchive.hpp
│ │ │ │ │ ├── binary_iarchive_impl.hpp
│ │ │ │ │ ├── binary_oarchive.hpp
│ │ │ │ │ ├── binary_oarchive_impl.hpp
│ │ │ │ │ ├── binary_wiarchive.hpp
│ │ │ │ │ ├── binary_woarchive.hpp
│ │ │ │ │ ├── codecvt_null.hpp
│ │ │ │ │ ├── detail/
│ │ │ │ │ │ ├── abi_prefix.hpp
│ │ │ │ │ │ ├── abi_suffix.hpp
│ │ │ │ │ │ ├── archive_serializer_map.hpp
│ │ │ │ │ │ ├── auto_link_archive.hpp
│ │ │ │ │ │ ├── auto_link_warchive.hpp
│ │ │ │ │ │ ├── basic_iarchive.hpp
│ │ │ │ │ │ ├── basic_iserializer.hpp
│ │ │ │ │ │ ├── basic_oarchive.hpp
│ │ │ │ │ │ ├── basic_oserializer.hpp
│ │ │ │ │ │ ├── basic_pointer_iserializer.hpp
│ │ │ │ │ │ ├── basic_pointer_oserializer.hpp
│ │ │ │ │ │ ├── basic_serializer.hpp
│ │ │ │ │ │ ├── basic_serializer_map.hpp
│ │ │ │ │ │ ├── check.hpp
│ │ │ │ │ │ ├── common_iarchive.hpp
│ │ │ │ │ │ ├── common_oarchive.hpp
│ │ │ │ │ │ ├── decl.hpp
│ │ │ │ │ │ ├── helper_collection.hpp
│ │ │ │ │ │ ├── interface_iarchive.hpp
│ │ │ │ │ │ ├── interface_oarchive.hpp
│ │ │ │ │ │ ├── iserializer.hpp
│ │ │ │ │ │ ├── oserializer.hpp
│ │ │ │ │ │ ├── polymorphic_iarchive_route.hpp
│ │ │ │ │ │ ├── polymorphic_oarchive_route.hpp
│ │ │ │ │ │ ├── register_archive.hpp
│ │ │ │ │ │ └── utf8_codecvt_facet.hpp
│ │ │ │ │ ├── dinkumware.hpp
│ │ │ │ │ ├── impl/
│ │ │ │ │ │ ├── archive_serializer_map.ipp
│ │ │ │ │ │ ├── basic_binary_iarchive.ipp
│ │ │ │ │ │ ├── basic_binary_iprimitive.ipp
│ │ │ │ │ │ ├── basic_binary_oarchive.ipp
│ │ │ │ │ │ ├── basic_binary_oprimitive.ipp
│ │ │ │ │ │ ├── basic_text_iarchive.ipp
│ │ │ │ │ │ ├── basic_text_iprimitive.ipp
│ │ │ │ │ │ ├── basic_text_oarchive.ipp
│ │ │ │ │ │ ├── basic_text_oprimitive.ipp
│ │ │ │ │ │ ├── basic_xml_grammar.hpp
│ │ │ │ │ │ ├── basic_xml_iarchive.ipp
│ │ │ │ │ │ ├── basic_xml_oarchive.ipp
│ │ │ │ │ │ ├── text_iarchive_impl.ipp
│ │ │ │ │ │ ├── text_oarchive_impl.ipp
│ │ │ │ │ │ ├── text_wiarchive_impl.ipp
│ │ │ │ │ │ ├── text_woarchive_impl.ipp
│ │ │ │ │ │ ├── xml_iarchive_impl.ipp
│ │ │ │ │ │ ├── xml_oarchive_impl.ipp
│ │ │ │ │ │ ├── xml_wiarchive_impl.ipp
│ │ │ │ │ │ └── xml_woarchive_impl.ipp
│ │ │ │ │ ├── iterators/
│ │ │ │ │ │ ├── base64_exception.hpp
│ │ │ │ │ │ ├── base64_from_binary.hpp
│ │ │ │ │ │ ├── binary_from_base64.hpp
│ │ │ │ │ │ ├── dataflow.hpp
│ │ │ │ │ │ ├── dataflow_exception.hpp
│ │ │ │ │ │ ├── escape.hpp
│ │ │ │ │ │ ├── insert_linebreaks.hpp
│ │ │ │ │ │ ├── istream_iterator.hpp
│ │ │ │ │ │ ├── mb_from_wchar.hpp
│ │ │ │ │ │ ├── ostream_iterator.hpp
│ │ │ │ │ │ ├── remove_whitespace.hpp
│ │ │ │ │ │ ├── transform_width.hpp
│ │ │ │ │ │ ├── unescape.hpp
│ │ │ │ │ │ ├── wchar_from_mb.hpp
│ │ │ │ │ │ ├── xml_escape.hpp
│ │ │ │ │ │ ├── xml_unescape.hpp
│ │ │ │ │ │ └── xml_unescape_exception.hpp
│ │ │ │ │ ├── polymorphic_binary_iarchive.hpp
│ │ │ │ │ ├── polymorphic_binary_oarchive.hpp
│ │ │ │ │ ├── polymorphic_iarchive.hpp
│ │ │ │ │ ├── polymorphic_oarchive.hpp
│ │ │ │ │ ├── polymorphic_text_iarchive.hpp
│ │ │ │ │ ├── polymorphic_text_oarchive.hpp
│ │ │ │ │ ├── polymorphic_text_wiarchive.hpp
│ │ │ │ │ ├── polymorphic_text_woarchive.hpp
│ │ │ │ │ ├── polymorphic_xml_iarchive.hpp
│ │ │ │ │ ├── polymorphic_xml_oarchive.hpp
│ │ │ │ │ ├── polymorphic_xml_wiarchive.hpp
│ │ │ │ │ ├── polymorphic_xml_woarchive.hpp
│ │ │ │ │ ├── text_iarchive.hpp
│ │ │ │ │ ├── text_oarchive.hpp
│ │ │ │ │ ├── text_wiarchive.hpp
│ │ │ │ │ ├── text_woarchive.hpp
│ │ │ │ │ ├── tmpdir.hpp
│ │ │ │ │ ├── wcslen.hpp
│ │ │ │ │ ├── xml_archive_exception.hpp
│ │ │ │ │ ├── xml_iarchive.hpp
│ │ │ │ │ ├── xml_oarchive.hpp
│ │ │ │ │ ├── xml_wiarchive.hpp
│ │ │ │ │ └── xml_woarchive.hpp
│ │ │ │ ├── array.hpp
│ │ │ │ ├── asio/
│ │ │ │ │ ├── async_result.hpp
│ │ │ │ │ ├── basic_datagram_socket.hpp
│ │ │ │ │ ├── basic_deadline_timer.hpp
│ │ │ │ │ ├── basic_io_object.hpp
│ │ │ │ │ ├── basic_raw_socket.hpp
│ │ │ │ │ ├── basic_seq_packet_socket.hpp
│ │ │ │ │ ├── basic_serial_port.hpp
│ │ │ │ │ ├── basic_signal_set.hpp
│ │ │ │ │ ├── basic_socket.hpp
│ │ │ │ │ ├── basic_socket_acceptor.hpp
│ │ │ │ │ ├── basic_socket_iostream.hpp
│ │ │ │ │ ├── basic_socket_streambuf.hpp
│ │ │ │ │ ├── basic_stream_socket.hpp
│ │ │ │ │ ├── basic_streambuf.hpp
│ │ │ │ │ ├── basic_streambuf_fwd.hpp
│ │ │ │ │ ├── basic_waitable_timer.hpp
│ │ │ │ │ ├── buffer.hpp
│ │ │ │ │ ├── buffered_read_stream.hpp
│ │ │ │ │ ├── buffered_read_stream_fwd.hpp
│ │ │ │ │ ├── buffered_stream.hpp
│ │ │ │ │ ├── buffered_stream_fwd.hpp
│ │ │ │ │ ├── buffered_write_stream.hpp
│ │ │ │ │ ├── buffered_write_stream_fwd.hpp
│ │ │ │ │ ├── buffers_iterator.hpp
│ │ │ │ │ ├── completion_condition.hpp
│ │ │ │ │ ├── connect.hpp
│ │ │ │ │ ├── coroutine.hpp
│ │ │ │ │ ├── datagram_socket_service.hpp
│ │ │ │ │ ├── deadline_timer.hpp
│ │ │ │ │ ├── deadline_timer_service.hpp
│ │ │ │ │ ├── detail/
│ │ │ │ │ │ ├── addressof.hpp
│ │ │ │ │ │ ├── array.hpp
│ │ │ │ │ │ ├── array_fwd.hpp
│ │ │ │ │ │ ├── assert.hpp
│ │ │ │ │ │ ├── atomic_count.hpp
│ │ │ │ │ │ ├── base_from_completion_cond.hpp
│ │ │ │ │ │ ├── bind_handler.hpp
│ │ │ │ │ │ ├── buffer_resize_guard.hpp
│ │ │ │ │ │ ├── buffer_sequence_adapter.hpp
│ │ │ │ │ │ ├── buffered_stream_storage.hpp
│ │ │ │ │ │ ├── call_stack.hpp
│ │ │ │ │ │ ├── chrono_time_traits.hpp
│ │ │ │ │ │ ├── completion_handler.hpp
│ │ │ │ │ │ ├── config.hpp
│ │ │ │ │ │ ├── consuming_buffers.hpp
│ │ │ │ │ │ ├── cstdint.hpp
│ │ │ │ │ │ ├── date_time_fwd.hpp
│ │ │ │ │ │ ├── deadline_timer_service.hpp
│ │ │ │ │ │ ├── dependent_type.hpp
│ │ │ │ │ │ ├── descriptor_ops.hpp
│ │ │ │ │ │ ├── descriptor_read_op.hpp
│ │ │ │ │ │ ├── descriptor_write_op.hpp
│ │ │ │ │ │ ├── dev_poll_reactor.hpp
│ │ │ │ │ │ ├── epoll_reactor.hpp
│ │ │ │ │ │ ├── event.hpp
│ │ │ │ │ │ ├── eventfd_select_interrupter.hpp
│ │ │ │ │ │ ├── fd_set_adapter.hpp
│ │ │ │ │ │ ├── fenced_block.hpp
│ │ │ │ │ │ ├── function.hpp
│ │ │ │ │ │ ├── gcc_arm_fenced_block.hpp
│ │ │ │ │ │ ├── gcc_hppa_fenced_block.hpp
│ │ │ │ │ │ ├── gcc_sync_fenced_block.hpp
│ │ │ │ │ │ ├── gcc_x86_fenced_block.hpp
│ │ │ │ │ │ ├── handler_alloc_helpers.hpp
│ │ │ │ │ │ ├── handler_cont_helpers.hpp
│ │ │ │ │ │ ├── handler_invoke_helpers.hpp
│ │ │ │ │ │ ├── handler_tracking.hpp
│ │ │ │ │ │ ├── handler_type_requirements.hpp
│ │ │ │ │ │ ├── hash_map.hpp
│ │ │ │ │ │ ├── impl/
│ │ │ │ │ │ │ ├── buffer_sequence_adapter.ipp
│ │ │ │ │ │ │ ├── descriptor_ops.ipp
│ │ │ │ │ │ │ ├── dev_poll_reactor.hpp
│ │ │ │ │ │ │ ├── dev_poll_reactor.ipp
│ │ │ │ │ │ │ ├── epoll_reactor.hpp
│ │ │ │ │ │ │ ├── epoll_reactor.ipp
│ │ │ │ │ │ │ ├── eventfd_select_interrupter.ipp
│ │ │ │ │ │ │ ├── handler_tracking.ipp
│ │ │ │ │ │ │ ├── kqueue_reactor.hpp
│ │ │ │ │ │ │ ├── kqueue_reactor.ipp
│ │ │ │ │ │ │ ├── pipe_select_interrupter.ipp
│ │ │ │ │ │ │ ├── posix_event.ipp
│ │ │ │ │ │ │ ├── posix_mutex.ipp
│ │ │ │ │ │ │ ├── posix_thread.ipp
│ │ │ │ │ │ │ ├── posix_tss_ptr.ipp
│ │ │ │ │ │ │ ├── reactive_descriptor_service.ipp
│ │ │ │ │ │ │ ├── reactive_serial_port_service.ipp
│ │ │ │ │ │ │ ├── reactive_socket_service_base.ipp
│ │ │ │ │ │ │ ├── resolver_service_base.ipp
│ │ │ │ │ │ │ ├── select_reactor.hpp
│ │ │ │ │ │ │ ├── select_reactor.ipp
│ │ │ │ │ │ │ ├── service_registry.hpp
│ │ │ │ │ │ │ ├── service_registry.ipp
│ │ │ │ │ │ │ ├── signal_set_service.ipp
│ │ │ │ │ │ │ ├── socket_ops.ipp
│ │ │ │ │ │ │ ├── socket_select_interrupter.ipp
│ │ │ │ │ │ │ ├── strand_service.hpp
│ │ │ │ │ │ │ ├── strand_service.ipp
│ │ │ │ │ │ │ ├── task_io_service.hpp
│ │ │ │ │ │ │ ├── task_io_service.ipp
│ │ │ │ │ │ │ ├── throw_error.ipp
│ │ │ │ │ │ │ ├── timer_queue_ptime.ipp
│ │ │ │ │ │ │ ├── timer_queue_set.ipp
│ │ │ │ │ │ │ ├── win_event.ipp
│ │ │ │ │ │ │ ├── win_iocp_handle_service.ipp
│ │ │ │ │ │ │ ├── win_iocp_io_service.hpp
│ │ │ │ │ │ │ ├── win_iocp_io_service.ipp
│ │ │ │ │ │ │ ├── win_iocp_serial_port_service.ipp
│ │ │ │ │ │ │ ├── win_iocp_socket_service_base.ipp
│ │ │ │ │ │ │ ├── win_mutex.ipp
│ │ │ │ │ │ │ ├── win_object_handle_service.ipp
│ │ │ │ │ │ │ ├── win_static_mutex.ipp
│ │ │ │ │ │ │ ├── win_thread.ipp
│ │ │ │ │ │ │ ├── win_tss_ptr.ipp
│ │ │ │ │ │ │ ├── winrt_ssocket_service_base.ipp
│ │ │ │ │ │ │ ├── winrt_timer_scheduler.hpp
│ │ │ │ │ │ │ ├── winrt_timer_scheduler.ipp
│ │ │ │ │ │ │ └── winsock_init.ipp
│ │ │ │ │ │ ├── io_control.hpp
│ │ │ │ │ │ ├── keyword_tss_ptr.hpp
│ │ │ │ │ │ ├── kqueue_reactor.hpp
│ │ │ │ │ │ ├── limits.hpp
│ │ │ │ │ │ ├── local_free_on_block_exit.hpp
│ │ │ │ │ │ ├── macos_fenced_block.hpp
│ │ │ │ │ │ ├── memory.hpp
│ │ │ │ │ │ ├── mutex.hpp
│ │ │ │ │ │ ├── noncopyable.hpp
│ │ │ │ │ │ ├── null_event.hpp
│ │ │ │ │ │ ├── null_fenced_block.hpp
│ │ │ │ │ │ ├── null_mutex.hpp
│ │ │ │ │ │ ├── null_reactor.hpp
│ │ │ │ │ │ ├── null_signal_blocker.hpp
│ │ │ │ │ │ ├── null_socket_service.hpp
│ │ │ │ │ │ ├── null_static_mutex.hpp
│ │ │ │ │ │ ├── null_thread.hpp
│ │ │ │ │ │ ├── null_tss_ptr.hpp
│ │ │ │ │ │ ├── object_pool.hpp
│ │ │ │ │ │ ├── old_win_sdk_compat.hpp
│ │ │ │ │ │ ├── op_queue.hpp
│ │ │ │ │ │ ├── operation.hpp
│ │ │ │ │ │ ├── pipe_select_interrupter.hpp
│ │ │ │ │ │ ├── pop_options.hpp
│ │ │ │ │ │ ├── posix_event.hpp
│ │ │ │ │ │ ├── posix_fd_set_adapter.hpp
│ │ │ │ │ │ ├── posix_mutex.hpp
│ │ │ │ │ │ ├── posix_signal_blocker.hpp
│ │ │ │ │ │ ├── posix_static_mutex.hpp
│ │ │ │ │ │ ├── posix_thread.hpp
│ │ │ │ │ │ ├── posix_tss_ptr.hpp
│ │ │ │ │ │ ├── push_options.hpp
│ │ │ │ │ │ ├── reactive_descriptor_service.hpp
│ │ │ │ │ │ ├── reactive_null_buffers_op.hpp
│ │ │ │ │ │ ├── reactive_serial_port_service.hpp
│ │ │ │ │ │ ├── reactive_socket_accept_op.hpp
│ │ │ │ │ │ ├── reactive_socket_connect_op.hpp
│ │ │ │ │ │ ├── reactive_socket_recv_op.hpp
│ │ │ │ │ │ ├── reactive_socket_recvfrom_op.hpp
│ │ │ │ │ │ ├── reactive_socket_recvmsg_op.hpp
│ │ │ │ │ │ ├── reactive_socket_send_op.hpp
│ │ │ │ │ │ ├── reactive_socket_sendto_op.hpp
│ │ │ │ │ │ ├── reactive_socket_service.hpp
│ │ │ │ │ │ ├── reactive_socket_service_base.hpp
│ │ │ │ │ │ ├── reactor.hpp
│ │ │ │ │ │ ├── reactor_fwd.hpp
│ │ │ │ │ │ ├── reactor_op.hpp
│ │ │ │ │ │ ├── reactor_op_queue.hpp
│ │ │ │ │ │ ├── regex_fwd.hpp
│ │ │ │ │ │ ├── resolve_endpoint_op.hpp
│ │ │ │ │ │ ├── resolve_op.hpp
│ │ │ │ │ │ ├── resolver_service.hpp
│ │ │ │ │ │ ├── resolver_service_base.hpp
│ │ │ │ │ │ ├── scoped_lock.hpp
│ │ │ │ │ │ ├── scoped_ptr.hpp
│ │ │ │ │ │ ├── select_interrupter.hpp
│ │ │ │ │ │ ├── select_reactor.hpp
│ │ │ │ │ │ ├── service_registry.hpp
│ │ │ │ │ │ ├── shared_ptr.hpp
│ │ │ │ │ │ ├── signal_blocker.hpp
│ │ │ │ │ │ ├── signal_handler.hpp
│ │ │ │ │ │ ├── signal_init.hpp
│ │ │ │ │ │ ├── signal_op.hpp
│ │ │ │ │ │ ├── signal_set_service.hpp
│ │ │ │ │ │ ├── socket_holder.hpp
│ │ │ │ │ │ ├── socket_ops.hpp
│ │ │ │ │ │ ├── socket_option.hpp
│ │ │ │ │ │ ├── socket_select_interrupter.hpp
│ │ │ │ │ │ ├── socket_types.hpp
│ │ │ │ │ │ ├── solaris_fenced_block.hpp
│ │ │ │ │ │ ├── static_mutex.hpp
│ │ │ │ │ │ ├── std_event.hpp
│ │ │ │ │ │ ├── std_fenced_block.hpp
│ │ │ │ │ │ ├── std_mutex.hpp
│ │ │ │ │ │ ├── std_static_mutex.hpp
│ │ │ │ │ │ ├── std_thread.hpp
│ │ │ │ │ │ ├── strand_service.hpp
│ │ │ │ │ │ ├── task_io_service.hpp
│ │ │ │ │ │ ├── task_io_service_operation.hpp
│ │ │ │ │ │ ├── task_io_service_thread_info.hpp
│ │ │ │ │ │ ├── thread.hpp
│ │ │ │ │ │ ├── thread_info_base.hpp
│ │ │ │ │ │ ├── throw_error.hpp
│ │ │ │ │ │ ├── throw_exception.hpp
│ │ │ │ │ │ ├── timer_queue.hpp
│ │ │ │ │ │ ├── timer_queue_base.hpp
│ │ │ │ │ │ ├── timer_queue_ptime.hpp
│ │ │ │ │ │ ├── timer_queue_set.hpp
│ │ │ │ │ │ ├── timer_scheduler.hpp
│ │ │ │ │ │ ├── timer_scheduler_fwd.hpp
│ │ │ │ │ │ ├── tss_ptr.hpp
│ │ │ │ │ │ ├── type_traits.hpp
│ │ │ │ │ │ ├── variadic_templates.hpp
│ │ │ │ │ │ ├── wait_handler.hpp
│ │ │ │ │ │ ├── wait_op.hpp
│ │ │ │ │ │ ├── weak_ptr.hpp
│ │ │ │ │ │ ├── win_event.hpp
│ │ │ │ │ │ ├── win_fd_set_adapter.hpp
│ │ │ │ │ │ ├── win_fenced_block.hpp
│ │ │ │ │ │ ├── win_iocp_handle_read_op.hpp
│ │ │ │ │ │ ├── win_iocp_handle_service.hpp
│ │ │ │ │ │ ├── win_iocp_handle_write_op.hpp
│ │ │ │ │ │ ├── win_iocp_io_service.hpp
│ │ │ │ │ │ ├── win_iocp_null_buffers_op.hpp
│ │ │ │ │ │ ├── win_iocp_operation.hpp
│ │ │ │ │ │ ├── win_iocp_overlapped_op.hpp
│ │ │ │ │ │ ├── win_iocp_overlapped_ptr.hpp
│ │ │ │ │ │ ├── win_iocp_serial_port_service.hpp
│ │ │ │ │ │ ├── win_iocp_socket_accept_op.hpp
│ │ │ │ │ │ ├── win_iocp_socket_connect_op.hpp
│ │ │ │ │ │ ├── win_iocp_socket_recv_op.hpp
│ │ │ │ │ │ ├── win_iocp_socket_recvfrom_op.hpp
│ │ │ │ │ │ ├── win_iocp_socket_recvmsg_op.hpp
│ │ │ │ │ │ ├── win_iocp_socket_send_op.hpp
│ │ │ │ │ │ ├── win_iocp_socket_service.hpp
│ │ │ │ │ │ ├── win_iocp_socket_service_base.hpp
│ │ │ │ │ │ ├── win_iocp_thread_info.hpp
│ │ │ │ │ │ ├── win_mutex.hpp
│ │ │ │ │ │ ├── win_object_handle_service.hpp
│ │ │ │ │ │ ├── win_static_mutex.hpp
│ │ │ │ │ │ ├── win_thread.hpp
│ │ │ │ │ │ ├── win_tss_ptr.hpp
│ │ │ │ │ │ ├── winapi_thread.hpp
│ │ │ │ │ │ ├── winrt_async_manager.hpp
│ │ │ │ │ │ ├── winrt_async_op.hpp
│ │ │ │ │ │ ├── winrt_resolve_op.hpp
│ │ │ │ │ │ ├── winrt_resolver_service.hpp
│ │ │ │ │ │ ├── winrt_socket_connect_op.hpp
│ │ │ │ │ │ ├── winrt_socket_recv_op.hpp
│ │ │ │ │ │ ├── winrt_socket_send_op.hpp
│ │ │ │ │ │ ├── winrt_ssocket_service.hpp
│ │ │ │ │ │ ├── winrt_ssocket_service_base.hpp
│ │ │ │ │ │ ├── winrt_timer_scheduler.hpp
│ │ │ │ │ │ ├── winrt_utils.hpp
│ │ │ │ │ │ ├── winsock_init.hpp
│ │ │ │ │ │ └── wrapped_handler.hpp
│ │ │ │ │ ├── error.hpp
│ │ │ │ │ ├── generic/
│ │ │ │ │ │ ├── basic_endpoint.hpp
│ │ │ │ │ │ ├── datagram_protocol.hpp
│ │ │ │ │ │ ├── detail/
│ │ │ │ │ │ │ ├── endpoint.hpp
│ │ │ │ │ │ │ └── impl/
│ │ │ │ │ │ │ └── endpoint.ipp
│ │ │ │ │ │ ├── raw_protocol.hpp
│ │ │ │ │ │ ├── seq_packet_protocol.hpp
│ │ │ │ │ │ └── stream_protocol.hpp
│ │ │ │ │ ├── handler_alloc_hook.hpp
│ │ │ │ │ ├── handler_continuation_hook.hpp
│ │ │ │ │ ├── handler_invoke_hook.hpp
│ │ │ │ │ ├── handler_type.hpp
│ │ │ │ │ ├── high_resolution_timer.hpp
│ │ │ │ │ ├── impl/
│ │ │ │ │ │ ├── buffered_read_stream.hpp
│ │ │ │ │ │ ├── buffered_write_stream.hpp
│ │ │ │ │ │ ├── connect.hpp
│ │ │ │ │ │ ├── error.ipp
│ │ │ │ │ │ ├── handler_alloc_hook.ipp
│ │ │ │ │ │ ├── io_service.hpp
│ │ │ │ │ │ ├── io_service.ipp
│ │ │ │ │ │ ├── read.hpp
│ │ │ │ │ │ ├── read_at.hpp
│ │ │ │ │ │ ├── read_until.hpp
│ │ │ │ │ │ ├── serial_port_base.hpp
│ │ │ │ │ │ ├── serial_port_base.ipp
│ │ │ │ │ │ ├── spawn.hpp
│ │ │ │ │ │ ├── src.cpp
│ │ │ │ │ │ ├── src.hpp
│ │ │ │ │ │ ├── use_future.hpp
│ │ │ │ │ │ ├── write.hpp
│ │ │ │ │ │ └── write_at.hpp
│ │ │ │ │ ├── io_service.hpp
│ │ │ │ │ ├── ip/
│ │ │ │ │ │ ├── address.hpp
│ │ │ │ │ │ ├── address_v4.hpp
│ │ │ │ │ │ ├── address_v6.hpp
│ │ │ │ │ │ ├── basic_endpoint.hpp
│ │ │ │ │ │ ├── basic_resolver.hpp
│ │ │ │ │ │ ├── basic_resolver_entry.hpp
│ │ │ │ │ │ ├── basic_resolver_iterator.hpp
│ │ │ │ │ │ ├── basic_resolver_query.hpp
│ │ │ │ │ │ ├── detail/
│ │ │ │ │ │ │ ├── endpoint.hpp
│ │ │ │ │ │ │ ├── impl/
│ │ │ │ │ │ │ │ └── endpoint.ipp
│ │ │ │ │ │ │ └── socket_option.hpp
│ │ │ │ │ │ ├── host_name.hpp
│ │ │ │ │ │ ├── icmp.hpp
│ │ │ │ │ │ ├── impl/
│ │ │ │ │ │ │ ├── address.hpp
│ │ │ │ │ │ │ ├── address.ipp
│ │ │ │ │ │ │ ├── address_v4.hpp
│ │ │ │ │ │ │ ├── address_v4.ipp
│ │ │ │ │ │ │ ├── address_v6.hpp
│ │ │ │ │ │ │ ├── address_v6.ipp
│ │ │ │ │ │ │ ├── basic_endpoint.hpp
│ │ │ │ │ │ │ └── host_name.ipp
│ │ │ │ │ │ ├── multicast.hpp
│ │ │ │ │ │ ├── resolver_query_base.hpp
│ │ │ │ │ │ ├── resolver_service.hpp
│ │ │ │ │ │ ├── tcp.hpp
│ │ │ │ │ │ ├── udp.hpp
│ │ │ │ │ │ ├── unicast.hpp
│ │ │ │ │ │ └── v6_only.hpp
│ │ │ │ │ ├── is_read_buffered.hpp
│ │ │ │ │ ├── is_write_buffered.hpp
│ │ │ │ │ ├── local/
│ │ │ │ │ │ ├── basic_endpoint.hpp
│ │ │ │ │ │ ├── connect_pair.hpp
│ │ │ │ │ │ ├── datagram_protocol.hpp
│ │ │ │ │ │ ├── detail/
│ │ │ │ │ │ │ ├── endpoint.hpp
│ │ │ │ │ │ │ └── impl/
│ │ │ │ │ │ │ └── endpoint.ipp
│ │ │ │ │ │ └── stream_protocol.hpp
│ │ │ │ │ ├── placeholders.hpp
│ │ │ │ │ ├── posix/
│ │ │ │ │ │ ├── basic_descriptor.hpp
│ │ │ │ │ │ ├── basic_stream_descriptor.hpp
│ │ │ │ │ │ ├── descriptor_base.hpp
│ │ │ │ │ │ ├── stream_descriptor.hpp
│ │ │ │ │ │ └── stream_descriptor_service.hpp
│ │ │ │ │ ├── raw_socket_service.hpp
│ │ │ │ │ ├── read.hpp
│ │ │ │ │ ├── read_at.hpp
│ │ │ │ │ ├── read_until.hpp
│ │ │ │ │ ├── seq_packet_socket_service.hpp
│ │ │ │ │ ├── serial_port.hpp
│ │ │ │ │ ├── serial_port_base.hpp
│ │ │ │ │ ├── serial_port_service.hpp
│ │ │ │ │ ├── signal_set.hpp
│ │ │ │ │ ├── signal_set_service.hpp
│ │ │ │ │ ├── socket_acceptor_service.hpp
│ │ │ │ │ ├── socket_base.hpp
│ │ │ │ │ ├── spawn.hpp
│ │ │ │ │ ├── ssl/
│ │ │ │ │ │ ├── basic_context.hpp
│ │ │ │ │ │ ├── context.hpp
│ │ │ │ │ │ ├── context_base.hpp
│ │ │ │ │ │ ├── context_service.hpp
│ │ │ │ │ │ ├── detail/
│ │ │ │ │ │ │ ├── buffered_handshake_op.hpp
│ │ │ │ │ │ │ ├── engine.hpp
│ │ │ │ │ │ │ ├── handshake_op.hpp
│ │ │ │ │ │ │ ├── impl/
│ │ │ │ │ │ │ │ ├── engine.ipp
│ │ │ │ │ │ │ │ └── openssl_init.ipp
│ │ │ │ │ │ │ ├── io.hpp
│ │ │ │ │ │ │ ├── openssl_init.hpp
│ │ │ │ │ │ │ ├── openssl_types.hpp
│ │ │ │ │ │ │ ├── password_callback.hpp
│ │ │ │ │ │ │ ├── read_op.hpp
│ │ │ │ │ │ │ ├── shutdown_op.hpp
│ │ │ │ │ │ │ ├── stream_core.hpp
│ │ │ │ │ │ │ ├── verify_callback.hpp
│ │ │ │ │ │ │ └── write_op.hpp
│ │ │ │ │ │ ├── error.hpp
│ │ │ │ │ │ ├── impl/
│ │ │ │ │ │ │ ├── context.hpp
│ │ │ │ │ │ │ ├── context.ipp
│ │ │ │ │ │ │ ├── error.ipp
│ │ │ │ │ │ │ ├── rfc2818_verification.ipp
│ │ │ │ │ │ │ └── src.hpp
│ │ │ │ │ │ ├── old/
│ │ │ │ │ │ │ ├── basic_context.hpp
│ │ │ │ │ │ │ ├── context_service.hpp
│ │ │ │ │ │ │ ├── detail/
│ │ │ │ │ │ │ │ ├── openssl_context_service.hpp
│ │ │ │ │ │ │ │ ├── openssl_operation.hpp
│ │ │ │ │ │ │ │ └── openssl_stream_service.hpp
│ │ │ │ │ │ │ ├── stream.hpp
│ │ │ │ │ │ │ └── stream_service.hpp
│ │ │ │ │ │ ├── rfc2818_verification.hpp
│ │ │ │ │ │ ├── stream.hpp
│ │ │ │ │ │ ├── stream_base.hpp
│ │ │ │ │ │ ├── stream_service.hpp
│ │ │ │ │ │ ├── verify_context.hpp
│ │ │ │ │ │ └── verify_mode.hpp
│ │ │ │ │ ├── ssl.hpp
│ │ │ │ │ ├── steady_timer.hpp
│ │ │ │ │ ├── strand.hpp
│ │ │ │ │ ├── stream_socket_service.hpp
│ │ │ │ │ ├── streambuf.hpp
│ │ │ │ │ ├── system_timer.hpp
│ │ │ │ │ ├── time_traits.hpp
│ │ │ │ │ ├── unyield.hpp
│ │ │ │ │ ├── use_future.hpp
│ │ │ │ │ ├── version.hpp
│ │ │ │ │ ├── wait_traits.hpp
│ │ │ │ │ ├── waitable_timer_service.hpp
│ │ │ │ │ ├── windows/
│ │ │ │ │ │ ├── basic_handle.hpp
│ │ │ │ │ │ ├── basic_object_handle.hpp
│ │ │ │ │ │ ├── basic_random_access_handle.hpp
│ │ │ │ │ │ ├── basic_stream_handle.hpp
│ │ │ │ │ │ ├── object_handle.hpp
│ │ │ │ │ │ ├── object_handle_service.hpp
│ │ │ │ │ │ ├── overlapped_ptr.hpp
│ │ │ │ │ │ ├── random_access_handle.hpp
│ │ │ │ │ │ ├── random_access_handle_service.hpp
│ │ │ │ │ │ ├── stream_handle.hpp
│ │ │ │ │ │ └── stream_handle_service.hpp
│ │ │ │ │ ├── write.hpp
│ │ │ │ │ ├── write_at.hpp
│ │ │ │ │ └── yield.hpp
│ │ │ │ ├── asio.hpp
│ │ │ │ ├── assert.hpp
│ │ │ │ ├── assign/
│ │ │ │ │ ├── assignment_exception.hpp
│ │ │ │ │ ├── list_inserter.hpp
│ │ │ │ │ ├── list_of.hpp
│ │ │ │ │ ├── ptr_list_inserter.hpp
│ │ │ │ │ ├── ptr_list_of.hpp
│ │ │ │ │ ├── ptr_map_inserter.hpp
│ │ │ │ │ ├── std/
│ │ │ │ │ │ ├── deque.hpp
│ │ │ │ │ │ ├── list.hpp
│ │ │ │ │ │ ├── map.hpp
│ │ │ │ │ │ ├── queue.hpp
│ │ │ │ │ │ ├── set.hpp
│ │ │ │ │ │ ├── slist.hpp
│ │ │ │ │ │ ├── stack.hpp
│ │ │ │ │ │ └── vector.hpp
│ │ │ │ │ └── std.hpp
│ │ │ │ ├── assign.hpp
│ │ │ │ ├── atomic/
│ │ │ │ │ ├── atomic.hpp
│ │ │ │ │ ├── atomic_flag.hpp
│ │ │ │ │ ├── capabilities.hpp
│ │ │ │ │ ├── detail/
│ │ │ │ │ │ ├── atomic_flag.hpp
│ │ │ │ │ │ ├── atomic_template.hpp
│ │ │ │ │ │ ├── bitwise_cast.hpp
│ │ │ │ │ │ ├── caps_gcc_alpha.hpp
│ │ │ │ │ │ ├── caps_gcc_arm.hpp
│ │ │ │ │ │ ├── caps_gcc_atomic.hpp
│ │ │ │ │ │ ├── caps_gcc_ppc.hpp
│ │ │ │ │ │ ├── caps_gcc_sparc.hpp
│ │ │ │ │ │ ├── caps_gcc_sync.hpp
│ │ │ │ │ │ ├── caps_gcc_x86.hpp
│ │ │ │ │ │ ├── caps_linux_arm.hpp
│ │ │ │ │ │ ├── caps_msvc_arm.hpp
│ │ │ │ │ │ ├── caps_msvc_x86.hpp
│ │ │ │ │ │ ├── caps_windows.hpp
│ │ │ │ │ │ ├── config.hpp
│ │ │ │ │ │ ├── int_sizes.hpp
│ │ │ │ │ │ ├── interlocked.hpp
│ │ │ │ │ │ ├── link.hpp
│ │ │ │ │ │ ├── lockpool.hpp
│ │ │ │ │ │ ├── operations.hpp
│ │ │ │ │ │ ├── operations_fwd.hpp
│ │ │ │ │ │ ├── operations_lockfree.hpp
│ │ │ │ │ │ ├── ops_cas_based.hpp
│ │ │ │ │ │ ├── ops_emulated.hpp
│ │ │ │ │ │ ├── ops_extending_cas_based.hpp
│ │ │ │ │ │ ├── ops_gcc_alpha.hpp
│ │ │ │ │ │ ├── ops_gcc_arm.hpp
│ │ │ │ │ │ ├── ops_gcc_atomic.hpp
│ │ │ │ │ │ ├── ops_gcc_ppc.hpp
│ │ │ │ │ │ ├── ops_gcc_sparc.hpp
│ │ │ │ │ │ ├── ops_gcc_sync.hpp
│ │ │ │ │ │ ├── ops_gcc_x86.hpp
│ │ │ │ │ │ ├── ops_gcc_x86_dcas.hpp
│ │ │ │ │ │ ├── ops_linux_arm.hpp
│ │ │ │ │ │ ├── ops_msvc_arm.hpp
│ │ │ │ │ │ ├── ops_msvc_common.hpp
│ │ │ │ │ │ ├── ops_msvc_x86.hpp
│ │ │ │ │ │ ├── ops_windows.hpp
│ │ │ │ │ │ ├── pause.hpp
│ │ │ │ │ │ ├── platform.hpp
│ │ │ │ │ │ └── storage_type.hpp
│ │ │ │ │ └── fences.hpp
│ │ │ │ ├── atomic.hpp
│ │ │ │ ├── bimap/
│ │ │ │ │ ├── bimap.hpp
│ │ │ │ │ ├── container_adaptor/
│ │ │ │ │ │ ├── associative_container_adaptor.hpp
│ │ │ │ │ │ ├── container_adaptor.hpp
│ │ │ │ │ │ ├── detail/
│ │ │ │ │ │ │ ├── comparison_adaptor.hpp
│ │ │ │ │ │ │ ├── functor_bag.hpp
│ │ │ │ │ │ │ ├── identity_converters.hpp
│ │ │ │ │ │ │ ├── key_extractor.hpp
│ │ │ │ │ │ │ └── non_unique_container_helper.hpp
│ │ │ │ │ │ ├── list_adaptor.hpp
│ │ │ │ │ │ ├── list_map_adaptor.hpp
│ │ │ │ │ │ ├── map_adaptor.hpp
│ │ │ │ │ │ ├── multimap_adaptor.hpp
│ │ │ │ │ │ ├── multiset_adaptor.hpp
│ │ │ │ │ │ ├── ordered_associative_container_adaptor.hpp
│ │ │ │ │ │ ├── sequence_container_adaptor.hpp
│ │ │ │ │ │ ├── set_adaptor.hpp
│ │ │ │ │ │ ├── support/
│ │ │ │ │ │ │ └── iterator_facade_converters.hpp
│ │ │ │ │ │ ├── unordered_associative_container_adaptor.hpp
│ │ │ │ │ │ ├── unordered_map_adaptor.hpp
│ │ │ │ │ │ ├── unordered_multimap_adaptor.hpp
│ │ │ │ │ │ ├── unordered_multiset_adaptor.hpp
│ │ │ │ │ │ ├── unordered_set_adaptor.hpp
│ │ │ │ │ │ ├── vector_adaptor.hpp
│ │ │ │ │ │ └── vector_map_adaptor.hpp
│ │ │ │ │ ├── detail/
│ │ │ │ │ │ ├── bimap_core.hpp
│ │ │ │ │ │ ├── concept_tags.hpp
│ │ │ │ │ │ ├── debug/
│ │ │ │ │ │ │ └── static_error.hpp
│ │ │ │ │ │ ├── generate_index_binder.hpp
│ │ │ │ │ │ ├── generate_relation_binder.hpp
│ │ │ │ │ │ ├── generate_view_binder.hpp
│ │ │ │ │ │ ├── is_set_type_of.hpp
│ │ │ │ │ │ ├── manage_additional_parameters.hpp
│ │ │ │ │ │ ├── manage_bimap_key.hpp
│ │ │ │ │ │ ├── map_view_base.hpp
│ │ │ │ │ │ ├── map_view_iterator.hpp
│ │ │ │ │ │ ├── modifier_adaptor.hpp
│ │ │ │ │ │ ├── non_unique_views_helper.hpp
│ │ │ │ │ │ ├── set_view_base.hpp
│ │ │ │ │ │ ├── set_view_iterator.hpp
│ │ │ │ │ │ ├── test/
│ │ │ │ │ │ │ └── check_metadata.hpp
│ │ │ │ │ │ └── user_interface_config.hpp
│ │ │ │ │ ├── list_of.hpp
│ │ │ │ │ ├── multiset_of.hpp
│ │ │ │ │ ├── property_map/
│ │ │ │ │ │ ├── set_support.hpp
│ │ │ │ │ │ └── unordered_set_support.hpp
│ │ │ │ │ ├── relation/
│ │ │ │ │ │ ├── detail/
│ │ │ │ │ │ │ ├── access_builder.hpp
│ │ │ │ │ │ │ ├── metadata_access_builder.hpp
│ │ │ │ │ │ │ ├── mutant.hpp
│ │ │ │ │ │ │ ├── static_access_builder.hpp
│ │ │ │ │ │ │ └── to_mutable_relation_functor.hpp
│ │ │ │ │ │ ├── member_at.hpp
│ │ │ │ │ │ ├── mutant_relation.hpp
│ │ │ │ │ │ ├── pair_layout.hpp
│ │ │ │ │ │ ├── structured_pair.hpp
│ │ │ │ │ │ ├── support/
│ │ │ │ │ │ │ ├── data_extractor.hpp
│ │ │ │ │ │ │ ├── get.hpp
│ │ │ │ │ │ │ ├── get_pair_functor.hpp
│ │ │ │ │ │ │ ├── is_tag_of_member_at.hpp
│ │ │ │ │ │ │ ├── member_with_tag.hpp
│ │ │ │ │ │ │ ├── opposite_tag.hpp
│ │ │ │ │ │ │ ├── pair_by.hpp
│ │ │ │ │ │ │ ├── pair_type_by.hpp
│ │ │ │ │ │ │ └── value_type_of.hpp
│ │ │ │ │ │ └── symmetrical_base.hpp
│ │ │ │ │ ├── set_of.hpp
│ │ │ │ │ ├── support/
│ │ │ │ │ │ ├── data_type_by.hpp
│ │ │ │ │ │ ├── iterator_type_by.hpp
│ │ │ │ │ │ ├── key_type_by.hpp
│ │ │ │ │ │ ├── lambda.hpp
│ │ │ │ │ │ ├── map_by.hpp
│ │ │ │ │ │ ├── map_type_by.hpp
│ │ │ │ │ │ └── value_type_by.hpp
│ │ │ │ │ ├── tags/
│ │ │ │ │ │ ├── support/
│ │ │ │ │ │ │ ├── apply_to_value_type.hpp
│ │ │ │ │ │ │ ├── default_tagged.hpp
│ │ │ │ │ │ │ ├── is_tagged.hpp
│ │ │ │ │ │ │ ├── overwrite_tagged.hpp
│ │ │ │ │ │ │ ├── tag_of.hpp
│ │ │ │ │ │ │ └── value_type_of.hpp
│ │ │ │ │ │ └── tagged.hpp
│ │ │ │ │ ├── unconstrained_set_of.hpp
│ │ │ │ │ ├── unordered_multiset_of.hpp
│ │ │ │ │ ├── unordered_set_of.hpp
│ │ │ │ │ ├── vector_of.hpp
│ │ │ │ │ └── views/
│ │ │ │ │ ├── list_map_view.hpp
│ │ │ │ │ ├── list_set_view.hpp
│ │ │ │ │ ├── map_view.hpp
│ │ │ │ │ ├── multimap_view.hpp
│ │ │ │ │ ├── multiset_view.hpp
│ │ │ │ │ ├── set_view.hpp
│ │ │ │ │ ├── unconstrained_map_view.hpp
│ │ │ │ │ ├── unconstrained_set_view.hpp
│ │ │ │ │ ├── unordered_map_view.hpp
│ │ │ │ │ ├── unordered_multimap_view.hpp
│ │ │ │ │ ├── unordered_multiset_view.hpp
│ │ │ │ │ ├── unordered_set_view.hpp
│ │ │ │ │ ├── vector_map_view.hpp
│ │ │ │ │ └── vector_set_view.hpp
│ │ │ │ ├── bimap.hpp
│ │ │ │ ├── bind/
│ │ │ │ │ ├── apply.hpp
│ │ │ │ │ ├── arg.hpp
│ │ │ │ │ ├── bind.hpp
│ │ │ │ │ ├── bind_cc.hpp
│ │ │ │ │ ├── bind_mf2_cc.hpp
│ │ │ │ │ ├── bind_mf_cc.hpp
│ │ │ │ │ ├── bind_template.hpp
│ │ │ │ │ ├── make_adaptable.hpp
│ │ │ │ │ ├── mem_fn.hpp
│ │ │ │ │ ├── mem_fn_cc.hpp
│ │ │ │ │ ├── mem_fn_template.hpp
│ │ │ │ │ ├── mem_fn_vw.hpp
│ │ │ │ │ ├── placeholders.hpp
│ │ │ │ │ ├── protect.hpp
│ │ │ │ │ └── storage.hpp
│ │ │ │ ├── bind.hpp
│ │ │ │ ├── blank.hpp
│ │ │ │ ├── blank_fwd.hpp
│ │ │ │ ├── call_traits.hpp
│ │ │ │ ├── cast.hpp
│ │ │ │ ├── cerrno.hpp
│ │ │ │ ├── checked_delete.hpp
│ │ │ │ ├── chrono/
│ │ │ │ │ ├── ceil.hpp
│ │ │ │ │ ├── chrono.hpp
│ │ │ │ │ ├── chrono_io.hpp
│ │ │ │ │ ├── clock_string.hpp
│ │ │ │ │ ├── config.hpp
│ │ │ │ │ ├── detail/
│ │ │ │ │ │ ├── inlined/
│ │ │ │ │ │ │ ├── chrono.hpp
│ │ │ │ │ │ │ ├── mac/
│ │ │ │ │ │ │ │ ├── chrono.hpp
│ │ │ │ │ │ │ │ ├── process_cpu_clocks.hpp
│ │ │ │ │ │ │ │ └── thread_clock.hpp
│ │ │ │ │ │ │ ├── posix/
│ │ │ │ │ │ │ │ ├── chrono.hpp
│ │ │ │ │ │ │ │ ├── process_cpu_clocks.hpp
│ │ │ │ │ │ │ │ └── thread_clock.hpp
│ │ │ │ │ │ │ ├── process_cpu_clocks.hpp
│ │ │ │ │ │ │ ├── thread_clock.hpp
│ │ │ │ │ │ │ └── win/
│ │ │ │ │ │ │ ├── chrono.hpp
│ │ │ │ │ │ │ ├── process_cpu_clocks.hpp
│ │ │ │ │ │ │ └── thread_clock.hpp
│ │ │ │ │ │ ├── is_evenly_divisible_by.hpp
│ │ │ │ │ │ ├── no_warning/
│ │ │ │ │ │ │ └── signed_unsigned_cmp.hpp
│ │ │ │ │ │ ├── scan_keyword.hpp
│ │ │ │ │ │ ├── static_assert.hpp
│ │ │ │ │ │ └── system.hpp
│ │ │ │ │ ├── duration.hpp
│ │ │ │ │ ├── floor.hpp
│ │ │ │ │ ├── include.hpp
│ │ │ │ │ ├── io/
│ │ │ │ │ │ ├── duration_get.hpp
│ │ │ │ │ │ ├── duration_io.hpp
│ │ │ │ │ │ ├── duration_put.hpp
│ │ │ │ │ │ ├── duration_style.hpp
│ │ │ │ │ │ ├── duration_units.hpp
│ │ │ │ │ │ ├── ios_base_state.hpp
│ │ │ │ │ │ ├── time_point_get.hpp
│ │ │ │ │ │ ├── time_point_io.hpp
│ │ │ │ │ │ ├── time_point_put.hpp
│ │ │ │ │ │ ├── time_point_units.hpp
│ │ │ │ │ │ ├── timezone.hpp
│ │ │ │ │ │ └── utility/
│ │ │ │ │ │ ├── ios_base_state_ptr.hpp
│ │ │ │ │ │ ├── manip_base.hpp
│ │ │ │ │ │ └── to_string.hpp
│ │ │ │ │ ├── io_v1/
│ │ │ │ │ │ └── chrono_io.hpp
│ │ │ │ │ ├── process_cpu_clocks.hpp
│ │ │ │ │ ├── round.hpp
│ │ │ │ │ ├── system_clocks.hpp
│ │ │ │ │ ├── thread_clock.hpp
│ │ │ │ │ ├── time_point.hpp
│ │ │ │ │ └── typeof/
│ │ │ │ │ └── boost/
│ │ │ │ │ ├── chrono/
│ │ │ │ │ │ └── chrono.hpp
│ │ │ │ │ └── ratio.hpp
│ │ │ │ ├── chrono.hpp
│ │ │ │ ├── circular_buffer/
│ │ │ │ │ ├── base.hpp
│ │ │ │ │ ├── debug.hpp
│ │ │ │ │ ├── details.hpp
│ │ │ │ │ └── space_optimized.hpp
│ │ │ │ ├── circular_buffer.hpp
│ │ │ │ ├── circular_buffer_fwd.hpp
│ │ │ │ ├── compatibility/
│ │ │ │ │ └── cpp_c_headers/
│ │ │ │ │ ├── cassert
│ │ │ │ │ ├── cctype
│ │ │ │ │ ├── cerrno
│ │ │ │ │ ├── cfloat
│ │ │ │ │ ├── climits
│ │ │ │ │ ├── clocale
│ │ │ │ │ ├── cmath
│ │ │ │ │ ├── csetjmp
│ │ │ │ │ ├── csignal
│ │ │ │ │ ├── cstdarg
│ │ │ │ │ ├── cstddef
│ │ │ │ │ ├── cstdio
│ │ │ │ │ ├── cstdlib
│ │ │ │ │ ├── cstring
│ │ │ │ │ ├── ctime
│ │ │ │ │ ├── cwchar
│ │ │ │ │ └── cwctype
│ │ │ │ ├── compressed_pair.hpp
│ │ │ │ ├── compute/
│ │ │ │ │ ├── algorithm/
│ │ │ │ │ │ ├── accumulate.hpp
│ │ │ │ │ │ ├── adjacent_difference.hpp
│ │ │ │ │ │ ├── adjacent_find.hpp
│ │ │ │ │ │ ├── all_of.hpp
│ │ │ │ │ │ ├── any_of.hpp
│ │ │ │ │ │ ├── binary_search.hpp
│ │ │ │ │ │ ├── copy.hpp
│ │ │ │ │ │ ├── copy_if.hpp
│ │ │ │ │ │ ├── copy_n.hpp
│ │ │ │ │ │ ├── count.hpp
│ │ │ │ │ │ ├── count_if.hpp
│ │ │ │ │ │ ├── detail/
│ │ │ │ │ │ │ ├── balanced_path.hpp
│ │ │ │ │ │ │ ├── binary_find.hpp
│ │ │ │ │ │ │ ├── compact.hpp
│ │ │ │ │ │ │ ├── copy_on_device.hpp
│ │ │ │ │ │ │ ├── copy_to_device.hpp
│ │ │ │ │ │ │ ├── copy_to_host.hpp
│ │ │ │ │ │ │ ├── count_if_with_ballot.hpp
│ │ │ │ │ │ │ ├── count_if_with_reduce.hpp
│ │ │ │ │ │ │ ├── count_if_with_threads.hpp
│ │ │ │ │ │ │ ├── find_extrema.hpp
│ │ │ │ │ │ │ ├── find_extrema_on_cpu.hpp
│ │ │ │ │ │ │ ├── find_extrema_with_atomics.hpp
│ │ │ │ │ │ │ ├── find_extrema_with_reduce.hpp
│ │ │ │ │ │ │ ├── find_if_with_atomics.hpp
│ │ │ │ │ │ │ ├── inplace_reduce.hpp
│ │ │ │ │ │ │ ├── insertion_sort.hpp
│ │ │ │ │ │ │ ├── merge_path.hpp
│ │ │ │ │ │ │ ├── merge_sort_on_cpu.hpp
│ │ │ │ │ │ │ ├── merge_sort_on_gpu.hpp
│ │ │ │ │ │ │ ├── merge_with_merge_path.hpp
│ │ │ │ │ │ │ ├── radix_sort.hpp
│ │ │ │ │ │ │ ├── random_fill.hpp
│ │ │ │ │ │ │ ├── reduce_by_key.hpp
│ │ │ │ │ │ │ ├── reduce_by_key_with_scan.hpp
│ │ │ │ │ │ │ ├── reduce_on_cpu.hpp
│ │ │ │ │ │ │ ├── reduce_on_gpu.hpp
│ │ │ │ │ │ │ ├── scan.hpp
│ │ │ │ │ │ │ ├── scan_on_cpu.hpp
│ │ │ │ │ │ │ ├── scan_on_gpu.hpp
│ │ │ │ │ │ │ ├── search_all.hpp
│ │ │ │ │ │ │ ├── serial_accumulate.hpp
│ │ │ │ │ │ │ ├── serial_count_if.hpp
│ │ │ │ │ │ │ ├── serial_find_extrema.hpp
│ │ │ │ │ │ │ ├── serial_merge.hpp
│ │ │ │ │ │ │ ├── serial_reduce.hpp
│ │ │ │ │ │ │ ├── serial_reduce_by_key.hpp
│ │ │ │ │ │ │ └── serial_scan.hpp
│ │ │ │ │ │ ├── equal.hpp
│ │ │ │ │ │ ├── equal_range.hpp
│ │ │ │ │ │ ├── exclusive_scan.hpp
│ │ │ │ │ │ ├── fill.hpp
│ │ │ │ │ │ ├── fill_n.hpp
│ │ │ │ │ │ ├── find.hpp
│ │ │ │ │ │ ├── find_end.hpp
│ │ │ │ │ │ ├── find_if.hpp
│ │ │ │ │ │ ├── find_if_not.hpp
│ │ │ │ │ │ ├── for_each.hpp
│ │ │ │ │ │ ├── for_each_n.hpp
│ │ │ │ │ │ ├── gather.hpp
│ │ │ │ │ │ ├── generate.hpp
│ │ │ │ │ │ ├── generate_n.hpp
│ │ │ │ │ │ ├── includes.hpp
│ │ │ │ │ │ ├── inclusive_scan.hpp
│ │ │ │ │ │ ├── inner_product.hpp
│ │ │ │ │ │ ├── inplace_merge.hpp
│ │ │ │ │ │ ├── iota.hpp
│ │ │ │ │ │ ├── is_partitioned.hpp
│ │ │ │ │ │ ├── is_permutation.hpp
│ │ │ │ │ │ ├── is_sorted.hpp
│ │ │ │ │ │ ├── lexicographical_compare.hpp
│ │ │ │ │ │ ├── lower_bound.hpp
│ │ │ │ │ │ ├── max_element.hpp
│ │ │ │ │ │ ├── merge.hpp
│ │ │ │ │ │ ├── min_element.hpp
│ │ │ │ │ │ ├── minmax_element.hpp
│ │ │ │ │ │ ├── mismatch.hpp
│ │ │ │ │ │ ├── next_permutation.hpp
│ │ │ │ │ │ ├── none_of.hpp
│ │ │ │ │ │ ├── nth_element.hpp
│ │ │ │ │ │ ├── partial_sum.hpp
│ │ │ │ │ │ ├── partition.hpp
│ │ │ │ │ │ ├── partition_copy.hpp
│ │ │ │ │ │ ├── partition_point.hpp
│ │ │ │ │ │ ├── prev_permutation.hpp
│ │ │ │ │ │ ├── random_shuffle.hpp
│ │ │ │ │ │ ├── reduce.hpp
│ │ │ │ │ │ ├── reduce_by_key.hpp
│ │ │ │ │ │ ├── remove.hpp
│ │ │ │ │ │ ├── remove_if.hpp
│ │ │ │ │ │ ├── replace.hpp
│ │ │ │ │ │ ├── replace_copy.hpp
│ │ │ │ │ │ ├── reverse.hpp
│ │ │ │ │ │ ├── reverse_copy.hpp
│ │ │ │ │ │ ├── rotate.hpp
│ │ │ │ │ │ ├── rotate_copy.hpp
│ │ │ │ │ │ ├── scatter.hpp
│ │ │ │ │ │ ├── scatter_if.hpp
│ │ │ │ │ │ ├── search.hpp
│ │ │ │ │ │ ├── search_n.hpp
│ │ │ │ │ │ ├── set_difference.hpp
│ │ │ │ │ │ ├── set_intersection.hpp
│ │ │ │ │ │ ├── set_symmetric_difference.hpp
│ │ │ │ │ │ ├── set_union.hpp
│ │ │ │ │ │ ├── sort.hpp
│ │ │ │ │ │ ├── sort_by_key.hpp
│ │ │ │ │ │ ├── stable_partition.hpp
│ │ │ │ │ │ ├── stable_sort.hpp
│ │ │ │ │ │ ├── stable_sort_by_key.hpp
│ │ │ │ │ │ ├── swap_ranges.hpp
│ │ │ │ │ │ ├── transform.hpp
│ │ │ │ │ │ ├── transform_if.hpp
│ │ │ │ │ │ ├── transform_reduce.hpp
│ │ │ │ │ │ ├── unique.hpp
│ │ │ │ │ │ ├── unique_copy.hpp
│ │ │ │ │ │ └── upper_bound.hpp
│ │ │ │ │ ├── algorithm.hpp
│ │ │ │ │ ├── allocator/
│ │ │ │ │ │ ├── buffer_allocator.hpp
│ │ │ │ │ │ └── pinned_allocator.hpp
│ │ │ │ │ ├── allocator.hpp
│ │ │ │ │ ├── async/
│ │ │ │ │ │ ├── future.hpp
│ │ │ │ │ │ ├── wait.hpp
│ │ │ │ │ │ └── wait_guard.hpp
│ │ │ │ │ ├── async.hpp
│ │ │ │ │ ├── buffer.hpp
│ │ │ │ │ ├── cl.hpp
│ │ │ │ │ ├── cl_ext.hpp
│ │ │ │ │ ├── closure.hpp
│ │ │ │ │ ├── command_queue.hpp
│ │ │ │ │ ├── config.hpp
│ │ │ │ │ ├── container/
│ │ │ │ │ │ ├── array.hpp
│ │ │ │ │ │ ├── basic_string.hpp
│ │ │ │ │ │ ├── detail/
│ │ │ │ │ │ │ └── scalar.hpp
│ │ │ │ │ │ ├── dynamic_bitset.hpp
│ │ │ │ │ │ ├── flat_map.hpp
│ │ │ │ │ │ ├── flat_set.hpp
│ │ │ │ │ │ ├── mapped_view.hpp
│ │ │ │ │ │ ├── stack.hpp
│ │ │ │ │ │ ├── string.hpp
│ │ │ │ │ │ ├── valarray.hpp
│ │ │ │ │ │ └── vector.hpp
│ │ │ │ │ ├── container.hpp
│ │ │ │ │ ├── context.hpp
│ │ │ │ │ ├── core.hpp
│ │ │ │ │ ├── detail/
│ │ │ │ │ │ ├── assert_cl_success.hpp
│ │ │ │ │ │ ├── buffer_value.hpp
│ │ │ │ │ │ ├── device_ptr.hpp
│ │ │ │ │ │ ├── diagnostic.hpp
│ │ │ │ │ │ ├── duration.hpp
│ │ │ │ │ │ ├── get_object_info.hpp
│ │ │ │ │ │ ├── getenv.hpp
│ │ │ │ │ │ ├── global_static.hpp
│ │ │ │ │ │ ├── is_buffer_iterator.hpp
│ │ │ │ │ │ ├── is_contiguous_iterator.hpp
│ │ │ │ │ │ ├── iterator_plus_distance.hpp
│ │ │ │ │ │ ├── iterator_range_size.hpp
│ │ │ │ │ │ ├── iterator_traits.hpp
│ │ │ │ │ │ ├── literal.hpp
│ │ │ │ │ │ ├── lru_cache.hpp
│ │ │ │ │ │ ├── meta_kernel.hpp
│ │ │ │ │ │ ├── mpl_vector_to_tuple.hpp
│ │ │ │ │ │ ├── nvidia_compute_capability.hpp
│ │ │ │ │ │ ├── parameter_cache.hpp
│ │ │ │ │ │ ├── path.hpp
│ │ │ │ │ │ ├── print_range.hpp
│ │ │ │ │ │ ├── read_write_single_value.hpp
│ │ │ │ │ │ ├── sha1.hpp
│ │ │ │ │ │ ├── variadic_macros.hpp
│ │ │ │ │ │ ├── vendor.hpp
│ │ │ │ │ │ └── work_size.hpp
│ │ │ │ │ ├── device.hpp
│ │ │ │ │ ├── event.hpp
│ │ │ │ │ ├── exception/
│ │ │ │ │ │ ├── context_error.hpp
│ │ │ │ │ │ ├── no_device_found.hpp
│ │ │ │ │ │ ├── opencl_error.hpp
│ │ │ │ │ │ └── unsupported_extension_error.hpp
│ │ │ │ │ ├── exception.hpp
│ │ │ │ │ ├── experimental/
│ │ │ │ │ │ ├── clamp_range.hpp
│ │ │ │ │ │ ├── malloc.hpp
│ │ │ │ │ │ ├── sort_by_transform.hpp
│ │ │ │ │ │ └── tabulate.hpp
│ │ │ │ │ ├── function.hpp
│ │ │ │ │ ├── functional/
│ │ │ │ │ │ ├── as.hpp
│ │ │ │ │ │ ├── atomic.hpp
│ │ │ │ │ │ ├── bind.hpp
│ │ │ │ │ │ ├── common.hpp
│ │ │ │ │ │ ├── convert.hpp
│ │ │ │ │ │ ├── detail/
│ │ │ │ │ │ │ ├── macros.hpp
│ │ │ │ │ │ │ ├── nvidia_ballot.hpp
│ │ │ │ │ │ │ ├── nvidia_popcount.hpp
│ │ │ │ │ │ │ └── unpack.hpp
│ │ │ │ │ │ ├── field.hpp
│ │ │ │ │ │ ├── geometry.hpp
│ │ │ │ │ │ ├── get.hpp
│ │ │ │ │ │ ├── hash.hpp
│ │ │ │ │ │ ├── identity.hpp
│ │ │ │ │ │ ├── integer.hpp
│ │ │ │ │ │ ├── logical.hpp
│ │ │ │ │ │ ├── math.hpp
│ │ │ │ │ │ ├── operator.hpp
│ │ │ │ │ │ ├── popcount.hpp
│ │ │ │ │ │ └── relational.hpp
│ │ │ │ │ ├── functional.hpp
│ │ │ │ │ ├── image/
│ │ │ │ │ │ ├── image1d.hpp
│ │ │ │ │ │ ├── image2d.hpp
│ │ │ │ │ │ ├── image3d.hpp
│ │ │ │ │ │ ├── image_format.hpp
│ │ │ │ │ │ ├── image_object.hpp
│ │ │ │ │ │ └── image_sampler.hpp
│ │ │ │ │ ├── image.hpp
│ │ │ │ │ ├── image2d.hpp
│ │ │ │ │ ├── image3d.hpp
│ │ │ │ │ ├── image_format.hpp
│ │ │ │ │ ├── image_sampler.hpp
│ │ │ │ │ ├── interop/
│ │ │ │ │ │ ├── eigen/
│ │ │ │ │ │ │ └── core.hpp
│ │ │ │ │ │ ├── eigen.hpp
│ │ │ │ │ │ ├── opencv/
│ │ │ │ │ │ │ ├── core.hpp
│ │ │ │ │ │ │ ├── highgui.hpp
│ │ │ │ │ │ │ └── ocl.hpp
│ │ │ │ │ │ ├── opencv.hpp
│ │ │ │ │ │ ├── opengl/
│ │ │ │ │ │ │ ├── acquire.hpp
│ │ │ │ │ │ │ ├── cl_gl.hpp
│ │ │ │ │ │ │ ├── cl_gl_ext.hpp
│ │ │ │ │ │ │ ├── context.hpp
│ │ │ │ │ │ │ ├── gl.hpp
│ │ │ │ │ │ │ ├── opengl_buffer.hpp
│ │ │ │ │ │ │ ├── opengl_renderbuffer.hpp
│ │ │ │ │ │ │ └── opengl_texture.hpp
│ │ │ │ │ │ ├── opengl.hpp
│ │ │ │ │ │ ├── qt/
│ │ │ │ │ │ │ ├── qimage.hpp
│ │ │ │ │ │ │ ├── qpoint.hpp
│ │ │ │ │ │ │ ├── qpointf.hpp
│ │ │ │ │ │ │ ├── qtcore.hpp
│ │ │ │ │ │ │ ├── qtgui.hpp
│ │ │ │ │ │ │ └── qvector.hpp
│ │ │ │ │ │ ├── qt.hpp
│ │ │ │ │ │ ├── vtk/
│ │ │ │ │ │ │ ├── bounds.hpp
│ │ │ │ │ │ │ ├── data_array.hpp
│ │ │ │ │ │ │ ├── matrix4x4.hpp
│ │ │ │ │ │ │ └── points.hpp
│ │ │ │ │ │ └── vtk.hpp
│ │ │ │ │ ├── iterator/
│ │ │ │ │ │ ├── buffer_iterator.hpp
│ │ │ │ │ │ ├── constant_buffer_iterator.hpp
│ │ │ │ │ │ ├── constant_iterator.hpp
│ │ │ │ │ │ ├── counting_iterator.hpp
│ │ │ │ │ │ ├── detail/
│ │ │ │ │ │ │ ├── get_base_iterator_buffer.hpp
│ │ │ │ │ │ │ └── swizzle_iterator.hpp
│ │ │ │ │ │ ├── discard_iterator.hpp
│ │ │ │ │ │ ├── function_input_iterator.hpp
│ │ │ │ │ │ ├── permutation_iterator.hpp
│ │ │ │ │ │ ├── strided_iterator.hpp
│ │ │ │ │ │ ├── transform_iterator.hpp
│ │ │ │ │ │ └── zip_iterator.hpp
│ │ │ │ │ ├── iterator.hpp
│ │ │ │ │ ├── kernel.hpp
│ │ │ │ │ ├── lambda/
│ │ │ │ │ │ ├── context.hpp
│ │ │ │ │ │ ├── functional.hpp
│ │ │ │ │ │ ├── get.hpp
│ │ │ │ │ │ ├── make_pair.hpp
│ │ │ │ │ │ ├── make_tuple.hpp
│ │ │ │ │ │ ├── placeholder.hpp
│ │ │ │ │ │ ├── placeholders.hpp
│ │ │ │ │ │ └── result_of.hpp
│ │ │ │ │ ├── lambda.hpp
│ │ │ │ │ ├── memory/
│ │ │ │ │ │ ├── local_buffer.hpp
│ │ │ │ │ │ └── svm_ptr.hpp
│ │ │ │ │ ├── memory.hpp
│ │ │ │ │ ├── memory_object.hpp
│ │ │ │ │ ├── pipe.hpp
│ │ │ │ │ ├── platform.hpp
│ │ │ │ │ ├── program.hpp
│ │ │ │ │ ├── random/
│ │ │ │ │ │ ├── bernoulli_distribution.hpp
│ │ │ │ │ │ ├── default_random_engine.hpp
│ │ │ │ │ │ ├── discrete_distribution.hpp
│ │ │ │ │ │ ├── linear_congruential_engine.hpp
│ │ │ │ │ │ ├── mersenne_twister_engine.hpp
│ │ │ │ │ │ ├── normal_distribution.hpp
│ │ │ │ │ │ ├── threefry_engine.hpp
│ │ │ │ │ │ ├── uniform_int_distribution.hpp
│ │ │ │ │ │ └── uniform_real_distribution.hpp
│ │ │ │ │ ├── random.hpp
│ │ │ │ │ ├── source.hpp
│ │ │ │ │ ├── svm.hpp
│ │ │ │ │ ├── system.hpp
│ │ │ │ │ ├── type_traits/
│ │ │ │ │ │ ├── common_type.hpp
│ │ │ │ │ │ ├── detail/
│ │ │ │ │ │ │ └── capture_traits.hpp
│ │ │ │ │ │ ├── is_device_iterator.hpp
│ │ │ │ │ │ ├── is_fundamental.hpp
│ │ │ │ │ │ ├── is_vector_type.hpp
│ │ │ │ │ │ ├── make_vector_type.hpp
│ │ │ │ │ │ ├── result_of.hpp
│ │ │ │ │ │ ├── scalar_type.hpp
│ │ │ │ │ │ ├── type_definition.hpp
│ │ │ │ │ │ ├── type_name.hpp
│ │ │ │ │ │ └── vector_size.hpp
│ │ │ │ │ ├── type_traits.hpp
│ │ │ │ │ ├── types/
│ │ │ │ │ │ ├── builtin.hpp
│ │ │ │ │ │ ├── complex.hpp
│ │ │ │ │ │ ├── fundamental.hpp
│ │ │ │ │ │ ├── pair.hpp
│ │ │ │ │ │ ├── struct.hpp
│ │ │ │ │ │ └── tuple.hpp
│ │ │ │ │ ├── types.hpp
│ │ │ │ │ ├── user_event.hpp
│ │ │ │ │ ├── utility/
│ │ │ │ │ │ ├── dim.hpp
│ │ │ │ │ │ ├── extents.hpp
│ │ │ │ │ │ ├── invoke.hpp
│ │ │ │ │ │ ├── program_cache.hpp
│ │ │ │ │ │ ├── source.hpp
│ │ │ │ │ │ └── wait_list.hpp
│ │ │ │ │ ├── utility.hpp
│ │ │ │ │ ├── version.hpp
│ │ │ │ │ └── wait_list.hpp
│ │ │ │ ├── compute.hpp
│ │ │ │ ├── concept/
│ │ │ │ │ ├── assert.hpp
│ │ │ │ │ ├── detail/
│ │ │ │ │ │ ├── backward_compatibility.hpp
│ │ │ │ │ │ ├── borland.hpp
│ │ │ │ │ │ ├── concept_def.hpp
│ │ │ │ │ │ ├── concept_undef.hpp
│ │ │ │ │ │ ├── general.hpp
│ │ │ │ │ │ ├── has_constraints.hpp
│ │ │ │ │ │ └── msvc.hpp
│ │ │ │ │ ├── requires.hpp
│ │ │ │ │ └── usage.hpp
│ │ │ │ ├── concept_archetype.hpp
│ │ │ │ ├── concept_check/
│ │ │ │ │ ├── borland.hpp
│ │ │ │ │ ├── general.hpp
│ │ │ │ │ ├── has_constraints.hpp
│ │ │ │ │ └── msvc.hpp
│ │ │ │ ├── concept_check.hpp
│ │ │ │ ├── config/
│ │ │ │ │ ├── abi/
│ │ │ │ │ │ ├── borland_prefix.hpp
│ │ │ │ │ │ ├── borland_suffix.hpp
│ │ │ │ │ │ ├── msvc_prefix.hpp
│ │ │ │ │ │ └── msvc_suffix.hpp
│ │ │ │ │ ├── abi_prefix.hpp
│ │ │ │ │ ├── abi_suffix.hpp
│ │ │ │ │ ├── auto_link.hpp
│ │ │ │ │ ├── compiler/
│ │ │ │ │ │ ├── borland.hpp
│ │ │ │ │ │ ├── clang.hpp
│ │ │ │ │ │ ├── codegear.hpp
│ │ │ │ │ │ ├── comeau.hpp
│ │ │ │ │ │ ├── common_edg.hpp
│ │ │ │ │ │ ├── compaq_cxx.hpp
│ │ │ │ │ │ ├── cray.hpp
│ │ │ │ │ │ ├── digitalmars.hpp
│ │ │ │ │ │ ├── gcc.hpp
│ │ │ │ │ │ ├── gcc_xml.hpp
│ │ │ │ │ │ ├── greenhills.hpp
│ │ │ │ │ │ ├── hp_acc.hpp
│ │ │ │ │ │ ├── intel.hpp
│ │ │ │ │ │ ├── kai.hpp
│ │ │ │ │ │ ├── metrowerks.hpp
│ │ │ │ │ │ ├── mpw.hpp
│ │ │ │ │ │ ├── nvcc.hpp
│ │ │ │ │ │ ├── pathscale.hpp
│ │ │ │ │ │ ├── pgi.hpp
│ │ │ │ │ │ ├── sgi_mipspro.hpp
│ │ │ │ │ │ ├── sunpro_cc.hpp
│ │ │ │ │ │ ├── vacpp.hpp
│ │ │ │ │ │ ├── visualc.hpp
│ │ │ │ │ │ └── xlcpp.hpp
│ │ │ │ │ ├── no_tr1/
│ │ │ │ │ │ ├── cmath.hpp
│ │ │ │ │ │ ├── complex.hpp
│ │ │ │ │ │ ├── functional.hpp
│ │ │ │ │ │ ├── memory.hpp
│ │ │ │ │ │ └── utility.hpp
│ │ │ │ │ ├── platform/
│ │ │ │ │ │ ├── aix.hpp
│ │ │ │ │ │ ├── amigaos.hpp
│ │ │ │ │ │ ├── beos.hpp
│ │ │ │ │ │ ├── bsd.hpp
│ │ │ │ │ │ ├── cloudabi.hpp
│ │ │ │ │ │ ├── cray.hpp
│ │ │ │ │ │ ├── cygwin.hpp
│ │ │ │ │ │ ├── haiku.hpp
│ │ │ │ │ │ ├── hpux.hpp
│ │ │ │ │ │ ├── irix.hpp
│ │ │ │ │ │ ├── linux.hpp
│ │ │ │ │ │ ├── macos.hpp
│ │ │ │ │ │ ├── qnxnto.hpp
│ │ │ │ │ │ ├── solaris.hpp
│ │ │ │ │ │ ├── symbian.hpp
│ │ │ │ │ │ ├── vms.hpp
│ │ │ │ │ │ ├── vxworks.hpp
│ │ │ │ │ │ └── win32.hpp
│ │ │ │ │ ├── posix_features.hpp
│ │ │ │ │ ├── requires_threads.hpp
│ │ │ │ │ ├── select_compiler_config.hpp
│ │ │ │ │ ├── select_platform_config.hpp
│ │ │ │ │ ├── select_stdlib_config.hpp
│ │ │ │ │ ├── stdlib/
│ │ │ │ │ │ ├── dinkumware.hpp
│ │ │ │ │ │ ├── libcomo.hpp
│ │ │ │ │ │ ├── libcpp.hpp
│ │ │ │ │ │ ├── libstdcpp3.hpp
│ │ │ │ │ │ ├── modena.hpp
│ │ │ │ │ │ ├── msl.hpp
│ │ │ │ │ │ ├── roguewave.hpp
│ │ │ │ │ │ ├── sgi.hpp
│ │ │ │ │ │ ├── stlport.hpp
│ │ │ │ │ │ └── vacpp.hpp
│ │ │ │ │ ├── suffix.hpp
│ │ │ │ │ ├── user.hpp
│ │ │ │ │ └── warning_disable.hpp
│ │ │ │ ├── config.hpp
│ │ │ │ ├── container/
│ │ │ │ │ ├── adaptive_pool.hpp
│ │ │ │ │ ├── allocator.hpp
│ │ │ │ │ ├── allocator_traits.hpp
│ │ │ │ │ ├── container_fwd.hpp
│ │ │ │ │ ├── deque.hpp
│ │ │ │ │ ├── detail/
│ │ │ │ │ │ ├── adaptive_node_pool.hpp
│ │ │ │ │ │ ├── adaptive_node_pool_impl.hpp
│ │ │ │ │ │ ├── addressof.hpp
│ │ │ │ │ │ ├── advanced_insert_int.hpp
│ │ │ │ │ │ ├── algorithm.hpp
│ │ │ │ │ │ ├── alloc_helpers.hpp
│ │ │ │ │ │ ├── alloc_lib.h
│ │ │ │ │ │ ├── allocation_type.hpp
│ │ │ │ │ │ ├── allocator_version_traits.hpp
│ │ │ │ │ │ ├── auto_link.hpp
│ │ │ │ │ │ ├── block_list.hpp
│ │ │ │ │ │ ├── block_slist.hpp
│ │ │ │ │ │ ├── compare_functors.hpp
│ │ │ │ │ │ ├── config_begin.hpp
│ │ │ │ │ │ ├── config_end.hpp
│ │ │ │ │ │ ├── construct_in_place.hpp
│ │ │ │ │ │ ├── copy_move_algo.hpp
│ │ │ │ │ │ ├── destroyers.hpp
│ │ │ │ │ │ ├── dispatch_uses_allocator.hpp
│ │ │ │ │ │ ├── dlmalloc.hpp
│ │ │ │ │ │ ├── flat_tree.hpp
│ │ │ │ │ │ ├── function_detector.hpp
│ │ │ │ │ │ ├── is_sorted.hpp
│ │ │ │ │ │ ├── iterator.hpp
│ │ │ │ │ │ ├── iterator_to_raw_pointer.hpp
│ │ │ │ │ │ ├── iterators.hpp
│ │ │ │ │ │ ├── math_functions.hpp
│ │ │ │ │ │ ├── min_max.hpp
│ │ │ │ │ │ ├── minimal_char_traits_header.hpp
│ │ │ │ │ │ ├── mpl.hpp
│ │ │ │ │ │ ├── multiallocation_chain.hpp
│ │ │ │ │ │ ├── mutex.hpp
│ │ │ │ │ │ ├── next_capacity.hpp
│ │ │ │ │ │ ├── node_alloc_holder.hpp
│ │ │ │ │ │ ├── node_pool.hpp
│ │ │ │ │ │ ├── node_pool_impl.hpp
│ │ │ │ │ │ ├── pair.hpp
│ │ │ │ │ │ ├── placement_new.hpp
│ │ │ │ │ │ ├── pool_common.hpp
│ │ │ │ │ │ ├── pool_common_alloc.hpp
│ │ │ │ │ │ ├── pool_resource.hpp
│ │ │ │ │ │ ├── singleton.hpp
│ │ │ │ │ │ ├── std_fwd.hpp
│ │ │ │ │ │ ├── to_raw_pointer.hpp
│ │ │ │ │ │ ├── transform_iterator.hpp
│ │ │ │ │ │ ├── tree.hpp
│ │ │ │ │ │ ├── type_traits.hpp
│ │ │ │ │ │ ├── value_init.hpp
│ │ │ │ │ │ ├── variadic_templates_tools.hpp
│ │ │ │ │ │ ├── version_type.hpp
│ │ │ │ │ │ └── workaround.hpp
│ │ │ │ │ ├── flat_map.hpp
│ │ │ │ │ ├── flat_set.hpp
│ │ │ │ │ ├── list.hpp
│ │ │ │ │ ├── map.hpp
│ │ │ │ │ ├── new_allocator.hpp
│ │ │ │ │ ├── node_allocator.hpp
│ │ │ │ │ ├── node_handle.hpp
│ │ │ │ │ ├── options.hpp
│ │ │ │ │ ├── pmr/
│ │ │ │ │ │ ├── deque.hpp
│ │ │ │ │ │ ├── flat_map.hpp
│ │ │ │ │ │ ├── flat_set.hpp
│ │ │ │ │ │ ├── global_resource.hpp
│ │ │ │ │ │ ├── list.hpp
│ │ │ │ │ │ ├── map.hpp
│ │ │ │ │ │ ├── memory_resource.hpp
│ │ │ │ │ │ ├── monotonic_buffer_resource.hpp
│ │ │ │ │ │ ├── polymorphic_allocator.hpp
│ │ │ │ │ │ ├── pool_options.hpp
│ │ │ │ │ │ ├── resource_adaptor.hpp
│ │ │ │ │ │ ├── set.hpp
│ │ │ │ │ │ ├── slist.hpp
│ │ │ │ │ │ ├── small_vector.hpp
│ │ │ │ │ │ ├── stable_vector.hpp
│ │ │ │ │ │ ├── string.hpp
│ │ │ │ │ │ ├── synchronized_pool_resource.hpp
│ │ │ │ │ │ ├── unsynchronized_pool_resource.hpp
│ │ │ │ │ │ └── vector.hpp
│ │ │ │ │ ├── scoped_allocator.hpp
│ │ │ │ │ ├── scoped_allocator_fwd.hpp
│ │ │ │ │ ├── set.hpp
│ │ │ │ │ ├── slist.hpp
│ │ │ │ │ ├── small_vector.hpp
│ │ │ │ │ ├── stable_vector.hpp
│ │ │ │ │ ├── static_vector.hpp
│ │ │ │ │ ├── string.hpp
│ │ │ │ │ ├── throw_exception.hpp
│ │ │ │ │ ├── uses_allocator.hpp
│ │ │ │ │ ├── uses_allocator_fwd.hpp
│ │ │ │ │ └── vector.hpp
│ │ │ │ ├── context/
│ │ │ │ │ ├── all.hpp
│ │ │ │ │ ├── continuation.hpp
│ │ │ │ │ ├── detail/
│ │ │ │ │ │ ├── apply.hpp
│ │ │ │ │ │ ├── config.hpp
│ │ │ │ │ │ ├── disable_overload.hpp
│ │ │ │ │ │ ├── exception.hpp
│ │ │ │ │ │ ├── exchange.hpp
│ │ │ │ │ │ ├── fcontext.hpp
│ │ │ │ │ │ ├── fcontext_arm.hpp
│ │ │ │ │ │ ├── fcontext_arm_mac.hpp
│ │ │ │ │ │ ├── fcontext_arm_win.hpp
│ │ │ │ │ │ ├── fcontext_i386.hpp
│ │ │ │ │ │ ├── fcontext_i386_win.hpp
│ │ │ │ │ │ ├── fcontext_mips.hpp
│ │ │ │ │ │ ├── fcontext_ppc.hpp
│ │ │ │ │ │ ├── fcontext_sparc.hpp
│ │ │ │ │ │ ├── fcontext_x86_64.hpp
│ │ │ │ │ │ ├── fcontext_x86_64_win.hpp
│ │ │ │ │ │ ├── index_sequence.hpp
│ │ │ │ │ │ ├── invoke.hpp
│ │ │ │ │ │ └── tuple.hpp
│ │ │ │ │ ├── execution_context.hpp
│ │ │ │ │ ├── execution_context_v1.hpp
│ │ │ │ │ ├── execution_context_v2.hpp
│ │ │ │ │ ├── execution_context_v2_void.ipp
│ │ │ │ │ ├── fixedsize_stack.hpp
│ │ │ │ │ ├── flags.hpp
│ │ │ │ │ ├── pooled_fixedsize_stack.hpp
│ │ │ │ │ ├── posix/
│ │ │ │ │ │ ├── fixedsize_stack.hpp
│ │ │ │ │ │ ├── protected_fixedsize_stack.hpp
│ │ │ │ │ │ └── segmented_stack.hpp
│ │ │ │ │ ├── preallocated.hpp
│ │ │ │ │ ├── protected_fixedsize_stack.hpp
│ │ │ │ │ ├── segmented_stack.hpp
│ │ │ │ │ ├── stack_context.hpp
│ │ │ │ │ ├── stack_traits.hpp
│ │ │ │ │ └── windows/
│ │ │ │ │ ├── fixedsize_stack.hpp
│ │ │ │ │ └── protected_fixedsize_stack.hpp
│ │ │ │ ├── convert/
│ │ │ │ │ ├── base.hpp
│ │ │ │ │ ├── detail/
│ │ │ │ │ │ ├── boost_parameter_ext.hpp
│ │ │ │ │ │ ├── char.hpp
│ │ │ │ │ │ ├── forward.hpp
│ │ │ │ │ │ ├── has_member.hpp
│ │ │ │ │ │ ├── is_callable.hpp
│ │ │ │ │ │ ├── is_converter.hpp
│ │ │ │ │ │ ├── is_fun.hpp
│ │ │ │ │ │ ├── is_string.hpp
│ │ │ │ │ │ └── range.hpp
│ │ │ │ │ ├── lexical_cast.hpp
│ │ │ │ │ ├── parameters.hpp
│ │ │ │ │ ├── printf.hpp
│ │ │ │ │ ├── spirit.hpp
│ │ │ │ │ ├── stream.hpp
│ │ │ │ │ └── strtol.hpp
│ │ │ │ ├── convert.hpp
│ │ │ │ ├── core/
│ │ │ │ │ ├── addressof.hpp
│ │ │ │ │ ├── checked_delete.hpp
│ │ │ │ │ ├── demangle.hpp
│ │ │ │ │ ├── enable_if.hpp
│ │ │ │ │ ├── explicit_operator_bool.hpp
│ │ │ │ │ ├── ignore_unused.hpp
│ │ │ │ │ ├── is_same.hpp
│ │ │ │ │ ├── lightweight_test.hpp
│ │ │ │ │ ├── lightweight_test_trait.hpp
│ │ │ │ │ ├── no_exceptions_support.hpp
│ │ │ │ │ ├── noncopyable.hpp
│ │ │ │ │ ├── null_deleter.hpp
│ │ │ │ │ ├── ref.hpp
│ │ │ │ │ ├── scoped_enum.hpp
│ │ │ │ │ ├── swap.hpp
│ │ │ │ │ ├── typeinfo.hpp
│ │ │ │ │ └── underlying_type.hpp
│ │ │ │ ├── coroutine/
│ │ │ │ │ ├── all.hpp
│ │ │ │ │ ├── asymmetric_coroutine.hpp
│ │ │ │ │ ├── attributes.hpp
│ │ │ │ │ ├── coroutine.hpp
│ │ │ │ │ ├── detail/
│ │ │ │ │ │ ├── config.hpp
│ │ │ │ │ │ ├── coroutine_context.hpp
│ │ │ │ │ │ ├── data.hpp
│ │ │ │ │ │ ├── flags.hpp
│ │ │ │ │ │ ├── parameters.hpp
│ │ │ │ │ │ ├── preallocated.hpp
│ │ │ │ │ │ ├── pull_coroutine_impl.hpp
│ │ │ │ │ │ ├── pull_coroutine_object.hpp
│ │ │ │ │ │ ├── pull_coroutine_synthesized.hpp
│ │ │ │ │ │ ├── push_coroutine_impl.hpp
│ │ │ │ │ │ ├── push_coroutine_object.hpp
│ │ │ │ │ │ ├── push_coroutine_synthesized.hpp
│ │ │ │ │ │ ├── setup.hpp
│ │ │ │ │ │ ├── symmetric_coroutine_call.hpp
│ │ │ │ │ │ ├── symmetric_coroutine_impl.hpp
│ │ │ │ │ │ ├── symmetric_coroutine_object.hpp
│ │ │ │ │ │ ├── symmetric_coroutine_yield.hpp
│ │ │ │ │ │ ├── trampoline.hpp
│ │ │ │ │ │ ├── trampoline_pull.hpp
│ │ │ │ │ │ └── trampoline_push.hpp
│ │ │ │ │ ├── exceptions.hpp
│ │ │ │ │ ├── flags.hpp
│ │ │ │ │ ├── posix/
│ │ │ │ │ │ ├── protected_stack_allocator.hpp
│ │ │ │ │ │ └── segmented_stack_allocator.hpp
│ │ │ │ │ ├── protected_stack_allocator.hpp
│ │ │ │ │ ├── segmented_stack_allocator.hpp
│ │ │ │ │ ├── stack_allocator.hpp
│ │ │ │ │ ├── stack_context.hpp
│ │ │ │ │ ├── stack_traits.hpp
│ │ │ │ │ ├── standard_stack_allocator.hpp
│ │ │ │ │ ├── symmetric_coroutine.hpp
│ │ │ │ │ └── windows/
│ │ │ │ │ └── protected_stack_allocator.hpp
│ │ │ │ ├── coroutine2/
│ │ │ │ │ ├── all.hpp
│ │ │ │ │ ├── coroutine.hpp
│ │ │ │ │ ├── detail/
│ │ │ │ │ │ ├── config.hpp
│ │ │ │ │ │ ├── coroutine.hpp
│ │ │ │ │ │ ├── create_control_block.ipp
│ │ │ │ │ │ ├── decay_copy.hpp
│ │ │ │ │ │ ├── disable_overload.hpp
│ │ │ │ │ │ ├── forced_unwind.hpp
│ │ │ │ │ │ ├── pull_control_block_cc.hpp
│ │ │ │ │ │ ├── pull_control_block_cc.ipp
│ │ │ │ │ │ ├── pull_control_block_ecv1.hpp
│ │ │ │ │ │ ├── pull_control_block_ecv1.ipp
│ │ │ │ │ │ ├── pull_coroutine.hpp
│ │ │ │ │ │ ├── pull_coroutine.ipp
│ │ │ │ │ │ ├── push_control_block_cc.hpp
│ │ │ │ │ │ ├── push_control_block_cc.ipp
│ │ │ │ │ │ ├── push_control_block_ecv1.hpp
│ │ │ │ │ │ ├── push_control_block_ecv1.ipp
│ │ │ │ │ │ ├── push_coroutine.hpp
│ │ │ │ │ │ ├── push_coroutine.ipp
│ │ │ │ │ │ ├── state.hpp
│ │ │ │ │ │ └── wrap.hpp
│ │ │ │ │ ├── fixedsize_stack.hpp
│ │ │ │ │ ├── pooled_fixedsize_stack.hpp
│ │ │ │ │ ├── protected_fixedsize_stack.hpp
│ │ │ │ │ └── segmented_stack.hpp
│ │ │ │ ├── crc.hpp
│ │ │ │ ├── cregex.hpp
│ │ │ │ ├── cstdfloat.hpp
│ │ │ │ ├── cstdint.hpp
│ │ │ │ ├── cstdlib.hpp
│ │ │ │ ├── current_function.hpp
│ │ │ │ ├── cxx11_char_types.hpp
│ │ │ │ ├── date_time/
│ │ │ │ │ ├── adjust_functors.hpp
│ │ │ │ │ ├── c_local_time_adjustor.hpp
│ │ │ │ │ ├── c_time.hpp
│ │ │ │ │ ├── compiler_config.hpp
│ │ │ │ │ ├── constrained_value.hpp
│ │ │ │ │ ├── date.hpp
│ │ │ │ │ ├── date_clock_device.hpp
│ │ │ │ │ ├── date_defs.hpp
│ │ │ │ │ ├── date_duration.hpp
│ │ │ │ │ ├── date_duration_types.hpp
│ │ │ │ │ ├── date_facet.hpp
│ │ │ │ │ ├── date_format_simple.hpp
│ │ │ │ │ ├── date_formatting.hpp
│ │ │ │ │ ├── date_formatting_limited.hpp
│ │ │ │ │ ├── date_formatting_locales.hpp
│ │ │ │ │ ├── date_generator_formatter.hpp
│ │ │ │ │ ├── date_generator_parser.hpp
│ │ │ │ │ ├── date_generators.hpp
│ │ │ │ │ ├── date_iterator.hpp
│ │ │ │ │ ├── date_names_put.hpp
│ │ │ │ │ ├── date_parsing.hpp
│ │ │ │ │ ├── dst_rules.hpp
│ │ │ │ │ ├── dst_transition_generators.hpp
│ │ │ │ │ ├── filetime_functions.hpp
│ │ │ │ │ ├── format_date_parser.hpp
│ │ │ │ │ ├── gregorian/
│ │ │ │ │ │ ├── conversion.hpp
│ │ │ │ │ │ ├── formatters.hpp
│ │ │ │ │ │ ├── formatters_limited.hpp
│ │ │ │ │ │ ├── greg_calendar.hpp
│ │ │ │ │ │ ├── greg_date.hpp
│ │ │ │ │ │ ├── greg_day.hpp
│ │ │ │ │ │ ├── greg_day_of_year.hpp
│ │ │ │ │ │ ├── greg_duration.hpp
│ │ │ │ │ │ ├── greg_duration_types.hpp
│ │ │ │ │ │ ├── greg_facet.hpp
│ │ │ │ │ │ ├── greg_month.hpp
│ │ │ │ │ │ ├── greg_serialize.hpp
│ │ │ │ │ │ ├── greg_weekday.hpp
│ │ │ │ │ │ ├── greg_year.hpp
│ │ │ │ │ │ ├── greg_ymd.hpp
│ │ │ │ │ │ ├── gregorian.hpp
│ │ │ │ │ │ ├── gregorian_io.hpp
│ │ │ │ │ │ ├── gregorian_types.hpp
│ │ │ │ │ │ └── parsers.hpp
│ │ │ │ │ ├── gregorian_calendar.hpp
│ │ │ │ │ ├── gregorian_calendar.ipp
│ │ │ │ │ ├── int_adapter.hpp
│ │ │ │ │ ├── iso_format.hpp
│ │ │ │ │ ├── local_time/
│ │ │ │ │ │ ├── conversion.hpp
│ │ │ │ │ │ ├── custom_time_zone.hpp
│ │ │ │ │ │ ├── date_duration_operators.hpp
│ │ │ │ │ │ ├── dst_transition_day_rules.hpp
│ │ │ │ │ │ ├── local_date_time.hpp
│ │ │ │ │ │ ├── local_time.hpp
│ │ │ │ │ │ ├── local_time_io.hpp
│ │ │ │ │ │ ├── local_time_types.hpp
│ │ │ │ │ │ ├── posix_time_zone.hpp
│ │ │ │ │ │ └── tz_database.hpp
│ │ │ │ │ ├── local_time_adjustor.hpp
│ │ │ │ │ ├── local_timezone_defs.hpp
│ │ │ │ │ ├── locale_config.hpp
│ │ │ │ │ ├── microsec_time_clock.hpp
│ │ │ │ │ ├── parse_format_base.hpp
│ │ │ │ │ ├── period.hpp
│ │ │ │ │ ├── period_formatter.hpp
│ │ │ │ │ ├── period_parser.hpp
│ │ │ │ │ ├── posix_time/
│ │ │ │ │ │ ├── conversion.hpp
│ │ │ │ │ │ ├── date_duration_operators.hpp
│ │ │ │ │ │ ├── posix_time.hpp
│ │ │ │ │ │ ├── posix_time_config.hpp
│ │ │ │ │ │ ├── posix_time_duration.hpp
│ │ │ │ │ │ ├── posix_time_io.hpp
│ │ │ │ │ │ ├── posix_time_legacy_io.hpp
│ │ │ │ │ │ ├── posix_time_system.hpp
│ │ │ │ │ │ ├── posix_time_types.hpp
│ │ │ │ │ │ ├── ptime.hpp
│ │ │ │ │ │ ├── time_formatters.hpp
│ │ │ │ │ │ ├── time_formatters_limited.hpp
│ │ │ │ │ │ ├── time_parsers.hpp
│ │ │ │ │ │ ├── time_period.hpp
│ │ │ │ │ │ └── time_serialize.hpp
│ │ │ │ │ ├── special_defs.hpp
│ │ │ │ │ ├── special_values_formatter.hpp
│ │ │ │ │ ├── special_values_parser.hpp
│ │ │ │ │ ├── string_convert.hpp
│ │ │ │ │ ├── string_parse_tree.hpp
│ │ │ │ │ ├── strings_from_facet.hpp
│ │ │ │ │ ├── time.hpp
│ │ │ │ │ ├── time_clock.hpp
│ │ │ │ │ ├── time_defs.hpp
│ │ │ │ │ ├── time_duration.hpp
│ │ │ │ │ ├── time_facet.hpp
│ │ │ │ │ ├── time_formatting_streams.hpp
│ │ │ │ │ ├── time_iterator.hpp
│ │ │ │ │ ├── time_parsing.hpp
│ │ │ │ │ ├── time_resolution_traits.hpp
│ │ │ │ │ ├── time_system_counted.hpp
│ │ │ │ │ ├── time_system_split.hpp
│ │ │ │ │ ├── time_zone_base.hpp
│ │ │ │ │ ├── time_zone_names.hpp
│ │ │ │ │ ├── tz_db_base.hpp
│ │ │ │ │ ├── wrapping_int.hpp
│ │ │ │ │ └── year_month_day.hpp
│ │ │ │ ├── date_time.hpp
│ │ │ │ ├── detail/
│ │ │ │ │ ├── algorithm.hpp
│ │ │ │ │ ├── allocator_utilities.hpp
│ │ │ │ │ ├── atomic_count.hpp
│ │ │ │ │ ├── atomic_redef_macros.hpp
│ │ │ │ │ ├── atomic_undef_macros.hpp
│ │ │ │ │ ├── basic_pointerbuf.hpp
│ │ │ │ │ ├── binary_search.hpp
│ │ │ │ │ ├── bitmask.hpp
│ │ │ │ │ ├── call_traits.hpp
│ │ │ │ │ ├── catch_exceptions.hpp
│ │ │ │ │ ├── compressed_pair.hpp
│ │ │ │ │ ├── container_fwd.hpp
│ │ │ │ │ ├── dynamic_bitset.hpp
│ │ │ │ │ ├── endian.hpp
│ │ │ │ │ ├── fenv.hpp
│ │ │ │ │ ├── has_default_constructor.hpp
│ │ │ │ │ ├── identifier.hpp
│ │ │ │ │ ├── indirect_traits.hpp
│ │ │ │ │ ├── interlocked.hpp
│ │ │ │ │ ├── is_incrementable.hpp
│ │ │ │ │ ├── is_sorted.hpp
│ │ │ │ │ ├── is_xxx.hpp
│ │ │ │ │ ├── iterator.hpp
│ │ │ │ │ ├── lcast_precision.hpp
│ │ │ │ │ ├── lightweight_main.hpp
│ │ │ │ │ ├── lightweight_mutex.hpp
│ │ │ │ │ ├── lightweight_test.hpp
│ │ │ │ │ ├── lightweight_test_report.hpp
│ │ │ │ │ ├── lightweight_thread.hpp
│ │ │ │ │ ├── named_template_params.hpp
│ │ │ │ │ ├── no_exceptions_support.hpp
│ │ │ │ │ ├── numeric_traits.hpp
│ │ │ │ │ ├── ob_compressed_pair.hpp
│ │ │ │ │ ├── quick_allocator.hpp
│ │ │ │ │ ├── reference_content.hpp
│ │ │ │ │ ├── scoped_enum_emulation.hpp
│ │ │ │ │ ├── select_type.hpp
│ │ │ │ │ ├── sp_typeinfo.hpp
│ │ │ │ │ ├── templated_streams.hpp
│ │ │ │ │ ├── utf8_codecvt_facet.hpp
│ │ │ │ │ ├── utf8_codecvt_facet.ipp
│ │ │ │ │ ├── winapi/
│ │ │ │ │ │ ├── GetCurrentProcess.hpp
│ │ │ │ │ │ ├── GetCurrentThread.hpp
│ │ │ │ │ │ ├── GetLastError.hpp
│ │ │ │ │ │ ├── GetProcessTimes.hpp
│ │ │ │ │ │ ├── GetThreadTimes.hpp
│ │ │ │ │ │ ├── access_rights.hpp
│ │ │ │ │ │ ├── apc.hpp
│ │ │ │ │ │ ├── basic_types.hpp
│ │ │ │ │ │ ├── character_code_conversion.hpp
│ │ │ │ │ │ ├── condition_variable.hpp
│ │ │ │ │ │ ├── config.hpp
│ │ │ │ │ │ ├── critical_section.hpp
│ │ │ │ │ │ ├── crypt.hpp
│ │ │ │ │ │ ├── dbghelp.hpp
│ │ │ │ │ │ ├── detail/
│ │ │ │ │ │ │ └── cast_ptr.hpp
│ │ │ │ │ │ ├── directory_management.hpp
│ │ │ │ │ │ ├── dll.hpp
│ │ │ │ │ │ ├── environment.hpp
│ │ │ │ │ │ ├── error_codes.hpp
│ │ │ │ │ │ ├── error_handling.hpp
│ │ │ │ │ │ ├── event.hpp
│ │ │ │ │ │ ├── file_management.hpp
│ │ │ │ │ │ ├── file_mapping.hpp
│ │ │ │ │ │ ├── get_current_process.hpp
│ │ │ │ │ │ ├── get_current_process_id.hpp
│ │ │ │ │ │ ├── get_current_thread.hpp
│ │ │ │ │ │ ├── get_current_thread_id.hpp
│ │ │ │ │ │ ├── get_last_error.hpp
│ │ │ │ │ │ ├── get_process_times.hpp
│ │ │ │ │ │ ├── get_system_directory.hpp
│ │ │ │ │ │ ├── get_thread_times.hpp
│ │ │ │ │ │ ├── handle_info.hpp
│ │ │ │ │ │ ├── handles.hpp
│ │ │ │ │ │ ├── heap_memory.hpp
│ │ │ │ │ │ ├── init_once.hpp
│ │ │ │ │ │ ├── jobs.hpp
│ │ │ │ │ │ ├── limits.hpp
│ │ │ │ │ │ ├── local_memory.hpp
│ │ │ │ │ │ ├── memory.hpp
│ │ │ │ │ │ ├── mutex.hpp
│ │ │ │ │ │ ├── overlapped.hpp
│ │ │ │ │ │ ├── page_protection_flags.hpp
│ │ │ │ │ │ ├── pipes.hpp
│ │ │ │ │ │ ├── priority_class.hpp
│ │ │ │ │ │ ├── process.hpp
│ │ │ │ │ │ ├── security.hpp
│ │ │ │ │ │ ├── semaphore.hpp
│ │ │ │ │ │ ├── shell.hpp
│ │ │ │ │ │ ├── show_window.hpp
│ │ │ │ │ │ ├── srw_lock.hpp
│ │ │ │ │ │ ├── synchronization.hpp
│ │ │ │ │ │ ├── system.hpp
│ │ │ │ │ │ ├── thread.hpp
│ │ │ │ │ │ ├── thread_pool.hpp
│ │ │ │ │ │ ├── time.hpp
│ │ │ │ │ │ ├── timers.hpp
│ │ │ │ │ │ ├── tls.hpp
│ │ │ │ │ │ ├── wait.hpp
│ │ │ │ │ │ └── waitable_timer.hpp
│ │ │ │ │ └── workaround.hpp
│ │ │ │ ├── dll/
│ │ │ │ │ ├── alias.hpp
│ │ │ │ │ ├── detail/
│ │ │ │ │ │ ├── aggressive_ptr_cast.hpp
│ │ │ │ │ │ ├── ctor_dtor.hpp
│ │ │ │ │ │ ├── demangling/
│ │ │ │ │ │ │ ├── demangle_symbol.hpp
│ │ │ │ │ │ │ ├── itanium.hpp
│ │ │ │ │ │ │ ├── mangled_storage_base.hpp
│ │ │ │ │ │ │ └── msvc.hpp
│ │ │ │ │ │ ├── elf_info.hpp
│ │ │ │ │ │ ├── get_mem_fn_type.hpp
│ │ │ │ │ │ ├── import_mangled_helpers.hpp
│ │ │ │ │ │ ├── macho_info.hpp
│ │ │ │ │ │ ├── pe_info.hpp
│ │ │ │ │ │ ├── posix/
│ │ │ │ │ │ │ ├── path_from_handle.hpp
│ │ │ │ │ │ │ ├── program_location_impl.hpp
│ │ │ │ │ │ │ └── shared_library_impl.hpp
│ │ │ │ │ │ ├── system_error.hpp
│ │ │ │ │ │ ├── type_info.hpp
│ │ │ │ │ │ ├── windows/
│ │ │ │ │ │ │ ├── path_from_handle.hpp
│ │ │ │ │ │ │ └── shared_library_impl.hpp
│ │ │ │ │ │ └── x_info_interface.hpp
│ │ │ │ │ ├── import.hpp
│ │ │ │ │ ├── import_class.hpp
│ │ │ │ │ ├── import_mangled.hpp
│ │ │ │ │ ├── library_info.hpp
│ │ │ │ │ ├── runtime_symbol_info.hpp
│ │ │ │ │ ├── shared_library.hpp
│ │ │ │ │ ├── shared_library_load_mode.hpp
│ │ │ │ │ └── smart_library.hpp
│ │ │ │ ├── dll.hpp
│ │ │ │ ├── dynamic_bitset/
│ │ │ │ │ ├── config.hpp
│ │ │ │ │ ├── dynamic_bitset.hpp
│ │ │ │ │ └── serialization.hpp
│ │ │ │ ├── dynamic_bitset.hpp
│ │ │ │ ├── dynamic_bitset_fwd.hpp
│ │ │ │ ├── enable_shared_from_this.hpp
│ │ │ │ ├── endian/
│ │ │ │ │ ├── arithmetic.hpp
│ │ │ │ │ ├── buffers.hpp
│ │ │ │ │ ├── conversion.hpp
│ │ │ │ │ ├── detail/
│ │ │ │ │ │ ├── config.hpp
│ │ │ │ │ │ ├── cover_operators.hpp
│ │ │ │ │ │ ├── disable_warnings.hpp
│ │ │ │ │ │ ├── disable_warnings_pop.hpp
│ │ │ │ │ │ ├── intrinsic.hpp
│ │ │ │ │ │ └── lightweight_test.hpp
│ │ │ │ │ ├── endian.hpp
│ │ │ │ │ └── std_pair.hpp
│ │ │ │ ├── exception/
│ │ │ │ │ ├── N3757.hpp
│ │ │ │ │ ├── all.hpp
│ │ │ │ │ ├── current_exception_cast.hpp
│ │ │ │ │ ├── detail/
│ │ │ │ │ │ ├── clone_current_exception.hpp
│ │ │ │ │ │ ├── error_info_impl.hpp
│ │ │ │ │ │ ├── exception_ptr.hpp
│ │ │ │ │ │ ├── is_output_streamable.hpp
│ │ │ │ │ │ ├── object_hex_dump.hpp
│ │ │ │ │ │ ├── shared_ptr.hpp
│ │ │ │ │ │ └── type_info.hpp
│ │ │ │ │ ├── diagnostic_information.hpp
│ │ │ │ │ ├── enable_current_exception.hpp
│ │ │ │ │ ├── enable_error_info.hpp
│ │ │ │ │ ├── errinfo_api_function.hpp
│ │ │ │ │ ├── errinfo_at_line.hpp
│ │ │ │ │ ├── errinfo_errno.hpp
│ │ │ │ │ ├── errinfo_file_handle.hpp
│ │ │ │ │ ├── errinfo_file_name.hpp
│ │ │ │ │ ├── errinfo_file_open_mode.hpp
│ │ │ │ │ ├── errinfo_nested_exception.hpp
│ │ │ │ │ ├── errinfo_type_info_name.hpp
│ │ │ │ │ ├── error_info.hpp
│ │ │ │ │ ├── exception.hpp
│ │ │ │ │ ├── get_error_info.hpp
│ │ │ │ │ ├── info.hpp
│ │ │ │ │ ├── info_tuple.hpp
│ │ │ │ │ ├── to_string.hpp
│ │ │ │ │ └── to_string_stub.hpp
│ │ │ │ ├── exception_ptr.hpp
│ │ │ │ ├── fiber/
│ │ │ │ │ ├── algo/
│ │ │ │ │ │ ├── algorithm.hpp
│ │ │ │ │ │ ├── round_robin.hpp
│ │ │ │ │ │ ├── shared_work.hpp
│ │ │ │ │ │ └── work_stealing.hpp
│ │ │ │ │ ├── all.hpp
│ │ │ │ │ ├── barrier.hpp
│ │ │ │ │ ├── buffered_channel.hpp
│ │ │ │ │ ├── channel_op_status.hpp
│ │ │ │ │ ├── condition_variable.hpp
│ │ │ │ │ ├── context.hpp
│ │ │ │ │ ├── detail/
│ │ │ │ │ │ ├── config.hpp
│ │ │ │ │ │ ├── context_spinlock_queue.hpp
│ │ │ │ │ │ ├── context_spmc_queue.hpp
│ │ │ │ │ │ ├── convert.hpp
│ │ │ │ │ │ ├── cpu_relax.hpp
│ │ │ │ │ │ ├── data.hpp
│ │ │ │ │ │ ├── decay_copy.hpp
│ │ │ │ │ │ ├── disable_overload.hpp
│ │ │ │ │ │ ├── fss.hpp
│ │ │ │ │ │ ├── futex.hpp
│ │ │ │ │ │ ├── spinlock.hpp
│ │ │ │ │ │ ├── spinlock_ttas.hpp
│ │ │ │ │ │ ├── spinlock_ttas_adaptive.hpp
│ │ │ │ │ │ ├── spinlock_ttas_adaptive_futex.hpp
│ │ │ │ │ │ ├── spinlock_ttas_futex.hpp
│ │ │ │ │ │ └── wrap.hpp
│ │ │ │ │ ├── exceptions.hpp
│ │ │ │ │ ├── fiber.hpp
│ │ │ │ │ ├── fixedsize_stack.hpp
│ │ │ │ │ ├── fss.hpp
│ │ │ │ │ ├── future/
│ │ │ │ │ │ ├── async.hpp
│ │ │ │ │ │ ├── detail/
│ │ │ │ │ │ │ ├── shared_state.hpp
│ │ │ │ │ │ │ ├── shared_state_object.hpp
│ │ │ │ │ │ │ ├── task_base.hpp
│ │ │ │ │ │ │ └── task_object.hpp
│ │ │ │ │ │ ├── future.hpp
│ │ │ │ │ │ ├── future_status.hpp
│ │ │ │ │ │ ├── packaged_task.hpp
│ │ │ │ │ │ └── promise.hpp
│ │ │ │ │ ├── future.hpp
│ │ │ │ │ ├── mutex.hpp
│ │ │ │ │ ├── operations.hpp
│ │ │ │ │ ├── policy.hpp
│ │ │ │ │ ├── pooled_fixedsize_stack.hpp
│ │ │ │ │ ├── properties.hpp
│ │ │ │ │ ├── protected_fixedsize_stack.hpp
│ │ │ │ │ ├── recursive_mutex.hpp
│ │ │ │ │ ├── recursive_timed_mutex.hpp
│ │ │ │ │ ├── scheduler.hpp
│ │ │ │ │ ├── segmented_stack.hpp
│ │ │ │ │ ├── timed_mutex.hpp
│ │ │ │ │ ├── type.hpp
│ │ │ │ │ └── unbuffered_channel.hpp
│ │ │ │ ├── filesystem/
│ │ │ │ │ ├── config.hpp
│ │ │ │ │ ├── convenience.hpp
│ │ │ │ │ ├── detail/
│ │ │ │ │ │ ├── macro_value.hpp
│ │ │ │ │ │ └── utf8_codecvt_facet.hpp
│ │ │ │ │ ├── exception.hpp
│ │ │ │ │ ├── fstream.hpp
│ │ │ │ │ ├── operations.hpp
│ │ │ │ │ ├── path.hpp
│ │ │ │ │ ├── path_traits.hpp
│ │ │ │ │ └── string_file.hpp
│ │ │ │ ├── filesystem.hpp
│ │ │ │ ├── flyweight/
│ │ │ │ │ ├── assoc_container_factory.hpp
│ │ │ │ │ ├── assoc_container_factory_fwd.hpp
│ │ │ │ │ ├── detail/
│ │ │ │ │ │ ├── archive_constructed.hpp
│ │ │ │ │ │ ├── default_value_policy.hpp
│ │ │ │ │ │ ├── dyn_perfect_fwd.hpp
│ │ │ │ │ │ ├── flyweight_core.hpp
│ │ │ │ │ │ ├── is_placeholder_expr.hpp
│ │ │ │ │ │ ├── nested_xxx_if_not_ph.hpp
│ │ │ │ │ │ ├── not_placeholder_expr.hpp
│ │ │ │ │ │ ├── perfect_fwd.hpp
│ │ │ │ │ │ ├── pp_perfect_fwd.hpp
│ │ │ │ │ │ ├── recursive_lw_mutex.hpp
│ │ │ │ │ │ ├── serialization_helper.hpp
│ │ │ │ │ │ └── value_tag.hpp
│ │ │ │ │ ├── factory_tag.hpp
│ │ │ │ │ ├── flyweight.hpp
│ │ │ │ │ ├── flyweight_fwd.hpp
│ │ │ │ │ ├── hashed_factory.hpp
│ │ │ │ │ ├── hashed_factory_fwd.hpp
│ │ │ │ │ ├── holder_tag.hpp
│ │ │ │ │ ├── intermodule_holder.hpp
│ │ │ │ │ ├── intermodule_holder_fwd.hpp
│ │ │ │ │ ├── key_value.hpp
│ │ │ │ │ ├── key_value_fwd.hpp
│ │ │ │ │ ├── locking_tag.hpp
│ │ │ │ │ ├── no_locking.hpp
│ │ │ │ │ ├── no_locking_fwd.hpp
│ │ │ │ │ ├── no_tracking.hpp
│ │ │ │ │ ├── no_tracking_fwd.hpp
│ │ │ │ │ ├── refcounted.hpp
│ │ │ │ │ ├── refcounted_fwd.hpp
│ │ │ │ │ ├── serialize.hpp
│ │ │ │ │ ├── set_factory.hpp
│ │ │ │ │ ├── set_factory_fwd.hpp
│ │ │ │ │ ├── simple_locking.hpp
│ │ │ │ │ ├── simple_locking_fwd.hpp
│ │ │ │ │ ├── static_holder.hpp
│ │ │ │ │ ├── static_holder_fwd.hpp
│ │ │ │ │ ├── tag.hpp
│ │ │ │ │ └── tracking_tag.hpp
│ │ │ │ ├── flyweight.hpp
│ │ │ │ ├── foreach.hpp
│ │ │ │ ├── foreach_fwd.hpp
│ │ │ │ ├── format/
│ │ │ │ │ ├── alt_sstream.hpp
│ │ │ │ │ ├── alt_sstream_impl.hpp
│ │ │ │ │ ├── detail/
│ │ │ │ │ │ ├── compat_workarounds.hpp
│ │ │ │ │ │ ├── config_macros.hpp
│ │ │ │ │ │ ├── msvc_disambiguater.hpp
│ │ │ │ │ │ ├── unset_macros.hpp
│ │ │ │ │ │ ├── workarounds_gcc-2_95.hpp
│ │ │ │ │ │ └── workarounds_stlport.hpp
│ │ │ │ │ ├── exceptions.hpp
│ │ │ │ │ ├── feed_args.hpp
│ │ │ │ │ ├── format_class.hpp
│ │ │ │ │ ├── format_fwd.hpp
│ │ │ │ │ ├── format_implementation.hpp
│ │ │ │ │ ├── free_funcs.hpp
│ │ │ │ │ ├── group.hpp
│ │ │ │ │ ├── internals.hpp
│ │ │ │ │ ├── internals_fwd.hpp
│ │ │ │ │ └── parsing.hpp
│ │ │ │ ├── format.hpp
│ │ │ │ ├── function/
│ │ │ │ │ ├── detail/
│ │ │ │ │ │ ├── function_iterate.hpp
│ │ │ │ │ │ ├── gen_maybe_include.pl
│ │ │ │ │ │ ├── maybe_include.hpp
│ │ │ │ │ │ └── prologue.hpp
│ │ │ │ │ ├── function0.hpp
│ │ │ │ │ ├── function1.hpp
│ │ │ │ │ ├── function10.hpp
│ │ │ │ │ ├── function2.hpp
│ │ │ │ │ ├── function3.hpp
│ │ │ │ │ ├── function4.hpp
│ │ │ │ │ ├── function5.hpp
│ │ │ │ │ ├── function6.hpp
│ │ │ │ │ ├── function7.hpp
│ │ │ │ │ ├── function8.hpp
│ │ │ │ │ ├── function9.hpp
│ │ │ │ │ ├── function_base.hpp
│ │ │ │ │ ├── function_fwd.hpp
│ │ │ │ │ ├── function_template.hpp
│ │ │ │ │ ├── function_typeof.hpp
│ │ │ │ │ └── gen_function_N.pl
│ │ │ │ ├── function.hpp
│ │ │ │ ├── function_equal.hpp
│ │ │ │ ├── function_output_iterator.hpp
│ │ │ │ ├── function_types/
│ │ │ │ │ ├── components.hpp
│ │ │ │ │ ├── config/
│ │ │ │ │ │ ├── cc_names.hpp
│ │ │ │ │ │ ├── compiler.hpp
│ │ │ │ │ │ └── config.hpp
│ │ │ │ │ ├── detail/
│ │ │ │ │ │ ├── class_transform.hpp
│ │ │ │ │ │ ├── classifier.hpp
│ │ │ │ │ │ ├── classifier_impl/
│ │ │ │ │ │ │ ├── arity10_0.hpp
│ │ │ │ │ │ │ ├── arity10_1.hpp
│ │ │ │ │ │ │ ├── arity20_0.hpp
│ │ │ │ │ │ │ ├── arity20_1.hpp
│ │ │ │ │ │ │ ├── arity30_0.hpp
│ │ │ │ │ │ │ ├── arity30_1.hpp
│ │ │ │ │ │ │ ├── arity40_0.hpp
│ │ │ │ │ │ │ ├── arity40_1.hpp
│ │ │ │ │ │ │ ├── arity50_0.hpp
│ │ │ │ │ │ │ ├── arity50_1.hpp
│ │ │ │ │ │ │ └── master.hpp
│ │ │ │ │ │ ├── components_as_mpl_sequence.hpp
│ │ │ │ │ │ ├── components_impl/
│ │ │ │ │ │ │ ├── arity10_0.hpp
│ │ │ │ │ │ │ ├── arity10_1.hpp
│ │ │ │ │ │ │ ├── arity20_0.hpp
│ │ │ │ │ │ │ ├── arity20_1.hpp
│ │ │ │ │ │ │ ├── arity30_0.hpp
│ │ │ │ │ │ │ ├── arity30_1.hpp
│ │ │ │ │ │ │ ├── arity40_0.hpp
│ │ │ │ │ │ │ ├── arity40_1.hpp
│ │ │ │ │ │ │ ├── arity50_0.hpp
│ │ │ │ │ │ │ ├── arity50_1.hpp
│ │ │ │ │ │ │ └── master.hpp
│ │ │ │ │ │ ├── cv_traits.hpp
│ │ │ │ │ │ ├── encoding/
│ │ │ │ │ │ │ ├── aliases_def.hpp
│ │ │ │ │ │ │ ├── aliases_undef.hpp
│ │ │ │ │ │ │ ├── def.hpp
│ │ │ │ │ │ │ └── undef.hpp
│ │ │ │ │ │ ├── pp_arity_loop.hpp
│ │ │ │ │ │ ├── pp_cc_loop/
│ │ │ │ │ │ │ ├── master.hpp
│ │ │ │ │ │ │ └── preprocessed.hpp
│ │ │ │ │ │ ├── pp_loop.hpp
│ │ │ │ │ │ ├── pp_retag_default_cc/
│ │ │ │ │ │ │ ├── master.hpp
│ │ │ │ │ │ │ └── preprocessed.hpp
│ │ │ │ │ │ ├── pp_tags/
│ │ │ │ │ │ │ ├── cc_tag.hpp
│ │ │ │ │ │ │ ├── master.hpp
│ │ │ │ │ │ │ └── preprocessed.hpp
│ │ │ │ │ │ ├── pp_variate_loop/
│ │ │ │ │ │ │ ├── master.hpp
│ │ │ │ │ │ │ └── preprocessed.hpp
│ │ │ │ │ │ ├── retag_default_cc.hpp
│ │ │ │ │ │ ├── synthesize.hpp
│ │ │ │ │ │ ├── synthesize_impl/
│ │ │ │ │ │ │ ├── arity10_0.hpp
│ │ │ │ │ │ │ ├── arity10_1.hpp
│ │ │ │ │ │ │ ├── arity20_0.hpp
│ │ │ │ │ │ │ ├── arity20_1.hpp
│ │ │ │ │ │ │ ├── arity30_0.hpp
│ │ │ │ │ │ │ ├── arity30_1.hpp
│ │ │ │ │ │ │ ├── arity40_0.hpp
│ │ │ │ │ │ │ ├── arity40_1.hpp
│ │ │ │ │ │ │ ├── arity50_0.hpp
│ │ │ │ │ │ │ ├── arity50_1.hpp
│ │ │ │ │ │ │ └── master.hpp
│ │ │ │ │ │ └── to_sequence.hpp
│ │ │ │ │ ├── function_arity.hpp
│ │ │ │ │ ├── function_pointer.hpp
│ │ │ │ │ ├── function_reference.hpp
│ │ │ │ │ ├── function_type.hpp
│ │ │ │ │ ├── is_callable_builtin.hpp
│ │ │ │ │ ├── is_function.hpp
│ │ │ │ │ ├── is_function_pointer.hpp
│ │ │ │ │ ├── is_function_reference.hpp
│ │ │ │ │ ├── is_member_function_pointer.hpp
│ │ │ │ │ ├── is_member_object_pointer.hpp
│ │ │ │ │ ├── is_member_pointer.hpp
│ │ │ │ │ ├── is_nonmember_callable_builtin.hpp
│ │ │ │ │ ├── member_function_pointer.hpp
│ │ │ │ │ ├── member_object_pointer.hpp
│ │ │ │ │ ├── parameter_types.hpp
│ │ │ │ │ ├── property_tags.hpp
│ │ │ │ │ └── result_type.hpp
│ │ │ │ ├── functional/
│ │ │ │ │ ├── factory.hpp
│ │ │ │ │ ├── forward_adapter.hpp
│ │ │ │ │ ├── hash/
│ │ │ │ │ │ ├── detail/
│ │ │ │ │ │ │ ├── float_functions.hpp
│ │ │ │ │ │ │ ├── hash_float.hpp
│ │ │ │ │ │ │ └── limits.hpp
│ │ │ │ │ │ ├── extensions.hpp
│ │ │ │ │ │ ├── hash.hpp
│ │ │ │ │ │ └── hash_fwd.hpp
│ │ │ │ │ ├── hash.hpp
│ │ │ │ │ ├── hash_fwd.hpp
│ │ │ │ │ ├── lightweight_forward_adapter.hpp
│ │ │ │ │ ├── overloaded_function/
│ │ │ │ │ │ ├── config.hpp
│ │ │ │ │ │ └── detail/
│ │ │ │ │ │ ├── base.hpp
│ │ │ │ │ │ └── function_type.hpp
│ │ │ │ │ ├── overloaded_function.hpp
│ │ │ │ │ └── value_factory.hpp
│ │ │ │ ├── functional.hpp
│ │ │ │ ├── fusion/
│ │ │ │ │ ├── adapted/
│ │ │ │ │ │ ├── adt/
│ │ │ │ │ │ │ ├── adapt_adt.hpp
│ │ │ │ │ │ │ ├── adapt_adt_named.hpp
│ │ │ │ │ │ │ ├── adapt_assoc_adt.hpp
│ │ │ │ │ │ │ ├── adapt_assoc_adt_named.hpp
│ │ │ │ │ │ │ └── detail/
│ │ │ │ │ │ │ ├── adapt_base.hpp
│ │ │ │ │ │ │ ├── adapt_base_assoc_attr_filler.hpp
│ │ │ │ │ │ │ ├── adapt_base_attr_filler.hpp
│ │ │ │ │ │ │ └── extension.hpp
│ │ │ │ │ │ ├── adt.hpp
│ │ │ │ │ │ ├── array/
│ │ │ │ │ │ │ ├── at_impl.hpp
│ │ │ │ │ │ │ ├── begin_impl.hpp
│ │ │ │ │ │ │ ├── category_of_impl.hpp
│ │ │ │ │ │ │ ├── deref_impl.hpp
│ │ │ │ │ │ │ ├── end_impl.hpp
│ │ │ │ │ │ │ ├── is_sequence_impl.hpp
│ │ │ │ │ │ │ ├── is_view_impl.hpp
│ │ │ │ │ │ │ ├── size_impl.hpp
│ │ │ │ │ │ │ ├── tag_of.hpp
│ │ │ │ │ │ │ ├── value_at_impl.hpp
│ │ │ │ │ │ │ └── value_of_impl.hpp
│ │ │ │ │ │ ├── array.hpp
│ │ │ │ │ │ ├── boost_array/
│ │ │ │ │ │ │ ├── array_iterator.hpp
│ │ │ │ │ │ │ ├── detail/
│ │ │ │ │ │ │ │ ├── at_impl.hpp
│ │ │ │ │ │ │ │ ├── begin_impl.hpp
│ │ │ │ │ │ │ │ ├── category_of_impl.hpp
│ │ │ │ │ │ │ │ ├── end_impl.hpp
│ │ │ │ │ │ │ │ ├── is_sequence_impl.hpp
│ │ │ │ │ │ │ │ ├── is_view_impl.hpp
│ │ │ │ │ │ │ │ ├── size_impl.hpp
│ │ │ │ │ │ │ │ └── value_at_impl.hpp
│ │ │ │ │ │ │ └── tag_of.hpp
│ │ │ │ │ │ ├── boost_array.hpp
│ │ │ │ │ │ ├── boost_tuple/
│ │ │ │ │ │ │ ├── boost_tuple_iterator.hpp
│ │ │ │ │ │ │ ├── detail/
│ │ │ │ │ │ │ │ ├── at_impl.hpp
│ │ │ │ │ │ │ │ ├── begin_impl.hpp
│ │ │ │ │ │ │ │ ├── build_cons.hpp
│ │ │ │ │ │ │ │ ├── category_of_impl.hpp
│ │ │ │ │ │ │ │ ├── convert_impl.hpp
│ │ │ │ │ │ │ │ ├── end_impl.hpp
│ │ │ │ │ │ │ │ ├── is_sequence_impl.hpp
│ │ │ │ │ │ │ │ ├── is_view_impl.hpp
│ │ │ │ │ │ │ │ ├── size_impl.hpp
│ │ │ │ │ │ │ │ └── value_at_impl.hpp
│ │ │ │ │ │ │ ├── mpl/
│ │ │ │ │ │ │ │ └── clear.hpp
│ │ │ │ │ │ │ └── tag_of.hpp
│ │ │ │ │ │ ├── boost_tuple.hpp
│ │ │ │ │ │ ├── mpl/
│ │ │ │ │ │ │ ├── detail/
│ │ │ │ │ │ │ │ ├── at_impl.hpp
│ │ │ │ │ │ │ │ ├── begin_impl.hpp
│ │ │ │ │ │ │ │ ├── category_of_impl.hpp
│ │ │ │ │ │ │ │ ├── empty_impl.hpp
│ │ │ │ │ │ │ │ ├── end_impl.hpp
│ │ │ │ │ │ │ │ ├── has_key_impl.hpp
│ │ │ │ │ │ │ │ ├── is_sequence_impl.hpp
│ │ │ │ │ │ │ │ ├── is_view_impl.hpp
│ │ │ │ │ │ │ │ ├── size_impl.hpp
│ │ │ │ │ │ │ │ └── value_at_impl.hpp
│ │ │ │ │ │ │ └── mpl_iterator.hpp
│ │ │ │ │ │ ├── mpl.hpp
│ │ │ │ │ │ ├── std_array/
│ │ │ │ │ │ │ ├── detail/
│ │ │ │ │ │ │ │ ├── array_size.hpp
│ │ │ │ │ │ │ │ ├── at_impl.hpp
│ │ │ │ │ │ │ │ ├── begin_impl.hpp
│ │ │ │ │ │ │ │ ├── category_of_impl.hpp
│ │ │ │ │ │ │ │ ├── end_impl.hpp
│ │ │ │ │ │ │ │ ├── is_sequence_impl.hpp
│ │ │ │ │ │ │ │ ├── is_view_impl.hpp
│ │ │ │ │ │ │ │ ├── size_impl.hpp
│ │ │ │ │ │ │ │ └── value_at_impl.hpp
│ │ │ │ │ │ │ ├── std_array_iterator.hpp
│ │ │ │ │ │ │ └── tag_of.hpp
│ │ │ │ │ │ ├── std_array.hpp
│ │ │ │ │ │ ├── std_pair.hpp
│ │ │ │ │ │ ├── std_tuple/
│ │ │ │ │ │ │ ├── detail/
│ │ │ │ │ │ │ │ ├── at_impl.hpp
│ │ │ │ │ │ │ │ ├── begin_impl.hpp
│ │ │ │ │ │ │ │ ├── build_std_tuple.hpp
│ │ │ │ │ │ │ │ ├── category_of_impl.hpp
│ │ │ │ │ │ │ │ ├── convert_impl.hpp
│ │ │ │ │ │ │ │ ├── end_impl.hpp
│ │ │ │ │ │ │ │ ├── is_sequence_impl.hpp
│ │ │ │ │ │ │ │ ├── is_view_impl.hpp
│ │ │ │ │ │ │ │ ├── size_impl.hpp
│ │ │ │ │ │ │ │ └── value_at_impl.hpp
│ │ │ │ │ │ │ ├── mpl/
│ │ │ │ │ │ │ │ └── clear.hpp
│ │ │ │ │ │ │ ├── std_tuple_iterator.hpp
│ │ │ │ │ │ │ └── tag_of.hpp
│ │ │ │ │ │ ├── std_tuple.hpp
│ │ │ │ │ │ ├── struct/
│ │ │ │ │ │ │ ├── adapt_assoc_struct.hpp
│ │ │ │ │ │ │ ├── adapt_assoc_struct_named.hpp
│ │ │ │ │ │ │ ├── adapt_struct.hpp
│ │ │ │ │ │ │ ├── adapt_struct_named.hpp
│ │ │ │ │ │ │ ├── define_assoc_struct.hpp
│ │ │ │ │ │ │ ├── define_struct.hpp
│ │ │ │ │ │ │ ├── define_struct_inline.hpp
│ │ │ │ │ │ │ └── detail/
│ │ │ │ │ │ │ ├── adapt_auto.hpp
│ │ │ │ │ │ │ ├── adapt_base.hpp
│ │ │ │ │ │ │ ├── adapt_base_assoc_attr_filler.hpp
│ │ │ │ │ │ │ ├── adapt_base_attr_filler.hpp
│ │ │ │ │ │ │ ├── adapt_is_tpl.hpp
│ │ │ │ │ │ │ ├── at_impl.hpp
│ │ │ │ │ │ │ ├── begin_impl.hpp
│ │ │ │ │ │ │ ├── category_of_impl.hpp
│ │ │ │ │ │ │ ├── define_struct.hpp
│ │ │ │ │ │ │ ├── define_struct_inline.hpp
│ │ │ │ │ │ │ ├── deref_data_impl.hpp
│ │ │ │ │ │ │ ├── deref_impl.hpp
│ │ │ │ │ │ │ ├── end_impl.hpp
│ │ │ │ │ │ │ ├── extension.hpp
│ │ │ │ │ │ │ ├── is_sequence_impl.hpp
│ │ │ │ │ │ │ ├── is_view_impl.hpp
│ │ │ │ │ │ │ ├── key_of_impl.hpp
│ │ │ │ │ │ │ ├── namespace.hpp
│ │ │ │ │ │ │ ├── preprocessor/
│ │ │ │ │ │ │ │ └── is_seq.hpp
│ │ │ │ │ │ │ ├── proxy_type.hpp
│ │ │ │ │ │ │ ├── size_impl.hpp
│ │ │ │ │ │ │ ├── value_at_impl.hpp
│ │ │ │ │ │ │ ├── value_of_data_impl.hpp
│ │ │ │ │ │ │ └── value_of_impl.hpp
│ │ │ │ │ │ └── struct.hpp
│ │ │ │ │ ├── adapted.hpp
│ │ │ │ │ ├── algorithm/
│ │ │ │ │ │ ├── auxiliary/
│ │ │ │ │ │ │ ├── copy.hpp
│ │ │ │ │ │ │ └── move.hpp
│ │ │ │ │ │ ├── auxiliary.hpp
│ │ │ │ │ │ ├── iteration/
│ │ │ │ │ │ │ ├── accumulate.hpp
│ │ │ │ │ │ │ ├── accumulate_fwd.hpp
│ │ │ │ │ │ │ ├── detail/
│ │ │ │ │ │ │ │ ├── fold.hpp
│ │ │ │ │ │ │ │ ├── for_each.hpp
│ │ │ │ │ │ │ │ ├── preprocessed/
│ │ │ │ │ │ │ │ │ ├── fold.hpp
│ │ │ │ │ │ │ │ │ ├── iter_fold.hpp
│ │ │ │ │ │ │ │ │ ├── reverse_fold.hpp
│ │ │ │ │ │ │ │ │ └── reverse_iter_fold.hpp
│ │ │ │ │ │ │ │ ├── segmented_fold.hpp
│ │ │ │ │ │ │ │ └── segmented_for_each.hpp
│ │ │ │ │ │ │ ├── fold.hpp
│ │ │ │ │ │ │ ├── fold_fwd.hpp
│ │ │ │ │ │ │ ├── for_each.hpp
│ │ │ │ │ │ │ ├── for_each_fwd.hpp
│ │ │ │ │ │ │ ├── iter_fold.hpp
│ │ │ │ │ │ │ ├── iter_fold_fwd.hpp
│ │ │ │ │ │ │ ├── reverse_fold.hpp
│ │ │ │ │ │ │ ├── reverse_fold_fwd.hpp
│ │ │ │ │ │ │ ├── reverse_iter_fold.hpp
│ │ │ │ │ │ │ └── reverse_iter_fold_fwd.hpp
│ │ │ │ │ │ ├── iteration.hpp
│ │ │ │ │ │ ├── query/
│ │ │ │ │ │ │ ├── all.hpp
│ │ │ │ │ │ │ ├── any.hpp
│ │ │ │ │ │ │ ├── count.hpp
│ │ │ │ │ │ │ ├── count_if.hpp
│ │ │ │ │ │ │ ├── detail/
│ │ │ │ │ │ │ │ ├── all.hpp
│ │ │ │ │ │ │ │ ├── any.hpp
│ │ │ │ │ │ │ │ ├── count.hpp
│ │ │ │ │ │ │ │ ├── count_if.hpp
│ │ │ │ │ │ │ │ ├── find_if.hpp
│ │ │ │ │ │ │ │ ├── segmented_find.hpp
│ │ │ │ │ │ │ │ └── segmented_find_if.hpp
│ │ │ │ │ │ │ ├── find.hpp
│ │ │ │ │ │ │ ├── find_fwd.hpp
│ │ │ │ │ │ │ ├── find_if.hpp
│ │ │ │ │ │ │ ├── find_if_fwd.hpp
│ │ │ │ │ │ │ └── none.hpp
│ │ │ │ │ │ ├── query.hpp
│ │ │ │ │ │ ├── transformation/
│ │ │ │ │ │ │ ├── clear.hpp
│ │ │ │ │ │ │ ├── detail/
│ │ │ │ │ │ │ │ ├── preprocessed/
│ │ │ │ │ │ │ │ │ ├── zip.hpp
│ │ │ │ │ │ │ │ │ ├── zip10.hpp
│ │ │ │ │ │ │ │ │ ├── zip20.hpp
│ │ │ │ │ │ │ │ │ ├── zip30.hpp
│ │ │ │ │ │ │ │ │ ├── zip40.hpp
│ │ │ │ │ │ │ │ │ └── zip50.hpp
│ │ │ │ │ │ │ │ ├── replace.hpp
│ │ │ │ │ │ │ │ └── replace_if.hpp
│ │ │ │ │ │ │ ├── erase.hpp
│ │ │ │ │ │ │ ├── erase_key.hpp
│ │ │ │ │ │ │ ├── filter.hpp
│ │ │ │ │ │ │ ├── filter_if.hpp
│ │ │ │ │ │ │ ├── flatten.hpp
│ │ │ │ │ │ │ ├── insert.hpp
│ │ │ │ │ │ │ ├── insert_range.hpp
│ │ │ │ │ │ │ ├── join.hpp
│ │ │ │ │ │ │ ├── pop_back.hpp
│ │ │ │ │ │ │ ├── pop_front.hpp
│ │ │ │ │ │ │ ├── push_back.hpp
│ │ │ │ │ │ │ ├── push_front.hpp
│ │ │ │ │ │ │ ├── remove.hpp
│ │ │ │ │ │ │ ├── remove_if.hpp
│ │ │ │ │ │ │ ├── replace.hpp
│ │ │ │ │ │ │ ├── replace_if.hpp
│ │ │ │ │ │ │ ├── reverse.hpp
│ │ │ │ │ │ │ ├── transform.hpp
│ │ │ │ │ │ │ └── zip.hpp
│ │ │ │ │ │ └── transformation.hpp
│ │ │ │ │ ├── algorithm.hpp
│ │ │ │ │ ├── container/
│ │ │ │ │ │ ├── deque/
│ │ │ │ │ │ │ ├── back_extended_deque.hpp
│ │ │ │ │ │ │ ├── convert.hpp
│ │ │ │ │ │ │ ├── deque.hpp
│ │ │ │ │ │ │ ├── deque_fwd.hpp
│ │ │ │ │ │ │ ├── deque_iterator.hpp
│ │ │ │ │ │ │ ├── detail/
│ │ │ │ │ │ │ │ ├── at_impl.hpp
│ │ │ │ │ │ │ │ ├── begin_impl.hpp
│ │ │ │ │ │ │ │ ├── build_deque.hpp
│ │ │ │ │ │ │ │ ├── convert_impl.hpp
│ │ │ │ │ │ │ │ ├── cpp03/
│ │ │ │ │ │ │ │ │ ├── as_deque.hpp
│ │ │ │ │ │ │ │ │ ├── build_deque.hpp
│ │ │ │ │ │ │ │ │ ├── deque.hpp
│ │ │ │ │ │ │ │ │ ├── deque_forward_ctor.hpp
│ │ │ │ │ │ │ │ │ ├── deque_fwd.hpp
│ │ │ │ │ │ │ │ │ ├── deque_initial_size.hpp
│ │ │ │ │ │ │ │ │ ├── deque_keyed_values.hpp
│ │ │ │ │ │ │ │ │ ├── deque_keyed_values_call.hpp
│ │ │ │ │ │ │ │ │ ├── limits.hpp
│ │ │ │ │ │ │ │ │ └── preprocessed/
│ │ │ │ │ │ │ │ │ ├── as_deque.hpp
│ │ │ │ │ │ │ │ │ ├── as_deque10.hpp
│ │ │ │ │ │ │ │ │ ├── as_deque20.hpp
│ │ │ │ │ │ │ │ │ ├── as_deque30.hpp
│ │ │ │ │ │ │ │ │ ├── as_deque40.hpp
│ │ │ │ │ │ │ │ │ ├── as_deque50.hpp
│ │ │ │ │ │ │ │ │ ├── deque.hpp
│ │ │ │ │ │ │ │ │ ├── deque10.hpp
│ │ │ │ │ │ │ │ │ ├── deque10_fwd.hpp
│ │ │ │ │ │ │ │ │ ├── deque20.hpp
│ │ │ │ │ │ │ │ │ ├── deque20_fwd.hpp
│ │ │ │ │ │ │ │ │ ├── deque30.hpp
│ │ │ │ │ │ │ │ │ ├── deque30_fwd.hpp
│ │ │ │ │ │ │ │ │ ├── deque40.hpp
│ │ │ │ │ │ │ │ │ ├── deque40_fwd.hpp
│ │ │ │ │ │ │ │ │ ├── deque50.hpp
│ │ │ │ │ │ │ │ │ ├── deque50_fwd.hpp
│ │ │ │ │ │ │ │ │ ├── deque_fwd.hpp
│ │ │ │ │ │ │ │ │ ├── deque_initial_size.hpp
│ │ │ │ │ │ │ │ │ ├── deque_initial_size10.hpp
│ │ │ │ │ │ │ │ │ ├── deque_initial_size20.hpp
│ │ │ │ │ │ │ │ │ ├── deque_initial_size30.hpp
│ │ │ │ │ │ │ │ │ ├── deque_initial_size40.hpp
│ │ │ │ │ │ │ │ │ ├── deque_initial_size50.hpp
│ │ │ │ │ │ │ │ │ ├── deque_keyed_values.hpp
│ │ │ │ │ │ │ │ │ ├── deque_keyed_values10.hpp
│ │ │ │ │ │ │ │ │ ├── deque_keyed_values20.hpp
│ │ │ │ │ │ │ │ │ ├── deque_keyed_values30.hpp
│ │ │ │ │ │ │ │ │ ├── deque_keyed_values40.hpp
│ │ │ │ │ │ │ │ │ └── deque_keyed_values50.hpp
│ │ │ │ │ │ │ │ ├── deque_keyed_values.hpp
│ │ │ │ │ │ │ │ ├── end_impl.hpp
│ │ │ │ │ │ │ │ ├── is_sequence_impl.hpp
│ │ │ │ │ │ │ │ ├── keyed_element.hpp
│ │ │ │ │ │ │ │ └── value_at_impl.hpp
│ │ │ │ │ │ │ └── front_extended_deque.hpp
│ │ │ │ │ │ ├── deque.hpp
│ │ │ │ │ │ ├── generation/
│ │ │ │ │ │ │ ├── cons_tie.hpp
│ │ │ │ │ │ │ ├── deque_tie.hpp
│ │ │ │ │ │ │ ├── detail/
│ │ │ │ │ │ │ │ ├── pp_deque_tie.hpp
│ │ │ │ │ │ │ │ ├── pp_list_tie.hpp
│ │ │ │ │ │ │ │ ├── pp_make_deque.hpp
│ │ │ │ │ │ │ │ ├── pp_make_list.hpp
│ │ │ │ │ │ │ │ ├── pp_make_map.hpp
│ │ │ │ │ │ │ │ ├── pp_make_set.hpp
│ │ │ │ │ │ │ │ ├── pp_make_vector.hpp
│ │ │ │ │ │ │ │ ├── pp_map_tie.hpp
│ │ │ │ │ │ │ │ ├── pp_vector_tie.hpp
│ │ │ │ │ │ │ │ └── preprocessed/
│ │ │ │ │ │ │ │ ├── deque_tie.hpp
│ │ │ │ │ │ │ │ ├── deque_tie10.hpp
│ │ │ │ │ │ │ │ ├── deque_tie20.hpp
│ │ │ │ │ │ │ │ ├── deque_tie30.hpp
│ │ │ │ │ │ │ │ ├── deque_tie40.hpp
│ │ │ │ │ │ │ │ ├── deque_tie50.hpp
│ │ │ │ │ │ │ │ ├── list_tie.hpp
│ │ │ │ │ │ │ │ ├── list_tie10.hpp
│ │ │ │ │ │ │ │ ├── list_tie20.hpp
│ │ │ │ │ │ │ │ ├── list_tie30.hpp
│ │ │ │ │ │ │ │ ├── list_tie40.hpp
│ │ │ │ │ │ │ │ ├── list_tie50.hpp
│ │ │ │ │ │ │ │ ├── make_deque.hpp
│ │ │ │ │ │ │ │ ├── make_deque10.hpp
│ │ │ │ │ │ │ │ ├── make_deque20.hpp
│ │ │ │ │ │ │ │ ├── make_deque30.hpp
│ │ │ │ │ │ │ │ ├── make_deque40.hpp
│ │ │ │ │ │ │ │ ├── make_deque50.hpp
│ │ │ │ │ │ │ │ ├── make_list.hpp
│ │ │ │ │ │ │ │ ├── make_list10.hpp
│ │ │ │ │ │ │ │ ├── make_list20.hpp
│ │ │ │ │ │ │ │ ├── make_list30.hpp
│ │ │ │ │ │ │ │ ├── make_list40.hpp
│ │ │ │ │ │ │ │ ├── make_list50.hpp
│ │ │ │ │ │ │ │ ├── make_map.hpp
│ │ │ │ │ │ │ │ ├── make_map10.hpp
│ │ │ │ │ │ │ │ ├── make_map20.hpp
│ │ │ │ │ │ │ │ ├── make_map30.hpp
│ │ │ │ │ │ │ │ ├── make_map40.hpp
│ │ │ │ │ │ │ │ ├── make_map50.hpp
│ │ │ │ │ │ │ │ ├── make_set.hpp
│ │ │ │ │ │ │ │ ├── make_set10.hpp
│ │ │ │ │ │ │ │ ├── make_set20.hpp
│ │ │ │ │ │ │ │ ├── make_set30.hpp
│ │ │ │ │ │ │ │ ├── make_set40.hpp
│ │ │ │ │ │ │ │ ├── make_set50.hpp
│ │ │ │ │ │ │ │ ├── make_vector.hpp
│ │ │ │ │ │ │ │ ├── make_vector10.hpp
│ │ │ │ │ │ │ │ ├── make_vector20.hpp
│ │ │ │ │ │ │ │ ├── make_vector30.hpp
│ │ │ │ │ │ │ │ ├── make_vector40.hpp
│ │ │ │ │ │ │ │ ├── make_vector50.hpp
│ │ │ │ │ │ │ │ ├── map_tie.hpp
│ │ │ │ │ │ │ │ ├── map_tie10.hpp
│ │ │ │ │ │ │ │ ├── map_tie20.hpp
│ │ │ │ │ │ │ │ ├── map_tie30.hpp
│ │ │ │ │ │ │ │ ├── map_tie40.hpp
│ │ │ │ │ │ │ │ ├── map_tie50.hpp
│ │ │ │ │ │ │ │ ├── vector_tie.hpp
│ │ │ │ │ │ │ │ ├── vector_tie10.hpp
│ │ │ │ │ │ │ │ ├── vector_tie20.hpp
│ │ │ │ │ │ │ │ ├── vector_tie30.hpp
│ │ │ │ │ │ │ │ ├── vector_tie40.hpp
│ │ │ │ │ │ │ │ └── vector_tie50.hpp
│ │ │ │ │ │ │ ├── ignore.hpp
│ │ │ │ │ │ │ ├── list_tie.hpp
│ │ │ │ │ │ │ ├── make_cons.hpp
│ │ │ │ │ │ │ ├── make_deque.hpp
│ │ │ │ │ │ │ ├── make_list.hpp
│ │ │ │ │ │ │ ├── make_map.hpp
│ │ │ │ │ │ │ ├── make_set.hpp
│ │ │ │ │ │ │ ├── make_vector.hpp
│ │ │ │ │ │ │ ├── map_tie.hpp
│ │ │ │ │ │ │ ├── pair_tie.hpp
│ │ │ │ │ │ │ └── vector_tie.hpp
│ │ │ │ │ │ ├── generation.hpp
│ │ │ │ │ │ ├── list/
│ │ │ │ │ │ │ ├── cons.hpp
│ │ │ │ │ │ │ ├── cons_fwd.hpp
│ │ │ │ │ │ │ ├── cons_iterator.hpp
│ │ │ │ │ │ │ ├── convert.hpp
│ │ │ │ │ │ │ ├── detail/
│ │ │ │ │ │ │ │ ├── at_impl.hpp
│ │ │ │ │ │ │ │ ├── begin_impl.hpp
│ │ │ │ │ │ │ │ ├── build_cons.hpp
│ │ │ │ │ │ │ │ ├── convert_impl.hpp
│ │ │ │ │ │ │ │ ├── cpp03/
│ │ │ │ │ │ │ │ │ ├── limits.hpp
│ │ │ │ │ │ │ │ │ ├── list.hpp
│ │ │ │ │ │ │ │ │ ├── list_forward_ctor.hpp
│ │ │ │ │ │ │ │ │ ├── list_fwd.hpp
│ │ │ │ │ │ │ │ │ ├── list_to_cons.hpp
│ │ │ │ │ │ │ │ │ ├── list_to_cons_call.hpp
│ │ │ │ │ │ │ │ │ └── preprocessed/
│ │ │ │ │ │ │ │ │ ├── list.hpp
│ │ │ │ │ │ │ │ │ ├── list10.hpp
│ │ │ │ │ │ │ │ │ ├── list10_fwd.hpp
│ │ │ │ │ │ │ │ │ ├── list20.hpp
│ │ │ │ │ │ │ │ │ ├── list20_fwd.hpp
│ │ │ │ │ │ │ │ │ ├── list30.hpp
│ │ │ │ │ │ │ │ │ ├── list30_fwd.hpp
│ │ │ │ │ │ │ │ │ ├── list40.hpp
│ │ │ │ │ │ │ │ │ ├── list40_fwd.hpp
│ │ │ │ │ │ │ │ │ ├── list50.hpp
│ │ │ │ │ │ │ │ │ ├── list50_fwd.hpp
│ │ │ │ │ │ │ │ │ ├── list_fwd.hpp
│ │ │ │ │ │ │ │ │ ├── list_to_cons.hpp
│ │ │ │ │ │ │ │ │ ├── list_to_cons10.hpp
│ │ │ │ │ │ │ │ │ ├── list_to_cons20.hpp
│ │ │ │ │ │ │ │ │ ├── list_to_cons30.hpp
│ │ │ │ │ │ │ │ │ ├── list_to_cons40.hpp
│ │ │ │ │ │ │ │ │ └── list_to_cons50.hpp
│ │ │ │ │ │ │ │ ├── deref_impl.hpp
│ │ │ │ │ │ │ │ ├── empty_impl.hpp
│ │ │ │ │ │ │ │ ├── end_impl.hpp
│ │ │ │ │ │ │ │ ├── equal_to_impl.hpp
│ │ │ │ │ │ │ │ ├── list_to_cons.hpp
│ │ │ │ │ │ │ │ ├── next_impl.hpp
│ │ │ │ │ │ │ │ ├── reverse_cons.hpp
│ │ │ │ │ │ │ │ ├── value_at_impl.hpp
│ │ │ │ │ │ │ │ └── value_of_impl.hpp
│ │ │ │ │ │ │ ├── list.hpp
│ │ │ │ │ │ │ ├── list_fwd.hpp
│ │ │ │ │ │ │ └── nil.hpp
│ │ │ │ │ │ ├── list.hpp
│ │ │ │ │ │ ├── map/
│ │ │ │ │ │ │ ├── convert.hpp
│ │ │ │ │ │ │ ├── detail/
│ │ │ │ │ │ │ │ ├── at_impl.hpp
│ │ │ │ │ │ │ │ ├── at_key_impl.hpp
│ │ │ │ │ │ │ │ ├── begin_impl.hpp
│ │ │ │ │ │ │ │ ├── build_map.hpp
│ │ │ │ │ │ │ │ ├── cpp03/
│ │ │ │ │ │ │ │ │ ├── as_map.hpp
│ │ │ │ │ │ │ │ │ ├── at_impl.hpp
│ │ │ │ │ │ │ │ │ ├── begin_impl.hpp
│ │ │ │ │ │ │ │ │ ├── convert.hpp
│ │ │ │ │ │ │ │ │ ├── convert_impl.hpp
│ │ │ │ │ │ │ │ │ ├── deref_data_impl.hpp
│ │ │ │ │ │ │ │ │ ├── deref_impl.hpp
│ │ │ │ │ │ │ │ │ ├── end_impl.hpp
│ │ │ │ │ │ │ │ │ ├── key_of_impl.hpp
│ │ │ │ │ │ │ │ │ ├── limits.hpp
│ │ │ │ │ │ │ │ │ ├── map.hpp
│ │ │ │ │ │ │ │ │ ├── map_forward_ctor.hpp
│ │ │ │ │ │ │ │ │ ├── map_fwd.hpp
│ │ │ │ │ │ │ │ │ ├── preprocessed/
│ │ │ │ │ │ │ │ │ │ ├── as_map.hpp
│ │ │ │ │ │ │ │ │ │ ├── as_map10.hpp
│ │ │ │ │ │ │ │ │ │ ├── as_map20.hpp
│ │ │ │ │ │ │ │ │ │ ├── as_map30.hpp
│ │ │ │ │ │ │ │ │ │ ├── as_map40.hpp
│ │ │ │ │ │ │ │ │ │ ├── as_map50.hpp
│ │ │ │ │ │ │ │ │ │ ├── map.hpp
│ │ │ │ │ │ │ │ │ │ ├── map10.hpp
│ │ │ │ │ │ │ │ │ │ ├── map10_fwd.hpp
│ │ │ │ │ │ │ │ │ │ ├── map20.hpp
│ │ │ │ │ │ │ │ │ │ ├── map20_fwd.hpp
│ │ │ │ │ │ │ │ │ │ ├── map30.hpp
│ │ │ │ │ │ │ │ │ │ ├── map30_fwd.hpp
│ │ │ │ │ │ │ │ │ │ ├── map40.hpp
│ │ │ │ │ │ │ │ │ │ ├── map40_fwd.hpp
│ │ │ │ │ │ │ │ │ │ ├── map50.hpp
│ │ │ │ │ │ │ │ │ │ ├── map50_fwd.hpp
│ │ │ │ │ │ │ │ │ │ └── map_fwd.hpp
│ │ │ │ │ │ │ │ │ ├── value_at_impl.hpp
│ │ │ │ │ │ │ │ │ ├── value_of_data_impl.hpp
│ │ │ │ │ │ │ │ │ └── value_of_impl.hpp
│ │ │ │ │ │ │ │ ├── end_impl.hpp
│ │ │ │ │ │ │ │ ├── map_impl.hpp
│ │ │ │ │ │ │ │ ├── map_index.hpp
│ │ │ │ │ │ │ │ ├── value_at_impl.hpp
│ │ │ │ │ │ │ │ └── value_at_key_impl.hpp
│ │ │ │ │ │ │ ├── map.hpp
│ │ │ │ │ │ │ ├── map_fwd.hpp
│ │ │ │ │ │ │ └── map_iterator.hpp
│ │ │ │ │ │ ├── map.hpp
│ │ │ │ │ │ ├── set/
│ │ │ │ │ │ │ ├── convert.hpp
│ │ │ │ │ │ │ ├── detail/
│ │ │ │ │ │ │ │ ├── as_set.hpp
│ │ │ │ │ │ │ │ ├── begin_impl.hpp
│ │ │ │ │ │ │ │ ├── convert_impl.hpp
│ │ │ │ │ │ │ │ ├── cpp03/
│ │ │ │ │ │ │ │ │ ├── as_set.hpp
│ │ │ │ │ │ │ │ │ ├── limits.hpp
│ │ │ │ │ │ │ │ │ ├── preprocessed/
│ │ │ │ │ │ │ │ │ │ ├── as_set.hpp
│ │ │ │ │ │ │ │ │ │ ├── as_set10.hpp
│ │ │ │ │ │ │ │ │ │ ├── as_set20.hpp
│ │ │ │ │ │ │ │ │ │ ├── as_set30.hpp
│ │ │ │ │ │ │ │ │ │ ├── as_set40.hpp
│ │ │ │ │ │ │ │ │ │ ├── as_set50.hpp
│ │ │ │ │ │ │ │ │ │ ├── set.hpp
│ │ │ │ │ │ │ │ │ │ ├── set10.hpp
│ │ │ │ │ │ │ │ │ │ ├── set10_fwd.hpp
│ │ │ │ │ │ │ │ │ │ ├── set20.hpp
│ │ │ │ │ │ │ │ │ │ ├── set20_fwd.hpp
│ │ │ │ │ │ │ │ │ │ ├── set30.hpp
│ │ │ │ │ │ │ │ │ │ ├── set30_fwd.hpp
│ │ │ │ │ │ │ │ │ │ ├── set40.hpp
│ │ │ │ │ │ │ │ │ │ ├── set40_fwd.hpp
│ │ │ │ │ │ │ │ │ │ ├── set50.hpp
│ │ │ │ │ │ │ │ │ │ ├── set50_fwd.hpp
│ │ │ │ │ │ │ │ │ │ └── set_fwd.hpp
│ │ │ │ │ │ │ │ │ ├── set.hpp
│ │ │ │ │ │ │ │ │ ├── set_forward_ctor.hpp
│ │ │ │ │ │ │ │ │ └── set_fwd.hpp
│ │ │ │ │ │ │ │ ├── deref_data_impl.hpp
│ │ │ │ │ │ │ │ ├── deref_impl.hpp
│ │ │ │ │ │ │ │ ├── end_impl.hpp
│ │ │ │ │ │ │ │ ├── key_of_impl.hpp
│ │ │ │ │ │ │ │ ├── value_of_data_impl.hpp
│ │ │ │ │ │ │ │ └── value_of_impl.hpp
│ │ │ │ │ │ │ ├── set.hpp
│ │ │ │ │ │ │ └── set_fwd.hpp
│ │ │ │ │ │ ├── set.hpp
│ │ │ │ │ │ ├── vector/
│ │ │ │ │ │ │ ├── convert.hpp
│ │ │ │ │ │ │ ├── detail/
│ │ │ │ │ │ │ │ ├── advance_impl.hpp
│ │ │ │ │ │ │ │ ├── as_vector.hpp
│ │ │ │ │ │ │ │ ├── at_impl.hpp
│ │ │ │ │ │ │ │ ├── begin_impl.hpp
│ │ │ │ │ │ │ │ ├── config.hpp
│ │ │ │ │ │ │ │ ├── convert_impl.hpp
│ │ │ │ │ │ │ │ ├── cpp03/
│ │ │ │ │ │ │ │ │ ├── as_vector.hpp
│ │ │ │ │ │ │ │ │ ├── limits.hpp
│ │ │ │ │ │ │ │ │ ├── preprocessed/
│ │ │ │ │ │ │ │ │ │ ├── as_vector.hpp
│ │ │ │ │ │ │ │ │ │ ├── as_vector10.hpp
│ │ │ │ │ │ │ │ │ │ ├── as_vector20.hpp
│ │ │ │ │ │ │ │ │ │ ├── as_vector30.hpp
│ │ │ │ │ │ │ │ │ │ ├── as_vector40.hpp
│ │ │ │ │ │ │ │ │ │ ├── as_vector50.hpp
│ │ │ │ │ │ │ │ │ │ ├── vector.hpp
│ │ │ │ │ │ │ │ │ │ ├── vector10.hpp
│ │ │ │ │ │ │ │ │ │ ├── vector10_fwd.hpp
│ │ │ │ │ │ │ │ │ │ ├── vector20.hpp
│ │ │ │ │ │ │ │ │ │ ├── vector20_fwd.hpp
│ │ │ │ │ │ │ │ │ │ ├── vector30.hpp
│ │ │ │ │ │ │ │ │ │ ├── vector30_fwd.hpp
│ │ │ │ │ │ │ │ │ │ ├── vector40.hpp
│ │ │ │ │ │ │ │ │ │ ├── vector40_fwd.hpp
│ │ │ │ │ │ │ │ │ │ ├── vector50.hpp
│ │ │ │ │ │ │ │ │ │ ├── vector50_fwd.hpp
│ │ │ │ │ │ │ │ │ │ ├── vector_chooser.hpp
│ │ │ │ │ │ │ │ │ │ ├── vector_chooser10.hpp
│ │ │ │ │ │ │ │ │ │ ├── vector_chooser20.hpp
│ │ │ │ │ │ │ │ │ │ ├── vector_chooser30.hpp
│ │ │ │ │ │ │ │ │ │ ├── vector_chooser40.hpp
│ │ │ │ │ │ │ │ │ │ ├── vector_chooser50.hpp
│ │ │ │ │ │ │ │ │ │ ├── vector_fwd.hpp
│ │ │ │ │ │ │ │ │ │ ├── vvector10.hpp
│ │ │ │ │ │ │ │ │ │ ├── vvector10_fwd.hpp
│ │ │ │ │ │ │ │ │ │ ├── vvector20.hpp
│ │ │ │ │ │ │ │ │ │ ├── vvector20_fwd.hpp
│ │ │ │ │ │ │ │ │ │ ├── vvector30.hpp
│ │ │ │ │ │ │ │ │ │ ├── vvector30_fwd.hpp
│ │ │ │ │ │ │ │ │ │ ├── vvector40.hpp
│ │ │ │ │ │ │ │ │ │ ├── vvector40_fwd.hpp
│ │ │ │ │ │ │ │ │ │ ├── vvector50.hpp
│ │ │ │ │ │ │ │ │ │ └── vvector50_fwd.hpp
│ │ │ │ │ │ │ │ │ ├── value_at_impl.hpp
│ │ │ │ │ │ │ │ │ ├── vector.hpp
│ │ │ │ │ │ │ │ │ ├── vector10.hpp
│ │ │ │ │ │ │ │ │ ├── vector10_fwd.hpp
│ │ │ │ │ │ │ │ │ ├── vector20.hpp
│ │ │ │ │ │ │ │ │ ├── vector20_fwd.hpp
│ │ │ │ │ │ │ │ │ ├── vector30.hpp
│ │ │ │ │ │ │ │ │ ├── vector30_fwd.hpp
│ │ │ │ │ │ │ │ │ ├── vector40.hpp
│ │ │ │ │ │ │ │ │ ├── vector40_fwd.hpp
│ │ │ │ │ │ │ │ │ ├── vector50.hpp
│ │ │ │ │ │ │ │ │ ├── vector50_fwd.hpp
│ │ │ │ │ │ │ │ │ ├── vector_forward_ctor.hpp
│ │ │ │ │ │ │ │ │ ├── vector_fwd.hpp
│ │ │ │ │ │ │ │ │ ├── vector_n.hpp
│ │ │ │ │ │ │ │ │ └── vector_n_chooser.hpp
│ │ │ │ │ │ │ │ ├── deref_impl.hpp
│ │ │ │ │ │ │ │ ├── distance_impl.hpp
│ │ │ │ │ │ │ │ ├── end_impl.hpp
│ │ │ │ │ │ │ │ ├── equal_to_impl.hpp
│ │ │ │ │ │ │ │ ├── next_impl.hpp
│ │ │ │ │ │ │ │ ├── prior_impl.hpp
│ │ │ │ │ │ │ │ ├── value_at_impl.hpp
│ │ │ │ │ │ │ │ └── value_of_impl.hpp
│ │ │ │ │ │ │ ├── vector.hpp
│ │ │ │ │ │ │ ├── vector10.hpp
│ │ │ │ │ │ │ ├── vector20.hpp
│ │ │ │ │ │ │ ├── vector30.hpp
│ │ │ │ │ │ │ ├── vector40.hpp
│ │ │ │ │ │ │ ├── vector50.hpp
│ │ │ │ │ │ │ ├── vector_fwd.hpp
│ │ │ │ │ │ │ └── vector_iterator.hpp
│ │ │ │ │ │ └── vector.hpp
│ │ │ │ │ ├── container.hpp
│ │ │ │ │ ├── functional/
│ │ │ │ │ │ ├── adapter/
│ │ │ │ │ │ │ ├── detail/
│ │ │ │ │ │ │ │ └── access.hpp
│ │ │ │ │ │ │ ├── fused.hpp
│ │ │ │ │ │ │ ├── fused_function_object.hpp
│ │ │ │ │ │ │ ├── fused_procedure.hpp
│ │ │ │ │ │ │ ├── limits.hpp
│ │ │ │ │ │ │ ├── unfused.hpp
│ │ │ │ │ │ │ └── unfused_typed.hpp
│ │ │ │ │ │ ├── adapter.hpp
│ │ │ │ │ │ ├── generation/
│ │ │ │ │ │ │ ├── detail/
│ │ │ │ │ │ │ │ └── gen_make_adapter.hpp
│ │ │ │ │ │ │ ├── make_fused.hpp
│ │ │ │ │ │ │ ├── make_fused_function_object.hpp
│ │ │ │ │ │ │ ├── make_fused_procedure.hpp
│ │ │ │ │ │ │ └── make_unfused.hpp
│ │ │ │ │ │ ├── generation.hpp
│ │ │ │ │ │ ├── invocation/
│ │ │ │ │ │ │ ├── detail/
│ │ │ │ │ │ │ │ └── that_ptr.hpp
│ │ │ │ │ │ │ ├── invoke.hpp
│ │ │ │ │ │ │ ├── invoke_function_object.hpp
│ │ │ │ │ │ │ ├── invoke_procedure.hpp
│ │ │ │ │ │ │ └── limits.hpp
│ │ │ │ │ │ └── invocation.hpp
│ │ │ │ │ ├── functional.hpp
│ │ │ │ │ ├── include/
│ │ │ │ │ │ ├── accumulate.hpp
│ │ │ │ │ │ ├── adapt_adt.hpp
│ │ │ │ │ │ ├── adapt_adt_named.cpp
│ │ │ │ │ │ ├── adapt_adt_named.hpp
│ │ │ │ │ │ ├── adapt_assoc_adt.hpp
│ │ │ │ │ │ ├── adapt_assoc_adt_named.hpp
│ │ │ │ │ │ ├── adapt_assoc_struct.hpp
│ │ │ │ │ │ ├── adapt_assoc_struct_named.hpp
│ │ │ │ │ │ ├── adapt_struct.hpp
│ │ │ │ │ │ ├── adapt_struct_named.hpp
│ │ │ │ │ │ ├── adapted.hpp
│ │ │ │ │ │ ├── adapter.hpp
│ │ │ │ │ │ ├── advance.hpp
│ │ │ │ │ │ ├── algorithm.hpp
│ │ │ │ │ │ ├── all.hpp
│ │ │ │ │ │ ├── any.hpp
│ │ │ │ │ │ ├── array.hpp
│ │ │ │ │ │ ├── as_deque.hpp
│ │ │ │ │ │ ├── as_list.hpp
│ │ │ │ │ │ ├── as_map.hpp
│ │ │ │ │ │ ├── as_set.hpp
│ │ │ │ │ │ ├── as_vector.hpp
│ │ │ │ │ │ ├── at.hpp
│ │ │ │ │ │ ├── at_c.hpp
│ │ │ │ │ │ ├── at_key.hpp
│ │ │ │ │ │ ├── auxiliary.hpp
│ │ │ │ │ │ ├── back.hpp
│ │ │ │ │ │ ├── begin.hpp
│ │ │ │ │ │ ├── boost_array.hpp
│ │ │ │ │ │ ├── boost_tuple.hpp
│ │ │ │ │ │ ├── category_of.hpp
│ │ │ │ │ │ ├── clear.hpp
│ │ │ │ │ │ ├── comparison.hpp
│ │ │ │ │ │ ├── cons.hpp
│ │ │ │ │ │ ├── cons_tie.hpp
│ │ │ │ │ │ ├── container.hpp
│ │ │ │ │ │ ├── convert.hpp
│ │ │ │ │ │ ├── copy.hpp
│ │ │ │ │ │ ├── count.hpp
│ │ │ │ │ │ ├── count_if.hpp
│ │ │ │ │ │ ├── deduce.hpp
│ │ │ │ │ │ ├── deduce_sequence.hpp
│ │ │ │ │ │ ├── define_assoc_struct.hpp
│ │ │ │ │ │ ├── define_struct.hpp
│ │ │ │ │ │ ├── define_struct_inline.hpp
│ │ │ │ │ │ ├── deque.hpp
│ │ │ │ │ │ ├── deque_fwd.hpp
│ │ │ │ │ │ ├── deque_tie.hpp
│ │ │ │ │ │ ├── deref.hpp
│ │ │ │ │ │ ├── deref_data.hpp
│ │ │ │ │ │ ├── distance.hpp
│ │ │ │ │ │ ├── empty.hpp
│ │ │ │ │ │ ├── end.hpp
│ │ │ │ │ │ ├── equal_to.hpp
│ │ │ │ │ │ ├── erase.hpp
│ │ │ │ │ │ ├── erase_key.hpp
│ │ │ │ │ │ ├── filter.hpp
│ │ │ │ │ │ ├── filter_if.hpp
│ │ │ │ │ │ ├── filter_view.hpp
│ │ │ │ │ │ ├── find.hpp
│ │ │ │ │ │ ├── find_if.hpp
│ │ │ │ │ │ ├── flatten.hpp
│ │ │ │ │ │ ├── flatten_view.hpp
│ │ │ │ │ │ ├── fold.hpp
│ │ │ │ │ │ ├── for_each.hpp
│ │ │ │ │ │ ├── front.hpp
│ │ │ │ │ │ ├── functional.hpp
│ │ │ │ │ │ ├── fused.hpp
│ │ │ │ │ │ ├── fused_function_object.hpp
│ │ │ │ │ │ ├── fused_procedure.hpp
│ │ │ │ │ │ ├── generation.hpp
│ │ │ │ │ │ ├── greater.hpp
│ │ │ │ │ │ ├── greater_equal.hpp
│ │ │ │ │ │ ├── has_key.hpp
│ │ │ │ │ │ ├── hash.hpp
│ │ │ │ │ │ ├── ignore.hpp
│ │ │ │ │ │ ├── in.hpp
│ │ │ │ │ │ ├── insert.hpp
│ │ │ │ │ │ ├── insert_range.hpp
│ │ │ │ │ │ ├── intrinsic.hpp
│ │ │ │ │ │ ├── invocation.hpp
│ │ │ │ │ │ ├── invoke.hpp
│ │ │ │ │ │ ├── invoke_function_object.hpp
│ │ │ │ │ │ ├── invoke_procedure.hpp
│ │ │ │ │ │ ├── io.hpp
│ │ │ │ │ │ ├── is_iterator.hpp
│ │ │ │ │ │ ├── is_segmented.hpp
│ │ │ │ │ │ ├── is_sequence.hpp
│ │ │ │ │ │ ├── is_view.hpp
│ │ │ │ │ │ ├── iter_fold.hpp
│ │ │ │ │ │ ├── iteration.hpp
│ │ │ │ │ │ ├── iterator.hpp
│ │ │ │ │ │ ├── iterator_adapter.hpp
│ │ │ │ │ │ ├── iterator_base.hpp
│ │ │ │ │ │ ├── iterator_facade.hpp
│ │ │ │ │ │ ├── iterator_range.hpp
│ │ │ │ │ │ ├── join.hpp
│ │ │ │ │ │ ├── joint_view.hpp
│ │ │ │ │ │ ├── key_of.hpp
│ │ │ │ │ │ ├── less.hpp
│ │ │ │ │ │ ├── less_equal.hpp
│ │ │ │ │ │ ├── list.hpp
│ │ │ │ │ │ ├── list_fwd.hpp
│ │ │ │ │ │ ├── list_tie.hpp
│ │ │ │ │ │ ├── make_cons.hpp
│ │ │ │ │ │ ├── make_deque.hpp
│ │ │ │ │ │ ├── make_fused.hpp
│ │ │ │ │ │ ├── make_fused_function_object.hpp
│ │ │ │ │ │ ├── make_fused_procedure.hpp
│ │ │ │ │ │ ├── make_list.hpp
│ │ │ │ │ │ ├── make_map.hpp
│ │ │ │ │ │ ├── make_set.hpp
│ │ │ │ │ │ ├── make_tuple.hpp
│ │ │ │ │ │ ├── make_unfused.hpp
│ │ │ │ │ │ ├── make_vector.hpp
│ │ │ │ │ │ ├── map.hpp
│ │ │ │ │ │ ├── map_fwd.hpp
│ │ │ │ │ │ ├── map_tie.hpp
│ │ │ │ │ │ ├── move.hpp
│ │ │ │ │ │ ├── mpl.hpp
│ │ │ │ │ │ ├── next.hpp
│ │ │ │ │ │ ├── nil.hpp
│ │ │ │ │ │ ├── none.hpp
│ │ │ │ │ │ ├── not_equal_to.hpp
│ │ │ │ │ │ ├── nview.hpp
│ │ │ │ │ │ ├── out.hpp
│ │ │ │ │ │ ├── pair.hpp
│ │ │ │ │ │ ├── pair_tie.hpp
│ │ │ │ │ │ ├── pop_back.hpp
│ │ │ │ │ │ ├── pop_front.hpp
│ │ │ │ │ │ ├── prior.hpp
│ │ │ │ │ │ ├── proxy_type.hpp
│ │ │ │ │ │ ├── push_back.hpp
│ │ │ │ │ │ ├── push_front.hpp
│ │ │ │ │ │ ├── query.hpp
│ │ │ │ │ │ ├── remove.hpp
│ │ │ │ │ │ ├── remove_if.hpp
│ │ │ │ │ │ ├── repetitive_view.hpp
│ │ │ │ │ │ ├── replace.hpp
│ │ │ │ │ │ ├── replace_if.hpp
│ │ │ │ │ │ ├── reverse.hpp
│ │ │ │ │ │ ├── reverse_fold.hpp
│ │ │ │ │ │ ├── reverse_iter_fold.hpp
│ │ │ │ │ │ ├── reverse_view.hpp
│ │ │ │ │ │ ├── segmented_fold_until.hpp
│ │ │ │ │ │ ├── segmented_iterator.hpp
│ │ │ │ │ │ ├── segments.hpp
│ │ │ │ │ │ ├── sequence.hpp
│ │ │ │ │ │ ├── sequence_base.hpp
│ │ │ │ │ │ ├── sequence_facade.hpp
│ │ │ │ │ │ ├── set.hpp
│ │ │ │ │ │ ├── set_fwd.hpp
│ │ │ │ │ │ ├── single_view.hpp
│ │ │ │ │ │ ├── size.hpp
│ │ │ │ │ │ ├── std_pair.hpp
│ │ │ │ │ │ ├── std_tuple.hpp
│ │ │ │ │ │ ├── struct.hpp
│ │ │ │ │ │ ├── support.hpp
│ │ │ │ │ │ ├── swap.hpp
│ │ │ │ │ │ ├── tag_of.hpp
│ │ │ │ │ │ ├── tag_of_fwd.hpp
│ │ │ │ │ │ ├── transform.hpp
│ │ │ │ │ │ ├── transform_view.hpp
│ │ │ │ │ │ ├── transformation.hpp
│ │ │ │ │ │ ├── tuple.hpp
│ │ │ │ │ │ ├── tuple_fwd.hpp
│ │ │ │ │ │ ├── tuple_tie.hpp
│ │ │ │ │ │ ├── unfused.hpp
│ │ │ │ │ │ ├── unfused_typed.hpp
│ │ │ │ │ │ ├── unused.hpp
│ │ │ │ │ │ ├── value_at.hpp
│ │ │ │ │ │ ├── value_at_key.hpp
│ │ │ │ │ │ ├── value_of.hpp
│ │ │ │ │ │ ├── value_of_data.hpp
│ │ │ │ │ │ ├── vector.hpp
│ │ │ │ │ │ ├── vector10.hpp
│ │ │ │ │ │ ├── vector20.hpp
│ │ │ │ │ │ ├── vector30.hpp
│ │ │ │ │ │ ├── vector40.hpp
│ │ │ │ │ │ ├── vector50.hpp
│ │ │ │ │ │ ├── vector_fwd.hpp
│ │ │ │ │ │ ├── vector_tie.hpp
│ │ │ │ │ │ ├── view.hpp
│ │ │ │ │ │ ├── void.hpp
│ │ │ │ │ │ ├── zip.hpp
│ │ │ │ │ │ └── zip_view.hpp
│ │ │ │ │ ├── iterator/
│ │ │ │ │ │ ├── advance.hpp
│ │ │ │ │ │ ├── basic_iterator.hpp
│ │ │ │ │ │ ├── deref.hpp
│ │ │ │ │ │ ├── deref_data.hpp
│ │ │ │ │ │ ├── detail/
│ │ │ │ │ │ │ ├── adapt_deref_traits.hpp
│ │ │ │ │ │ │ ├── adapt_value_traits.hpp
│ │ │ │ │ │ │ ├── advance.hpp
│ │ │ │ │ │ │ ├── distance.hpp
│ │ │ │ │ │ │ ├── segment_sequence.hpp
│ │ │ │ │ │ │ ├── segmented_equal_to.hpp
│ │ │ │ │ │ │ ├── segmented_iterator.hpp
│ │ │ │ │ │ │ └── segmented_next_impl.hpp
│ │ │ │ │ │ ├── distance.hpp
│ │ │ │ │ │ ├── equal_to.hpp
│ │ │ │ │ │ ├── iterator_adapter.hpp
│ │ │ │ │ │ ├── iterator_facade.hpp
│ │ │ │ │ │ ├── key_of.hpp
│ │ │ │ │ │ ├── mpl/
│ │ │ │ │ │ │ ├── convert_iterator.hpp
│ │ │ │ │ │ │ └── fusion_iterator.hpp
│ │ │ │ │ │ ├── mpl.hpp
│ │ │ │ │ │ ├── next.hpp
│ │ │ │ │ │ ├── prior.hpp
│ │ │ │ │ │ ├── segmented_iterator.hpp
│ │ │ │ │ │ ├── value_of.hpp
│ │ │ │ │ │ └── value_of_data.hpp
│ │ │ │ │ ├── iterator.hpp
│ │ │ │ │ ├── mpl/
│ │ │ │ │ │ ├── at.hpp
│ │ │ │ │ │ ├── back.hpp
│ │ │ │ │ │ ├── begin.hpp
│ │ │ │ │ │ ├── clear.hpp
│ │ │ │ │ │ ├── detail/
│ │ │ │ │ │ │ └── clear.hpp
│ │ │ │ │ │ ├── empty.hpp
│ │ │ │ │ │ ├── end.hpp
│ │ │ │ │ │ ├── erase.hpp
│ │ │ │ │ │ ├── erase_key.hpp
│ │ │ │ │ │ ├── front.hpp
│ │ │ │ │ │ ├── has_key.hpp
│ │ │ │ │ │ ├── insert.hpp
│ │ │ │ │ │ ├── insert_range.hpp
│ │ │ │ │ │ ├── pop_back.hpp
│ │ │ │ │ │ ├── pop_front.hpp
│ │ │ │ │ │ ├── push_back.hpp
│ │ │ │ │ │ ├── push_front.hpp
│ │ │ │ │ │ └── size.hpp
│ │ │ │ │ ├── mpl.hpp
│ │ │ │ │ ├── sequence/
│ │ │ │ │ │ ├── comparison/
│ │ │ │ │ │ │ ├── detail/
│ │ │ │ │ │ │ │ ├── equal_to.hpp
│ │ │ │ │ │ │ │ ├── greater.hpp
│ │ │ │ │ │ │ │ ├── greater_equal.hpp
│ │ │ │ │ │ │ │ ├── less.hpp
│ │ │ │ │ │ │ │ ├── less_equal.hpp
│ │ │ │ │ │ │ │ └── not_equal_to.hpp
│ │ │ │ │ │ │ ├── enable_comparison.hpp
│ │ │ │ │ │ │ ├── equal_to.hpp
│ │ │ │ │ │ │ ├── greater.hpp
│ │ │ │ │ │ │ ├── greater_equal.hpp
│ │ │ │ │ │ │ ├── less.hpp
│ │ │ │ │ │ │ ├── less_equal.hpp
│ │ │ │ │ │ │ └── not_equal_to.hpp
│ │ │ │ │ │ ├── comparison.hpp
│ │ │ │ │ │ ├── convert.hpp
│ │ │ │ │ │ ├── hash.hpp
│ │ │ │ │ │ ├── intrinsic/
│ │ │ │ │ │ │ ├── at.hpp
│ │ │ │ │ │ │ ├── at_c.hpp
│ │ │ │ │ │ │ ├── at_key.hpp
│ │ │ │ │ │ │ ├── back.hpp
│ │ │ │ │ │ │ ├── begin.hpp
│ │ │ │ │ │ │ ├── detail/
│ │ │ │ │ │ │ │ ├── segmented_begin.hpp
│ │ │ │ │ │ │ │ ├── segmented_begin_impl.hpp
│ │ │ │ │ │ │ │ ├── segmented_end.hpp
│ │ │ │ │ │ │ │ ├── segmented_end_impl.hpp
│ │ │ │ │ │ │ │ └── segmented_size.hpp
│ │ │ │ │ │ │ ├── empty.hpp
│ │ │ │ │ │ │ ├── end.hpp
│ │ │ │ │ │ │ ├── front.hpp
│ │ │ │ │ │ │ ├── has_key.hpp
│ │ │ │ │ │ │ ├── segments.hpp
│ │ │ │ │ │ │ ├── size.hpp
│ │ │ │ │ │ │ ├── swap.hpp
│ │ │ │ │ │ │ ├── value_at.hpp
│ │ │ │ │ │ │ └── value_at_key.hpp
│ │ │ │ │ │ ├── intrinsic.hpp
│ │ │ │ │ │ ├── intrinsic_fwd.hpp
│ │ │ │ │ │ ├── io/
│ │ │ │ │ │ │ ├── detail/
│ │ │ │ │ │ │ │ ├── in.hpp
│ │ │ │ │ │ │ │ ├── manip.hpp
│ │ │ │ │ │ │ │ └── out.hpp
│ │ │ │ │ │ │ ├── in.hpp
│ │ │ │ │ │ │ └── out.hpp
│ │ │ │ │ │ ├── io.hpp
│ │ │ │ │ │ └── sequence_facade.hpp
│ │ │ │ │ ├── sequence.hpp
│ │ │ │ │ ├── support/
│ │ │ │ │ │ ├── as_const.hpp
│ │ │ │ │ │ ├── category_of.hpp
│ │ │ │ │ │ ├── config.hpp
│ │ │ │ │ │ ├── deduce.hpp
│ │ │ │ │ │ ├── deduce_sequence.hpp
│ │ │ │ │ │ ├── detail/
│ │ │ │ │ │ │ ├── access.hpp
│ │ │ │ │ │ │ ├── and.hpp
│ │ │ │ │ │ │ ├── as_fusion_element.hpp
│ │ │ │ │ │ │ ├── category_of.hpp
│ │ │ │ │ │ │ ├── enabler.hpp
│ │ │ │ │ │ │ ├── index_sequence.hpp
│ │ │ │ │ │ │ ├── is_mpl_sequence.hpp
│ │ │ │ │ │ │ ├── is_same_size.hpp
│ │ │ │ │ │ │ ├── is_view.hpp
│ │ │ │ │ │ │ ├── mpl_iterator_category.hpp
│ │ │ │ │ │ │ ├── pp_round.hpp
│ │ │ │ │ │ │ ├── segmented_fold_until_impl.hpp
│ │ │ │ │ │ │ └── unknown_key.hpp
│ │ │ │ │ │ ├── is_iterator.hpp
│ │ │ │ │ │ ├── is_segmented.hpp
│ │ │ │ │ │ ├── is_sequence.hpp
│ │ │ │ │ │ ├── is_view.hpp
│ │ │ │ │ │ ├── iterator_base.hpp
│ │ │ │ │ │ ├── pair.hpp
│ │ │ │ │ │ ├── segmented_fold_until.hpp
│ │ │ │ │ │ ├── sequence_base.hpp
│ │ │ │ │ │ ├── tag_of.hpp
│ │ │ │ │ │ ├── tag_of_fwd.hpp
│ │ │ │ │ │ ├── unused.hpp
│ │ │ │ │ │ └── void.hpp
│ │ │ │ │ ├── support.hpp
│ │ │ │ │ ├── tuple/
│ │ │ │ │ │ ├── detail/
│ │ │ │ │ │ │ ├── make_tuple.hpp
│ │ │ │ │ │ │ ├── preprocessed/
│ │ │ │ │ │ │ │ ├── make_tuple.hpp
│ │ │ │ │ │ │ │ ├── make_tuple10.hpp
│ │ │ │ │ │ │ │ ├── make_tuple20.hpp
│ │ │ │ │ │ │ │ ├── make_tuple30.hpp
│ │ │ │ │ │ │ │ ├── make_tuple40.hpp
│ │ │ │ │ │ │ │ ├── make_tuple50.hpp
│ │ │ │ │ │ │ │ ├── tuple.hpp
│ │ │ │ │ │ │ │ ├── tuple10.hpp
│ │ │ │ │ │ │ │ ├── tuple10_fwd.hpp
│ │ │ │ │ │ │ │ ├── tuple20.hpp
│ │ │ │ │ │ │ │ ├── tuple20_fwd.hpp
│ │ │ │ │ │ │ │ ├── tuple30.hpp
│ │ │ │ │ │ │ │ ├── tuple30_fwd.hpp
│ │ │ │ │ │ │ │ ├── tuple40.hpp
│ │ │ │ │ │ │ │ ├── tuple40_fwd.hpp
│ │ │ │ │ │ │ │ ├── tuple50.hpp
│ │ │ │ │ │ │ │ ├── tuple50_fwd.hpp
│ │ │ │ │ │ │ │ ├── tuple_fwd.hpp
│ │ │ │ │ │ │ │ ├── tuple_tie.hpp
│ │ │ │ │ │ │ │ ├── tuple_tie10.hpp
│ │ │ │ │ │ │ │ ├── tuple_tie20.hpp
│ │ │ │ │ │ │ │ ├── tuple_tie30.hpp
│ │ │ │ │ │ │ │ ├── tuple_tie40.hpp
│ │ │ │ │ │ │ │ └── tuple_tie50.hpp
│ │ │ │ │ │ │ ├── tuple.hpp
│ │ │ │ │ │ │ ├── tuple_expand.hpp
│ │ │ │ │ │ │ ├── tuple_fwd.hpp
│ │ │ │ │ │ │ └── tuple_tie.hpp
│ │ │ │ │ │ ├── make_tuple.hpp
│ │ │ │ │ │ ├── tuple.hpp
│ │ │ │ │ │ ├── tuple_fwd.hpp
│ │ │ │ │ │ └── tuple_tie.hpp
│ │ │ │ │ ├── tuple.hpp
│ │ │ │ │ ├── view/
│ │ │ │ │ │ ├── detail/
│ │ │ │ │ │ │ └── strictest_traversal.hpp
│ │ │ │ │ │ ├── filter_view/
│ │ │ │ │ │ │ ├── detail/
│ │ │ │ │ │ │ │ ├── begin_impl.hpp
│ │ │ │ │ │ │ │ ├── deref_data_impl.hpp
│ │ │ │ │ │ │ │ ├── deref_impl.hpp
│ │ │ │ │ │ │ │ ├── end_impl.hpp
│ │ │ │ │ │ │ │ ├── equal_to_impl.hpp
│ │ │ │ │ │ │ │ ├── key_of_impl.hpp
│ │ │ │ │ │ │ │ ├── next_impl.hpp
│ │ │ │ │ │ │ │ ├── size_impl.hpp
│ │ │ │ │ │ │ │ ├── value_of_data_impl.hpp
│ │ │ │ │ │ │ │ └── value_of_impl.hpp
│ │ │ │ │ │ │ ├── filter_view.hpp
│ │ │ │ │ │ │ └── filter_view_iterator.hpp
│ │ │ │ │ │ ├── filter_view.hpp
│ │ │ │ │ │ ├── flatten_view/
│ │ │ │ │ │ │ ├── flatten_view.hpp
│ │ │ │ │ │ │ └── flatten_view_iterator.hpp
│ │ │ │ │ │ ├── flatten_view.hpp
│ │ │ │ │ │ ├── iterator_range/
│ │ │ │ │ │ │ ├── detail/
│ │ │ │ │ │ │ │ ├── at_impl.hpp
│ │ │ │ │ │ │ │ ├── begin_impl.hpp
│ │ │ │ │ │ │ │ ├── end_impl.hpp
│ │ │ │ │ │ │ │ ├── is_segmented_impl.hpp
│ │ │ │ │ │ │ │ ├── segmented_iterator_range.hpp
│ │ │ │ │ │ │ │ ├── segments_impl.hpp
│ │ │ │ │ │ │ │ ├── size_impl.hpp
│ │ │ │ │ │ │ │ └── value_at_impl.hpp
│ │ │ │ │ │ │ └── iterator_range.hpp
│ │ │ │ │ │ ├── iterator_range.hpp
│ │ │ │ │ │ ├── joint_view/
│ │ │ │ │ │ │ ├── detail/
│ │ │ │ │ │ │ │ ├── begin_impl.hpp
│ │ │ │ │ │ │ │ ├── deref_data_impl.hpp
│ │ │ │ │ │ │ │ ├── deref_impl.hpp
│ │ │ │ │ │ │ │ ├── end_impl.hpp
│ │ │ │ │ │ │ │ ├── key_of_impl.hpp
│ │ │ │ │ │ │ │ ├── next_impl.hpp
│ │ │ │ │ │ │ │ ├── value_of_data_impl.hpp
│ │ │ │ │ │ │ │ └── value_of_impl.hpp
│ │ │ │ │ │ │ ├── joint_view.hpp
│ │ │ │ │ │ │ ├── joint_view_fwd.hpp
│ │ │ │ │ │ │ └── joint_view_iterator.hpp
│ │ │ │ │ │ ├── joint_view.hpp
│ │ │ │ │ │ ├── nview/
│ │ │ │ │ │ │ ├── detail/
│ │ │ │ │ │ │ │ ├── advance_impl.hpp
│ │ │ │ │ │ │ │ ├── at_impl.hpp
│ │ │ │ │ │ │ │ ├── begin_impl.hpp
│ │ │ │ │ │ │ │ ├── cpp03/
│ │ │ │ │ │ │ │ │ └── nview_impl.hpp
│ │ │ │ │ │ │ │ ├── deref_impl.hpp
│ │ │ │ │ │ │ │ ├── distance_impl.hpp
│ │ │ │ │ │ │ │ ├── end_impl.hpp
│ │ │ │ │ │ │ │ ├── equal_to_impl.hpp
│ │ │ │ │ │ │ │ ├── next_impl.hpp
│ │ │ │ │ │ │ │ ├── nview_impl.hpp
│ │ │ │ │ │ │ │ ├── prior_impl.hpp
│ │ │ │ │ │ │ │ ├── size_impl.hpp
│ │ │ │ │ │ │ │ ├── value_at_impl.hpp
│ │ │ │ │ │ │ │ └── value_of_impl.hpp
│ │ │ │ │ │ │ ├── nview.hpp
│ │ │ │ │ │ │ └── nview_iterator.hpp
│ │ │ │ │ │ ├── nview.hpp
│ │ │ │ │ │ ├── repetitive_view/
│ │ │ │ │ │ │ ├── detail/
│ │ │ │ │ │ │ │ ├── begin_impl.hpp
│ │ │ │ │ │ │ │ ├── deref_impl.hpp
│ │ │ │ │ │ │ │ ├── end_impl.hpp
│ │ │ │ │ │ │ │ ├── next_impl.hpp
│ │ │ │ │ │ │ │ └── value_of_impl.hpp
│ │ │ │ │ │ │ ├── repetitive_view.hpp
│ │ │ │ │ │ │ ├── repetitive_view_fwd.hpp
│ │ │ │ │ │ │ └── repetitive_view_iterator.hpp
│ │ │ │ │ │ ├── repetitive_view.hpp
│ │ │ │ │ │ ├── reverse_view/
│ │ │ │ │ │ │ ├── detail/
│ │ │ │ │ │ │ │ ├── advance_impl.hpp
│ │ │ │ │ │ │ │ ├── at_impl.hpp
│ │ │ │ │ │ │ │ ├── begin_impl.hpp
│ │ │ │ │ │ │ │ ├── deref_data_impl.hpp
│ │ │ │ │ │ │ │ ├── deref_impl.hpp
│ │ │ │ │ │ │ │ ├── distance_impl.hpp
│ │ │ │ │ │ │ │ ├── end_impl.hpp
│ │ │ │ │ │ │ │ ├── key_of_impl.hpp
│ │ │ │ │ │ │ │ ├── next_impl.hpp
│ │ │ │ │ │ │ │ ├── prior_impl.hpp
│ │ │ │ │ │ │ │ ├── value_at_impl.hpp
│ │ │ │ │ │ │ │ ├── value_of_data_impl.hpp
│ │ │ │ │ │ │ │ └── value_of_impl.hpp
│ │ │ │ │ │ │ ├── reverse_view.hpp
│ │ │ │ │ │ │ └── reverse_view_iterator.hpp
│ │ │ │ │ │ ├── reverse_view.hpp
│ │ │ │ │ │ ├── single_view/
│ │ │ │ │ │ │ ├── detail/
│ │ │ │ │ │ │ │ ├── advance_impl.hpp
│ │ │ │ │ │ │ │ ├── at_impl.hpp
│ │ │ │ │ │ │ │ ├── begin_impl.hpp
│ │ │ │ │ │ │ │ ├── deref_impl.hpp
│ │ │ │ │ │ │ │ ├── distance_impl.hpp
│ │ │ │ │ │ │ │ ├── end_impl.hpp
│ │ │ │ │ │ │ │ ├── equal_to_impl.hpp
│ │ │ │ │ │ │ │ ├── next_impl.hpp
│ │ │ │ │ │ │ │ ├── prior_impl.hpp
│ │ │ │ │ │ │ │ ├── size_impl.hpp
│ │ │ │ │ │ │ │ ├── value_at_impl.hpp
│ │ │ │ │ │ │ │ └── value_of_impl.hpp
│ │ │ │ │ │ │ ├── single_view.hpp
│ │ │ │ │ │ │ └── single_view_iterator.hpp
│ │ │ │ │ │ ├── single_view.hpp
│ │ │ │ │ │ ├── transform_view/
│ │ │ │ │ │ │ ├── detail/
│ │ │ │ │ │ │ │ ├── advance_impl.hpp
│ │ │ │ │ │ │ │ ├── apply_transform_result.hpp
│ │ │ │ │ │ │ │ ├── at_impl.hpp
│ │ │ │ │ │ │ │ ├── begin_impl.hpp
│ │ │ │ │ │ │ │ ├── deref_impl.hpp
│ │ │ │ │ │ │ │ ├── distance_impl.hpp
│ │ │ │ │ │ │ │ ├── end_impl.hpp
│ │ │ │ │ │ │ │ ├── equal_to_impl.hpp
│ │ │ │ │ │ │ │ ├── next_impl.hpp
│ │ │ │ │ │ │ │ ├── prior_impl.hpp
│ │ │ │ │ │ │ │ ├── value_at_impl.hpp
│ │ │ │ │ │ │ │ └── value_of_impl.hpp
│ │ │ │ │ │ │ ├── transform_view.hpp
│ │ │ │ │ │ │ ├── transform_view_fwd.hpp
│ │ │ │ │ │ │ └── transform_view_iterator.hpp
│ │ │ │ │ │ ├── transform_view.hpp
│ │ │ │ │ │ ├── zip_view/
│ │ │ │ │ │ │ ├── detail/
│ │ │ │ │ │ │ │ ├── advance_impl.hpp
│ │ │ │ │ │ │ │ ├── at_impl.hpp
│ │ │ │ │ │ │ │ ├── begin_impl.hpp
│ │ │ │ │ │ │ │ ├── deref_impl.hpp
│ │ │ │ │ │ │ │ ├── distance_impl.hpp
│ │ │ │ │ │ │ │ ├── end_impl.hpp
│ │ │ │ │ │ │ │ ├── equal_to_impl.hpp
│ │ │ │ │ │ │ │ ├── next_impl.hpp
│ │ │ │ │ │ │ │ ├── prior_impl.hpp
│ │ │ │ │ │ │ │ ├── size_impl.hpp
│ │ │ │ │ │ │ │ ├── value_at_impl.hpp
│ │ │ │ │ │ │ │ └── value_of_impl.hpp
│ │ │ │ │ │ │ ├── zip_view.hpp
│ │ │ │ │ │ │ ├── zip_view_iterator.hpp
│ │ │ │ │ │ │ └── zip_view_iterator_fwd.hpp
│ │ │ │ │ │ └── zip_view.hpp
│ │ │ │ │ └── view.hpp
│ │ │ │ ├── generator_iterator.hpp
│ │ │ │ ├── geometry/
│ │ │ │ │ ├── algorithms/
│ │ │ │ │ │ ├── append.hpp
│ │ │ │ │ │ ├── area.hpp
│ │ │ │ │ │ ├── assign.hpp
│ │ │ │ │ │ ├── buffer.hpp
│ │ │ │ │ │ ├── centroid.hpp
│ │ │ │ │ │ ├── clear.hpp
│ │ │ │ │ │ ├── comparable_distance.hpp
│ │ │ │ │ │ ├── convert.hpp
│ │ │ │ │ │ ├── convex_hull.hpp
│ │ │ │ │ │ ├── correct.hpp
│ │ │ │ │ │ ├── covered_by.hpp
│ │ │ │ │ │ ├── crosses.hpp
│ │ │ │ │ │ ├── detail/
│ │ │ │ │ │ │ ├── as_range.hpp
│ │ │ │ │ │ │ ├── assign_box_corners.hpp
│ │ │ │ │ │ │ ├── assign_indexed_point.hpp
│ │ │ │ │ │ │ ├── assign_values.hpp
│ │ │ │ │ │ │ ├── azimuth.hpp
│ │ │ │ │ │ │ ├── buffer/
│ │ │ │ │ │ │ │ ├── buffer_inserter.hpp
│ │ │ │ │ │ │ │ ├── buffer_policies.hpp
│ │ │ │ │ │ │ │ ├── buffered_piece_collection.hpp
│ │ │ │ │ │ │ │ ├── buffered_ring.hpp
│ │ │ │ │ │ │ │ ├── get_piece_turns.hpp
│ │ │ │ │ │ │ │ ├── line_line_intersection.hpp
│ │ │ │ │ │ │ │ ├── parallel_continue.hpp
│ │ │ │ │ │ │ │ ├── turn_in_original_visitor.hpp
│ │ │ │ │ │ │ │ └── turn_in_piece_visitor.hpp
│ │ │ │ │ │ │ ├── calculate_null.hpp
│ │ │ │ │ │ │ ├── calculate_sum.hpp
│ │ │ │ │ │ │ ├── centroid/
│ │ │ │ │ │ │ │ └── translating_transformer.hpp
│ │ │ │ │ │ │ ├── check_iterator_range.hpp
│ │ │ │ │ │ │ ├── closest_feature/
│ │ │ │ │ │ │ │ ├── geometry_to_range.hpp
│ │ │ │ │ │ │ │ ├── point_to_range.hpp
│ │ │ │ │ │ │ │ └── range_to_range.hpp
│ │ │ │ │ │ │ ├── comparable_distance/
│ │ │ │ │ │ │ │ ├── implementation.hpp
│ │ │ │ │ │ │ │ └── interface.hpp
│ │ │ │ │ │ │ ├── convert_indexed_to_indexed.hpp
│ │ │ │ │ │ │ ├── convert_point_to_point.hpp
│ │ │ │ │ │ │ ├── counting.hpp
│ │ │ │ │ │ │ ├── course.hpp
│ │ │ │ │ │ │ ├── direction_code.hpp
│ │ │ │ │ │ │ ├── disjoint/
│ │ │ │ │ │ │ │ ├── areal_areal.hpp
│ │ │ │ │ │ │ │ ├── box_box.hpp
│ │ │ │ │ │ │ │ ├── implementation.hpp
│ │ │ │ │ │ │ │ ├── interface.hpp
│ │ │ │ │ │ │ │ ├── linear_areal.hpp
│ │ │ │ │ │ │ │ ├── linear_linear.hpp
│ │ │ │ │ │ │ │ ├── linear_segment_or_box.hpp
│ │ │ │ │ │ │ │ ├── multipoint_geometry.hpp
│ │ │ │ │ │ │ │ ├── multirange_geometry.hpp
│ │ │ │ │ │ │ │ ├── point_box.hpp
│ │ │ │ │ │ │ │ ├── point_geometry.hpp
│ │ │ │ │ │ │ │ ├── point_point.hpp
│ │ │ │ │ │ │ │ └── segment_box.hpp
│ │ │ │ │ │ │ ├── distance/
│ │ │ │ │ │ │ │ ├── backward_compatibility.hpp
│ │ │ │ │ │ │ │ ├── box_to_box.hpp
│ │ │ │ │ │ │ │ ├── default_strategies.hpp
│ │ │ │ │ │ │ │ ├── geometry_to_segment_or_box.hpp
│ │ │ │ │ │ │ │ ├── implementation.hpp
│ │ │ │ │ │ │ │ ├── interface.hpp
│ │ │ │ │ │ │ │ ├── is_comparable.hpp
│ │ │ │ │ │ │ │ ├── iterator_selector.hpp
│ │ │ │ │ │ │ │ ├── linear_or_areal_to_areal.hpp
│ │ │ │ │ │ │ │ ├── linear_to_linear.hpp
│ │ │ │ │ │ │ │ ├── multipoint_to_geometry.hpp
│ │ │ │ │ │ │ │ ├── point_to_geometry.hpp
│ │ │ │ │ │ │ │ ├── range_to_geometry_rtree.hpp
│ │ │ │ │ │ │ │ ├── segment_to_box.hpp
│ │ │ │ │ │ │ │ └── segment_to_segment.hpp
│ │ │ │ │ │ │ ├── envelope/
│ │ │ │ │ │ │ │ ├── box.hpp
│ │ │ │ │ │ │ │ ├── implementation.hpp
│ │ │ │ │ │ │ │ ├── initialize.hpp
│ │ │ │ │ │ │ │ ├── interface.hpp
│ │ │ │ │ │ │ │ ├── intersects_antimeridian.hpp
│ │ │ │ │ │ │ │ ├── linear.hpp
│ │ │ │ │ │ │ │ ├── multipoint.hpp
│ │ │ │ │ │ │ │ ├── point.hpp
│ │ │ │ │ │ │ │ ├── range.hpp
│ │ │ │ │ │ │ │ ├── range_of_boxes.hpp
│ │ │ │ │ │ │ │ ├── segment.hpp
│ │ │ │ │ │ │ │ └── transform_units.hpp
│ │ │ │ │ │ │ ├── equals/
│ │ │ │ │ │ │ │ ├── collect_vectors.hpp
│ │ │ │ │ │ │ │ └── point_point.hpp
│ │ │ │ │ │ │ ├── expand/
│ │ │ │ │ │ │ │ ├── box.hpp
│ │ │ │ │ │ │ │ ├── implementation.hpp
│ │ │ │ │ │ │ │ ├── indexed.hpp
│ │ │ │ │ │ │ │ ├── interface.hpp
│ │ │ │ │ │ │ │ ├── point.hpp
│ │ │ │ │ │ │ │ └── segment.hpp
│ │ │ │ │ │ │ ├── expand_by_epsilon.hpp
│ │ │ │ │ │ │ ├── extreme_points.hpp
│ │ │ │ │ │ │ ├── for_each_range.hpp
│ │ │ │ │ │ │ ├── get_left_turns.hpp
│ │ │ │ │ │ │ ├── get_max_size.hpp
│ │ │ │ │ │ │ ├── has_self_intersections.hpp
│ │ │ │ │ │ │ ├── interior_iterator.hpp
│ │ │ │ │ │ │ ├── intersection/
│ │ │ │ │ │ │ │ ├── box_box.hpp
│ │ │ │ │ │ │ │ ├── implementation.hpp
│ │ │ │ │ │ │ │ ├── interface.hpp
│ │ │ │ │ │ │ │ └── multi.hpp
│ │ │ │ │ │ │ ├── is_simple/
│ │ │ │ │ │ │ │ ├── always_simple.hpp
│ │ │ │ │ │ │ │ ├── areal.hpp
│ │ │ │ │ │ │ │ ├── debug_print_boundary_points.hpp
│ │ │ │ │ │ │ │ ├── failure_policy.hpp
│ │ │ │ │ │ │ │ ├── implementation.hpp
│ │ │ │ │ │ │ │ ├── interface.hpp
│ │ │ │ │ │ │ │ ├── linear.hpp
│ │ │ │ │ │ │ │ └── multipoint.hpp
│ │ │ │ │ │ │ ├── is_valid/
│ │ │ │ │ │ │ │ ├── box.hpp
│ │ │ │ │ │ │ │ ├── complement_graph.hpp
│ │ │ │ │ │ │ │ ├── debug_complement_graph.hpp
│ │ │ │ │ │ │ │ ├── debug_print_turns.hpp
│ │ │ │ │ │ │ │ ├── debug_validity_phase.hpp
│ │ │ │ │ │ │ │ ├── has_duplicates.hpp
│ │ │ │ │ │ │ │ ├── has_invalid_coordinate.hpp
│ │ │ │ │ │ │ │ ├── has_spikes.hpp
│ │ │ │ │ │ │ │ ├── has_valid_self_turns.hpp
│ │ │ │ │ │ │ │ ├── implementation.hpp
│ │ │ │ │ │ │ │ ├── interface.hpp
│ │ │ │ │ │ │ │ ├── is_acceptable_turn.hpp
│ │ │ │ │ │ │ │ ├── linear.hpp
│ │ │ │ │ │ │ │ ├── multipolygon.hpp
│ │ │ │ │ │ │ │ ├── pointlike.hpp
│ │ │ │ │ │ │ │ ├── polygon.hpp
│ │ │ │ │ │ │ │ ├── ring.hpp
│ │ │ │ │ │ │ │ └── segment.hpp
│ │ │ │ │ │ │ ├── max_interval_gap.hpp
│ │ │ │ │ │ │ ├── multi_modify.hpp
│ │ │ │ │ │ │ ├── multi_modify_with_predicate.hpp
│ │ │ │ │ │ │ ├── multi_sum.hpp
│ │ │ │ │ │ │ ├── normalize.hpp
│ │ │ │ │ │ │ ├── not.hpp
│ │ │ │ │ │ │ ├── num_distinct_consecutive_points.hpp
│ │ │ │ │ │ │ ├── occupation_info.hpp
│ │ │ │ │ │ │ ├── overlay/
│ │ │ │ │ │ │ │ ├── add_rings.hpp
│ │ │ │ │ │ │ │ ├── aggregate_operations.hpp
│ │ │ │ │ │ │ │ ├── append_no_duplicates.hpp
│ │ │ │ │ │ │ │ ├── append_no_dups_or_spikes.hpp
│ │ │ │ │ │ │ │ ├── assign_parents.hpp
│ │ │ │ │ │ │ │ ├── backtrack_check_si.hpp
│ │ │ │ │ │ │ │ ├── check_enrich.hpp
│ │ │ │ │ │ │ │ ├── clip_linestring.hpp
│ │ │ │ │ │ │ │ ├── cluster_info.hpp
│ │ │ │ │ │ │ │ ├── convert_ring.hpp
│ │ │ │ │ │ │ │ ├── copy_segment_point.hpp
│ │ │ │ │ │ │ │ ├── copy_segments.hpp
│ │ │ │ │ │ │ │ ├── debug_turn_info.hpp
│ │ │ │ │ │ │ │ ├── do_reverse.hpp
│ │ │ │ │ │ │ │ ├── enrich_intersection_points.hpp
│ │ │ │ │ │ │ │ ├── enrichment_info.hpp
│ │ │ │ │ │ │ │ ├── follow.hpp
│ │ │ │ │ │ │ │ ├── follow_linear_linear.hpp
│ │ │ │ │ │ │ │ ├── get_intersection_points.hpp
│ │ │ │ │ │ │ │ ├── get_relative_order.hpp
│ │ │ │ │ │ │ │ ├── get_ring.hpp
│ │ │ │ │ │ │ │ ├── get_turn_info.hpp
│ │ │ │ │ │ │ │ ├── get_turn_info_for_endpoint.hpp
│ │ │ │ │ │ │ │ ├── get_turn_info_helpers.hpp
│ │ │ │ │ │ │ │ ├── get_turn_info_la.hpp
│ │ │ │ │ │ │ │ ├── get_turn_info_ll.hpp
│ │ │ │ │ │ │ │ ├── get_turns.hpp
│ │ │ │ │ │ │ │ ├── handle_colocations.hpp
│ │ │ │ │ │ │ │ ├── inconsistent_turns_exception.hpp
│ │ │ │ │ │ │ │ ├── intersection_box_box.hpp
│ │ │ │ │ │ │ │ ├── intersection_insert.hpp
│ │ │ │ │ │ │ │ ├── less_by_segment_ratio.hpp
│ │ │ │ │ │ │ │ ├── linear_linear.hpp
│ │ │ │ │ │ │ │ ├── overlay.hpp
│ │ │ │ │ │ │ │ ├── overlay_type.hpp
│ │ │ │ │ │ │ │ ├── pointlike_linear.hpp
│ │ │ │ │ │ │ │ ├── pointlike_pointlike.hpp
│ │ │ │ │ │ │ │ ├── ring_properties.hpp
│ │ │ │ │ │ │ │ ├── segment_identifier.hpp
│ │ │ │ │ │ │ │ ├── select_rings.hpp
│ │ │ │ │ │ │ │ ├── self_turn_points.hpp
│ │ │ │ │ │ │ │ ├── sort_by_side.hpp
│ │ │ │ │ │ │ │ ├── stream_info.hpp
│ │ │ │ │ │ │ │ ├── traversal.hpp
│ │ │ │ │ │ │ │ ├── traversal_info.hpp
│ │ │ │ │ │ │ │ ├── traversal_ring_creator.hpp
│ │ │ │ │ │ │ │ ├── traversal_switch_detector.hpp
│ │ │ │ │ │ │ │ ├── traverse.hpp
│ │ │ │ │ │ │ │ ├── turn_info.hpp
│ │ │ │ │ │ │ │ └── visit_info.hpp
│ │ │ │ │ │ │ ├── partition.hpp
│ │ │ │ │ │ │ ├── point_is_spike_or_equal.hpp
│ │ │ │ │ │ │ ├── point_on_border.hpp
│ │ │ │ │ │ │ ├── recalculate.hpp
│ │ │ │ │ │ │ ├── relate/
│ │ │ │ │ │ │ │ ├── areal_areal.hpp
│ │ │ │ │ │ │ │ ├── boundary_checker.hpp
│ │ │ │ │ │ │ │ ├── de9im.hpp
│ │ │ │ │ │ │ │ ├── follow_helpers.hpp
│ │ │ │ │ │ │ │ ├── implementation.hpp
│ │ │ │ │ │ │ │ ├── interface.hpp
│ │ │ │ │ │ │ │ ├── less.hpp
│ │ │ │ │ │ │ │ ├── linear_areal.hpp
│ │ │ │ │ │ │ │ ├── linear_linear.hpp
│ │ │ │ │ │ │ │ ├── point_geometry.hpp
│ │ │ │ │ │ │ │ ├── point_point.hpp
│ │ │ │ │ │ │ │ ├── relate_impl.hpp
│ │ │ │ │ │ │ │ ├── result.hpp
│ │ │ │ │ │ │ │ ├── topology_check.hpp
│ │ │ │ │ │ │ │ └── turns.hpp
│ │ │ │ │ │ │ ├── relation/
│ │ │ │ │ │ │ │ ├── implementation.hpp
│ │ │ │ │ │ │ │ └── interface.hpp
│ │ │ │ │ │ │ ├── ring_identifier.hpp
│ │ │ │ │ │ │ ├── sections/
│ │ │ │ │ │ │ │ ├── range_by_section.hpp
│ │ │ │ │ │ │ │ ├── section_box_policies.hpp
│ │ │ │ │ │ │ │ ├── section_functions.hpp
│ │ │ │ │ │ │ │ └── sectionalize.hpp
│ │ │ │ │ │ │ ├── signed_size_type.hpp
│ │ │ │ │ │ │ ├── single_geometry.hpp
│ │ │ │ │ │ │ ├── sub_range.hpp
│ │ │ │ │ │ │ ├── sweep.hpp
│ │ │ │ │ │ │ ├── throw_on_empty_input.hpp
│ │ │ │ │ │ │ ├── turns/
│ │ │ │ │ │ │ │ ├── compare_turns.hpp
│ │ │ │ │ │ │ │ ├── debug_turn.hpp
│ │ │ │ │ │ │ │ ├── filter_continue_turns.hpp
│ │ │ │ │ │ │ │ ├── print_turns.hpp
│ │ │ │ │ │ │ │ └── remove_duplicate_turns.hpp
│ │ │ │ │ │ │ └── within/
│ │ │ │ │ │ │ ├── point_in_geometry.hpp
│ │ │ │ │ │ │ └── within_no_turns.hpp
│ │ │ │ │ │ ├── difference.hpp
│ │ │ │ │ │ ├── disjoint.hpp
│ │ │ │ │ │ ├── dispatch/
│ │ │ │ │ │ │ ├── disjoint.hpp
│ │ │ │ │ │ │ ├── distance.hpp
│ │ │ │ │ │ │ ├── envelope.hpp
│ │ │ │ │ │ │ ├── expand.hpp
│ │ │ │ │ │ │ ├── is_simple.hpp
│ │ │ │ │ │ │ └── is_valid.hpp
│ │ │ │ │ │ ├── distance.hpp
│ │ │ │ │ │ ├── envelope.hpp
│ │ │ │ │ │ ├── equals.hpp
│ │ │ │ │ │ ├── expand.hpp
│ │ │ │ │ │ ├── for_each.hpp
│ │ │ │ │ │ ├── intersection.hpp
│ │ │ │ │ │ ├── intersects.hpp
│ │ │ │ │ │ ├── is_convex.hpp
│ │ │ │ │ │ ├── is_empty.hpp
│ │ │ │ │ │ ├── is_simple.hpp
│ │ │ │ │ │ ├── is_valid.hpp
│ │ │ │ │ │ ├── length.hpp
│ │ │ │ │ │ ├── make.hpp
│ │ │ │ │ │ ├── not_implemented.hpp
│ │ │ │ │ │ ├── num_geometries.hpp
│ │ │ │ │ │ ├── num_interior_rings.hpp
│ │ │ │ │ │ ├── num_points.hpp
│ │ │ │ │ │ ├── num_segments.hpp
│ │ │ │ │ │ ├── overlaps.hpp
│ │ │ │ │ │ ├── perimeter.hpp
│ │ │ │ │ │ ├── point_on_surface.hpp
│ │ │ │ │ │ ├── relate.hpp
│ │ │ │ │ │ ├── relation.hpp
│ │ │ │ │ │ ├── remove_spikes.hpp
│ │ │ │ │ │ ├── reverse.hpp
│ │ │ │ │ │ ├── simplify.hpp
│ │ │ │ │ │ ├── sym_difference.hpp
│ │ │ │ │ │ ├── touches.hpp
│ │ │ │ │ │ ├── transform.hpp
│ │ │ │ │ │ ├── union.hpp
│ │ │ │ │ │ ├── unique.hpp
│ │ │ │ │ │ ├── validity_failure_type.hpp
│ │ │ │ │ │ └── within.hpp
│ │ │ │ │ ├── arithmetic/
│ │ │ │ │ │ ├── arithmetic.hpp
│ │ │ │ │ │ ├── cross_product.hpp
│ │ │ │ │ │ ├── determinant.hpp
│ │ │ │ │ │ ├── dot_product.hpp
│ │ │ │ │ │ └── normalize.hpp
│ │ │ │ │ ├── core/
│ │ │ │ │ │ ├── access.hpp
│ │ │ │ │ │ ├── assert.hpp
│ │ │ │ │ │ ├── closure.hpp
│ │ │ │ │ │ ├── coordinate_dimension.hpp
│ │ │ │ │ │ ├── coordinate_system.hpp
│ │ │ │ │ │ ├── coordinate_type.hpp
│ │ │ │ │ │ ├── cs.hpp
│ │ │ │ │ │ ├── exception.hpp
│ │ │ │ │ │ ├── exterior_ring.hpp
│ │ │ │ │ │ ├── geometry_id.hpp
│ │ │ │ │ │ ├── interior_rings.hpp
│ │ │ │ │ │ ├── interior_type.hpp
│ │ │ │ │ │ ├── is_areal.hpp
│ │ │ │ │ │ ├── mutable_range.hpp
│ │ │ │ │ │ ├── point_order.hpp
│ │ │ │ │ │ ├── point_type.hpp
│ │ │ │ │ │ ├── radian_access.hpp
│ │ │ │ │ │ ├── radius.hpp
│ │ │ │ │ │ ├── reverse_dispatch.hpp
│ │ │ │ │ │ ├── ring_type.hpp
│ │ │ │ │ │ ├── srs.hpp
│ │ │ │ │ │ ├── tag.hpp
│ │ │ │ │ │ ├── tag_cast.hpp
│ │ │ │ │ │ ├── tags.hpp
│ │ │ │ │ │ └── topological_dimension.hpp
│ │ │ │ │ ├── formulas/
│ │ │ │ │ │ ├── andoyer_inverse.hpp
│ │ │ │ │ │ ├── area_formulas.hpp
│ │ │ │ │ │ ├── differential_quantities.hpp
│ │ │ │ │ │ ├── eccentricity_sqr.hpp
│ │ │ │ │ │ ├── flattening.hpp
│ │ │ │ │ │ ├── geographic.hpp
│ │ │ │ │ │ ├── gnomonic_intersection.hpp
│ │ │ │ │ │ ├── gnomonic_spheroid.hpp
│ │ │ │ │ │ ├── result_direct.hpp
│ │ │ │ │ │ ├── result_inverse.hpp
│ │ │ │ │ │ ├── sjoberg_intersection.hpp
│ │ │ │ │ │ ├── spherical.hpp
│ │ │ │ │ │ ├── thomas_direct.hpp
│ │ │ │ │ │ ├── thomas_inverse.hpp
│ │ │ │ │ │ ├── vertex_latitude.hpp
│ │ │ │ │ │ ├── vincenty_direct.hpp
│ │ │ │ │ │ └── vincenty_inverse.hpp
│ │ │ │ │ ├── geometries/
│ │ │ │ │ │ ├── adapted/
│ │ │ │ │ │ │ ├── boost_array.hpp
│ │ │ │ │ │ │ ├── boost_fusion.hpp
│ │ │ │ │ │ │ ├── boost_polygon/
│ │ │ │ │ │ │ │ ├── box.hpp
│ │ │ │ │ │ │ │ ├── hole_iterator.hpp
│ │ │ │ │ │ │ │ ├── holes_proxy.hpp
│ │ │ │ │ │ │ │ ├── point.hpp
│ │ │ │ │ │ │ │ ├── polygon.hpp
│ │ │ │ │ │ │ │ ├── ring.hpp
│ │ │ │ │ │ │ │ └── ring_proxy.hpp
│ │ │ │ │ │ │ ├── boost_polygon.hpp
│ │ │ │ │ │ │ ├── boost_range/
│ │ │ │ │ │ │ │ ├── adjacent_filtered.hpp
│ │ │ │ │ │ │ │ ├── filtered.hpp
│ │ │ │ │ │ │ │ ├── reversed.hpp
│ │ │ │ │ │ │ │ ├── sliced.hpp
│ │ │ │ │ │ │ │ ├── strided.hpp
│ │ │ │ │ │ │ │ └── uniqued.hpp
│ │ │ │ │ │ │ ├── boost_tuple.hpp
│ │ │ │ │ │ │ ├── c_array.hpp
│ │ │ │ │ │ │ ├── std_array.hpp
│ │ │ │ │ │ │ └── std_pair_as_segment.hpp
│ │ │ │ │ │ ├── box.hpp
│ │ │ │ │ │ ├── concepts/
│ │ │ │ │ │ │ ├── box_concept.hpp
│ │ │ │ │ │ │ ├── check.hpp
│ │ │ │ │ │ │ ├── linestring_concept.hpp
│ │ │ │ │ │ │ ├── multi_linestring_concept.hpp
│ │ │ │ │ │ │ ├── multi_point_concept.hpp
│ │ │ │ │ │ │ ├── multi_polygon_concept.hpp
│ │ │ │ │ │ │ ├── point_concept.hpp
│ │ │ │ │ │ │ ├── polygon_concept.hpp
│ │ │ │ │ │ │ ├── ring_concept.hpp
│ │ │ │ │ │ │ └── segment_concept.hpp
│ │ │ │ │ │ ├── geometries.hpp
│ │ │ │ │ │ ├── helper_geometry.hpp
│ │ │ │ │ │ ├── linestring.hpp
│ │ │ │ │ │ ├── multi_linestring.hpp
│ │ │ │ │ │ ├── multi_point.hpp
│ │ │ │ │ │ ├── multi_polygon.hpp
│ │ │ │ │ │ ├── point.hpp
│ │ │ │ │ │ ├── point_xy.hpp
│ │ │ │ │ │ ├── pointing_segment.hpp
│ │ │ │ │ │ ├── polygon.hpp
│ │ │ │ │ │ ├── register/
│ │ │ │ │ │ │ ├── box.hpp
│ │ │ │ │ │ │ ├── linestring.hpp
│ │ │ │ │ │ │ ├── multi_linestring.hpp
│ │ │ │ │ │ │ ├── multi_point.hpp
│ │ │ │ │ │ │ ├── multi_polygon.hpp
│ │ │ │ │ │ │ ├── point.hpp
│ │ │ │ │ │ │ ├── ring.hpp
│ │ │ │ │ │ │ └── segment.hpp
│ │ │ │ │ │ ├── ring.hpp
│ │ │ │ │ │ ├── segment.hpp
│ │ │ │ │ │ └── variant.hpp
│ │ │ │ │ ├── geometry.hpp
│ │ │ │ │ ├── index/
│ │ │ │ │ │ ├── adaptors/
│ │ │ │ │ │ │ └── query.hpp
│ │ │ │ │ │ ├── detail/
│ │ │ │ │ │ │ ├── algorithms/
│ │ │ │ │ │ │ │ ├── bounds.hpp
│ │ │ │ │ │ │ │ ├── comparable_distance_centroid.hpp
│ │ │ │ │ │ │ │ ├── comparable_distance_far.hpp
│ │ │ │ │ │ │ │ ├── comparable_distance_near.hpp
│ │ │ │ │ │ │ │ ├── content.hpp
│ │ │ │ │ │ │ │ ├── diff_abs.hpp
│ │ │ │ │ │ │ │ ├── intersection_content.hpp
│ │ │ │ │ │ │ │ ├── is_valid.hpp
│ │ │ │ │ │ │ │ ├── margin.hpp
│ │ │ │ │ │ │ │ ├── minmaxdist.hpp
│ │ │ │ │ │ │ │ ├── nth_element.hpp
│ │ │ │ │ │ │ │ ├── path_intersection.hpp
│ │ │ │ │ │ │ │ ├── segment_intersection.hpp
│ │ │ │ │ │ │ │ ├── smallest_for_indexable.hpp
│ │ │ │ │ │ │ │ ├── sum_for_indexable.hpp
│ │ │ │ │ │ │ │ └── union_content.hpp
│ │ │ │ │ │ │ ├── assert.hpp
│ │ │ │ │ │ │ ├── bounded_view.hpp
│ │ │ │ │ │ │ ├── config_begin.hpp
│ │ │ │ │ │ │ ├── config_end.hpp
│ │ │ │ │ │ │ ├── distance_predicates.hpp
│ │ │ │ │ │ │ ├── exception.hpp
│ │ │ │ │ │ │ ├── is_bounding_geometry.hpp
│ │ │ │ │ │ │ ├── is_indexable.hpp
│ │ │ │ │ │ │ ├── meta.hpp
│ │ │ │ │ │ │ ├── predicates.hpp
│ │ │ │ │ │ │ ├── rtree/
│ │ │ │ │ │ │ │ ├── adaptors.hpp
│ │ │ │ │ │ │ │ ├── iterators.hpp
│ │ │ │ │ │ │ │ ├── kmeans/
│ │ │ │ │ │ │ │ │ ├── kmeans.hpp
│ │ │ │ │ │ │ │ │ └── split.hpp
│ │ │ │ │ │ │ │ ├── linear/
│ │ │ │ │ │ │ │ │ ├── linear.hpp
│ │ │ │ │ │ │ │ │ └── redistribute_elements.hpp
│ │ │ │ │ │ │ │ ├── node/
│ │ │ │ │ │ │ │ │ ├── concept.hpp
│ │ │ │ │ │ │ │ │ ├── node.hpp
│ │ │ │ │ │ │ │ │ ├── node_elements.hpp
│ │ │ │ │ │ │ │ │ ├── pairs.hpp
│ │ │ │ │ │ │ │ │ ├── scoped_deallocator.hpp
│ │ │ │ │ │ │ │ │ ├── subtree_destroyer.hpp
│ │ │ │ │ │ │ │ │ ├── variant_dynamic.hpp
│ │ │ │ │ │ │ │ │ ├── variant_static.hpp
│ │ │ │ │ │ │ │ │ ├── variant_visitor.hpp
│ │ │ │ │ │ │ │ │ ├── weak_dynamic.hpp
│ │ │ │ │ │ │ │ │ ├── weak_static.hpp
│ │ │ │ │ │ │ │ │ └── weak_visitor.hpp
│ │ │ │ │ │ │ │ ├── options.hpp
│ │ │ │ │ │ │ │ ├── pack_create.hpp
│ │ │ │ │ │ │ │ ├── quadratic/
│ │ │ │ │ │ │ │ │ ├── quadratic.hpp
│ │ │ │ │ │ │ │ │ └── redistribute_elements.hpp
│ │ │ │ │ │ │ │ ├── query_iterators.hpp
│ │ │ │ │ │ │ │ ├── rstar/
│ │ │ │ │ │ │ │ │ ├── choose_next_node.hpp
│ │ │ │ │ │ │ │ │ ├── insert.hpp
│ │ │ │ │ │ │ │ │ ├── redistribute_elements.hpp
│ │ │ │ │ │ │ │ │ └── rstar.hpp
│ │ │ │ │ │ │ │ ├── utilities/
│ │ │ │ │ │ │ │ │ ├── are_boxes_ok.hpp
│ │ │ │ │ │ │ │ │ ├── are_counts_ok.hpp
│ │ │ │ │ │ │ │ │ ├── are_levels_ok.hpp
│ │ │ │ │ │ │ │ │ ├── gl_draw.hpp
│ │ │ │ │ │ │ │ │ ├── print.hpp
│ │ │ │ │ │ │ │ │ ├── statistics.hpp
│ │ │ │ │ │ │ │ │ └── view.hpp
│ │ │ │ │ │ │ │ └── visitors/
│ │ │ │ │ │ │ │ ├── children_box.hpp
│ │ │ │ │ │ │ │ ├── copy.hpp
│ │ │ │ │ │ │ │ ├── count.hpp
│ │ │ │ │ │ │ │ ├── destroy.hpp
│ │ │ │ │ │ │ │ ├── distance_query.hpp
│ │ │ │ │ │ │ │ ├── insert.hpp
│ │ │ │ │ │ │ │ ├── is_leaf.hpp
│ │ │ │ │ │ │ │ ├── iterator.hpp
│ │ │ │ │ │ │ │ ├── remove.hpp
│ │ │ │ │ │ │ │ └── spatial_query.hpp
│ │ │ │ │ │ │ ├── serialization.hpp
│ │ │ │ │ │ │ ├── tags.hpp
│ │ │ │ │ │ │ ├── translator.hpp
│ │ │ │ │ │ │ ├── tuples.hpp
│ │ │ │ │ │ │ ├── utilities.hpp
│ │ │ │ │ │ │ ├── varray.hpp
│ │ │ │ │ │ │ └── varray_detail.hpp
│ │ │ │ │ │ ├── distance_predicates.hpp
│ │ │ │ │ │ ├── equal_to.hpp
│ │ │ │ │ │ ├── indexable.hpp
│ │ │ │ │ │ ├── inserter.hpp
│ │ │ │ │ │ ├── parameters.hpp
│ │ │ │ │ │ ├── predicates.hpp
│ │ │ │ │ │ └── rtree.hpp
│ │ │ │ │ ├── io/
│ │ │ │ │ │ ├── dsv/
│ │ │ │ │ │ │ └── write.hpp
│ │ │ │ │ │ ├── io.hpp
│ │ │ │ │ │ ├── svg/
│ │ │ │ │ │ │ ├── svg_mapper.hpp
│ │ │ │ │ │ │ ├── write.hpp
│ │ │ │ │ │ │ ├── write_svg.hpp
│ │ │ │ │ │ │ └── write_svg_multi.hpp
│ │ │ │ │ │ └── wkt/
│ │ │ │ │ │ ├── detail/
│ │ │ │ │ │ │ ├── prefix.hpp
│ │ │ │ │ │ │ └── wkt_multi.hpp
│ │ │ │ │ │ ├── read.hpp
│ │ │ │ │ │ ├── stream.hpp
│ │ │ │ │ │ ├── wkt.hpp
│ │ │ │ │ │ └── write.hpp
│ │ │ │ │ ├── iterators/
│ │ │ │ │ │ ├── base.hpp
│ │ │ │ │ │ ├── closing_iterator.hpp
│ │ │ │ │ │ ├── concatenate_iterator.hpp
│ │ │ │ │ │ ├── detail/
│ │ │ │ │ │ │ ├── point_iterator/
│ │ │ │ │ │ │ │ ├── inner_range_type.hpp
│ │ │ │ │ │ │ │ ├── iterator_type.hpp
│ │ │ │ │ │ │ │ └── value_type.hpp
│ │ │ │ │ │ │ └── segment_iterator/
│ │ │ │ │ │ │ ├── iterator_type.hpp
│ │ │ │ │ │ │ ├── range_segment_iterator.hpp
│ │ │ │ │ │ │ └── value_type.hpp
│ │ │ │ │ │ ├── dispatch/
│ │ │ │ │ │ │ ├── point_iterator.hpp
│ │ │ │ │ │ │ └── segment_iterator.hpp
│ │ │ │ │ │ ├── ever_circling_iterator.hpp
│ │ │ │ │ │ ├── flatten_iterator.hpp
│ │ │ │ │ │ ├── has_one_element.hpp
│ │ │ │ │ │ ├── point_iterator.hpp
│ │ │ │ │ │ ├── point_reverse_iterator.hpp
│ │ │ │ │ │ └── segment_iterator.hpp
│ │ │ │ │ ├── multi/
│ │ │ │ │ │ ├── algorithms/
│ │ │ │ │ │ │ ├── append.hpp
│ │ │ │ │ │ │ ├── area.hpp
│ │ │ │ │ │ │ ├── centroid.hpp
│ │ │ │ │ │ │ ├── clear.hpp
│ │ │ │ │ │ │ ├── convert.hpp
│ │ │ │ │ │ │ ├── correct.hpp
│ │ │ │ │ │ │ ├── covered_by.hpp
│ │ │ │ │ │ │ ├── detail/
│ │ │ │ │ │ │ │ ├── extreme_points.hpp
│ │ │ │ │ │ │ │ ├── for_each_range.hpp
│ │ │ │ │ │ │ │ ├── modify.hpp
│ │ │ │ │ │ │ │ ├── modify_with_predicate.hpp
│ │ │ │ │ │ │ │ ├── multi_sum.hpp
│ │ │ │ │ │ │ │ ├── overlay/
│ │ │ │ │ │ │ │ │ ├── copy_segment_point.hpp
│ │ │ │ │ │ │ │ │ ├── copy_segments.hpp
│ │ │ │ │ │ │ │ │ ├── get_ring.hpp
│ │ │ │ │ │ │ │ │ ├── get_turns.hpp
│ │ │ │ │ │ │ │ │ └── self_turn_points.hpp
│ │ │ │ │ │ │ │ ├── point_on_border.hpp
│ │ │ │ │ │ │ │ └── sections/
│ │ │ │ │ │ │ │ ├── range_by_section.hpp
│ │ │ │ │ │ │ │ └── sectionalize.hpp
│ │ │ │ │ │ │ ├── disjoint.hpp
│ │ │ │ │ │ │ ├── distance.hpp
│ │ │ │ │ │ │ ├── envelope.hpp
│ │ │ │ │ │ │ ├── equals.hpp
│ │ │ │ │ │ │ ├── for_each.hpp
│ │ │ │ │ │ │ ├── intersection.hpp
│ │ │ │ │ │ │ ├── length.hpp
│ │ │ │ │ │ │ ├── num_geometries.hpp
│ │ │ │ │ │ │ ├── num_interior_rings.hpp
│ │ │ │ │ │ │ ├── num_points.hpp
│ │ │ │ │ │ │ ├── perimeter.hpp
│ │ │ │ │ │ │ ├── remove_spikes.hpp
│ │ │ │ │ │ │ ├── reverse.hpp
│ │ │ │ │ │ │ ├── simplify.hpp
│ │ │ │ │ │ │ ├── transform.hpp
│ │ │ │ │ │ │ ├── unique.hpp
│ │ │ │ │ │ │ └── within.hpp
│ │ │ │ │ │ ├── core/
│ │ │ │ │ │ │ ├── closure.hpp
│ │ │ │ │ │ │ ├── geometry_id.hpp
│ │ │ │ │ │ │ ├── interior_rings.hpp
│ │ │ │ │ │ │ ├── is_areal.hpp
│ │ │ │ │ │ │ ├── point_order.hpp
│ │ │ │ │ │ │ ├── point_type.hpp
│ │ │ │ │ │ │ ├── ring_type.hpp
│ │ │ │ │ │ │ ├── tags.hpp
│ │ │ │ │ │ │ └── topological_dimension.hpp
│ │ │ │ │ │ ├── geometries/
│ │ │ │ │ │ │ ├── concepts/
│ │ │ │ │ │ │ │ ├── check.hpp
│ │ │ │ │ │ │ │ ├── multi_linestring_concept.hpp
│ │ │ │ │ │ │ │ ├── multi_point_concept.hpp
│ │ │ │ │ │ │ │ └── multi_polygon_concept.hpp
│ │ │ │ │ │ │ ├── multi_geometries.hpp
│ │ │ │ │ │ │ ├── multi_linestring.hpp
│ │ │ │ │ │ │ ├── multi_point.hpp
│ │ │ │ │ │ │ ├── multi_polygon.hpp
│ │ │ │ │ │ │ └── register/
│ │ │ │ │ │ │ ├── multi_linestring.hpp
│ │ │ │ │ │ │ ├── multi_point.hpp
│ │ │ │ │ │ │ └── multi_polygon.hpp
│ │ │ │ │ │ ├── io/
│ │ │ │ │ │ │ ├── dsv/
│ │ │ │ │ │ │ │ └── write.hpp
│ │ │ │ │ │ │ └── wkt/
│ │ │ │ │ │ │ ├── detail/
│ │ │ │ │ │ │ │ └── prefix.hpp
│ │ │ │ │ │ │ ├── read.hpp
│ │ │ │ │ │ │ ├── wkt.hpp
│ │ │ │ │ │ │ └── write.hpp
│ │ │ │ │ │ ├── multi.hpp
│ │ │ │ │ │ ├── strategies/
│ │ │ │ │ │ │ └── cartesian/
│ │ │ │ │ │ │ └── centroid_average.hpp
│ │ │ │ │ │ └── views/
│ │ │ │ │ │ └── detail/
│ │ │ │ │ │ └── range_type.hpp
│ │ │ │ │ ├── policies/
│ │ │ │ │ │ ├── compare.hpp
│ │ │ │ │ │ ├── disjoint_interrupt_policy.hpp
│ │ │ │ │ │ ├── is_valid/
│ │ │ │ │ │ │ ├── default_policy.hpp
│ │ │ │ │ │ │ ├── failing_reason_policy.hpp
│ │ │ │ │ │ │ └── failure_type_policy.hpp
│ │ │ │ │ │ ├── predicate_based_interrupt_policy.hpp
│ │ │ │ │ │ ├── relate/
│ │ │ │ │ │ │ ├── direction.hpp
│ │ │ │ │ │ │ ├── intersection_points.hpp
│ │ │ │ │ │ │ ├── intersection_ratios.hpp
│ │ │ │ │ │ │ └── tupled.hpp
│ │ │ │ │ │ └── robustness/
│ │ │ │ │ │ ├── get_rescale_policy.hpp
│ │ │ │ │ │ ├── no_rescale_policy.hpp
│ │ │ │ │ │ ├── rescale_policy.hpp
│ │ │ │ │ │ ├── robust_point_type.hpp
│ │ │ │ │ │ ├── robust_type.hpp
│ │ │ │ │ │ ├── segment_ratio.hpp
│ │ │ │ │ │ └── segment_ratio_type.hpp
│ │ │ │ │ ├── strategies/
│ │ │ │ │ │ ├── agnostic/
│ │ │ │ │ │ │ ├── buffer_distance_asymmetric.hpp
│ │ │ │ │ │ │ ├── buffer_distance_symmetric.hpp
│ │ │ │ │ │ │ ├── hull_graham_andrew.hpp
│ │ │ │ │ │ │ ├── point_in_box_by_side.hpp
│ │ │ │ │ │ │ ├── point_in_point.hpp
│ │ │ │ │ │ │ ├── point_in_poly_oriented_winding.hpp
│ │ │ │ │ │ │ ├── point_in_poly_winding.hpp
│ │ │ │ │ │ │ └── simplify_douglas_peucker.hpp
│ │ │ │ │ │ ├── area.hpp
│ │ │ │ │ │ ├── azimuth.hpp
│ │ │ │ │ │ ├── buffer.hpp
│ │ │ │ │ │ ├── cartesian/
│ │ │ │ │ │ │ ├── area_surveyor.hpp
│ │ │ │ │ │ │ ├── azimuth.hpp
│ │ │ │ │ │ │ ├── box_in_box.hpp
│ │ │ │ │ │ │ ├── buffer_end_flat.hpp
│ │ │ │ │ │ │ ├── buffer_end_round.hpp
│ │ │ │ │ │ │ ├── buffer_join_miter.hpp
│ │ │ │ │ │ │ ├── buffer_join_round.hpp
│ │ │ │ │ │ │ ├── buffer_join_round_by_divide.hpp
│ │ │ │ │ │ │ ├── buffer_point_circle.hpp
│ │ │ │ │ │ │ ├── buffer_point_square.hpp
│ │ │ │ │ │ │ ├── buffer_side_straight.hpp
│ │ │ │ │ │ │ ├── centroid_average.hpp
│ │ │ │ │ │ │ ├── centroid_bashein_detmer.hpp
│ │ │ │ │ │ │ ├── centroid_weighted_length.hpp
│ │ │ │ │ │ │ ├── disjoint_segment_box.hpp
│ │ │ │ │ │ │ ├── distance_projected_point.hpp
│ │ │ │ │ │ │ ├── distance_projected_point_ax.hpp
│ │ │ │ │ │ │ ├── distance_pythagoras.hpp
│ │ │ │ │ │ │ ├── distance_pythagoras_box_box.hpp
│ │ │ │ │ │ │ ├── distance_pythagoras_point_box.hpp
│ │ │ │ │ │ │ ├── envelope_segment.hpp
│ │ │ │ │ │ │ ├── intersection.hpp
│ │ │ │ │ │ │ ├── point_in_box.hpp
│ │ │ │ │ │ │ ├── point_in_poly_crossings_multiply.hpp
│ │ │ │ │ │ │ ├── point_in_poly_franklin.hpp
│ │ │ │ │ │ │ ├── side_by_triangle.hpp
│ │ │ │ │ │ │ └── side_of_intersection.hpp
│ │ │ │ │ │ ├── centroid.hpp
│ │ │ │ │ │ ├── comparable_distance_result.hpp
│ │ │ │ │ │ ├── compare.hpp
│ │ │ │ │ │ ├── concepts/
│ │ │ │ │ │ │ ├── area_concept.hpp
│ │ │ │ │ │ │ ├── centroid_concept.hpp
│ │ │ │ │ │ │ ├── convex_hull_concept.hpp
│ │ │ │ │ │ │ ├── distance_concept.hpp
│ │ │ │ │ │ │ ├── segment_intersect_concept.hpp
│ │ │ │ │ │ │ ├── simplify_concept.hpp
│ │ │ │ │ │ │ └── within_concept.hpp
│ │ │ │ │ │ ├── convex_hull.hpp
│ │ │ │ │ │ ├── covered_by.hpp
│ │ │ │ │ │ ├── default_area_result.hpp
│ │ │ │ │ │ ├── default_comparable_distance_result.hpp
│ │ │ │ │ │ ├── default_distance_result.hpp
│ │ │ │ │ │ ├── default_length_result.hpp
│ │ │ │ │ │ ├── default_strategy.hpp
│ │ │ │ │ │ ├── disjoint.hpp
│ │ │ │ │ │ ├── distance.hpp
│ │ │ │ │ │ ├── distance_result.hpp
│ │ │ │ │ │ ├── envelope.hpp
│ │ │ │ │ │ ├── geographic/
│ │ │ │ │ │ │ ├── area.hpp
│ │ │ │ │ │ │ ├── azimuth.hpp
│ │ │ │ │ │ │ ├── distance.hpp
│ │ │ │ │ │ │ ├── distance_andoyer.hpp
│ │ │ │ │ │ │ ├── distance_thomas.hpp
│ │ │ │ │ │ │ ├── distance_vincenty.hpp
│ │ │ │ │ │ │ ├── envelope_segment.hpp
│ │ │ │ │ │ │ ├── intersection.hpp
│ │ │ │ │ │ │ ├── intersection_elliptic.hpp
│ │ │ │ │ │ │ ├── mapping_ssf.hpp
│ │ │ │ │ │ │ ├── parameters.hpp
│ │ │ │ │ │ │ ├── side.hpp
│ │ │ │ │ │ │ ├── side_andoyer.hpp
│ │ │ │ │ │ │ ├── side_thomas.hpp
│ │ │ │ │ │ │ └── side_vincenty.hpp
│ │ │ │ │ │ ├── intersection.hpp
│ │ │ │ │ │ ├── intersection_result.hpp
│ │ │ │ │ │ ├── intersection_strategies.hpp
│ │ │ │ │ │ ├── relate.hpp
│ │ │ │ │ │ ├── side.hpp
│ │ │ │ │ │ ├── side_info.hpp
│ │ │ │ │ │ ├── spherical/
│ │ │ │ │ │ │ ├── area.hpp
│ │ │ │ │ │ │ ├── azimuth.hpp
│ │ │ │ │ │ │ ├── compare_circular.hpp
│ │ │ │ │ │ │ ├── distance_cross_track.hpp
│ │ │ │ │ │ │ ├── distance_cross_track_point_box.hpp
│ │ │ │ │ │ │ ├── distance_haversine.hpp
│ │ │ │ │ │ │ ├── envelope_segment.hpp
│ │ │ │ │ │ │ ├── intersection.hpp
│ │ │ │ │ │ │ ├── side_by_cross_track.hpp
│ │ │ │ │ │ │ └── ssf.hpp
│ │ │ │ │ │ ├── strategies.hpp
│ │ │ │ │ │ ├── strategy_transform.hpp
│ │ │ │ │ │ ├── tags.hpp
│ │ │ │ │ │ ├── transform/
│ │ │ │ │ │ │ ├── inverse_transformer.hpp
│ │ │ │ │ │ │ ├── map_transformer.hpp
│ │ │ │ │ │ │ └── matrix_transformers.hpp
│ │ │ │ │ │ ├── transform.hpp
│ │ │ │ │ │ └── within.hpp
│ │ │ │ │ ├── util/
│ │ │ │ │ │ ├── add_const_if_c.hpp
│ │ │ │ │ │ ├── bare_type.hpp
│ │ │ │ │ │ ├── calculation_type.hpp
│ │ │ │ │ │ ├── closure_as_bool.hpp
│ │ │ │ │ │ ├── combine_if.hpp
│ │ │ │ │ │ ├── compress_variant.hpp
│ │ │ │ │ │ ├── condition.hpp
│ │ │ │ │ │ ├── coordinate_cast.hpp
│ │ │ │ │ │ ├── for_each_coordinate.hpp
│ │ │ │ │ │ ├── has_infinite_coordinate.hpp
│ │ │ │ │ │ ├── has_nan_coordinate.hpp
│ │ │ │ │ │ ├── has_non_finite_coordinate.hpp
│ │ │ │ │ │ ├── math.hpp
│ │ │ │ │ │ ├── normalize_spheroidal_box_coordinates.hpp
│ │ │ │ │ │ ├── normalize_spheroidal_coordinates.hpp
│ │ │ │ │ │ ├── order_as_direction.hpp
│ │ │ │ │ │ ├── parameter_type_of.hpp
│ │ │ │ │ │ ├── promote_floating_point.hpp
│ │ │ │ │ │ ├── promote_integral.hpp
│ │ │ │ │ │ ├── range.hpp
│ │ │ │ │ │ ├── rational.hpp
│ │ │ │ │ │ ├── readme.txt
│ │ │ │ │ │ ├── select_calculation_type.hpp
│ │ │ │ │ │ ├── select_coordinate_type.hpp
│ │ │ │ │ │ ├── select_most_precise.hpp
│ │ │ │ │ │ └── transform_variant.hpp
│ │ │ │ │ └── views/
│ │ │ │ │ ├── box_view.hpp
│ │ │ │ │ ├── closeable_view.hpp
│ │ │ │ │ ├── detail/
│ │ │ │ │ │ ├── boundary_view/
│ │ │ │ │ │ │ ├── implementation.hpp
│ │ │ │ │ │ │ └── interface.hpp
│ │ │ │ │ │ ├── boundary_view.hpp
│ │ │ │ │ │ ├── indexed_point_view.hpp
│ │ │ │ │ │ ├── normalized_view.hpp
│ │ │ │ │ │ ├── points_view.hpp
│ │ │ │ │ │ ├── range_type.hpp
│ │ │ │ │ │ └── two_dimensional_view.hpp
│ │ │ │ │ ├── identity_view.hpp
│ │ │ │ │ ├── reversible_view.hpp
│ │ │ │ │ └── segment_view.hpp
│ │ │ │ ├── geometry.hpp
│ │ │ │ ├── get_pointer.hpp
│ │ │ │ ├── gil/
│ │ │ │ │ ├── algorithm.hpp
│ │ │ │ │ ├── bit_aligned_pixel_iterator.hpp
│ │ │ │ │ ├── bit_aligned_pixel_reference.hpp
│ │ │ │ │ ├── channel.hpp
│ │ │ │ │ ├── channel_algorithm.hpp
│ │ │ │ │ ├── cmyk.hpp
│ │ │ │ │ ├── color_base.hpp
│ │ │ │ │ ├── color_base_algorithm.hpp
│ │ │ │ │ ├── color_convert.hpp
│ │ │ │ │ ├── deprecated.hpp
│ │ │ │ │ ├── device_n.hpp
│ │ │ │ │ ├── extension/
│ │ │ │ │ │ ├── dynamic_image/
│ │ │ │ │ │ │ ├── algorithm.hpp
│ │ │ │ │ │ │ ├── any_image.hpp
│ │ │ │ │ │ │ ├── any_image_view.hpp
│ │ │ │ │ │ │ ├── apply_operation.hpp
│ │ │ │ │ │ │ ├── apply_operation_base.hpp
│ │ │ │ │ │ │ ├── dynamic_at_c.hpp
│ │ │ │ │ │ │ ├── dynamic_image_all.hpp
│ │ │
================================================
FILE CONTENTS
================================================
================================================
FILE: .circleci/config.yml
================================================
version: 2
jobs:
build-and-test:
macos:
xcode: '9.0.1'
working_directory: ~/numenta/nupic.core
parallelism: 1
environment:
XCODE_SCHEME: nupic
XCODE_WORKSPACE: nupic
ARCHFLAGS: -arch x86_64
PYTHONPATH: ~/Library/Python/2.7/lib/python/site-packages
PYBIN: ~/Library/Python/2.7/bin
steps:
# Machine Setup
- run:
name: Make sure to use OS X in CircleCI Web UI
command: |
if [[ "$OSTYPE" != "darwin"* ]]; then
echo "Must set option to use OS X in CircleCI Web UI" && exit 1;
fi
- run: sudo systemsetup -settimezone 'GMT'
- run:
name: Restoring system python
command: |
brew uninstall python
curl https://bootstrap.pypa.io/get-pip.py | python - --user
echo 'export PATH=$HOME/Library/Python/2.7/bin:$PATH' >> $BASH_ENV
- run:
name: Installing cmake
command: brew install cmake
- checkout
# Dependencies
# Restore the dependency cache
- restore_cache:
keys:
# This branch if available
- v1-dep-{{ .Branch }}-
# Default branch if not
- v1-dep-master-
# Any branch if there are none on the default branch - this should be
# unnecessary if you have your default branch configured correctly
- v1-dep-
- run:
name: Installing dependencies
command: |
pip install --user --upgrade --verbose pip setuptools setuptools-scm
pip install --no-cache-dir --user -r bindings/py/requirements.txt --verbose || exit
# Save dependency cache
- save_cache:
key: v1-dep-{{ .Branch }}-{{ epoch }}
paths:
# This is a broad list of cache paths to include many possible
# development environments.
- vendor/bundle
- ~/virtualenvs
- ~/.m2
- ~/.ivy2
- ~/.bundle
- ~/.go_workspace
- ~/.gradle
- ~/.cache/bower
# Build
- run:
name: Compiling
environment:
VERBOSE: 1
command: |
mkdir -p build/scripts
cd build/scripts
cmake ../.. -DCMAKE_BUILD_TYPE=Release -DNTA_COV_ENABLED=ON -DCMAKE_INSTALL_PREFIX=../release -DPY_EXTENSIONS_DIR=../../bindings/py/src/nupic/bindings
make | grep -v -F '\\-\\- Installing:'
make install 2>&1 | grep -v -F 'Installing:'
- run:
name: Build distribution
command: |
python setup.py bdist_wheel
mkdir -p dist/include/nupic
mv bindings/py/dist/*.whl dist/
cp bindings/py/requirements.txt dist/
cp build/release/include/nupic/Version.hpp dist/include/nupic/
# Test
- run:
name: Running python tests
command: |
mkdir -p tests/py
pip install --user --no-index --find-links=$CIRCLE_WORKING_DIRECTORY/dist/ nupic.bindings
py.test --junitxml tests/py/junit-test-results.xml bindings/py/tests
- run:
name: Running C++ Tests
command: |
mkdir -p tests/cpp
pushd build/release/bin
./cpp_region_test
./py_region_test
./helloregion
./hello_sp_tp
./prototest
./unit_tests --gtest_output=xml:$CIRCLE_WORKING_DIRECTORY/tests/cpp/unit_tests_report.xml
- store_test_results:
path: tests
- store_artifacts:
path: dist/*.whl
- persist_to_workspace:
root: dist
paths:
- nupic.bindings*.whl
- requirements.txt
- include/nupic
deploy-s3:
machine: true
steps:
- attach_workspace:
at: dist
- run:
name: Deploying to S3
command: |
pip install awscli --upgrade --user
tar -zcv -f nupic_core-${CIRCLE_SHA1}-darwin64.tar.gz dist
aws s3 cp nupic_core-${CIRCLE_SHA1}-darwin64.tar.gz s3://artifacts.numenta.org/numenta/nupic.core/circle/
workflows:
version: 2
build-test-deploy:
jobs:
- build-and-test
- deploy-s3:
requires:
- build-and-test
filters:
branches:
only: master
================================================
FILE: .clang-format
================================================
---
Language: Cpp
BasedOnStyle: LLVM
DisableFormat: false
...
================================================
FILE: .gitignore
================================================
.metadata
.idea
*.manifest
*.cache
*~
*.DS_Store
*.swp
*.pyc
*.pkl
# Coverage files
.coverage
htmlcov/
# IDE project files
/nbproject/
.vscode
.ycm_extra_conf.py
# Build files
build/
junit-test-results.xml
# /
/.gdb_history
# Doxygen generated doc
html/
# SWIG
bindings/py/src/nupic/bindings/*.cxx
bindings/py/src/nupic/bindings/*.py
bindings/py/src/nupic/bindings/*.so
bindings/py/src/nupic/*.so
bindings/py/src/nupic.bindings.egg-info
================================================
FILE: .travis.yml
================================================
sudo: false
language: cpp
osx_image: xcode6.4
os:
- osx
compiler:
- clang
env:
global:
- NUPICCORE = ${TRAVIS_BUILD_DIR}
- PATH=${TRAVIS_BUILD_DIR}/python/bin:$PATH
- PLATFORM=${TRAVIS_OS_NAME}
- ARCHFLAGS="-arch x86_64"
# AWS keys are for manual uploads of wheel to S3.
- AWS_ACCESS_KEY_ID=AKIAIGHYSEHV3WFKOWNQ
# AWS_SECRET_ACCESS_KEY encrypted below
- secure: "Ixm9TYZAZbCQicUTIZTY7XKNK82WF+f1jsaGtIxnGQmn0LKhKBjQnsZmhzQ7LDQeLUjRY3wM6xrX3YdP5T7WWiiqBiNCRz8oFxl/fBSm7LyuNo2CEGD9rsG6ZAY/sKKYNX5TuG78giJXwYZpq4LbVwy3W5ZlC626H7iXLQ6xDxw="
virtualenv:
system_site_packages: true
# Successful builds are archived and uploaded to S3 for bamboo releases.
before_deploy:
- "PLATFORM='darwin'"
- cd $TRAVIS_BUILD_DIR
- ./ci/travis/before_deploy.sh
- cp $TRAVIS_BUILD_DIR/bindings/py/requirements.txt $TRAVIS_BUILD_DIR/bindings/py/dist/
- mkdir -p $TRAVIS_BUILD_DIR/bindings/py/dist/include/nupic
- cp ${TRAVIS_BUILD_DIR}/build/release/include/nupic/Version.hpp $TRAVIS_BUILD_DIR/bindings/py/dist/include/nupic
- mkdir -p $TRAVIS_BUILD_DIR/bindings/py/dist/bin
- cp ${TRAVIS_BUILD_DIR}/build/release/bin/py_region_test $TRAVIS_BUILD_DIR/bindings/py/dist/bin
- mkdir -p $TRAVIS_BUILD_DIR/release
- tar -zcvf $TRAVIS_BUILD_DIR/release/nupic_core-${TRAVIS_COMMIT}-${PLATFORM}64.tar.gz $TRAVIS_BUILD_DIR/bindings/py/dist
deploy:
provider: s3
access_key_id: AKIAIGHYSEHV3WFKOWNQ
secret_access_key:
secure: YhyY/6r2LNya8OZEmVOj+fv0lY5bBPqvy8MnsdLlptXa2uqwvezkCMNKiQ+wA+tOu+BS7VRRp86DhUqCpTZ3jUM2Mwdhud/Smq7D2X8vtZBiTVcOKfQcaypDE6Zu9Zp0SjMOSf6yiq6Ruu7D5QtZ4rtaq+5uPlvbgUXRZoZm0Po=
bucket: artifacts.numenta.org
region: us-west-2
local-dir: "$TRAVIS_BUILD_DIR/release"
upload-dir: "numenta/nupic.core"
skip_cleanup: true
# Deploying on master branch from osx/clang
on:
branch: master
condition:
- "( ${TRAVIS_OS_NAME}--${CC} = 'osx--clang' )"
notifications:
email:
recipients:
- "discourse-nupic-developers@numenta.org"
on_success: never
on_failure: change
irc:
channels:
- "irc.freenode.net#nupic-hackers"
webhooks:
- urls:
- https://webhooks.gitter.im/e/68f77bae61efa5c931f8
- https://api.keen.io/3.0/projects/5555161e2fd4b1326f14444a/events/travis-webhooks?api_key=a2e613bbb19b9b1f71a5543b7b677563551b4c3fe98534269546ff666ae453f82505791772faefc48682ee882ac7e99d2c3bfae7c7c19db7b5e7bbda34039119e4b42f5bf41bcea62d4ea9731db4a455141be7d5e8c715cb06366922eae0358e84abc2704ce16bb77b01fec3476cbac6
before_install:
- ". ./ci/travis/before_install-osx.sh"
install:
- "mkdir -p $TRAVIS_BUILD_DIR/build/scripts"
- "cd $TRAVIS_BUILD_DIR/build/scripts"
- "mkdir -p $TRAVIS_BUILD_DIR/build/release"
- "cmake --version"
# Enable test coverage for travis-ci build
- "cmake $TRAVIS_BUILD_DIR -DNTA_COV_ENABLED=ON -DCMAKE_INSTALL_PREFIX=${TRAVIS_BUILD_DIR}/build/release -DPY_EXTENSIONS_DIR=$TRAVIS_BUILD_DIR/bindings/py/src/nupic/bindings"
# Configure bash such that a failure in any link in the pipe causes the whole pipe to fail
- "set -o pipefail"
- "VERBOSE=1 make|grep -v -F '\\-\\- Installing:'"
- "make install 2>&1|grep -v -F 'Installing:'"
- "cd $TRAVIS_BUILD_DIR"
- "python setup.py install --user"
script:
# Some tests (e.g., helloregion) expect this to be the current directory and
# this also matches current instructions in nupic.core/README.md
- "cd $TRAVIS_BUILD_DIR/build/release/bin"
# legacy binary tests
- "${TRAVIS_BUILD_DIR}/build/release/bin/connections_performance_test"
- "${TRAVIS_BUILD_DIR}/build/release/bin/cpp_region_test"
- "${TRAVIS_BUILD_DIR}/build/release/bin/py_region_test"
- "${TRAVIS_BUILD_DIR}/build/release/bin/helloregion"
- "${TRAVIS_BUILD_DIR}/build/release/bin/hello_sp_tp"
- "${TRAVIS_BUILD_DIR}/build/release/bin/prototest"
# unit tests
# TODO Why does it mkdir build/scripts/artifacts, but then points gtest_otput to build/artifacts?
- "mkdir -p $TRAVIS_BUILD_DIR/build/scripts/artifacts"
- "${TRAVIS_BUILD_DIR}/build/release/bin/unit_tests --gtest_output=xml:${TRAVIS_BUILD_DIR}/build/artifacts/unit_tests_report.xml"
# run python tests
- "py.test ${TRAVIS_BUILD_DIR}/bindings/py/tests"
# output unit tests report
- "cd $TRAVIS_BUILD_DIR/build/artifacts/"
# transform the JUnit-style xml report to html
- "xsltproc $TRAVIS_BUILD_DIR/docs/xunit.xslt unit_tests_report.xml > unit_tests_report.html"
================================================
FILE: CHANGELOG.md
================================================
# Changelog
## 1.0.6
* This release was because of a deployment problem with 1.0.5 and issues with pypi.
## 1.0.5
* 58754cf7 NUP-2519: Upgrade pycapnp to 0.6.3
* 64fb803e DEVOPS-383: Move deploy to S3 job to circleci workflow
* 16dbf534 DEVOPS-383: Migrate CircleCI builds from 1.0 to 2.0
* ec14f2f5 pip install --use-wheel" was deprecated. See https://pip.pypa.io/en/stable/news/#deprecations-and-removals
* c2d31a95 ignore YCM configuration
* f7b86e0f "pip install --use-wheel" was deprecated. See https://pip.pypa.io/en/stable/news/#deprecations-and-removals
* 42df6caa NUP-2504: fix clang link optimization issue on private template function
* f5bc76b6 NUP-2504: Add unit test to softmax overflow
* 203493ed NUP-2506: Add missing state fields to serialization
* 5f1ddcbb NUP-2514: fix traversal limit
* 7e33ca44 NUP-2506: Add missing operator '==' to classes used in tests
* e5e48c8e fix accumulate
* b3513853 add softmax function
* 0032fbf5 Fix softmax overflow
## 1.0.4
* 860459cf NUP-2506: Add operator '==' to classes used in tests
* ac43320f NUP-2505: Remove win32 build from CI
* 6a580c06 Fix not include ClassifierResult.hpp error
* de567a4e NUP-2495: Update clang-format instructions
* 2f027a7b NUP-2475: Add sparse link validation
* 3071b8a5 DEVOPS-353: Update "setSparseOutput" documentation
* 7ae0d64f NUP-2495: Check style using clang-format
* 8a1d5eeb NUP-2475: Make sure Network API links use the same dtype at both ends
* 4e800a64 DEVOPS-353: Fix tests to run with nupic.core directly instead of nupic
* 9ae6155d DEVOPS-353: Implement sparse links
* de88baaa DEVOPS-353: Add 'isSparse' attribute to input/output
* 1e486fde DEVOPS-353: Allow element count to be smaller than buffer size
* c9377d52 Fix cmake version and project name
* f069c310 Add missing include required for NTA_ASSERT
* a6c186ae reformat code using clang-format
* 70d43da1 NUP-2492: Add constructor vs initialize test regarding Issue #1386
* dabd7f87 NUP-2491: Validate global inhibition parameters
## 1.0.3
* https://github.com/numenta/nupic.core/issues/1380 Added stronger type checking for SP compute input.
## 1.0.2
* NUP-2481: Update capnp to 0.6.1
* NUP-2469: Mark version as pre-release
* Don't run iwyu if doing gcc build
* RES-571 Explicitly declare cmake 3.3 minimum requirement
## 1.0.1
* NUP-2481: Update capnp to 0.6.1
* Don't run iwyu if doing gcc build
* RES-571 Explicitly declare cmake 3.3 minimum requirement
## 1.0.0
* Convert getProtoType to getSchema to be consistent with Python interface in nupic
* Add Circle badge to README
* Make --user optional since manylinux doens't use it
* Remove build tools setup for Linux CI jobs since new base image already provides these tools
* NUP-2341: Expose capnp serialization to SVM swig interface
* NUP-2341: Add missing 'getSchema'
* update boost to 1.64.0 stable release
* Add a "checkInputs" param to the TemporalMemory
## 0.7.2
* Add SWIG support for Cells4 capnp serialization
## 0.7.1
* SP optimization using minmax_element (#1326)
* Add capnp serialization to Cells4, Cell, Segment, SegmentUpdates, CState, etc. (#1346)
* Fix missing actValue in SDR classifier SWIG interface (#1348)
## 0.7.0
* Give clear exception when clients attempt to reuse ClassifierResult instance with SDRClassifier (PR #1342)
* Remove FastClaClassifier (PR #1341)
* Allow SDR classifier to handle multiple category (PR #1339)
* Add Cap'n Proto serialization to SVM (PR #1338)
## 0.6.3
* Change the Connections to stop doing automatic segment / synapse cleanup
* Revamp the TemporalMemory proto so that it captures all information
* For numpy, use a single PyArray_API symbol per binary rather than one per cpp file
* Use numpy 1.12.1
* Use pycapnp 0.5.12
* Use latest pytest 3.0.7, pytest-cov 2.5.0, pytest-xdist 1.16.0
## 0.6.2
* Updated Circle CI configuration and switch to that for OS X builds (instead of Travis CI)
* Documentation updates: PyRegion
* IWYU documentation update
* Fixed C++ boolean ref counting bug that caused segfaults when running Python projects
* Update pytest and pycapnp dependency versions
* Implemented byte buffer passing as alternative Python<->C++ strategy for capnp serialization logic. This has some memory/speed overhead but avoids ABI issues that could cause crashes
* Fixed prototest to get meaningful comparison numbers
## 0.6.1
* Eliminate installation of unnecessary header files when building nupic.bindings. Install Version.hpp unconditionally for the sake of the deployment usage in .travis.yaml
* Fixed servicing of delayed links such that the circular buffers of all links within a network are refreshed at the end of each time step; and 0-delay links copy data directly from src to dest, bypassing the circular buffer altogether.
* Add a nNonZerosPerRowOnCols SparseMatrix method
* Fix up some out of date SWIG interface code
## 0.6.0
* NUP-2366 Remove no-longer-relevent test code
* NUP-2366 Do not pass arguments in initialize, remove conflicting docstring
* Add a unit test for mapSegmentsToCells
* Change segments to UInt32 to speed up the bindings
* Fix up fetch_remote script to properly poll until the build is complete.
* Updates to tests moved over from nupic
* removed shebangs
* Changed all copyright headers on all files to AGPL.
* Tests folder refactored
* Reads version from VERSION for doc output
* Fixing travis-ci unit tests
* Doxygen only creates XML, used by Breathe to create docs.
## 0.5.3
* Added comment explaining the nuance of the static variables in Cells4::adaptSegment
* Improved explanation of containers in Cells4::adaptSegment implementation.
* Regenerate SWIG bindings C++ files if any headers change.
* Enable -D_LIBCPP_DEBUG=0 for debug-lite in Clang builds (e.g., OS X). NOTE: Clan't debug mode is not mature, and anything above level 0 appears to require debug build of libc++ during linking, which it not present by default on OS X.
* Fixed deletion of wrong synapses and index-out-of-bounds in Cells4::adaptSegment/Segment::freeNSynapses.
* corrected typo in CHANGELOG.md (boostingStrength -> boostStrength)
* Remove ExtendedTemporalMemory proto
* Fix bug in unit test, make TM catch this bug in DEBUG builds
* Perf: Densify prevActiveCells rather than binary searching
* Get POC of OS X build on circle.ci up and running.
* Bump version to prerelease.
## 0.5.1
* Improved network API introspection
* Fix bug with region dimensions inference in network API. fixes #1212
* Updates to info in RELEASE.md
* Fixup import favoring native unittest
* Use xcode6.4 image per documentation at https://docs.travis-ci.com/user/osx-ci-environment/#OS-X-Version
* NUP-2316 Fixed OS X build failure on xcode 8 caused by included some files in static library that shouldn't have been included.
* Misc. changes for sparse matrices and using them in Connections. Moving loops to C++.
## 0.5.0
* Link: Implemented delayed links. NOTE: this is not backwards compatible with CLAModel class, so Nupic will be updated as well.
* SparseMatrix: Stop copying input vectors
* Drop the declare_namespace call - Issue #1072
* SparseMatrix: Add option to specify rows in nNonZerosPerRow
* SparseMatrix: setRandomZerosOnOuter with list of counts
* SparseMatrix: rightVecSumAtNZ cleanup
* SparseMatrix: Put cols in dense array even when not necessary
* Removes experimental code that will now live in nupic.research.core.
* Removed unused, obsolete NetworkFactory class.
## 0.4.16
* SpatialPooler: Stop rounding the boost factors
* SpatialPooler: Rename "maxBoost" to "boostStrength"
* SpatialPooler: Remove minActiveDutyCycles and minPctActiveDutyCycles from spatial pooler
## 0.4.15
* SpatialPooler: Tweak the boost factor rounding to mimic numpy's rounding of float32s
## 0.4.14
* SpatialPooler: New boosting algorithm
* SpatialPooler: Stop putting tie-break info into the overlaps. `getBoostedOverlaps()` return values are now more correct.
* SpatialPooler: Use an EPSILON when comparing permanences to a threshold to avoid floating point differences.
* SpatialPooler: Round the boost factors to two decimal places to avoid floating point differences.
## 0.4.13
* Use VERSION file when generating docs.
* 64-bit gcc on Windows build error
* New: setZerosOnOuter, increaseRowNonZeroCountsOnOuterTo
* Remove a nupic.math test that should stay in nupic
* Use unittest, not unittest2, to match the nupic.core CI config
* Add C++ unit tests for the new SparseMatrix methods
* Finish moving nupic.bindings math tests to nupic.core
* s/AboveAndBelow/BelowAndAbove
* Moves some tests for SWIG bindings from nupic to nupic.core
* Better method names: s/AboveAndBelow/BelowAndAbove
* Four new SparseMatrix methods, enabling batch synapse learning
* Expose the nrows,ncols SparseBinaryMatrix ctor in the bindings
## 0.4.12
* Updated to numpy 1.11.2 everywhere.
* Initialize timer variable in 'Regioncpp' file
## 0.4.11
* Botched release, unavailable.
## 0.4.10
* Removes version as part of iterative artifact name
* Deleted linux ci scripts for travis.
* Removed calls to linux ci scripts, forced platform=darwin
* Remove gcc builds from matrix.
* Using image w/ same version of xcode as last passing master build
* Remove some executables from test list that we don't want to run every build.
* Complete test coverage for region registration.
* Reduce build times by removing some executables from build.
* Update py_region_test for new behavior and make sure the test is run in CI.
* Fixes #1108 by only throwing exception when registering region with class name that is already registered if the new region is from a different module than the original.
* Remove unused vagrant configuration
* Remove default values for vectors because GCC can't handle it
* gcc error: checking whether a UInt is positive
* "depolarizeCells", "reinforceCandidates", "growthCandidates"
## 0.4.9
* Obey wrapAround paramater for columns, not just inputs
* Make sure exceptions are properly exposed when parsing dataType in region spec.
* Network API: allow Bools to be used as creation params
* DEVOPS-157 Remove now-unused RESULT_KEY env var from the build-and-test-nupic-bindings.sh interface.
* Handle new synapsesForSegment behavior in Connections perf test
## 0.4.8
* Add missing argument to `Set-PsDebug -Trace`
* Issue1075 fix py_region_test failure on windows (#1082)
* Perf: Walk neighborhoods via iterators.
## 0.4.7
* Check that TM input is sorted indices in Release builds
* Update inhibition comments and docstrings.
* Use C arrays in TemporalMemory. Allows numpy array reuse.
* Added that `-DNUPIC_BUILD_PYEXT_MODULES=ON` is the default at this time.
* Added information about usage of the NUPIC_BUILD_PYEXT_MODULES cmake property.
* Describe flatIdx in Connections docstring
* Consistent param ordering between implementations.
* Store "numActivePotentialSynapses". No more "SegmentOverlap".
## 0.4.6
* Templates: Stop inferring const unnecessarily
* Build error sometimes in clang -- need copy constructor
* Check that minThreshold <= activationThreshold
* Split compute into activateCells and activateDendrites
* TM and ETM cleanup
* ETM: Grow synapses on active segments, not just matching segments
* Removal of MSVC TP compilation flag
* Also do the learnOnOneCell serializaton check in ::save
* Implement learnOnOneCell in the ETM
## 0.4.5
* Removed no longer used pre-built Swig executables for various flavors of Linux; nupic.core automatically builds Swig from embedded sources on non-Windows platforms.
* DEVOPS-141 Apply an export map to OS X, Linux, and MINGW builds of nupic.bindings shared objects.
* Refactor extension build steps into a function shared by algorithms, math, engine_internal, etc. in preparation for adding export maps.
* Work around issue in cmake 2.8.7: have external project AprUtil1StaticLib depend directly on external project Apr1StaticLib instead of its library wrapper ${APR1_STATIC_LIB_TARGET}; the latter was incorrectly interperting the dependency as another external project instead of library; but worked correctly on cmake 2.8.12.
* Completed wrapping of external static libs in `add_library` targets
* Represent external build of capnproto as single static library with target name ${CAPNP_STATIC_LIB_TARGET} and containing all capnproto library objects.
* No need for custom target in CREATE_CAPNPC_COMMAND function, since nupic_core_solo is the only consumer of the custom command's outputs.
* Try building nupic_core_solo intermediate static library without specifying system libraries. It's a static library and shouldn't need additional linking information.
* Removed nupic_core_solo from installed targets, since it's only an intermediate artifact and not intended to be an output product.
* issue-1034 Reorganized build to link nupic_core static library tests against the "combined" nupic_core static library, which is considered an output artifact, instead of nupic_core_solo static lib, which is only an intermediate step.
* Use library utils to correctly combine multiple static libraries into a single one.
* DEVOPS-135 Implement a hacky work-around by preloading pycapnp's exteions DLL in RTLD_GLOBAL mode, which enables resultion of capnproto references when nupic.bidnings extensions are loaded.
* Consider EPSILON while finding minPermanenceSynapse
* Refactor to make GCC stop finding false positives
* New implementation of GCC_UNINITIALIZED_VAR
* DEVOPS-135 Remove capnproto from python extensions shared libs in order to avoid conflict with capnproto methods compiled into pycapnp, possibly compiled with a different compiler/version and with different compiler/linker flags. Instead, we rely on dynamic linking of the necessary symbols from capnproto in pycapnp.
* Avoid clang error "unknown warning option '-Wno-maybe-uninitialized'"
* Store EPSILON as a static const Permanence
* Disable GCC's maybe-uninitialized warnings. Too many false positives.
* Fixes nupic.core github issue #1031: rename EXTERNAL_STATICLIB_CONFIGURE_DEFINITIONS_OPTIMIZED_STR to EXTERNAL_STATICLIB_CONFIGURE_DEFINITIONS_OPTIMIZED and turn it into a list.
* fixes floating point comparison bug
* Use group_by in TemporalMemory. No more ExcitedColumns.
* Work around another GCC maybe-uninitialized faulty error
* Build error when including <GroupBy.hpp> without <algorithm>
* a fresh look at ExcitedColumns: it's just a group_by
* Fixed indexing bug in serialization
* Fix the unsigned int underflow bug in the ETM
* Workaround for a mingwpy issue
* DEVOPS_116 Add stock Numenta file headers and improve some comments in manylinux wheel build scripts.
* Fixed version bug in SDR classifier deserialization
* Updated bindings to handle SDR classifier
* Fix bug in TemporalMemory save / load
* Make getLeastUsedCell non-allocating
* Put ExcitedColumns in a namespace to avoid collisions
* Add apical dendrites to ExtendedTemporalMemory
* DEVOPS-116 Implement prototype manylinux wheel build using docker image numenta/manylinux1_x86_64:centos6.8
* Stop implying pycapnp is in requirements.txt
* Updated SDRClassifier to match header file on getters/setters
* Fixed memory error (off-by-one in weight matrix creation)
* Fixed include bug in SDRClassifier
* Stable implementation of save/load for SDRClassifier
* Ignore installed version of pip.
* Make sure pip gets installed and that we get console output for everything.
* DEVOPS-84 Add support for building nupic.bindings for OS X in bamboo
* change heap allocation to stack allocation of Network
* Merged upstream changes and backed out the disabling of link time optimizations since it now appears to work on the ARM.
* Add a "formInternalConnections" parameter
* Add new "experimental" SWIG module
* Move ETM to "experimental" namespace
* Support "external active cells" in the ETM
* Use std::move to keep the previous active cells
* Untangle the pieces that calculate segment excitation
* Get rid of the Cell struct
* Initial version of ExtendedTemporalMemory: copy-pasted TM
* added blurps for CMAKE_AR and CMAKE_RANLIB
* CMakeLists.txt cleaned up, vars renamed, docs updated
* Updates pycapnp to 0.5.8.
* network-factory adds missing newline to test file
* network-factory updates test to ensure created network is unregistered.
* deprecate-spec-vars moves documentation from Spec to PyRegion
* network-factory adds a test to show that creating a network without any regions or links works
* network-factory expose functions to bindings and extend functionality to accept a yaml string
* network-factory cleans up includes and makes createNetworkFromYaml public
* updated conditional cmake_args, fixes #981
* network-factory passes yaml parser instead of path
* network-factory ensure Network destructor is called on error
* deprecate-spec-vars set defaults for regionLevel and requireSplitterMap and make them optional
* Removed the duplicate conditional addition of the NTA_ASM compiler flag from src/CMakeLists.txt. The original remains in CommonCompilerConfig.
* Removed check for Wreturn-type compatibility
* CMake warning if total memory is less than 1GB
* Added back the -O2 flag and the -Wno-return-type flag
* GCC Bitness handling
* Remove NTA_ASM flag
* Removed the inversion of the NTA_ASM logic made by @codedhard
* 1. Added CMake flag to make arm specific changes to the build 2. Used new CMake flag to disable inline assembly in build 3. Added NTA_ASM conditional to parts of ArrayAlgo.hpp that didn't use it to enable inline assembly
* Add visualization event handlers to Connections class
## 0.4.4
* Timer: test drift
* add CSV parser library
## 0.4.3
* Adds include-what-you-use option in CMake configuration.
* Use the supported mingwpy toolchain from pypi.anaconda.org/carlkl/simple
* Define BOOST_MATH_NO_LONG_DOUBLE_MATH_FUNCTIONS for nupic.core source build in attempt to make build work with official mingwpy toolchain
* Protect all public member variables (except connections)
* Move algorithm details out of the compute method
* Split bamboo linux build into debug and release.
* Move common environment setup for Bamboo into separate script.
* Update SWIG to use local tarfile rather than download from sourceforge.
* Store the new lastUsedIteration, don't just increment old one
* Unit test: destroyed synapse + segment reuse
* Bugfix: Keep the destroyed synapses count in sync.
* Walk the columns and segments via ExcitedColumns iterator
* Fail loudly when Python regions reassign an output
* Disable asserts in release builds
* De-duplicate a loop.
* Removes 'long double', NTA_QUAD_PRECISION, and Real128 references from our code.
* Add Proto for SDR Classifier
* TemporalMemory: replace phases with "columnSegmentWalk". Much faster.
* MovingAverage.compute() returns updated value
## 0.4.2
* Define and use environment variables containing compiler and linker flags specifically for 3rd-party source code.
* Revert to installing mingwpy toolchains from https://bitbucket.org/carlkl/mingw-w64-for-python/downloads.
* Better rand() approach, won't ever be greater than 1
* Stop computing overlaps twice per timestep. 4% faster.
* Stop storing segment overlap counts in a map. Now 56% faster.
* Enable errors for windows32 build in the matrix.
* Use proper float comparisons to avoid issues on 32 vs 64 bit machines.
* Perf: When using sets, use std::set::find, not std::find
* Swig needs `-include cmath` when building with mingw toolchain.
* Initialize swig_generated_file_compile_flags directly from COMMON_CXX_FLAGS_OPTIMIZED to avoid -Werror.
* Comment out header and binary install targets in CapnProto.cmake, since this is a duplicate of the exact same steps in srce/CMakeLists.txt, which installs other externals as well.
* Attempt to fix execution of helloregion test from Travis build by modifying .travis.yml to change directory to build/release/bin just as instructed by nupic.core/README.md.
* Added a comment about nupic.core's swig wraps relying on the macro CAPNP_LITE to have a value.
* Fix windows build of nupic.core's Swig wraps that expects CAPNP_LITE not only to be defined (capnp recommends just defining it), but to actually have a value (non-zero).
* Invoke additional nupic.core tests in Travis to make sure that things get tested and tests don't get broken again unnoticed: connections_performance_test helloregion hello_sp_tp prototest
* Refactored CommonCompilerConfig.cmake to exposed optimized and unoptimized flag sets. Fixed linux GCC build of CapnProto components by changing its configuration to use unoptimized versions of common flags. Cleaned up use of local variables in src/CMakeFiles.txt. nupic.core/CmakeLists.txt is now the only place that defines REPOSITORY_DIR for use by other modules. Fixed dependency in add_custom_command function inside CREATE_CAPNPC_COMMAND to use passed-in arg SPEC_FILES instead of a property from src/CMakeLists.txt.
* Add BITNESS to Swig.cmake
## 0.4.1
* Cast arg to UInt32 to avoid call resolution ambiguity on the value.write() method on Win32 platform.
* Finish adding support for the Bool type
* Expose encoder's 'n' so other regions' inputWidth is calculable from the outside
* Remove reference to deleted Linear.cpp.
* Run nupic.core encoders via boilerplate Sensor wrapper
* Removes Linear.hpp, Linear.cpp, and reference in algorithms.i since it doesn't appear to be used anywhere.
* Support Debug builds in Clang, put them in README
* Add a NTA_BasicType_Bool so that we can parse bools in YAML
* FloatEncoder base, no more common Encoder, new signature
* Prepends BINDINGS_VERSION plus dot separater to wheel filename
* Fix integer division bug, add tests that would catch this bug
* Don't divide by a constant. Multiply. Dodges divide-by-0.
* Explicitly mark all derived virtual methods as virtual.
* Fix gcc build issue
* C++ Encoder base + ScalarEncoder + ported unit tests
## 0.4.0
* Reduce EPSILON threshold for TM to minitage compatibility issues.
* Updates AV yaml to push a commit-sha'd wheel to AWS
* Reduce permanence threshold by epsilon before comparing to avoid rounding edge cases
* Make threshold for destroying synapses larger to catch roundoff errors
* Make comparison identical to python
* Add accessors for TM columnForCell and cellsForColumn
* Temporal Memory: recordIteration should be false in second call to computeActivity
* Fix: Incompatibility in Connections.computeActivity with python
* Change TM init parameters to accept segment and synapse limit.
## 0.3.1
* Secondary sort on segment idx
* Sort segments before iterating for python compatibility
* Sort unpredictedActiveColumns before iterating for python compatibility
## 0.3.0
* Updated SWIG bindings for accessors
* Added TemporalMemory accessors
* Update bindings for C++ Connections to expose 'read' class method
* Destroy lowest permanence synapse when synapse limit is reached
* Fix for bug in Segment::freeNSynapses
* Added initialization code from Tester::init into PathTest::PathTest that is required for PathTest::copyInTemp to run successfully.
* Remove references to Tester from UnitTestMain.cpp
* Deleted Tester class and TesterTest files
* Update SWIG binding of Network to add read class method
* Refactor PyRegion subclasses to take specific proto object in read
* Update SWIG binding of TemporalPooler to add read class method
* Enable basic building with ninja (cmake -GNinja)
* Added include of Log.hpp in NodeSet.hpp
* Update SWIG bindings of SpatialPooler and CLAClassifier to add read class methods to C++ classes
## 0.2.7
* Full filename for twine.
* Absolute path for twine's binary file upload.
## 0.2.6
* Fixed incorrect binary path for twine.
## 0.2.5
* Fixing twine upload of windows binary.
## 0.2.4
* Working out issues with the release process.
## 0.2.3
* Windows Support!
* Add bindings for CLAClassifier serialization
* Adding Windows twine pip install and PyPi upload
* Storing release version in VERSION in proj root.
* Makes build-from-source the default behavior for capnp and swig, requiring the flags FIND_CAPNP or FIND_SWIG to be specified in order to use a preinstalled version.
* Add Dockerfile for building nupic.core from source
* Update of Windows bindings setup
* Add "python setup.py test" option (fixes #697)
* Adding a CMake ExternalProject to download capnp win32 compiler tools
* Simplify setup.py, remove unused command line args, add setup.py clean command. Update Travis to build Python extensions as part of cmake so Python install doesn't rebuild them.
* Allow finding pre-built capnp.
* Revert back to numpy==1.9.2
## 0.2.2
* First changelog entry.
================================================
FILE: CMakeLists.txt
================================================
# Copyright 2015-2017 Numenta Inc.
#
# Copyright may exist in Contributors' modifications
# and/or contributions to the work.
#
# Use of this source code is governed by the MIT
# license that can be found in the LICENSE file or at
# https://opensource.org/licenses/MIT.
cmake_minimum_required(VERSION 3.3)
project(nupic_core CXX)
set(CMAKE_MODULE_PATH "${PROJECT_SOURCE_DIR}")
set(CMAKE_VERBOSE_MAKEFILE OFF)
set(CMAKE_EXPORT_COMPILE_COMMANDS ON)
get_filename_component(REPOSITORY_DIR ${PROJECT_SOURCE_DIR} ABSOLUTE)
# if( POLICY CMP0046 )
# cmake_policy(VERSION 3.3)
# # The new policy for add_dependencies is to now error if a dependency target
# # is not found. The old policy didn't care and continued through configuration
# cmake_policy(SET CMP0046 OLD)
# endif()
# if( POLICY CMP0054 )
# # The OLD behavior for this policy is to dereference variables and interpret
# # keywords even if they are quoted or bracketed. The NEW behavior is to not
# # dereference variables or interpret keywords that have been quoted or bracketed.
# cmake_policy(SET CMP0054 OLD)
# endif()
#
# Global NuPIC CMake options
#
option(NUPIC_BUILD_PYEXT_MODULES
"Turn on building of python extension modules for nupic.bindings; turn off to build only static nupic_core lib with full symbol visibility."
ON)
message(STATUS "NUPIC_BUILD_PYEXT_MODULES = ${NUPIC_BUILD_PYEXT_MODULES}")
message(STATUS "PY_EXTENSIONS_DIR = ${PY_EXTENSIONS_DIR}")
message(STATUS "CMAKE_CXX_COMPILER_ID = ${CMAKE_CXX_COMPILER_ID}")
message(STATUS "CMAKE_C_COMPILER = ${CMAKE_C_COMPILER}")
message(STATUS "CMAKE_CXX_COMPILER = ${CMAKE_CXX_COMPILER}")
message(STATUS "CMAKE_BUILD_TYPE = ${CMAKE_BUILD_TYPE}")
message(STATUS "CMAKE_INSTALL_PREFIX = ${CMAKE_INSTALL_PREFIX}")
# Identify platform name.
string(TOLOWER ${CMAKE_SYSTEM_NAME} PLATFORM)
# Define a platform suffix, eg ${PLATFORM}${BITNESS}${PLATFORM_SUFFIX}
if (MSYS OR MINGW)
set(PLATFORM_SUFFIX -gcc)
endif()
# Make sure we can link against any specified paths.
include_directories(SYSTEM ${CMAKE_INCLUDE_PATH})
set(EP_BASE ${CMAKE_BINARY_DIR}/ThirdParty)
# Determine common toolchain settings, compiler and link flags
include(CommonCompilerConfig)
# Set up builds of external dependencies and get their exports.
# (see individual external/*.cmake modules for exported settings and functions)
add_subdirectory(external)
include_directories(SYSTEM ${EXTERNAL_INCLUDE_DIRS})
# Now build nupic_core project.
add_subdirectory(src)
================================================
FILE: CONTRIBUTING.md
================================================
## We'd love your help!
For information about contributing to NuPIC, please read about our [Development Process](https://github.com/numenta/nupic/wiki/Development-Process).
================================================
FILE: CommonCompilerConfig.cmake
================================================
# Copyright 2013-2016 Numenta Inc.
#
# Copyright may exist in Contributors' modifications
# and/or contributions to the work.
#
# Use of this source code is governed by the MIT
# license that can be found in the LICENSE file or at
# https://opensource.org/licenses/MIT.
# Configures common compiler/linker/loader settings for internal and external
# sources.
#
# NOTE SETTINGS THAT ARE SPECIFIC TO THIS OR THAT MODULE DO NOT BELONG HERE.
# INPUTS:
#
# PLATFORM: lowercase ${CMAKE_SYSTEM_NAME}
# OUTPUTS:
#
# BITNESS: Platform bitness: 32 or 64
#
# COMMON_COMPILER_DEFINITIONS: list of -D define flags for the compilation of
# source files; e.g., for cmake `add_definitions()`
# COMMON_COMPILER_DEFINITIONS_STR: string variant of COMMON_COMPILER_DEFINITIONS
#
# EXTERNAL_C_FLAGS_UNOPTIMIZED: string of C flags without explicit optimization flags for 3rd-party sources
#
# EXTERNAL_C_FLAGS_OPTIMIZED: EXTERNAL_C_FLAGS_UNOPTIMIZED plus optimizations
#
# EXTERNAL_CXX_FLAGS_UNOPTIMIZED: string of C++ flags without explicit optimization flags for 3rd-party sources.
#
# EXTERNAL_LINKER_FLAGS_UNOPTIMIZED: string of linker flags for linking 3rd-party executables
# and shared libraries (DLLs) without explicit optimization
# settings. This property is for use with
# EXTERNAL_C_FLAGS_UNOPTIMIZED and EXTERNAL_CXX_FLAGS_UNOPTIMIZED
#
# EXTERNAL_LINKER_FLAGS_OPTIMIZED: string of linker flags for linking 3rd-party executables
# and shared libraries (DLLs) with optimizations that are
# compatible with EXTERNAL_C_FLAGS_OPTIMIZED and EXTERNAL_CXX_FLAGS_OPTIMIZED
#
# EXTERNAL_STATICLIB_CMAKE_DEFINITIONS_OPTIMIZED: list of -D cmake definitions corresponding to
# EXTERNAL_C_FLAGS_OPTIMIZED (e. g. use of gcc-ar and gcc-ranlib wrappers for gcc >= 4.9
# in combination with Link Time Optimization)
#
# EXTERNAL_STATICLIB_CONFIGURE_DEFINITIONS_OPTIMIZED: variant of
# EXTERNAL_STATICLIB_CMAKE_DEFINITIONS_OPTIMIZED used for
# configure-based builds
#
# INTERNAL_CXX_FLAGS_OPTIMIZED: string of C++ flags with explicit optimization flags for internal sources
#
# INTERNAL_LINKER_FLAGS_OPTIMIZED: string of linker flags for linking internal executables
# and shared libraries (DLLs) with optimizations that are
# compatible with INTERNAL_CXX_FLAGS_OPTIMIZED
#
# PYEXT_LINKER_FLAGS_OPTIMIZED: string of linker flags for linking python extension
# shared libraries (DLLs) with optimizations that are
# compatible with EXTERNAL_CXX_FLAGS_OPTIMIZED.
#
# CMAKE_AR: Name of archiving tool (ar) for static libraries. See cmake documentation
#
# CMAKE_RANLIB: Name of randomizing tool (ranlib) for static libraries. See cmake documentation
#
# CMAKE_LINKER: updated, if needed; use ld.gold if available. See cmake
# documentation
#
# NOTE The XXX_OPTIMIZED flags are quite aggresive - if your code misbehaves for
# strange reasons, try compiling without them.
# NOTE much of the code below was factored out from src/CMakeLists.txt
if(NOT DEFINED PLATFORM)
message(FATAL_ERROR "PLATFORM property not defined: PLATFORM=${PLATFORM}")
endif()
include(CheckCXXCompilerFlag)
# Init exported properties
set(COMMON_COMPILER_DEFINITIONS)
set(COMMON_COMPILER_DEFINITIONS_STR)
set(INTERNAL_CXX_FLAGS_OPTIMIZED)
set(INTERNAL_LINKER_FLAGS_OPTIMIZED)
set(PYEXT_LINKER_FLAGS_OPTIMIZED)
set(EXTERNAL_C_FLAGS_UNOPTIMIZED)
set(EXTERNAL_C_FLAGS_OPTIMIZED)
set(EXTERNAL_CXX_FLAGS_UNOPTIMIZED)
set(EXTERNAL_CXX_FLAGS_OPTIMIZED)
set(EXTERNAL_LINKER_FLAGS_UNOPTIMIZED)
set(EXTERNAL_LINKER_FLAGS_OPTIMIZED)
set(EXTERNAL_STATICLIB_CMAKE_DEFINITIONS_OPTIMIZED)
set(EXTERNAL_STATICLIB_CONFIGURE_DEFINITIONS_OPTIMIZED)
# Identify platform "bitness".
if(CMAKE_SIZEOF_VOID_P EQUAL 8)
set(BITNESS 64)
else()
set(BITNESS 32)
endif()
message(STATUS "CMAKE BITNESS=${BITNESS}")
# Check memory limits (in megabytes)
if(CMAKE_MAJOR_VERSION GREATER 2)
cmake_host_system_information(RESULT available_physical_memory QUERY AVAILABLE_PHYSICAL_MEMORY)
cmake_host_system_information(RESULT available_virtual_memory QUERY AVAILABLE_VIRTUAL_MEMORY)
math(EXPR available_memory "${available_physical_memory}+${available_virtual_memory}")
message(STATUS "CMAKE MEMORY=${available_memory}")
# Python bindings (particularly mathPYTHON_wrap.cxx) requires more than
# 1GB of memory for compiling with GCC. Send a warning if available memory
# (physical plus virtual(swap)) is less than 1GB
if(${available_memory} LESS 1024)
message(WARNING "Less than 1GB of memory available, compilation may run out of memory!")
endif()
endif()
# Compiler `-D*` definitions
if(UNIX) # or UNIX like (i.e. APPLE and CYGWIN)
set(COMMON_COMPILER_DEFINITIONS
${COMMON_COMPILER_DEFINITIONS}
-DHAVE_UNISTD_H)
elseif(MSVC OR MSYS OR MINGW)
set(COMMON_COMPILER_DEFINITIONS
${COMMON_COMPILER_DEFINITIONS}
-DPSAPI_VERSION=1
-DWIN32
-D_WINDOWS
-D_MBCS
-D_CRT_SECURE_NO_WARNINGS
-DNDEBUG
-D_VARIADIC_MAX=10
-DNOMINMAX)
if(MSYS OR MINGW)
set(COMMON_COMPILER_DEFINITIONS
${COMMON_COMPILER_DEFINITIONS}
-DHAVE_UNISTD_H)
endif()
endif()
#
# Set linker (ld)
# use ld.gold if available
#
execute_process(COMMAND ld.gold --version RESULT_VARIABLE EXIT_CODE)
if(EXIT_CODE EQUAL 0)
message("Using ld.gold as LINKER.")
set(CMAKE_LINKER "ld.gold")
endif()
#
# Determine stdlib settings
#
set(stdlib_cxx "")
set(stdlib_common "")
if(${CMAKE_SYSTEM_NAME} MATCHES "Darwin")
set(stdlib_cxx "${stdlib_cxx} -stdlib=libc++")
endif()
if (${CMAKE_CXX_COMPILER_ID} STREQUAL "GNU")
if (${NUPIC_BUILD_PYEXT_MODULES} AND "${PLATFORM}" STREQUAL "linux")
# NOTE When building manylinux python extensions, we want the static
# libstdc++ due to differences in c++ ABI between the older toolchain in the
# manylinux Docker image and libstdc++ in newer linux distros that is
# compiled with the c++11 ABI. for example, with shared libstdc++, the
# manylinux-built extension is unable to catch std::ios::failure exception
# raised by the shared libstdc++.so while running on Ubuntu 16.04.
set(stdlib_cxx "${stdlib_cxx} -static-libstdc++")
# NOTE We need to use shared libgcc to be able to throw and catch exceptions
# across different shared libraries, as may be the case when our python
# extensions runtime-link to capnproto symbols in pycapnp's extension.
set(stdlib_common "${stdlib_common} -shared-libgcc")
else()
set(stdlib_common "${stdlib_common} -static-libgcc")
set(stdlib_cxx "${stdlib_cxx} -static-libstdc++")
endif()
endif()
#
# Determine Optimization flags here
# These are quite aggresive flags, if your code misbehaves for strange reasons,
# try compiling without them.
#
if(NOT ${CMAKE_CXX_COMPILER_ID} STREQUAL "MSVC")
set(optimization_flags_cc "${optimization_flags_cc} -O2")
set(optimization_flags_cc "-pipe ${optimization_flags_cc}") #TODO use -Ofast instead of -O3
set(optimization_flags_lt "-O2 ${optimization_flags_lt}")
if(NOT ${CMAKE_SYSTEM_PROCESSOR} STREQUAL "armv7l")
set(optimization_flags_cc "${optimization_flags_cc} -mtune=generic")
endif()
if(${CMAKE_CXX_COMPILER_ID} STREQUAL "GNU" AND NOT MINGW)
set(optimization_flags_cc "${optimization_flags_cc} -fuse-ld=gold")
# NOTE -flto must go together in both cc and ld flags; also, it's presently incompatible
# with the -g option in at least some GNU compilers (saw in `man gcc` on Ubuntu)
set(optimization_flags_cc "${optimization_flags_cc} -fuse-linker-plugin -flto-report -flto") #TODO fix LTO for clang
set(optimization_flags_lt "${optimization_flags_lt} -flto") #TODO LTO for clang too
endif()
endif()
#
# compiler specific settings and warnings here
#
set(shared_compile_flags "")
set(internal_compiler_warning_flags "")
set(external_compiler_warning_flags "")
set(cxx_flags_unoptimized "")
set(shared_linker_flags_unoptimized "")
set(fail_link_on_undefined_symbols_flags "")
set(allow_link_with_undefined_symbols_flags "")
if(${CMAKE_CXX_COMPILER_ID} STREQUAL "MSVC")
# MS Visual C
set(shared_compile_flags "${shared_compile_flags} /Zc:wchar_t /Gm- /fp:precise /errorReport:prompt /W1 /WX- /GR /Gd /GS /Oy- /EHs /analyze- /nologo")
set(shared_linker_flags_unoptimized "${shared_linker_flags_unoptimized} /NOLOGO /SAFESEH:NO /NODEFAULTLIB:LIBCMT")
if("${BITNESS}" STREQUAL "32")
set(shared_linker_flags_unoptimized "${shared_linker_flags_unoptimized} /MACHINE:X86")
else()
set(shared_linker_flags_unoptimized "${shared_linker_flags_unoptimized} /MACHINE:X${BITNESS}")
endif()
else()
# LLVM Clang / Gnu GCC
set(cxx_flags_unoptimized "${cxx_flags_unoptimized} ${stdlib_cxx} -std=c++11")
if (${NUPIC_BUILD_PYEXT_MODULES})
# Hide all symbols in DLLs except the ones with explicit visibility;
# see https://gcc.gnu.org/wiki/Visibility
set(cxx_flags_unoptimized "${cxx_flags_unoptimized} -fvisibility-inlines-hidden")
set(shared_compile_flags "${shared_compile_flags} -fvisibility=hidden")
endif()
set(shared_compile_flags "${shared_compile_flags} ${stdlib_common} -fdiagnostics-show-option")
set (internal_compiler_warning_flags "${internal_compiler_warning_flags} -Werror -Wextra -Wreturn-type -Wunused -Wno-unused-variable -Wno-unused-parameter -Wno-missing-field-initializers")
set (external_compiler_warning_flags "${external_compiler_warning_flags} -Wno-unused-variable -Wno-unused-parameter -Wno-incompatible-pointer-types -Wno-deprecated-declarations")
CHECK_CXX_COMPILER_FLAG(-m${BITNESS} compiler_supports_machine_option)
if (compiler_supports_machine_option)
set(shared_compile_flags "${shared_compile_flags} -m${BITNESS}")
set(shared_linker_flags_unoptimized "${shared_linker_flags_unoptimized} -m${BITNESS}")
endif()
if("${CMAKE_SYSTEM_PROCESSOR}" STREQUAL "armv7l")
set(shared_compile_flags "${shared_compile_flags} -marm")
set(shared_linker_flags_unoptimized "${shared_linker_flags_unoptimized} -marm")
endif()
if(NOT ${CMAKE_SYSTEM_NAME} MATCHES "Windows")
set(shared_compile_flags "${shared_compile_flags} -fPIC")
set (internal_compiler_warning_flags "${internal_compiler_warning_flags} -Wall")
if(${CMAKE_CXX_COMPILER_ID} MATCHES "Clang")
set(shared_compile_flags "${shared_compile_flags} -Wno-deprecated-register")
endif()
endif()
set(shared_linker_flags_unoptimized "${shared_linker_flags_unoptimized} ${stdlib_common} ${stdlib_cxx}")
endif()
# Don't allow undefined symbols when linking executables
if(${CMAKE_CXX_COMPILER_ID} STREQUAL "GNU")
set(fail_link_on_undefined_symbols_flags "-Wl,--no-undefined")
elseif(${CMAKE_CXX_COMPILER_ID} MATCHES "Clang")
set(fail_link_on_undefined_symbols_flags "-Wl,-undefined,error")
endif()
# Don't force python extensions to link to specific libpython during build:
# python symbols are made available to extensions atomatically once loaded
#
# NOTE Windows DLLs are shared executables with their own main; they require
# all symbols to resolve at link time.
if(NOT "${PLATFORM}" STREQUAL "windows")
if(${CMAKE_CXX_COMPILER_ID} STREQUAL "GNU")
set(allow_link_with_undefined_symbols_flags "-Wl,--allow-shlib-undefined")
elseif(${CMAKE_CXX_COMPILER_ID} MATCHES "Clang")
set(allow_link_with_undefined_symbols_flags "-Wl,-undefined,dynamic_lookup")
endif()
endif()
# Compatibility with gcc >= 4.9 which requires the use of gcc's own wrappers for
# ar and ranlib in combination with LTO works also with LTO disabled
IF(UNIX AND CMAKE_COMPILER_IS_GNUCXX AND (NOT "${CMAKE_BUILD_TYPE}" STREQUAL "Debug") AND
(CMAKE_CXX_COMPILER_VERSION VERSION_GREATER "4.9" OR
CMAKE_CXX_COMPILER_VERSION VERSION_EQUAL "4.9"))
set(CMAKE_AR "gcc-ar")
set(CMAKE_RANLIB "gcc-ranlib")
# EXTERNAL_STATICLIB_CMAKE_DEFINITIONS_OPTIMIZED duplicates settings for
# CMAKE_AR and CMAKE_RANLIB. This is a workaround for a CMAKE bug
# (https://gitlab.kitware.com/cmake/cmake/issues/15547) that prevents
# the correct propagation of CMAKE_AR and CMAKE_RANLIB variables to all
# externals
list(APPEND EXTERNAL_STATICLIB_CMAKE_DEFINITIONS_OPTIMIZED
-DCMAKE_AR:PATH=gcc-ar
-DCMAKE_RANLIB:PATH=gcc-ranlib)
# And ditto for externals that use the configure-based build system
list(APPEND EXTERNAL_STATICLIB_CONFIGURE_DEFINITIONS_OPTIMIZED
AR=gcc-ar
RANLIB=gcc-ranlib)
ENDIF()
#
# Set up Debug vs. Release options
#
set(build_type_specific_compile_flags)
set(build_type_specific_linker_flags)
if("${CMAKE_BUILD_TYPE}" STREQUAL "Debug")
set (build_type_specific_compile_flags "${build_type_specific_compile_flags} -g")
set(build_type_specific_linker_flags "${build_type_specific_linker_flags} -O0")
if(${CMAKE_CXX_COMPILER_ID} STREQUAL "GNU" OR MINGW)
set (build_type_specific_compile_flags "${build_type_specific_compile_flags} -Og")
# Enable diagnostic features of standard class templates, including ability
# to examine containers in gdb.
# See https://gcc.gnu.org/onlinedocs/libstdc++/manual/debug_mode_using.html
list(APPEND COMMON_COMPILER_DEFINITIONS -D_GLIBCXX_DEBUG)
elseif(${CMAKE_CXX_COMPILER_ID} STREQUAL "Clang")
# NOTE: debug mode is immature in Clang, and values of _LIBCPP_DEBUG above 0
# require the debug build of libc++ to be present at linktime on OS X.
list(APPEND COMMON_COMPILER_DEFINITIONS -D_LIBCPP_DEBUG=0)
endif()
# Disable optimizations
set(optimization_flags_cc)
set(optimization_flags_lt)
endif()
#
# Assemble compiler and linker properties
#
# Settings for internal nupic.core code
set(INTERNAL_CXX_FLAGS_OPTIMIZED "${build_type_specific_compile_flags} ${shared_compile_flags} ${cxx_flags_unoptimized} ${internal_compiler_warning_flags} ${optimization_flags_cc}")
set(complete_linker_flags_unoptimized "${build_type_specific_linker_flags} ${shared_linker_flags_unoptimized}")
set(complete_linker_flags_unoptimized "${complete_linker_flags_unoptimized} ${fail_link_on_undefined_symbols_flags}")
set(INTERNAL_LINKER_FLAGS_OPTIMIZED "${complete_linker_flags_unoptimized} ${optimization_flags_lt}")
# Settings for third-party code and code generated by 3rd-party tools (e.g., Swig bindings)
# (NOTE we omit the explicit compiler warning-related flags here to avoid
# polluting build output with warnings from code that we don't control)
set(EXTERNAL_C_FLAGS_UNOPTIMIZED "${build_type_specific_compile_flags} ${shared_compile_flags} ${external_compiler_warning_flags}")
set(EXTERNAL_C_FLAGS_OPTIMIZED "${EXTERNAL_C_FLAGS_UNOPTIMIZED} ${optimization_flags_cc}")
set(PYEXT_LINKER_FLAGS_OPTIMIZED "${build_type_specific_linker_flags} ${shared_linker_flags_unoptimized}")
set(PYEXT_LINKER_FLAGS_OPTIMIZED "${PYEXT_LINKER_FLAGS_OPTIMIZED} ${optimization_flags_lt}")
set(PYEXT_LINKER_FLAGS_OPTIMIZED "${PYEXT_LINKER_FLAGS_OPTIMIZED} ${allow_link_with_undefined_symbols_flags}")
set(EXTERNAL_CXX_FLAGS_UNOPTIMIZED "${build_type_specific_compile_flags} ${shared_compile_flags} ${external_compiler_warning_flags} ${cxx_flags_unoptimized}")
set(EXTERNAL_CXX_FLAGS_OPTIMIZED "${EXTERNAL_CXX_FLAGS_UNOPTIMIZED} ${optimization_flags_cc}")
set(EXTERNAL_LINKER_FLAGS_UNOPTIMIZED "${complete_linker_flags_unoptimized}")
set(EXTERNAL_LINKER_FLAGS_OPTIMIZED "${INTERNAL_LINKER_FLAGS_OPTIMIZED}")
#
# Provide a string variant of the COMMON_COMPILER_DEFINITIONS list
#
set(COMMON_COMPILER_DEFINITIONS_STR)
foreach(compiler_definition ${COMMON_COMPILER_DEFINITIONS})
set(COMMON_COMPILER_DEFINITIONS_STR "${COMMON_COMPILER_DEFINITIONS_STR} ${compiler_definition}")
endforeach()
message(STATUS "INTERNAL_CXX_FLAGS_OPTIMIZED=${INTERNAL_CXX_FLAGS_OPTIMIZED}")
message(STATUS "INTERNAL_LINKER_FLAGS_OPTIMIZED=${INTERNAL_LINKER_FLAGS_OPTIMIZED}")
message(STATUS "EXTERNAL_C_FLAGS_UNOPTIMIZED=${EXTERNAL_C_FLAGS_UNOPTIMIZED}")
message(STATUS "EXTERNAL_C_FLAGS_OPTIMIZED=${EXTERNAL_C_FLAGS_OPTIMIZED}")
message(STATUS "PYEXT_LINKER_FLAGS_OPTIMIZED=${PYEXT_LINKER_FLAGS_OPTIMIZED}")
message(STATUS "EXTERNAL_CXX_FLAGS_UNOPTIMIZED=${EXTERNAL_CXX_FLAGS_UNOPTIMIZED}")
message(STATUS "EXTERNAL_CXX_FLAGS_OPTIMIZED=${EXTERNAL_CXX_FLAGS_OPTIMIZED}")
message(STATUS "EXTERNAL_LINKER_FLAGS_UNOPTIMIZED=${EXTERNAL_LINKER_FLAGS_UNOPTIMIZED}")
message(STATUS "EXTERNAL_LINKER_FLAGS_OPTIMIZED=${EXTERNAL_LINKER_FLAGS_OPTIMIZED}")
message(STATUS "COMMON_COMPILER_DEFINITIONS=${COMMON_COMPILER_DEFINITIONS}")
message(STATUS "COMMON_COMPILER_DEFINITIONS_STR=${COMMON_COMPILER_DEFINITIONS_STR}")
message(STATUS "EXTERNAL_STATICLIB_CMAKE_DEFINITIONS_OPTIMIZED=${EXTERNAL_STATICLIB_CMAKE_DEFINITIONS_OPTIMIZED}")
message(STATUS "EXTERNAL_STATICLIB_CONFIGURE_DEFINITIONS_OPTIMIZED=${EXTERNAL_STATICLIB_CONFIGURE_DEFINITIONS_OPTIMIZED}")
================================================
FILE: DEPENDENCIES.md
================================================
# Dependencies
This file declares all dependencies nupic.core has on third-party code, including their licenses.
- Capn Proto ([MIT License](https://github.com/sandstorm-io/capnproto/blob/master/LICENSE))
- Boost ([Boost Software License](https://github.com/numenta/nupic.core/blob/master/external/licenses/LICENSE.boost_1_52_0.txt))
- googletest ([googletest License](https://github.com/numenta/nupic.core/blob/master/external/licenses/LICENSE.googletest-1.7.0.txt))
- yaml-cpp ([yaml-cpp License](https://github.com/jbeder/yaml-cpp/blob/master/LICENSE))
- cycle_counter ([License](https://github.com/numenta/nupic.core/blob/master/external/common/include/cycle_counter.hpp))
- zlib ([License](https://github.com/numenta/nupic.core/blob/master/external/licenses/LICENSE.zlib-1.2.3.txt))
- apr ([License](https://github.com/numenta/nupic.core/blob/master/external/licenses/LICENSE.apr-1.2.2.txt))
- apr-util ([License](https://github.com/numenta/nupic.core/blob/master/external/licenses/LICENSE.apr-util-1.2.2.txt))
- freetype ([License](https://github.com/numenta/nupic.core/blob/master/external/licenses/LICENSE.freetype-2.3.4.txt))
- libsvm ([License](https://github.com/numenta/nupic.core/blob/master/external/licenses/LICENSE.libsvm-2.84.txt))
- opencv ([License](https://github.com/numenta/nupic.core/blob/master/external/licenses/LICENSE.opencv-1.0.0.txt))
## Python Dependencies
- numpy ([License](http://www.numpy.org/license.html))
- pycapnp ([License](https://github.com/jparyani/pycapnp/blob/develop/LICENSE))
- pytest ([License](https://bitbucket.org/pytest-dev/pytest/src/45921b2e640011d8f169a7f13fd79218f88c7495/LICENSE?at=default))
- pytest-cov ([MIT License](https://github.com/schlamar/pytest-cov/blob/2.0/pytest-cov/LICENSE.txt))
- pytest-xdist ([MIT License](https://bitbucket.org/pytest-dev/pytest-xdist/src/00cfff4834e718fd3c1ccec40811e734d796f631/LICENSE?at=default))
================================================
FILE: Dockerfile
================================================
FROM ubuntu:14.04
RUN apt-get update && \
apt-get install -y \
curl \
wget \
git-core \
gcc \
g++ \
cmake \
python \
python2.7 \
python2.7-dev \
zlib1g-dev \
bzip2 \
libyaml-dev \
libyaml-0-2
RUN wget http://releases.numenta.org/pip/1ebd3cb7a5a3073058d0c9552ab074bd/get-pip.py -O - | python
RUN pip install --upgrade setuptools
RUN pip install wheel
ENV CC gcc
ENV CXX g++
ADD . /usr/local/src/nupic.core
WORKDIR /usr/local/src/nupic.core
# Explicitly specify --cache-dir, --build, and --no-clean so that build
# artifacts may be extracted from the container later. Final built python
# packages can be found in /usr/local/src/nupic.core/bindings/py/dist
RUN pip install \
--cache-dir /usr/local/src/nupic.core/pip-cache \
--build /usr/local/src/nupic.core/pip-build \
--no-clean \
pycapnp==0.6.3 \
-r bindings/py/requirements.txt && \
python setup.py bdist bdist_dumb bdist_wheel sdist
================================================
FILE: LICENSE.txt
================================================
Copyright 2013-2024 Numenta Inc.
Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:
The above copyright notice and this permission notice shall be included in all
copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
SOFTWARE.
================================================
FILE: README.md
================================================
<img src="http://numenta.org/87b23beb8a4b7dea7d88099bfb28d182.svg" alt="NuPIC Logo" width=100/>
As of September 2023 this repository contains code from legacy Hierarchical Temporal Memory (HTM) Numenta projects that have been in maintenance mode for several years.
# NuPIC Core [](https://travis-ci.org/numenta/nupic.core) [](https://ci.appveyor.com/project/numenta-ci/nupic-core/branch/master) [](https://circleci.com/gh/numenta/nupic.core) [](https://coveralls.io/r/numenta/nupic.core?branch=master)
This repository contains the C++ source code for the Numenta Platform for Intelligent Computing ([NuPIC](http://numenta.org/nupic.html)). It will eventually contain all algorithms for NuPIC, but is currently in a transition period. For details on building NuPIC within the python environment, please see http://github.com/numenta/nupic.
## Installing from a Release
You can install the `nupic.bindings` Python package from PyPI:
pip install nupic.bindings
Optionally include `--user` or other flags to determine where the package is installed.
> **Note**: On Linux this will do a source installation and will require that the prerequisites specified below are installed.
## Building from Source
Important notes:
* `$NUPIC_CORE` is the current location of the repository that you downloaded from GitHub.
* Platform specific Readme.md text files exist in some `external/` subdirectories
* See the main [wiki](https://github.com/numenta/nupic.core/wiki) for more build notes
### Prerequisites
- Python - We recommend you use the system version where possibly.
- Version 2.7
- [NumPy](http://www.numpy.org/) - Can be installed through some system package managers or via [pip](https://pip.pypa.io/)
- Version 1.12.1
- [pycapnp](http://jparyani.github.io/pycapnp/)
- Version 0.5.8 (_Linux and OSX only_)
- [CMake](http://www.cmake.org/)
> **Note**: On Windows, Python package dependencies require the following compiler package to be installed: [Microsoft Visual C++ Compiler for Python 2.7](https://www.microsoft.com/en-gb/download/details.aspx?id=44266)
The Python dependencies (NumPy and pycapnp) can be installed with `pip`:
pip install -r bindings/py/requirements.txt
### Simple Source Installation (does not support incremental builds)
The easiest way to build from source is as follows. This does not support incremental builds.
python setup.py install
Optionally include `--user` or other flags to determine where the package is installed.
### Testing the Installation
Regardless of how you install `nupic.bindings`, the `nupic-bindings-check` command-line script should be installed. Make sure that you include the Python `bin` installation location in your `PATH` environment variable and then execute the script:
nupic-bindings-check
### Developer Installation
This option is for developers that would like the ability to do incremental builds of the C++ or for those that are using the C++ libraries directly.
> **Note**: The following sub-sections are related to Linux and OSX only. For Windows refer to the `external\windows64-gcc\README.md` file.
#### Configure and generate C++ build files:
mkdir -p $NUPIC_CORE/build/scripts
cd $NUPIC_CORE/build/scripts
cmake $NUPIC_CORE -DCMAKE_BUILD_TYPE=Release -DCMAKE_INSTALL_PREFIX=../release -DPY_EXTENSIONS_DIR=$NUPIC_CORE/bindings/py/src/nupic/bindings
Notes:
- This will generate Release build files. For a debug build, change `-DCMAKE_BUILD_TYPE` to `Debug`.
- To build nupic.core for generating the nupic.bindings python extension, pass `-DNUPIC_BUILD_PYEXT_MODULES=ON`; it is the default at this time.
- To build nupic.core as a standalone static library, pass `-DNUPIC_BUILD_PYEXT_MODULES=OFF`.
- If you have dependencies precompiled but not in standard system locations then you can specify where to find them with `-DCMAKE_PREFIX_PATH` (for bin/lib) and `-DCMAKE_INCLUDE_PATH` (for header files).
- The `-DCMAKE_INSTALL_PREFIX=../release` option shown above is optional, and specifies the location where `nupic.core` should be installed. If omitted, `nupic.core` will be installed in a system location. Using this option is useful when testing versions of `nupic.core` language bindings in [`bindings`](bindings).
- Setting `-DPY_EXTENSIONS_DIR` copies the Python exension files to the specified directory. If the extensions aren't present when the Python build/installation is invoked then the setup.py file will run the cmake/make process to generate them. Make sure to include this flag if you want to do incremental builds of the Python extensions.
- On OSX with multiple Python installs (e.g. via brew) cmake might erroneously pick various pieces from different installs which will likely produce abort trap at runtime. Remove cmake cache and re-run cmake with `-DPYTHON_LIBRARY=/path/to/lib/libpython2.7.dylib` and `-DPYTHON_INCLUDE_DIR=/path/to/include/python2.7` options to override with desired Python install path.
- To use Include What You Use during compilation, pass `-DNUPIC-IWYU=ON`. This requires that IWYU is installed and findable by CMake, with a minimum CMake version of 3.3. IWYU can be installed from https://include-what-you-use.org/ for Windows and Linux, and on OS X using https://github.com/jasonmp85/homebrew-iwyu.
- If you would like to install all headers, libraries, and executables to the install location for C++ clients when building the nupic.binding python extensions, pass `-NUPIC_TOGGLE_INSTALL=ON`.
#### Build:
# While still in $NUPIC_CORE/build/scripts
make -j3
> **Note**: The `-j3` option specifies '3' as the maximum number of parallel jobs/threads that Make will use during the build in order to gain speed. However, you can increase this number depending your CPU.
#### Install:
# While still in $NUPIC_CORE/build/scripts
make install
#### Run the tests:
cd $NUPIC_CORE/build/release/bin
./cpp_region_test
./unit_tests
...
#### Install nupic.bindings Python library:
cd $NUPIC_CORE
python setup.py develop
> **Note**: If the extensions haven't been built already then this will call the cmake/make process to generate them.
If you get a gcc exit code 1, you may consider running this instead:
python setup.py develop --user
If you are installing on Mac OS X, you must add the instruction `ARCHFLAGS="-arch x86_64"` before the python call:
ARCHFLAGS="-arch x86_64" python setup.py develop
Alternatively, you can use the `install` command (as opposed to `develop`) to copy the installation files rather than link to the source location.
python setup.py install
> _Note_: If you get a "permission denied" error when using the setup commands above, you may add the `--user` flag to install to a location in your home directory, which should resolve any permissions issues. Doing this, you may need to add this location to your PATH and PYTHONPATH.
Once it is installed, you can import NuPIC bindings library to your python script using:
import nupic.bindings
You can run the nupic.bindings tests via `setup.py`:
python setup.py test
### Using graphical interface
#### Generate the IDE solution:
* Open CMake executable.
* Specify the source folder (`$NUPIC_CORE/src`).
* Specify the build system folder (`$NUPIC_CORE/build/scripts`), i.e. where IDE solution will be created.
* Click `Generate`.
* Choose the IDE that interest you (remember that IDE choice is limited to your OS, i.e. Visual Studio is available only on CMake for Windows).
#### Build:
* Open `nupic_core.*proj` solution file generated on `$NUPIC_CORE/build/scripts`.
* Run `ALL_BUILD` project from your IDE.
#### Run the tests:
* Run any `tests_*` project from your IDE (check `output` panel to see the results).
## Build Documentation
Run doxygen, optionally specifying the version as an environment variable:
PROJECT_VERSION=`cat VERSION` doxygen
The results will be written out to the `html` directory.
================================================
FILE: RELEASE.md
================================================
# Release Process
1. Select a green build in Bamboo that has the changes that you want to release
2. Ensure that this build has the correct version in the VERSION file
3. Create a Bamboo release with version matching the VERSION file in the repo
4. Deploy the release in Bamboo. This will:
- Validate that the Bamboo release number matches the wheel versions.
- Push the wheels to PyPI
- Push the source archive to S3
- Create a Github release
- Tag the repo commit with the version
- Bump the VERSION file to the next bugfix release number
================================================
FILE: VERSION
================================================
1.0.7.dev0
================================================
FILE: appveyor.yml
================================================
#---------------------------------#
# general configuration #
#---------------------------------#
image: Visual Studio 2015
# version format
version: 0.3.0.{build}
branches:
except:
- gh-pages
skip_commits:
# Add [av skip] to commit messages to skip AppVeyor building
# Add [ci skip] to skip Travis and AppVeyor building
message: /\[av skip\]/
#---------------------------------#
# environment configuration #
#---------------------------------#
# http://www.appveyor.com/docs/environment-variables
# http://www.appveyor.com/docs/installed-software
init:
- git config --global core.autocrlf input
clone_folder: c:\projects\nupic-core
clone_depth: 1
# Can't have a shallow clone because the CMake process will be
# calling into git to write the current SHA into the binaries.
shallow_clone: false
environment:
COMPILER_FAMILY: GCC
AWS_ACCESS_KEY_ID:
secure: /9U0mCHp3k1U8Y5CY/kDqwCKG2gqchG/T/UlVWo8SME=
AWS_SECRET_ACCESS_KEY:
secure: /8wO17Gir0XAiecJkHeE3jxOJzvyl0+uWcl7BKCuN0FC795golsL8905VmNuRl1o
PYPI_USERNAME: numenta
PYPI_PASSWORD:
secure: UgABryPYZg823OcD1XRosA==
matrix:
# Win64-gcc
- PYTHON_VERSION: "2.7.9"
PYTHON_ARCH: "64"
PYTHONHOME: "C:\\Python27-x64"
NC_CMAKE_GENERATOR: "MinGW Makefiles"
external_static_subdir: "windows64-gcc"
wheel_name_suffix: "win_amd64"
# Win32-gcc
# - PYTHON_VERSION: "2.7.9"
# PYTHON_ARCH: "32"
# PYTHONHOME: "C:\\Python27"
# NC_CMAKE_GENERATOR: "MinGW Makefiles"
# external_static_subdir: "windows32-gcc"
# wheel_name_suffix: "win32"
# # Win64-Visual Studio
# - PYTHON_VERSION: "2.7.9"
# PYTHON_ARCH: "64"
# PYTHONHOME: "C:\\Python27-x64"
# NC_CMAKE_GENERATOR: "Visual Studio 14 2015 Win64"
# external_static_subdir: "windows64"
# wheel_name_suffix: "win_amd64"
matrix:
allow_failures:
# Checking if Visual Studio build is possible
- NC_CMAKE_GENERATOR: "Visual Studio 14 2015 Win64"
#---------------------------------#
# build configuration #
#---------------------------------#
# configuration values must be compatible with CMAKE_BUILD_TYPE: Debug or Release
configuration: Release
install:
# Dump appveyor build vars for diagnostics
- "ECHO APPVEYOR_FORCED_BUILD: %APPVEYOR_FORCED_BUILD%"
- "ECHO APPVEYOR_RE_BUILD: %APPVEYOR_RE_BUILD%"
- set NUPIC_CORE=c:\projects\nupic-core
- set EXTERNAL_WINDOWS_DIR=%NUPIC_CORE%\external\%external_static_subdir%
- set ARTIFACTS_DIR=%NUPIC_CORE%\build\artifacts
- for /f %%i in ('type VERSION') do set BINDINGS_VERSION=%%i
- echo Binding version = %BINDINGS_VERSION%
- set PYTHONPATH=%PYTHONHOME%
- set PATH=%PYTHONHOME%\Scripts;%PYTHONHOME%;%PATH%
# Make unix-compatible patch.exe available to the build by copying it from
# Git\usr\bin (that we remove from PATH) to another directory and adding it to
# PATH; the reason we copy it is that logic below removes
# C:\Program Files\Git\usr\bin from Path to avoid build issue resulting from
# sh.exe being on the path.
- mkdir "C:\Program Files\PatchFromGit"
- ps: copy "C:\Program Files\Git\usr\bin\patch.exe" "C:\Program Files\PatchFromGit"
- ps: copy "C:\Program Files\Git\usr\bin\msys*.dll" "C:\Program Files\PatchFromGit"
- set PATH=C:\Program Files\PatchFromGit;%PATH%
- echo %PATH%
#
# Install Python 2.7.x, Pip, Wheel, and NumPy
#
- cd %NUPIC_CORE%\ci\appveyor
- ps: .\install_python_pip.ps1
#
# Install mingwpy toolchain
#
- ECHO "Installing MinGW toolchain for Python"
# Install the version of mingwpy toolchain that generates targets compatible
# with the installed python (Win32 vs. Win64). The compiler tools are
# installed into %PYTHONHOME%/Scripts/
- cmd: "%PYTHONHOME%\\Scripts\\pip.exe install -i https://pypi.anaconda.org/carlkl/simple mingwpy==0.1.0b3"
- cmd: "where g++"
- cmd: "g++ --version"
- cmd: "dir %PYTHONHOME%\\share\\mingwpy"
# Setup MinGW GCC as a valid distutils compiler
- cp %EXTERNAL_WINDOWS_DIR%\bin\distutils.cfg %PYTHONHOME%\Lib\distutils\distutils.cfg
# Display the version and architecture for Python to help with diagnostics
- "python --version"
- "where python"
- "python -c \"import struct; print(struct.calcsize('P') * 8)\""
# It's useful to know our cmake version
- cmd: where cmake
- cmd: cmake --version
# Check NumPy, etc. installed correctly
- cmd: pip list
- cd %NUPIC_CORE%
- mkdir %NUPIC_CORE%\build\
- mkdir %NUPIC_CORE%\build\release
- mkdir %NUPIC_CORE%\build\scripts
# Remove sh.exe from the paths (CMake doesn't like it)
- set PATH=%PATH:C:\Program Files (x86)\Git\bin;=%
- set PATH=%PATH:C:\Program Files\Git\usr\bin;=%
- set PATH=%PATH:C:\MinGW\msys\1.0\bin;=%
# Verify that patch command is available
- "where patch"
# Fake KJ-Async and Capnp-RPC libs, not needed in Lite mode
# http://www.cmake.org/Wiki/CmakeMingw
- cd %NUPIC_CORE%\build\scripts
- cmake -G "%NC_CMAKE_GENERATOR%"
-DCMAKE_BUILD_TYPE=%configuration%
-DCMAKE_INSTALL_PREFIX=%NUPIC_CORE%\build\release
-DPY_EXTENSIONS_DIR=%NUPIC_CORE%\bindings\py\src\nupic\bindings
%NUPIC_CORE%
build_script:
- cd %NUPIC_CORE%\build\scripts
# Run build, using portable, toolchain-agnostic mechanism to start it
- cmake.exe --build "%NUPIC_CORE%\build\scripts" --target install --config %configuration%
- cd %NUPIC_CORE%
- python setup.py sdist bdist bdist_wheel
- set NUPIC_BINDINGS_WHEEL_NAME=nupic.bindings-%BINDINGS_VERSION%-cp27-none-%wheel_name_suffix%.whl
# Copy final wheel to NUPIC_CORE, so that AppVeyor can see it as an artifact
- ps: copy .\bindings\py\dist\$env:NUPIC_BINDINGS_WHEEL_NAME .
# Copy final wheel, to appropriately named wheel for use with NuPIC
# iterative builds (via nupic\.nupic_modules long-SHA reference).
# Ties in with this Pip regex;
# https://github.com/pypa/pip/blob/develop/pip/wheel.py#L616
- ps: copy .\$env:NUPIC_BINDINGS_WHEEL_NAME .\nupic.bindings-$env:APPVEYOR_REPO_COMMIT-cp27-none-$env:wheel_name_suffix.whl
after_build:
# Install nupic.bindings first, because py_region_test.exe depends on it.
- pip install .\%NUPIC_BINDINGS_WHEEL_NAME%
# Run legacy binary tests
- mkdir %ARTIFACTS_DIR%
- cd %NUPIC_CORE%\build\release\bin
- py_region_test.exe
- connections_performance_test.exe
- cpp_region_test.exe
- helloregion.exe
- hello_sp_tp.exe
- prototest.exe
- unit_tests.exe --gtest_output=xml:%ARTIFACTS_DIR%\unit_tests_report.xml
# Run python tests
- cd %NUPIC_CORE%
- python setup.py test
# Disable automatic tests
test: off
artifacts:
# Non-recursive search in build folder for Wheels
- path: '*.whl'
# NOTE: This is turned off and will likely be removed once deployments of
# releases are controlled from a central authority. -- Matt
# -----------------------------------------------------------------------
# on_success:
# # Github tagged builds
# - cmd: echo "executing on_success"
# - ps: >-
# If ($env:APPVEYOR_REPO_TAG -eq "true" -or $env:APPVEYOR_REPO_TAG -eq "True") {
# Write-Host "Uploading bindings to PYPI"
# pip install httplib requests twine --upgrade
# twine upload -u $env:PYPI_USERNAME -p $env:PYPI_PASSWORD -r pypi $env:NUPIC_CORE\bindings\py\dist\nupic.bindings-$env:BINDINGS_VERSION-cp27-none-$env:wheel_name_suffix.whl
# }
deploy:
# Iterative builds
- provider: S3
access_key_id: AKIAIGHYSEHV3WFKOWNQ
secret_access_key:
secure: /8wO17Gir0XAiecJkHeE3jxOJzvyl0+uWcl7BKCuN0FC795golsL8905VmNuRl1o
bucket: "artifacts.numenta.org"
region: us-west-2
set_public: true
artifact: "nupic.bindings-$(APPVEYOR_REPO_COMMIT)-cp27-none-$(wheel_name_suffix).whl"
folder: "numenta/nupic.core/releases/nupic.bindings"
on:
branch: master
================================================
FILE: bindings/py/dummy.c
================================================
#include <stdio.h>
int main()
{
return 0;
}
void initdummy() {}
================================================
FILE: bindings/py/requirements.txt
================================================
#See http://www.pip-installer.org/en/latest/requirements.html for details
numpy==1.12.1
pytest==3.0.7
pytest-cov==2.5.0
pytest-xdist==1.16.0
pycapnp==0.6.3
================================================
FILE: bindings/py/setup.py
================================================
# Copyright 2015 Numenta Inc.
#
# Copyright may exist in Contributors' modifications
# and/or contributions to the work.
#
# Use of this source code is governed by the MIT
# license that can be found in the LICENSE file or at
# https://opensource.org/licenses/MIT.
"""This file builds and installs the NuPIC Core Python bindings."""
import glob
import os
import shutil
import subprocess
import sys
import tempfile
from setuptools import Command, find_packages, setup
from setuptools.command.test import test as BaseTestCommand
from distutils.core import Extension
PY_BINDINGS = os.path.dirname(os.path.realpath(__file__))
REPO_DIR = os.path.abspath(os.path.join(PY_BINDINGS, os.pardir, os.pardir))
DARWIN_PLATFORM = "darwin"
LINUX_PLATFORM = "linux"
UNIX_PLATFORMS = [LINUX_PLATFORM, DARWIN_PLATFORM]
WINDOWS_PLATFORMS = ["windows"]
def getVersion():
"""
Get version from local file.
"""
with open(os.path.join(REPO_DIR, "VERSION"), "r") as versionFile:
return versionFile.read().strip()
class CleanCommand(Command):
"""Command for cleaning up intermediate build files."""
description = "Command for cleaning up generated extension files."
user_options = []
def initialize_options(self):
pass
def finalize_options(self):
pass
def run(self):
platform = getPlatformInfo()
files = getExtensionFileNames(platform)
for f in files:
try:
os.remove(f)
except OSError:
pass
def fixPath(path):
"""
Ensures paths are correct for linux and windows
"""
path = os.path.abspath(os.path.expanduser(path))
if path.startswith("\\"):
return "C:" + path
return path
def findRequirements(platform):
"""
Read the requirements.txt file and parse into requirements for setup's
install_requirements option.
"""
includePycapnp = platform not in WINDOWS_PLATFORMS
requirementsPath = fixPath(os.path.join(PY_BINDINGS, "requirements.txt"))
return [
line.strip()
for line in open(requirementsPath).readlines()
if not line.startswith("#") and (not line.startswith("pycapnp") or includePycapnp)
]
class TestCommand(BaseTestCommand):
user_options = [("pytest-args=", "a", "Arguments to pass to py.test")]
def initialize_options(self):
BaseTestCommand.initialize_options(self)
self.pytest_args = [] # pylint: disable=W0201
def finalize_options(self):
BaseTestCommand.finalize_options(self)
self.test_args = []
self.test_suite = True
def run_tests(self):
import pytest
cwd = os.getcwd()
try:
os.chdir("tests")
errno = pytest.main(self.pytest_args)
finally:
os.chdir(cwd)
sys.exit(errno)
def getPlatformInfo():
"""Identify platform."""
if "linux" in sys.platform:
platform = "linux"
elif "darwin" in sys.platform:
platform = "darwin"
# win32
elif sys.platform.startswith("win"):
platform = "windows"
else:
raise Exception("Platform '%s' is unsupported!" % sys.platform)
return platform
def getExtensionFileNames(platform):
if platform in WINDOWS_PLATFORMS:
libExtension = "pyd"
else:
libExtension = "so"
libNames = ("algorithms", "engine_internal", "math")
swigPythonFiles = ["{}.py".format(name) for name in libNames]
swigLibFiles = ["_{}.{}".format(name, libExtension) for name in libNames]
files = [os.path.join(PY_BINDINGS, "src", "nupic", "bindings", name)
for name in list(swigPythonFiles + swigLibFiles)]
return files
def getExtensionFiles(platform):
files = getExtensionFileNames(platform)
for f in files:
if not os.path.exists(f):
generateExtensions()
break
return files
def generateExtensions():
tmpDir = tempfile.mkdtemp()
cwd = os.getcwd()
try:
scriptsDir = os.path.join(tmpDir, "scripts")
releaseDir = os.path.join(tmpDir, "release")
pyExtensionsDir = os.path.join(PY_BINDINGS, "src", "nupic", "bindings")
os.mkdir(scriptsDir)
os.chdir(scriptsDir)
subprocess.check_call(
["cmake", REPO_DIR, "-DCMAKE_INSTALL_PREFIX={}".format(releaseDir),
"-DPY_EXTENSIONS_DIR={}".format(pyExtensionsDir)])
subprocess.check_call(["make", "-j3"])
subprocess.check_call(["make", "install"])
finally:
shutil.rmtree(tmpDir, ignore_errors=True)
os.chdir(cwd)
if __name__ == "__main__":
platform = getPlatformInfo()
if platform == DARWIN_PLATFORM and not "ARCHFLAGS" in os.environ:
raise Exception("To build NuPIC Core bindings in OS X, you must "
"`export ARCHFLAGS=\"-arch x86_64\"`.")
# Run CMake if extension files are missing.
getExtensionFiles(platform)
# Copy the proto files into the proto Python package.
destDir = os.path.relpath(os.path.join("src", "nupic", "proto"))
for protoPath in glob.glob(os.path.relpath(os.path.join(
"..", "..", "src", "nupic", "proto", "*.capnp"))):
shutil.copy(protoPath, destDir)
print "\nSetup SWIG Python module"
setup(
name="nupic.bindings",
version=getVersion(),
# This distribution contains platform-specific C++ libraries, but they are not
# built with distutils. So we must create a dummy Extension object so when we
# create a binary file it knows to make it platform-specific.
ext_modules=[Extension('nupic.dummy', sources = ['dummy.c'])],
package_dir = {"": "src"},
packages=find_packages("src"),
namespace_packages=["nupic"],
install_requires=findRequirements(platform),
package_data={
"nupic.proto": ["*.capnp"],
"nupic.bindings": ["*.so", "*.pyd"],
"nupic.bindings.tools": ["*.capnp"],
},
extras_require = {"capnp": ["pycapnp==0.6.3"]},
zip_safe=False,
cmdclass={
"clean": CleanCommand,
"test": TestCommand,
},
description="Numenta Platform for Intelligent Computing - bindings",
author="Numenta",
author_email="help@numenta.org",
url="https://github.com/numenta/nupic.core",
long_description = "Python bindings for nupic core.",
classifiers=[
"Programming Language :: Python",
"Programming Language :: Python :: 2",
"License :: OSI Approved :: MIT License",
"Operating System :: MacOS :: MacOS X",
"Operating System :: POSIX :: Linux",
"Operating System :: Microsoft :: Windows",
# It has to be "5 - Production/Stable" or else pypi rejects it!
"Development Status :: 5 - Production/Stable",
"Environment :: Console",
"Intended Audience :: Science/Research",
"Topic :: Scientific/Engineering :: Artificial Intelligence"
],
entry_points = {
"console_scripts": [
"nupic-bindings-check = nupic.bindings.check:checkMain",
],
},
)
================================================
FILE: bindings/py/src/nupic/__init__.py
================================================
# Copyright 2013 Numenta Inc.
#
# Copyright may exist in Contributors' modifications
# and/or contributions to the work.
#
# Use of this source code is governed by the MIT
# license that can be found in the LICENSE file or at
# https://opensource.org/licenses/MIT.
"""
## @file
"""
__import__('pkg_resources').declare_namespace(__name__)
================================================
FILE: bindings/py/src/nupic/bindings/regions/PyRegion.py
================================================
# Copyright 2013-2015 Numenta Inc.
#
# Copyright may exist in Contributors' modifications
# and/or contributions to the work.
#
# Use of this source code is governed by the MIT
# license that can be found in the LICENSE file or at
# https://opensource.org/licenses/MIT.
"""
This file defines the base class for Python regions.
"""
import numpy
import collections
RealNumpyDType = numpy.float32
from abc import ABCMeta, abstractmethod
class DictReadOnlyWrapper(collections.Mapping):
"""
Provides read-only access to a dict. When dict items are mutable, they can
still be mutated in-place, but dict items can't be reassigned.
"""
def __init__(self, d):
self._d = d
def __iter__(self):
return iter(self._d)
def __len__(self):
return len(self._d)
def __getitem__(self, key):
return self._d[key]
class PyRegion(object):
"""
PyRegion provides services to its sub-classes (the actual regions):
- Define and document the interface of a Python region
- Enforce implementation of required methods
- Default implementation for some methods
PyRegion is an abstract base class (http://docs.python.org/library/abc.html).
If a subclass doesn't implement all its abstract methods it can't be
instantiated. Note, that the signature of implemented abstract method in the
subclass doesn't need to match the signature of the abstract method in the
base class. This is very important for
:meth:`~nupic.bindings.regions.PyRegion.PyRegion.__init__` in this case.
The abstract methods (decorated with ``@abstract`` method) are:
* :meth:`~nupic.bindings.regions.PyRegion.PyRegion.__init__`
* :meth:`~nupic.bindings.regions.PyRegion.PyRegion.initialize`
* :meth:`~nupic.bindings.regions.PyRegion.PyRegion.compute`
In addition, some PyRegion methods raise ``NotImplementedError`` which throws
an exception if called. A sub-class may opt not to implement these
methods, but if such a methods is called then a ``NotImplementedError`` will
be raised. This is useful for methods like :meth:`setParameterArray` if a
particular subclass has no array parameters.
The not implemented methods are:
* :meth:`~nupic.bindings.regions.PyRegion.PyRegion.getSpec` (class method)
* :meth:`~nupic.bindings.regions.PyRegion.PyRegion.setParameter`
* :meth:`~nupic.bindings.regions.PyRegion.PyRegion.setParameterArray`
* :meth:`~nupic.bindings.regions.PyRegion.PyRegion.getOutputElementCount`
The :meth:`~nupic.bindings.regions.PyRegion.PyRegion.getSpec` is a class
method, which is actually required but since
it's not an instance method the ``@abstractmethod`` decorator doesn't apply.
Finally, PyRegion provides reasonable default implementation to some methods.
Sub-classes may opt to override these methods or use the default
implementation (often recommended).
The implemented methods are:
* :meth:`~nupic.bindings.regions.PyRegion.PyRegion.getParameter`
* :meth:`~nupic.bindings.regions.PyRegion.PyRegion.getParameterArray`
* :meth:`~nupic.bindings.regions.PyRegion.PyRegion.getParameterArrayCount`
* :meth:`~nupic.bindings.regions.PyRegion.PyRegion.executeMethod`
"""
__metaclass__ = ABCMeta
@classmethod
def getSpec(cls):
"""
This class method is called by NuPIC before creating a Region.
:returns: (dict) the region spec for this region. Keys described below:
- ``description`` (string) user-provided description
- ``singleNodeOnly`` (bool) True if this Region supports only a single
node
- ``inputs`` (dict) keys are the names of the inputs and the values are
dictionaries with these keys:
- ``description`` (string) user-provided description
- ``regionLevel`` (bool) True if this is a "region-level" input
- ``dataType`` (string) describing the data type, usually ``Real32``
- ``count`` (int) items in the input. 0 means unspecified.
- ``required`` (bool) whether the input is must be connected
- ``isDefaultInput`` (bool) must be True for exactly one input
- ``requireSplitterMap`` (bool) [just set this to False.]
- ``isSparse`` (bool) whether the input is sparse
- ``outputs`` (dict) similar structure to inputs. The keys
are:
- ``description``
- ``dataType``
- ``count``
- ``regionLevel``
- ``isDefaultOutput``
- ``isSparse``
- ``parameters`` (dict) of dicts with the following keys:
- ``description``
- ``dataType``
- ``count``
- ``constraints`` (optional)
- ``accessMode`` (one of "ReadWrite", "Read", "Create")
"""
raise NotImplementedError()
@abstractmethod
def __init__(self, *args, **kwars):
"""Initialize the node with creation parameters from the node spec
Should be implemented by subclasses (unless there are no creation params)
"""
@abstractmethod
def initialize(self):
"""Initialize the node after the network is fully linked
It is called once by NuPIC before the first call to
:meth:`~nupic.bindings.regions.PyRegion.PyRegion.compute`. It is
a good place to perform one time initialization that depend on the inputs
and/or outputs. The region may also remember its inputs and outputs here
because they will not change.
"""
@abstractmethod
def compute(self, inputs, outputs):
"""Perform the main computation.
This method is called in each iteration for each phase the node supports.
:param inputs: (dict) of numpy arrays (one per input)
:param outputs: (dict) of numpy arrays (one per output)
"""
def guardedCompute(self, inputs, outputs):
"""The C++ entry point to compute.
:param inputs: (dict) of numpy arrays (one per input)
:param outputs: (dict) of numpy arrays (one per output)
"""
return self.compute(inputs, DictReadOnlyWrapper(outputs))
def getOutputElementCount(self, name):
"""
If the region has multiple nodes (all must have the same output
size) then just the number of output elements of a single node
should be returned.
:param name: (string) the name of the output
:returns: (int) number of elements in the output of a single node.
"""
raise NotImplementedError()
def getParameter(self, name, index):
"""Default implementation that return an attribute with the requested name.
This method provides a default implementation of
:meth:`~nupic.bindings.regions.PyRegion.PyRegion.getParameter` that
simply returns an attribute with the parameter name. If the Region
conceptually contains multiple nodes with separate state, the ``index``
argument is used to request a parameter of a specific node inside the
region. In case of a region-level parameter the index should be ``-1``.
The implementation prevents accessing parameters names that start with
``_``. It may be better to enforce this convention at the node spec level.
:param name: (string) name of requested parameter
:param index: (int) index of node inside the region (if relevant)
"""
if name.startswith('_'):
raise Exception('Parameter name must not start with an underscore')
value = getattr(self, name)
return value
def getParameterArrayCount(self, name, index):
"""Default implementation that return the length of the attribute.
This default implementation goes hand in hand with
:meth:`~nupic.bindings.regions.PyRegion.PyRegion.getParameterArray`.
If you override one of them in your subclass, you should probably override
both of them.
The implementation prevents accessing parameters names that start with
``_``. It may be better to enforce this convention at the node spec level.
:param name: (string) name of requested parameter
:param index: (int) index of node inside the region (if relevant)
:raises: Exception if parameter starts with ``_``.
"""
if name.startswith('_'):
raise Exception('Parameter name must not start with an underscore')
return len(self.parameters[name])
def getParameterArray(self, name, index, array):
"""Default implementation that return an attribute with the requested name.
This method provides a default implementation of
:meth:`~nupic.bindings.regions.PyRegion.PyRegion.getParameterArray`
that returns an attribute with the parameter name. If the Region
conceptually contains multiple nodes with separate state the ``index``
argument is used to request a parameter of a specific node inside the
region. The attribute value is written into the output array. No type or
sanity checks are performed for performance reasons. If something goes awry
it will result in a low-level exception. If you are unhappy about it you can
implement your own
:meth:`~nupic.bindings.regions.PyRegion.PyRegion.getParameterArray`
method in the subclass.
The implementation prevents accessing parameters names that start with
``_``. It may be better to enforce this convention at the node spec level.
:param name: (string) name of requested parameter
:param index: (int) index of node inside the region (if relevant)
:param array: output numpy array that the value is written to
:raises: Exception if parameter starts with ``_``.
"""
if name.startswith('_'):
raise Exception('Parameter name must not start with an underscore')
v = getattr(self, name)
# Not performing sanity checks for performance reasons.
#assert array.dtype == v.dtype
#assert len(array) == len(v)
array[:] = v
def setParameter(self, name, index, value):
"""Set the value of a parameter.
If the Region conceptually contains multiple nodes with separate state
the ``index`` argument is used set a parameter of a specific node inside
the region.
:param name: (string) name of requested parameter
:param index: (int) index of node inside the region (if relevant)
:param value: (object) the value to assign to the requested parameter
:raises: NotImplementedError if function is not implemented in subclass
"""
raise NotImplementedError("The method setParameter is not implemented.")
def setParameterArray(self, name, index, array):
"""Set the value of an array parameter
If the Region conceptually contains multiple nodes with separate state
the 'index' argument is used set a parameter of a specific node inside
the region.
:param name: (string) name of requested parameter
:param index: (int) index of node inside the region (if relevant)
:param array: the value to assign to the requested parameter (a numpy array)
:raises: NotImplementedError if function is not implemented in subclass
"""
raise NotImplementedError()
def serializeExtraData(self, filePath):
"""This method is called during network serialization with an external
filename that can be used to bypass pickle for saving large binary states.
:param filePath: (string) full filepath and name
"""
pass
def deSerializeExtraData(self, filePath):
"""This method is called during network deserialization with an external
filename that can be used to bypass pickle for loading large binary states.
:param filePath: (string) full filepath and name
"""
pass
@staticmethod
def getSchema():
"""Return the pycapnp proto type that the class uses for serialization.
This is used to convert the proto into the proper type before passing it
into the read or write method of the subclass.
:returns: PyRegionProto prototype object
:raises: NotImplementedError if function is not implemented in subclass
"""
raise NotImplementedError()
def write(self, proto):
"""
Calls :meth:`~nupic.bindings.regions.PyRegion.PyRegion.writeToProto`
on subclass after converting proto to specific type using
:meth:`~nupic.bindings.regions.PyRegion.PyRegion.getSchema`.
:param proto: PyRegionProto capnproto object
"""
regionImpl = proto.regionImpl.as_struct(self.getSchema())
self.writeToProto(regionImpl)
@classmethod
def read(cls, proto):
"""
Calls :meth:`~nupic.bindings.regions.PyRegion.PyRegion.readFromProto`
on subclass after converting proto to specific type using
:meth:`~nupic.bindings.regions.PyRegion.PyRegion.getSchema`.
:param proto: PyRegionProto capnproto object
"""
regionImpl = proto.regionImpl.as_struct(cls.getSchema())
return cls.readFromProto(regionImpl)
def writeToProto(self, proto):
"""Write state to proto object.
The type of proto is determined by
:meth:`~nupic.bindings.regions.PyRegion.PyRegion.getSchema`.
:raises: NotImplementedError if function is not implemented in subclass
"""
raise NotImplementedError()
@classmethod
def readFromProto(cls, proto):
"""Read state from proto object.
The type of proto is determined by
:meth:`~nupic.bindings.regions.PyRegion.PyRegion.getSchema`.
:raises: NotImplementedError if function is not implemented in subclass
"""
raise NotImplementedError()
def executeMethod(self, methodName, args):
"""Executes a method named ``methodName`` with the specified arguments.
This method is called when the user executes a command as defined in
the node spec. It provides a perfectly reasonble implementation
of the command mechanism. As a sub-class developer you just need to
implement a method for each command in the node spec. Note that due to
the command mechanism only unnamed argument are supported.
:param methodName: (string) the name of the method that correspond to a
command in the spec.
:param args: (list) of arguments that will be passed to the method
"""
if not hasattr(self, methodName):
raise Exception('Missing command method: ' + methodName)
m = getattr(self, methodName)
if not hasattr(m, '__call__'):
raise Exception('Command: ' + methodName + ' must be callable')
return m(*args)
@staticmethod
def setSparseOutput(outputs, name, value):
"""
Set region sparse output value.
The region output memory is owned by the c++ caller and cannot be changed
directly from python. Use this method to update the sparse output fields in
the "outputs" array so it can be resized from the c++ code.
:param outputs: (dict) of numpy arrays. This is the original outputs dict
owned by the C++ caller, passed to region via the compute method to
be updated.
:param name: (string) name of an existing output to modify
:param value: (list) list of UInt32 indices of all the nonzero entries
representing the sparse array to be set
"""
# The region output memory is owned by the c++ and cannot be changed from
# python. We use a special attribule named "__{name}_len__" to pass
# the sparse array length back to c++
lenAttr = "__{}_len__".format(name)
if lenAttr not in outputs:
raise Exception("Output {} is not a valid sparse output".format(name))
if outputs[name].size < value.size:
raise Exception(
"Output {} must be less than {}. Given value size is {}".format(
name, outputs[name].size, value.size))
outputs[lenAttr][0] = value.size
outputs[name][:value.size] = value
================================================
FILE: bindings/py/src/nupic/bindings/regions/TestNode.py
================================================
# Copyright 2015 Numenta Inc.
#
# Copyright may exist in Contributors' modifications
# and/or contributions to the work.
#
# Use of this source code is governed by the MIT
# license that can be found in the LICENSE file or at
# https://opensource.org/licenses/MIT.
import numpy
from nupic.bindings.regions.PyRegion import PyRegion
try:
import capnp
except ImportError:
capnp = None
if capnp:
from nupic.proto.TestNodeProto_capnp import TestNodeProto
class TestNode(PyRegion):
@classmethod
def getSpec(cls):
if hasattr(TestNode, '_failIngetSpec'):
assert False, 'Failing in TestNode.getSpec() as requested'
result = dict(
description='The node spec of the NuPIC 2 Python TestNode',
singleNodeOnly=False,
inputs=dict(
bottomUpIn=dict(
description='Primary input for the node',
dataType='Real64',
count=0,
required=True,
regionLevel=False,
isDefaultInput=True,
requireSplitterMap=False
)
),
outputs=dict(
bottomUpOut=dict(
description='Primary output for the node',
dataType='Real64',
count=0,
regionLevel=False,
isDefaultOutput=True
)
),
parameters=dict(
int32Param=dict(
description='Int32 scalar parameter',
dataType='Int32',
count=1,
constraints='',
defaultValue='32',
accessMode='ReadWrite'
),
uint32Param=dict(
description='UInt32 scalar parameter',
dataType='UInt32',
count=1,
constraints='',
defaultValue='33',
accessMode='ReadWrite'
),
int64Param=dict(
description='Int64 scalar parameter',
dataType='Int64',
count=1,
constraints='',
defaultValue='64',
accessMode='ReadWrite'
),
uint64Param=dict(
description='UInt64 scalar parameter',
dataType='UInt64',
count=1,
constraints='',
defaultValue='65',
accessMode='ReadWrite'
),
real32Param=dict(
description='Real32 scalar parameter',
dataType='Real32',
count=1,
constraints='',
defaultValue='32.1',
accessMode='ReadWrite'
),
real64Param=dict(
description='Real64 scalar parameter',
dataType='Real64',
count=1,
constraints='',
defaultValue='64.1',
accessMode='ReadWrite'
),
boolParam=dict(
description='bool parameter',
dataType='Bool',
count=1,
constraints='',
defaultValue='false',
accessMode='ReadWrite'
),
real32arrayParam=dict(
description='Real32 array parameter',
dataType='Real32',
count=0, # array
constraints='',
defaultValue='',
accessMode='ReadWrite'
),
int64arrayParam=dict(
description='Int64 array parameter',
dataType='Int64',
count=0, # array
constraints='',
defaultValue='',
accessMode='ReadWrite'
),
boolArrayParam=dict(
description='bool array parameter',
dataType='Bool',
count=0, # array
constraints='',
defaultValue='',
accessMode='ReadWrite'
),
stringParam=dict(
description='String parameter',
dataType='Byte',
count=0, # string is conventionally Byte/0
constraints='',
defaultValue='nodespec value',
accessMode='ReadWrite'
),
failInInit=dict(
description='For testing failure in __init__()',
dataType='Int32',
count=1,
constraints='',
defaultValue='0',
accessMode='ReadWrite'
),
failInCompute=dict(
description='For testing failure in compute()',
dataType='Int32',
count=1,
constraints='',
defaultValue='0',
accessMode='ReadWrite'
),
),
commands=dict()
)
print result
return result
def __init__(self, *args, **kwargs):
""" """
# Facilitate failing in __init__ to test error handling
if 'failInInit' in kwargs:
assert False, 'TestNode.__init__() Failing on purpose as requested'
# Check if should fail in compute to test error handling
self._failInCompute = kwargs.pop('failInCompute', False)
# set these to a bunch of incorrect values, just to make
# sure they are set correctly by the nodespec.
self.parameters = dict(
int32Param=32,
uint32Param=33,
int64Param=64,
uint64Param=65,
real32Param=32.1,
real64Param=64.1,
boolParam=False,
real32ArrayParam=numpy.arange(10).astype('float32'),
real64ArrayParam=numpy.arange(10).astype('float64'),
# Construct int64 array in the same way as in C++
int64ArrayParam=numpy.arange(4).astype('int64'),
boolArrayParam=numpy.array([False]*4),
stringParam="nodespec value")
for key in kwargs:
if not key in self.parameters:
raise Exception("TestNode found keyword %s but there is no parameter with that name" % key)
self.parameters[key] = kwargs[key]
self.outputElementCount = 2 # used for computation
self._delta = 1
self._iter = 0
for i in xrange(0,4):
self.parameters["int64ArrayParam"][i] = i*64
def getParameter(self, name, index):
assert name in self.parameters
return self.parameters[name]
def setParameter(self, name, index, value):
assert name in self.parameters
self.parameters[name] = value
def initialize(self):
print 'TestNode.initialize() here.'
def compute(self, inputs, outputs):
if self._failInCompute:
assert False, 'TestNode.compute() Failing on purpose as requested'
def getOutputElementCount(self, name):
assert name == 'bottomUpOut'
return self.outputElementCount
def getParameterArrayCount(self, name, index):
assert name.endswith('ArrayParam')
print 'len(self.parameters[%s]) = %d' % (name, len(self.parameters[name]))
return len(self.parameters[name])
def getParameterArray(self, name, index, array):
assert name.endswith('ArrayParam')
assert name in self.parameters
v = self.parameters[name]
assert len(array) == len(v)
assert array.dtype == v.dtype
array[:] = v
def setParameterArray(self, name, index, array):
assert name.endswith('ArrayParam')
assert name in self.parameters
assert array.dtype == self.parameters[name].dtype
self.parameters[name] = numpy.array(array)
def getSchema():
return None
def writeArray(self, regionImpl, name, dtype, castFn):
count = self.getParameterArrayCount(name, 0)
param = numpy.zeros(count, dtype=dtype)
self.getParameterArray(name, 0, param)
field = regionImpl.init(name, count)
for i in range(count):
field[i] = castFn(param[i])
def write(self, proto):
regionImpl = proto.regionImpl.as_struct(TestNodeProto)
regionImpl.int32Param = self.getParameter("int32Param", 0)
regionImpl.uint32Param = self.getParameter("uint32Param", 0);
regionImpl.int64Param = self.getParameter("int64Param", 0);
regionImpl.uint64Param = self.getParameter("uint64Param", 0);
regionImpl.real32Param = self.getParameter("real32Param", 0);
regionImpl.real64Param = self.getParameter("real64Param", 0);
regionImpl.boolParam = self.getParameter("boolParam", 0);
regionImpl.stringParam = self.getParameter("stringParam", 0);
regionImpl.delta = self._delta
regionImpl.iterations = self._iter
self.writeArray(regionImpl, "int64ArrayParam", "Int64", lambda x: int(x))
self.writeArray(regionImpl, "real32ArrayParam", "Float32", lambda x: float(x))
self.writeArray(regionImpl, "boolArrayParam", "Bool", lambda x: bool(x))
def readArray(self, regionImpl, name, dtype):
field = getattr(regionImpl, name)
count = len(field)
param = numpy.zeros(count, dtype=dtype)
for i in range(count):
param[i] = field[i]
self.setParameter(name, 0, param)
@classmethod
def read(cls, proto):
instance = cls()
regionImpl = proto.regionImpl.as_struct(TestNodeProto)
instance.setParameter("int32Param", 0, regionImpl.int32Param)
instance.setParameter("uint32Param", 0, regionImpl.uint32Param)
instance.setParameter("int64Param", 0, regionImpl.int64Param)
instance.setParameter("uint64Param", 0, regionImpl.uint64Param)
instance.setParameter("real32Param", 0, regionImpl.real32Param)
instance.setParameter("real64Param", 0, regionImpl.real64Param)
instance.setParameter("boolParam", 0, regionImpl.boolParam)
instance.setParameter("stringParam", 0, regionImpl.stringParam)
instance._delta = regionImpl.delta
instance._iter = regionImpl.iterations
instance.readArray(regionImpl, "int64ArrayParam", "Int64")
instance.readArray(regionImpl, "real32ArrayParam", "Float32")
instance.readArray(regionImpl, "boolArrayParam", "Bool")
return instance
================================================
FILE: bindings/py/src/nupic/bindings/regions/__init__.py
================================================
# Copyright 2015 Numenta Inc.
#
# Copyright may exist in Contributors' modifications
# and/or contributions to the work.
#
# Use of this source code is governed by the MIT
# license that can be found in the LICENSE file or at
# https://opensource.org/licenses/MIT.
================================================
FILE: bindings/py/src/nupic/bindings/tools/SerializationTestPyRegionProto.capnp
================================================
@0x8ae35855f4636f7b;
using import "/nupic/proto/RandomProto.capnp".RandomProto;
struct SerializationTestPyRegionProto {
dataWidth @0 :UInt32;
random @1 :RandomProto;
}
================================================
FILE: bindings/py/src/nupic/bindings/tools/__init__.py
================================================
# Copyright 2017 Numenta Inc.
#
# Copyright may exist in Contributors' modifications
# and/or contributions to the work.
#
# Use of this source code is governed by the MIT
# license that can be found in the LICENSE file or at
# https://opensource.org/licenses/MIT.
"""
## @file
"""
================================================
FILE: bindings/py/src/nupic/bindings/tools/cyclical_serialization_perf.py
================================================
#!/usr/bin/env python
# Copyright 2017 Numenta Inc.
#
# Copyright may exist in Contributors' modifications
# and/or contributions to the work.
#
# Use of this source code is governed by the MIT
# license that can be found in the LICENSE file or at
# https://opensource.org/licenses/MIT.
"""Capnp serialization performance test that involves a network that contains
a simple PyRegion which in turn contains an extension-based Random instance.
"""
import json
import time
# NOTE need to import capnp first to activate the magic necessary for
# NetworkProto_capnp, etc.
import capnp
from nupic.proto.NetworkProto_capnp import NetworkProto
import nupic.bindings.engine_internal as engine
from nupic.bindings.tools.serialization_test_py_region import \
SerializationTestPyRegion
_SERIALIZATION_LOOPS = 100000
_DESERIALIZATION_LOOPS = 100000
# Capnp reader traveral limit (see capnp::ReaderOptions)
_TRAVERSAL_LIMIT_IN_WORDS = 1 << 63
# Capnp reader nesting limit (see capnp::ReaderOptions)
_NESTING_LIMIT = 1 << 31
# Empirically-derived value of maximum deserialization calls on a single reader
# instance for our network to avoid hitting the capnp kj exception
# "Exceeded message traversal limit". (see capnp::ReaderOptions)
_MAX_DESERIALIZATION_LOOPS_PER_READER = 100000
def _runTest():
net = engine.Network()
net.addRegion(SerializationTestPyRegion.__name__,
"py." + SerializationTestPyRegion.__name__,
json.dumps({
"dataWidth": 128,
"randomSeed": 99,
}))
# Measure serialization
startSerializationTime = time.time()
for i in xrange(_SERIALIZATION_LOOPS):
# NOTE pycapnp's builder.from_dict (used in nupic.bindings) leaks
# memory if called on the same builder more than once, so we construct a
# fresh builder here
builderProto = NetworkProto.new_message()
net.write(builderProto)
elapsedSerializationTime = time.time() - startSerializationTime
builderBytes = builderProto.to_bytes()
# Measure deserialization
startDeserializationTime = time.time()
deserializationCount = 0
while deserializationCount < _DESERIALIZATION_LOOPS:
# NOTE: periodicaly create a new reader to avoid "Exceeded message traversal
# limit" error
readerProto = NetworkProto.from_bytes(
builderBytes,
traversal_limit_in_words=_TRAVERSAL_LIMIT_IN_WORDS,
nesting_limit=_NESTING_LIMIT)
numReads = min(_DESERIALIZATION_LOOPS - deserializationCount,
_MAX_DESERIALIZATION_LOOPS_PER_READER)
for _ in xrange(numReads):
engine.Network.read(readerProto)
deserializationCount += numReads
elapsedDeserializationTime = time.time() - startDeserializationTime
# Print report
print _SERIALIZATION_LOOPS, "Serialization loops in", \
elapsedSerializationTime, "seconds."
print "\t", elapsedSerializationTime/_SERIALIZATION_LOOPS, "seconds per loop."
print deserializationCount, "Deserialization loops in", \
elapsedDeserializationTime, "seconds."
print "\t", elapsedDeserializationTime/deserializationCount, "seconds per loop."
def main():
"""Measure capnp serialization performance of a network containing a simple
python region that in-turn contains a Random instance.
"""
engine.Network.registerPyRegion(__name__,
SerializationTestPyRegion.__name__)
try:
_runTest()
finally:
engine.Network.unregisterPyRegion(SerializationTestPyRegion.__name__)
if __name__ == "__main__":
main()
================================================
FILE: bindings/py/src/nupic/bindings/tools/random_serialization_perf.py
================================================
#!/usr/bin/env python
# Copyright 2017 Numenta Inc.
#
# Copyright may exist in Contributors' modifications
# and/or contributions to the work.
#
# Use of this source code is governed by the MIT
# license that can be found in the LICENSE file or at
# https://opensource.org/licenses/MIT.
"""Capnp serialization performance test of the extension-based Random class.
"""
import time
# NOTE need to import capnp first to activate the magic necessary for
# RandomProto_capnp, etc.
import capnp
from nupic.proto.RandomProto_capnp import RandomProto
from nupic.bindings.math import Random
_SERIALIZATION_LOOPS = 100000
_DESERIALIZATION_LOOPS = 100000
# Capnp reader traveral limit (see capnp::ReaderOptions)
_TRAVERSAL_LIMIT_IN_WORDS = 1 << 63
# Capnp reader nesting limit (see capnp::ReaderOptions)
_NESTING_LIMIT = 1 << 31
# Empirically-derived value of maximum deserialization calls on a single reader
# instance for our Random to avoid hitting the capnp kj exception
# "Exceeded message traversal limit". (see capnp::ReaderOptions)
_MAX_DESERIALIZATION_LOOPS_PER_READER = 200000
def main():
"""Measure capnp serialization performance of Random
"""
r = Random(42)
# Measure serialization
startSerializationTime = time.time()
for i in xrange(_SERIALIZATION_LOOPS):
# NOTE pycapnp's builder.from_dict (used in nupic.bindings) leaks
# memory if called on the same builder more than once, so we construct a
# fresh builder here
builderProto = RandomProto.new_message()
r.write(builderProto)
elapsedSerializationTime = time.time() - startSerializationTime
builderBytes = builderProto.to_bytes()
# Measure deserialization
startDeserializationTime = time.time()
deserializationCount = 0
while deserializationCount < _DESERIALIZATION_LOOPS:
# NOTE: periodicaly create a new reader to avoid "Exceeded message traversal
# limit" error
readerProto = RandomProto.from_bytes(
builderBytes,
traversal_limit_in_words=_TRAVERSAL_LIMIT_IN_WORDS,
nesting_limit=_NESTING_LIMIT)
numReads = min(_DESERIALIZATION_LOOPS - deserializationCount,
_MAX_DESERIALIZATION_LOOPS_PER_READER)
for _ in xrange(numReads):
r.read(readerProto)
deserializationCount += numReads
elapsedDeserializationTime = time.time() - startDeserializationTime
# Print report
print _SERIALIZATION_LOOPS, "Serialization loops in", \
elapsedSerializationTime, "seconds."
print "\t", elapsedSerializationTime/_SERIALIZATION_LOOPS, "seconds per loop."
print deserializationCount, "Deserialization loops in", \
elapsedDeserializationTime, "seconds."
print "\t", elapsedDeserializationTime/deserializationCount, "seconds per loop."
if __name__ == "__main__":
main()
================================================
FILE: bindings/py/src/nupic/bindings/tools/serialization_test_py_region.py
================================================
# Copyright 2017 Numenta Inc.
#
# Copyright may exist in Contributors' modifications
# and/or contributions to the work.
#
# Use of this source code is governed by the MIT
# license that can be found in the LICENSE file or at
# https://opensource.org/licenses/MIT.
"""Simple custom python region containing an extension-based Random instance
for use in capnp network serialization test and cyclical serialization
performance tool.
"""
try:
# NOTE need to import capnp first to activate the magic necessary for
# PythonDummyRegion_capnp, etc.
import capnp
except ImportError:
capnp = None
else:
from nupic.bindings.tools.SerializationTestPyRegionProto_capnp import \
SerializationTestPyRegionProto
from nupic.bindings.math import Random
from nupic.bindings.regions.PyRegion import PyRegion
class SerializationTestPyRegion(PyRegion):
"""Custom python region for testing serialization/deserialization of network
containing a python region that contains a nupic.bindings-based Random
instance.
"""
def __init__(self, dataWidth, randomSeed):
if dataWidth <= 0:
raise ValueError("Parameter dataWidth must be > 0")
# Arbitrary value that's compatible with UInt32 in the proto schema
# for testing serialization of python-native property
self._dataWidth = dataWidth
# For testing serialization of object implemented in the extension
self._rand = Random(randomSeed)
@property
def dataWidth(self):
return self._dataWidth
@property
def randomSeed(self):
return self._rand.getSeed()
@staticmethod
def getSchema():
"""Return the pycapnp proto type that the class uses for serialization.
This is used to convert the proto into the proper type before passing it
into the read or write method of the subclass.
"""
return SerializationTestPyRegionProto
def writeToProto(self, proto):
"""Write state to proto object.
The type of proto is determined by getSchema().
"""
proto.dataWidth = self._dataWidth
self._rand.write(proto.random)
@classmethod
def readFromProto(cls, proto):
"""Read state from proto object.
The type of proto is determined by getSchema().
:returns: Instance of SerializationTestPyRegion initialized from proto
"""
obj = object.__new__(cls)
obj._dataWidth = proto.dataWidth
obj._rand = Random()
obj._rand.read(proto.random)
return obj
def initialize(self, dims=None, splitterMaps=None):
pass
def compute(self, inputs, outputs):
"""
Run one iteration of SerializationTestPyRegion's compute
"""
outputs["out"][:] = inputs["in"]
@classmethod
def getSpec(cls):
"""Return the Spec for SerializationTestPyRegion.
"""
spec = {
"description":SerializationTestPyRegion.__doc__,
"singleNodeOnly":True,
"inputs":{
"in":{
"description":"The input vector.",
"dataType":"Real32",
"count":0,
"required":True,
"regionLevel":False,
"isDefaultInput":True,
"requireSplitterMap":False},
},
"outputs":{
"out":{
"description":"A copy of the input vector.",
"dataType":"Real32",
"count":0,
"regionLevel":True,
"isDefaultOutput":True},
},
"parameters":{
"dataWidth":{
"description":"Size of inputs",
"accessMode":"Read",
"dataType":"UInt32",
"count":1,
"constraints":""},
"randomSeed":{
"description":"Seed for constructing the Random instance",
"accessMode":"Read",
"dataType":"UInt32",
"count":1,
"constraints":""},
},
}
return spec
def getOutputElementCount(self, name):
if name == "out":
return self._dataWidth
else:
raise Exception("Unrecognized output: " + name)
================================================
FILE: bindings/py/src/nupic/proto/.gitignore
================================================
*.capnp
================================================
FILE: bindings/py/src/nupic/proto/__init__.py
================================================
# Copyright 2015 Numenta Inc.
#
# Copyright may exist in Contributors' modifications
# and/or contributions to the work.
#
# Use of this source code is governed by the MIT
# license that can be found in the LICENSE file or at
# https://opensource.org/licenses/MIT.
================================================
FILE: bindings/py/tests/__init__.py
================================================
# Copyright 2015 Numenta Inc.
#
# Copyright may exist in Contributors' modifications
# and/or contributions to the work.
#
# Use of this source code is governed by the MIT
# license that can be found in the LICENSE file or at
# https://opensource.org/licenses/MIT.
================================================
FILE: bindings/py/tests/algorithms/cells4_test.py
================================================
# Copyright 2013-2017 Numenta Inc.
#
# Copyright may exist in Contributors' modifications
# and/or contributions to the work.
#
# Use of this source code is governed by the MIT
# license that can be found in the LICENSE file or at
# https://opensource.org/licenses/MIT.
"""Unit tests for Cells4."""
import cPickle as pickle
import os
import numpy
import unittest
from nupic.bindings.math import Random
from nupic.bindings.algorithms import Cells4
_RGEN = Random(43)
def createCells4(nCols=8,
nCellsPerCol=4,
activationThreshold=1,
minThreshold=1,
newSynapseCount=2,
segUpdateValidDuration=2,
permInitial=0.5,
permConnected=0.8,
permMax=1.0,
permDec=0.1,
permInc=0.2,
globalDecay=0.05,
doPooling=True,
pamLength=2,
maxAge=3,
seed=42,
initFromCpp=True,
checkSynapseConsistency=False):
cells = Cells4(nCols,
nCellsPerCol,
activationThreshold,
minThreshold,
newSynapseCount,
segUpdateValidDuration,
permInitial,
permConnected,
permMax,
permDec,
permInc,
globalDecay,
doPooling,
seed,
initFromCpp,
checkSynapseConsistency)
cells.setPamLength(pamLength)
cells.setMaxAge(maxAge)
cells.setMaxInfBacktrack(4)
for i in xrange(nCols):
for j in xrange(nCellsPerCol):
cells.addNewSegment(i, j, True if j % 2 == 0 else False,
[((i + 1) % nCols, (j + 1) % nCellsPerCol)])
return cells
class Cells4Test(unittest.TestCase):
@staticmethod
def _cellsDiff(cell1, cell2):
"""Test that the two cell instances have the same segments and synapses."""
result = True
# Check that each cell has the same number of segments and synapses
for c in xrange(cell1.nColumns()):
if not result:
break
for i in xrange(cell1.nCellsPerCol()):
if cell1.nSegmentsOnCell(c, i) != cell2.nSegmentsOnCell(c, i):
print "Num segments different in cell:", c, i,
print "numbers = ", cell1.nSegmentsOnCell(c, i), \
cell2.nSegmentsOnCell(c, i)
result = False
break
else:
c1 = cell1.getCell(c, i)
c2 = cell2.getCell(c, i)
for j in xrange(cell1.nSegmentsOnCell(c, i)):
seg1 = c1.getSegment(j)
seg2 = c2.getSegment(j)
if seg1.size() != seg2.size():
result = False
break
for k in xrange(seg1.size()):
sourceCellIdx1 = seg1.getSrcCellIdx(k)
sourceCellIdx2 = seg1.getSrcCellIdx(k)
if sourceCellIdx1 != sourceCellIdx2:
result = False
break
perm1 = seg1.getPermanence(k)
perm2 = seg2.getPermanence(k)
if perm1 != perm2:
result = False
break
if result == True:
print "TP's match"
return result
def _testPersistence(self, cells):
"""This will pickle the cells instance, unpickle it, and test to ensure
the unpickled instance is identical to the pre-pickled version.
"""
pickle.dump(cells, open("test.pkl", "wb"))
cells.saveToFile("test2.bin")
cells2 = pickle.load(open("test.pkl"))
# Test all public attributes of Cells4 that should get pickled
for f1, f2 in zip(dir(cells), dir(cells2)):
if f1[0] != "_" and f1 not in ["initialize", "setStatePointers",
"getStates", "rebuildOutSynapses"]:
ff1, ff2 = getattr(cells, f1), getattr(cells, f2)
try:
r1, r2 = ff1(), ff2()
resultsEqual = (r1 == r2)
except (NotImplementedError, RuntimeError, TypeError, ValueError):
continue
self.assertTrue(resultsEqual, "Cells do not match.")
# Ensure that the cells are identical
self.assertTrue(self._cellsDiff(cells, cells2))
os.unlink("test.pkl")
# Now try the Cells4.saveToFile method.
pickle.dump(cells, open("test.pkl", "wb"))
cells.saveToFile("test2.bin")
cells2 = Cells4()
cells2.loadFromFile("test2.bin")
self.assertTrue(self._cellsDiff(cells, cells2))
# Test all public attributes of Cells4 that should get pickled
for f1, f2 in zip(dir(cells), dir(cells2)):
if f1[0] != "_" and f1 not in ["initialize", "setStatePointers",
"getStates", "rebuildOutSynapses"]:
ff1, ff2 = getattr(cells, f1), getattr(cells, f2)
try:
r1, r2 = ff1(), ff2()
resultsEqual = (r1 == r2)
except (NotImplementedError, RuntimeError, TypeError, ValueError):
continue
self.assertTrue(resultsEqual, "Cells do not match.")
# Ensure that the cells are identical
self.assertTrue(self._cellsDiff(cells, cells2))
os.unlink("test2.bin")
def testLearn(self):
# Make sure we set non-default parameters so we can test persistence
nCols = 8
nCellsPerCol = 4
activationThreshold = 1
minThreshold = 1
newSynapseCount = 2
segUpdateValidDuration = 2
permInitial = .5
permConnected = .8
permMax = 1.0
permDec = .1
permInc = .2
globalDecay = .05
doPooling = True
pamLength = 2
maxAge = 3
activeStateT = numpy.zeros((nCols, nCellsPerCol), dtype="uint32")
activeStateT1 = numpy.zeros((nCols, nCellsPerCol), dtype="uint32")
predictedStateT = numpy.zeros((nCols, nCellsPerCol), dtype="uint32")
predictedStateT1 = numpy.zeros((nCols, nCellsPerCol), dtype="uint32")
colConfidenceT = numpy.zeros(nCols, dtype="float32")
colConfidenceT1 = numpy.zeros(nCols, dtype="float32")
confidenceT = numpy.zeros((nCols, nCellsPerCol), dtype="float32")
confidenceT1 = numpy.zeros((nCols, nCellsPerCol), dtype="float32")
cells = Cells4(nCols,
nCellsPerCol,
activationThreshold,
minThreshold,
newSynapseCount,
segUpdateValidDuration,
permInitial,
permConnected,
permMax,
permDec,
permInc,
globalDecay,
doPooling,
42)
cells.setStatePointers(activeStateT, activeStateT1,
predictedStateT, predictedStateT1,
colConfidenceT, colConfidenceT1,
confidenceT, confidenceT1)
cells.setPamLength(pamLength)
cells.setMaxAge(maxAge)
cells.setMaxInfBacktrack(4)
cells.setVerbosity(4)
for i in xrange(nCols):
for j in xrange(nCellsPerCol):
print "Adding segment: ", i, j, [((i + 1) % nCols,
(j + 1) % nCellsPerCol)]
cells.addNewSegment(i, j, True if j % 2 == 0 else False,
[((i + 1) % nCols, (j + 1) % nCellsPerCol)])
for i in xrange(10):
x = numpy.zeros(nCols, dtype="uint32")
_RGEN.initializeUInt32Array(x, 2)
print "Input:", x
cells.compute(x, True, True)
cells.rebuildOutSynapses()
self._testPersistence(cells)
for i in xrange(100):
x = numpy.zeros(nCols, dtype="uint32")
_RGEN.initializeUInt32Array(x, 2)
cells.compute(x, True, False)
self._testPersistence(cells)
def testEquals(self):
nCols = 10
c1 = createCells4(nCols)
c2 = createCells4(nCols)
self.assertEquals(c1, c2)
# learn
data = [numpy.random.choice(nCols, nCols/3, False) for _ in xrange(10)]
for idx in data:
x = numpy.zeros(nCols, dtype="float32")
x[idx] = 1.0
c1.compute(x, True, True)
c2.compute(x, True, True)
self.assertEquals(c1, c2)
self.assertEquals(c1, c2)
c1.rebuildOutSynapses()
c2.rebuildOutSynapses()
self.assertEquals(c1, c2)
# inference
data = [numpy.random.choice(nCols, nCols/3, False) for _ in xrange(100)]
for idx in data:
x = numpy.zeros(nCols, dtype="float32")
x[idx] = 1.0
c1.compute(x, True, False)
c2.compute(x, True, False)
self.assertEquals(c1, c2)
self.assertEquals(c1, c2)
================================================
FILE: bindings/py/tests/algorithms/svm_test.py
================================================
# Copyright 2013-2017 Numenta Inc.
#
# Copyright may exist in Contributors' modifications
# and/or contributions to the work.
#
# Use of this source code is governed by the MIT
# license that can be found in the LICENSE file or at
# https://opensource.org/licenses/MIT.
"""Unit tests for the SVM classifiers."""
import cPickle as pickle
import hashlib
import os
import numpy as np
import unittest
from nupic.bindings.algorithms import svm_dense, svm_01
from nupic.bindings.math import GetNumpyDataType
_SEED = 42
_RGEN = np.random.RandomState(_SEED)
# 32 bits for sse
_DTYPE = GetNumpyDataType("NTA_Real")
class SVMTest(unittest.TestCase):
"""Unit tests for the SVM classifier."""
def testGetstateSetstate(self):
nDims = 32 # need multiple of 8, because of sse
nClass = 4
size = 20
labels = _RGEN.random_integers(0, nClass - 1, size)
samples = np.zeros((size, nDims), dtype=_DTYPE)
centers = np.array([[0, 0], [0, 1], [1, 0], [1, 1]])
for i in range(0, size):
t = 6.28 * _RGEN.random_sample()
samples[i][0] = 2 * centers[labels[i]][0] + 0.5*_RGEN.rand() * np.cos(t)
samples[i][1] = 2 * centers[labels[i]][1] + 0.5*_RGEN.rand() * np.sin(t)
classifier = svm_dense(0, nDims, seed=_SEED, probability = True)
for y, xList in zip(labels, samples):
x = np.array(xList, dtype=_DTYPE)
classifier.add_sample(float(y), x)
classifier.train(gamma=1.0/3.0, C=100, eps=1e-1)
classifier.cross_validate(2, gamma=0.5, C=10, eps=1e-3)
s1 = classifier.__getstate__()
h1 = hashlib.md5(s1).hexdigest()
classifier2 = svm_dense(0, nDims)
classifier2.__setstate__(s1)
s2 = classifier2.__getstate__()
h2 = hashlib.md5(s2).hexdigest()
self.assertEqual(h1, h2)
with open("svm_test.bin", "wb") as f:
pickle.dump(classifier, f)
with open("svm_test.bin", "rb") as f:
classifier3 = pickle.load(f)
s3 = classifier3.__getstate__()
h3 = hashlib.md5(s3).hexdigest()
self.assertEqual(h1, h3)
os.unlink("svm_test.bin")
def testPersistentSize(self):
for _ in range(2):
# Multiple of 8 because of sse.
nDims = 32
nClass = _RGEN.randint(4, 8)
size = _RGEN.randint(20, 50)
labels = _RGEN.random_integers(0, nClass - 1, size)
samples = _RGEN.normal(size=(size, nDims)).astype(_DTYPE)
classifier = svm_dense(0, nDims, seed=_SEED, probability=True)
for y, xList in zip(labels, samples):
x = np.array(xList, dtype=_DTYPE)
classifier.add_sample(float(y), x)
classifier.train(gamma=1.0/3.0, C=100, eps=1e-1)
classifier.cross_validate(2, gamma=0.5, C=10, eps=1e-3)
s = classifier.__getstate__()
print "nDims=", nDims, "nClass=", nClass, "n_vectors=", size,
print "dense:", len(s), classifier.persistent_size(),
self.assertEqual(len(s), classifier.persistent_size())
classifier01 = svm_01(0, nDims, seed=_SEED, probability=True)
for y, xList in zip(labels, samples):
x = np.array(xList, dtype=_DTYPE)
classifier01.add_sample(float(y), x)
classifier01.train(gamma=1.0/3.0, C=100, eps=1e-1)
classifier01.cross_validate(2, gamma=0.5, C=10, eps=1e-3)
s = classifier01.__getstate__()
print "0/1", len(s), classifier01.persistent_size()
self.assertEqual(len(s), classifier01.persistent_size())
# TODO: Add appropriate assertions and re-enable this test.
@unittest.skip("Legacy test that is out of date.")
def testScalability(self):
# Multiple of 8 for sse.
nDims = 32
nClass = 3
size = 1000
labels = _RGEN.random_integers(0, nClass - 1, size)
samples = np.random.random(size=(size, nDims)).astype(_DTYPE)
classifier = svm_dense(0, nDims, seed=_SEED)
for y, xList in zip(labels, samples):
x = np.array(xList, dtype=_DTYPE)
classifier.add_sample(float(y), x)
print "training"
classifier.train(gamma=1.0/3.0, C=100, eps=1e-1)
print "cross validation"
classifier.cross_validate(2, gamma=0.5, C=10, eps=1e-3)
================================================
FILE: bindings/py/tests/array_algorithms_test.py
================================================
#!/usr/bin/env python
# Copyright 2013 Numenta Inc.
#
# Copyright may exist in Contributors' modifications
# and/or contributions to the work.
#
# Use of this source code is governed by the MIT
# license that can be found in the LICENSE file or at
# https://opensource.org/licenses/MIT.
"""Unit tests for array algorithms."""
import unittest
import numpy
from nupic.bindings.math import nearlyZeroRange
class TestArrayAlgos(unittest.TestCase):
def setUp(self):
self.x = numpy.zeros((10))
def testNearlyZeroRange1(self):
self.assertTrue(nearlyZeroRange(self.x))
def testNearlyZeroRange2(self):
self.assertTrue(nearlyZeroRange(self.x, 1e-8))
def testNearlyZeroRange3(self):
self.assertTrue(nearlyZeroRange(self.x, 2))
if __name__ == '__main__':
unittest.main()
================================================
FILE: bindings/py/tests/cast_mode_test.py
================================================
#!/usr/bin/env python
# Copyright 2013 Numenta Inc.
#
# Copyright may exist in Contributors' modifications
# and/or contributions to the work.
#
# Use of this source code is governed by the MIT
# license that can be found in the LICENSE file or at
# https://opensource.org/licenses/MIT.
"""Cast mode test."""
import sys
import numpy
import unittest
from nupic.bindings.math import SM32
class TestCastMode(unittest.TestCase):
@unittest.skipIf(sys.platform == "linux2",
"Castmode test disabled on linux -- fails")
def testCastMode(self):
"""Test for an obscure error that is fixed by the -castmode flag to swig.
This code will throw an exception if the error exists.
"""
hist = SM32(5, 10)
t = numpy.array([0, 0, 1, 0, 1, 0, 0, 1, 0, 1], dtype='float32')
hist.setRowFromDense(0, t)
hist.setRowFromDense(1, t)
self.assertSequenceEqual(tuple(hist.getRow(1)),
(0, 0, 1, 0, 1, 0, 0, 1, 0, 1))
if __name__ == "__main__":
unittest.main()
================================================
FILE: bindings/py/tests/check_test.py
================================================
# Copyright 2015 Numenta Inc.
#
# Copyright may exist in Contributors' modifications
# and/or contributions to the work.
#
# Use of this source code is governed by the MIT
# license that can be found in the LICENSE file or at
# https://opensource.org/licenses/MIT.
import unittest
import nupic.bindings.check as check
class LoadBindingsTest(unittest.TestCase):
def testImportBindingsInstalled(self):
"""Test that we can import nupic.bindings"""
check.checkImportBindingsInstalled()
def testImportBindingsExtensions(self):
"""Test that we can load C extensions under nupic.binding"""
check.checkImportBindingsExtensions()
================================================
FILE: bindings/py/tests/connections_test.py
================================================
#!/usr/bin/env python
# Copyright 2017 Numenta Inc.
#
# Copyright may exist in Contributors' modifications
# and/or contributions to the work.
#
# Use of this source code is governed by the MIT
# license that can be found in the LICENSE file or at
# https://opensource.org/licenses/MIT.
"""Unit tests for connections classes"""
import numpy as np
import unittest
from nupic.bindings.math import Random, SparseMatrixConnections
class ConnectionsTest(unittest.TestCase):
def test_computeActivity(self):
for (name, cells, inputs, activeInputs,
initialPermanence,
expected) in (("Basic test",
[1, 2, 3], [42, 43, 44],
[42, 44], 0.45,
[2, 2, 2]),
("Small permanence",
[1, 2, 3], [42, 43, 44],
[42, 44], 0.01,
[2, 2, 2]),
("No segments",
[], [42, 43, 44],
[42, 44], 0.45,
[]),
("No active inputs",
[1, 2, 3], [42, 43, 44],
[], 0.45,
[0, 0, 0])
):
connections = SparseMatrixConnections(2048, 2048)
segments = connections.createSegments(cells)
connections.growSynapses(segments, inputs, initialPermanence)
overlaps = connections.computeActivity(activeInputs)
np.testing.assert_equal(overlaps[segments], expected, name)
def test_computeActivity_thresholded(self):
for (name, cells, inputs, activeInputs,
initialPermanence, connectedPermanence,
expected) in (("Accepted",
[1, 2, 3], [42, 43, 44],
[42, 44], 0.55, 0.5,
[2, 2, 2]),
("Rejected",
[1, 2, 3], [42, 43, 44],
[42, 44], 0.55, 0.6,
[0, 0, 0]),
("No segments",
[], [42, 43, 44],
[42, 44], 0.55, 0.5,
[]),
("No active inputs",
[1, 2, 3], [42, 43, 44],
[], 0.55, 0.5,
[0, 0, 0])
):
connections = SparseMatrixConnections(2048, 2048)
segments = connections.createSegments(cells)
connections.growSynapses(segments, inputs, initialPermanence)
overlaps = connections.computeActivity(activeInputs, connectedPermanence)
np.testing.assert_equal(overlaps[segments], expected, name)
def test_adjustSynapses(self):
for (name, cells, inputs,
adjustedSegments, activeInputs,
initialPermanence, activeDelta, inactiveDelta, connectedPermanence,
expected) in (("Basic test",
[1, 2, 3], [42, 43, 44],
[0, 2], [42, 44],
0.45, 0.1, -0.1, 0.5,
[2, 0, 2]),
("Reward inactive",
[1, 2, 3], [42, 43, 44],
[0, 2], [42, 44],
0.45, -0.1, 0.1, 0.5,
[1, 0, 1]),
("No segments",
[1, 2, 3], [42, 43, 44],
[], [42, 44],
0.45, 0.1, -0.1, 0.5,
[0, 0, 0]),
("No active synapses",
[1, 2, 3], [42, 43, 44],
[0, 2], [],
0.45, 0.1, -0.1, 0.5,
[0, 0, 0]),
("Delta of zero",
[1, 2, 3], [42, 43, 44],
[0, 2], [42, 44],
0.55, 0.0, 0.0, 0.5,
[3, 3, 3])
):
connections = SparseMatrixConnections(2048, 2048)
segments = connections.createSegments(cells)
connections.growSynapses(segments, inputs, initialPermanence)
connections.adjustSynapses(segments[adjustedSegments],
activeInputs, activeDelta, inactiveDelta)
overlaps = connections.computeActivity(inputs, connectedPermanence)
np.testing.assert_equal(overlaps[segments], expected, name)
def test_adjustActiveSynapses(self):
for (name, cells, inputs,
adjustedSegments, activeInputs,
initialPermanence, delta, connectedPermanence,
expected) in (("Basic test",
[1, 2, 3], [42, 43, 44],
[0, 2], [42, 44],
0.45, 0.1, 0.5,
[2, 0, 2]),
("Negative increment",
[1, 2, 3], [42, 43, 44],
[0, 2], [42, 44],
0.55, -0.1, 0.5,
[1, 3, 1]),
("No segments",
[1, 2, 3], [42, 43, 44],
[], [42, 44],
0.45, 0.1, 0.5,
[0, 0, 0]),
("No active synapses",
[1, 2, 3], [42, 43, 44],
[0, 2], [],
0.45, 0.1, 0.5,
[0, 0, 0]),
("Delta of zero",
[1, 2, 3], [42, 43, 44],
[0, 2], [42, 44],
0.55, 0.0, 0.5,
[3, 3, 3])
):
connections = SparseMatrixConnections(2048, 2048)
segments = connections.createSegments(cells)
connections.growSynapses(segments, inputs, initialPermanence)
connections.adjustActiveSynapses(segments[adjustedSegments],
activeInputs, delta)
overlaps = connections.computeActivity(inputs, connectedPermanence)
np.testing.assert_equal(overlaps[segments], expected, name)
def test_adjustInactiveSynapses(self):
for (name, cells, inputs,
adjustedSegments, activeInputs,
initialPermanence, delta, connectedPermanence,
expected) in (("Basic test",
[1, 2, 3], [42, 43, 44],
[0, 2], [42, 44],
0.45, 0.1, 0.5,
[1, 0, 1]),
("Negative increment",
[1, 2, 3], [42, 43, 44],
[0, 2], [42, 44],
0.55, -0.1, 0.5,
[2, 3, 2]),
("No segments",
[1, 2, 3], [42, 43, 44],
[], [42, 44],
0.45, 0.1, 0.5,
[0, 0, 0]),
("No active synapses",
[1, 2, 3], [42, 43, 44],
[0, 2], [],
0.45, 0.1, 0.5,
[3, 0, 3]),
("Delta of zero",
[1, 2, 3], [42, 43, 44],
[0, 2], [42, 44],
0.55, 0.0, 0.5,
[3, 3, 3])
):
connections = SparseMatrixConnections(2048, 2048)
segments = connections.createSegments(cells)
connections.growSynapses(segments, inputs, initialPermanence)
connections.adjustInactiveSynapses(segments[adjustedSegments],
activeInputs, delta)
overlaps = connections.computeActivity(inputs, connectedPermanence)
np.testing.assert_equal(overlaps[segments], expected, name)
def test_whenPermanenceFallsBelowZero(self):
connections = SparseMatrixConnections(2048, 2048)
segments = connections.createSegments([1, 2, 3])
connections.growSynapses(segments, [42, 43], 0.05)
connections.adjustSynapses(segments, [42, 43], -0.06, 0.0)
np.testing.assert_equal(connections.mapSegmentsToSynapseCounts(segments),
[0, 0, 0])
connections.growSynapses(segments, [42, 43], 0.05)
connections.adjustSynapses(segments, [], 0.0, -0.06)
np.testing.assert_equal(connections.mapSegmentsToSynapseCounts(segments),
[0, 0, 0])
connections.growSynapses(segments, [42, 43], 0.05)
connections.adjustActiveSynapses(segments, [42, 43], -0.06)
np.testing.assert_equal(connections.mapSegmentsToSynapseCounts(segments),
[0, 0, 0])
connections.growSynapses(segments, [42, 43], 0.05)
connections.adjustInactiveSynapses(segments, [], -0.06)
np.testing.assert_equal(connections.mapSegmentsToSynapseCounts(segments),
[0, 0, 0])
def test_growSynapses(self):
for (name,
cells, growingSegments,
presynapticInputs, activeInputs,
initialPermanence, connectedPermanence,
expected) in (("Basic test",
[1, 2, 3], [0, 2],
[42, 43, 44], [42, 43],
0.55, 0.5,
[2, 0, 2]),
("No segments selected",
[1, 2, 3], [],
[42, 43, 44], [42, 43],
0.55, 0.5,
[0, 0, 0]),
("No inputs selected",
[1, 2, 3], [0, 2],
[], [42, 43],
0.55, 0.5,
[0, 0, 0])
):
connections = SparseMatrixConnections(2048, 2048)
segments = connections.createSegments(cells)
connections.growSynapses(segments[growingSegments], presynapticInputs,
initialPermanence)
overlaps = connections.computeActivity(activeInputs, connectedPermanence)
np.testing.assert_equal(overlaps[segments], expected, name)
def test_growSynapsesToSample_single(self):
rng = Random()
for (name,
cells, growingSegments,
initialConnectedInputs, presynapticInputs, activeInputs,
initialPermanence, connectedPermanence, sampleSize,
expected) in (("Basic test",
[1, 2, 3], [0, 2],
[], [42, 43, 44, 45],
[42, 43, 44, 45], 0.55, 0.5, 2,
[2, 0, 2]),
("One already connected",
[1, 2, 3], [0, 2],
[42], [42, 43, 44, 45],
[42, 43, 44, 45], 0.55, 0.5, 2,
[3, 0, 3]),
("Higher sample size than axon count",
[1, 2, 3], [0, 2],
[], [42, 43, 44, 45],
[42, 43, 44, 45], 0.55, 0.5, 10,
[4, 0, 4]),
("Higher sample size than available axon count",
[1, 2, 3], [0, 2],
[42, 43], [42, 43, 44, 45],
[42, 43, 44, 45], 0.55, 0.5, 3,
[4, 0, 4])
):
connections = SparseMatrixConnections(2048, 2048)
segments = connections.createSegments(cells)
connections.growSynapses(
segments[growingSegments], initialConnectedInputs, initialPermanence)
connections.growSynapsesToSample(
segments[growingSegments], presynapticInputs,
sampleSize, initialPermanence, rng)
overlaps = connections.computeActivity(activeInputs, connectedPermanence)
np.testing.assert_equal(overlaps[segments], expected, name)
for (name,
cells, growingSegments,
initialConnectedInputs, presynapticInputs, activeInputs,
initialPermanence, connectedPermanence,
sampleSize) in (("Basic randomness test",
[1, 2, 3], [0, 2],
[], [42, 43, 44, 45],
[42, 43], 0.55, 0.5, 2),
):
# Activate a subset of the inputs. The resulting overlaps should
# differ on various trials.
firstResult = None
differingResults = False
for _ in xrange(20):
connections = SparseMatrixConnections(2048, 2048)
segments = connections.createSegments(cells)
connections.growSynapses(
segments[growingSegments], initialConnectedInputs, initialPermanence)
connections.growSynapsesToSample(
segments[growingSegments], presynapticInputs,
sampleSize, initialPermanence, rng)
overlaps = connections.computeActivity(activeInputs,
connectedPermanence)
if firstResult is None:
firstResult = overlaps[segments]
else:
differingResults = not np.array_equal(overlaps[segments], firstResult)
if differingResults:
break
self.assertTrue(differingResults, name)
def test_growSynapsesToSample_multi(self):
rng = Random()
for (name,
cells, growingSegments,
initialConnectedInputs, presynapticInputs, activeInputs,
initialPermanence, connectedPermanence, sampleSizes,
expected) in (("Basic test",
[1, 2, 3], [0, 2],
[], [42, 43, 44, 45],
[42, 43, 44, 45], 0.55, 0.5,
[2, 3],
[2, 0, 3]),
("One already connected",
[1, 2, 3], [0, 2],
[42], [42, 43, 44, 45],
[42, 43, 44, 45], 0.55, 0.5,
[1, 2],
[2, 0, 3]),
("Higher sample size than axon count",
[1, 2, 3], [0, 2],
[], [42, 43, 44, 45],
[42, 43, 44, 45], 0.55, 0.5,
[5, 10],
[4, 0, 4]),
("Higher sample size than available axon count",
[1, 2, 3], [0, 2],
[42, 43], [42, 43, 44, 45],
[42, 43, 44, 45], 0.55, 0.5,
[3, 3],
[4, 0, 4])
):
connections = SparseMatrixConnections(2048, 2048)
segments = connections.createSegments(cells)
connections.growSynapses(
segments[growingSegments], initialConnectedInputs, initialPermanence)
connections.growSynapsesToSample(
segments[growingSegments], presynapticInputs,
sampleSizes, initialPermanence, rng)
overlaps = connections.computeActivity(activeInputs, connectedPermanence)
np.testing.assert_equal(overlaps[segments], expected, name)
for (name,
cells, growingSegments,
initialConnectedInputs, presynapticInputs, activeInputs,
initialPermanence, connectedPermanence,
sampleSizes) in (("Basic randomness test",
[1, 2, 3], [0, 2],
[], [42, 43, 44, 45],
[42, 43], 0.55, 0.5, [2, 3]),
):
# Activate a subset of the inputs. The resulting overlaps should
# differ on various trials.
firstResult = None
differingResults = False
for _ in xrange(20):
connections = SparseMatrixConnections(2048, 2048)
segments = connections.createSegments(cells)
connections.growSynapses(
segments[growingSegments], initialConnectedInputs, initialPermanence)
connections.growSynapsesToSample(
segments[growingSegments], presynapticInputs,
sampleSizes, initialPermanence, rng)
overlaps = connections.computeActivity(activeInputs,
connectedPermanence)
if firstResult is None:
firstResult = overlaps[segments]
else:
differingResults = not np.array_equal(overlaps[segments], firstResult)
if differingResults:
break
self.assertTrue(differingResults, name)
def test_clipPermanences(self):
connections = SparseMatrixConnections(2048, 2048)
# Destroy synapses with permanences <= 0.0
segments = connections.createSegments([1, 2, 3])
connections.growSynapses(segments, [42, 43, 44], 0.05)
connections.growSynapses(segments, [45, 46], 0.1)
connections.adjustInactiveSynapses(segments, [], -0.1)
connections.clipPermanences(segments)
np.testing.assert_equal(connections.mapSegmentsToSynapseCounts(segments),
[0, 0, 0])
# Clip permanences to 1.0
connections.growSynapses(segments, [42, 43, 44], 0.95)
connections.adjustInactiveSynapses(segments, [], 0.50)
connections.clipPermanences(segments)
np.testing.assert_equal(connections.mapSegmentsToSynapseCounts(segments),
[3, 3, 3])
connections.adjustInactiveSynapses(segments, [], -0.5)
overlaps1 = connections.computeActivity([42, 43, 44], 0.49)
overlaps2 = connections.computeActivity([42, 43, 44], 0.51)
np.testing.assert_equal(overlaps1, [3, 3, 3])
np.testing.assert_equal(overlaps2, [0, 0, 0])
def test_mapSegmentsToSynapseCounts(self):
connections = SparseMatrixConnections(2048, 2048)
segments = connections.createSegments([1, 2, 3])
connections.growSynapses(segments, [42, 43, 44], 0.5)
np.testing.assert_equal(connections.mapSegmentsToSynapseCounts(segments),
[3, 3, 3])
segments2 = connections.createSegments([4, 5])
np.testing.assert_equal(connections.mapSegmentsToSynapseCounts(segments2),
[0, 0])
np.testing.assert_equal(connections.mapSegmentsToSynapseCounts([]),
[])
================================================
FILE: bindings/py/tests/network_test.py
================================================
# Copyright 2017 Numenta Inc.
#
# Copyright may exist in Contributors' modifications
# and/or contributions to the work.
#
# Use of this source code is governed by the MIT
# license that can be found in the LICENSE file or at
# https://opensource.org/licenses/MIT.
import json
import unittest
import pytest
try:
# NOTE need to import capnp first to activate the magic necessary for
# PythonDummyRegion_capnp, etc.
import capnp
except ImportError:
capnp = None
else:
from nupic.proto.NetworkProto_capnp import NetworkProto
from nupic.bindings.regions.PyRegion import PyRegion
import nupic.bindings.engine_internal as engine
from nupic.bindings.tools.serialization_test_py_region import \
SerializationTestPyRegion
class TestLinks(PyRegion):
"""
Test region used to test link validation
"""
def __init__(self): pass
def initialize(self): pass
def compute(self): pass
def getOutputElementCount(self): pass
@classmethod
def getSpec(cls):
return {
"description": TestLinks.__doc__,
"singleNodeOnly": True,
"inputs": {
"UInt32": {
"description": "UInt32 Data",
"dataType": "UInt32",
"isDefaultInput": True,
"required": False,
"count": 0
},
"Real32": {
"description": "Real32 Data",
"dataType": "Real32",
"isDefaultInput": False,
"required": False,
"count": 0
},
},
"outputs": {
"UInt32": {
"description": "UInt32 Data",
"dataType": "UInt32",
"isDefaultOutput": True,
"required": False,
"count": 0
},
"Real32": {
"description": "Real32 Data",
"dataType": "Real32",
"isDefaultOutput": False,
"required": False,
"count": 0
},
},
"parameters": { }
}
class NetworkTest(unittest.TestCase):
def setUp(self):
"""Register test region"""
engine.Network.registerPyRegion(TestLinks.__module__, TestLinks.__name__)
@unittest.skipUnless(
capnp, "pycapnp is not installed, skipping serialization test.")
def testCapnpSerializationWithPyRegion(self):
"""Test capnp (de)serialization of network containing a python region"""
engine.Network.registerPyRegion(__name__,
SerializationTestPyRegion.__name__)
try:
srcNet = engine.Network()
srcNet.addRegion(SerializationTestPyRegion.__name__,
"py." + SerializationTestPyRegion.__name__,
json.dumps({
"dataWidth": 128,
"randomSeed": 99,
}))
# Serialize
builderProto = NetworkProto.new_message()
srcNet.write(builderProto)
# Construct NetworkProto reader from populated builder
readerProto = NetworkProto.from_bytes(builderProto.to_bytes())
# Deserialize
destNet = engine.Network.read(readerProto)
destRegion = destNet.getRegions().getByName(
SerializationTestPyRegion.__name__)
self.assertEqual(destRegion.getParameterUInt32("dataWidth"), 128)
self.assertEqual(destRegion.getParameterUInt32("randomSeed"), 99)
finally:
engine.Network.unregisterPyRegion(SerializationTestPyRegion.__name__)
def testSimpleTwoRegionNetworkIntrospection(self):
# Create Network instance
network = engine.Network()
# Add two TestNode regions to network
network.addRegion("region1", "TestNode", "")
network.addRegion("region2", "TestNode", "")
# Set dimensions on first region
region1 = network.getRegions().getByName("region1")
region1.setDimensions(engine.Dimensions([1, 1]))
# Link region1 and region2
network.link("region1", "region2", "UniformLink", "")
# Initialize network
network.initialize()
for linkName, link in network.getLinks():
# Compare Link API to what we know about the network
self.assertEqual(link.toString(), linkName)
self.assertEqual(link.getDestRegionName(), "region2")
self.assertEqual(link.getSrcRegionName(), "region1")
self.assertEqual(link.getLinkType(), "UniformLink")
self.assertEqual(link.getDestInputName(), "bottomUpIn")
self.assertEqual(link.getSrcOutputName(), "bottomUpOut")
break
else:
self.fail("Unable to iterate network links.")
def testNetworkLinkTypeValidation(self):
"""
This tests whether the links source and destination dtypes match
"""
network = engine.Network()
network.addRegion("from", "py.TestLinks", "")
network.addRegion("to", "py.TestLinks", "")
# Check for valid links
network.link("from", "to", "UniformLink", "", "UInt32", "UInt32")
network.link("from", "to", "UniformLink", "", "Real32", "Real32")
# Check for invalid links
with pytest.raises(RuntimeError):
network.link("from", "to", "UniformLink", "", "Real32", "UInt32")
with pytest.raises(RuntimeError):
network.link("from", "to", "UniformLink", "", "UInt32", "Real32")
def testParameters(self):
n = engine.Network()
l1 = n.addRegion("l1", "TestNode", "")
scalars = [
("int32Param", l1.getParameterInt32, l1.setParameterInt32, 32, int, 35),
("uint32Param", l1.getParameterUInt32, l1.setParameterUInt32, 33, int, 36),
("int64Param", l1.getParameterInt64, l1.setParameterInt64, 64, long, 74),
("uint64Param", l1.getParameterUInt64, l1.setParameterUInt64, 65, long, 75),
("real32Param", l1.getParameterReal32, l1.setParameterReal32, 32.1, float, 33.1),
("real64Param", l1.getParameterReal64, l1.setParameterReal64, 64.1, float, 65.1),
("stringParam", l1.getParameterString, l1.setParameterString, "nodespec value", str, "new value")]
for paramName, paramGetFunc, paramSetFunc, initval, paramtype, newval in scalars:
# Check the initial value for each parameter.
x = paramGetFunc(paramName)
self.assertEqual(type(x), paramtype, paramName)
if initval is None:
continue
if type(x) == float:
self.assertTrue(abs(x - initval) < 0.00001, paramName)
else:
self.assertEqual(x, initval, paramName)
# Now set the value, and check to make sure the value is updated
paramSetFunc(paramName, newval)
x = paramGetFunc(paramName)
self.assertEqual(type(x), paramtype)
if type(x) == float:
self.assertTrue(abs(x - newval) < 0.00001)
else:
self.assertEqual(x, newval)
================================================
FILE: bindings/py/tests/nupic_random_test.py
================================================
#!/usr/bin/env python
# Copyright 2017 Numenta Inc.
#
# Copyright may exist in Contributors' modifications
# and/or contributions to the work.
#
# Use of this source code is governed by the MIT
# license that can be found in the LICENSE file or at
# https://opensource.org/licenses/MIT.
"""NuPIC random module tests."""
import cPickle as pickle
import tempfile
import unittest
import numpy
try:
# NOTE need to import capnp first to activate the magic necessary for
# RandomProto_capnp, etc.
import capnp
except ImportError:
capnp = None
else:
from nupic.proto.RandomProto_capnp import RandomProto
from nupic.bindings.math import Random
class TestNupicRandom(unittest.TestCase):
@unittest.skipUnless(
capnp, "pycapnp is not installed, skipping serialization test.")
def testCapnpSerialization(self):
"""Test capnp serialization of NuPIC randomness."""
# Simple test: make sure that dumping / loading works...
r = Random(99)
builderProto = RandomProto.new_message()
r.write(builderProto)
readerProto = RandomProto.from_bytes(builderProto.to_bytes())
test1 = [r.getUInt32() for _ in xrange(10)]
r = Random(1);
r.read(readerProto)
self.assertEqual(r.getSeed(), 99)
test2 = [r.getUInt32() for _ in xrange(10)]
self.assertEqual(test1, test2,
"Simple NuPIC random capnp serialization check failed.")
# A little tricker: dump / load _after_ some numbers have been generated
# (in the first test). Things should still work...
# ...the idea of this test is to make sure that the pickle code isn't just
# saving the initial seed...
builderProto = RandomProto.new_message()
r.write(builderProto)
readerProto = RandomProto.from_bytes(builderProto.to_bytes())
test3 = [r.getUInt32() for _ in xrange(10)]
r = Random();
r.read(readerProto)
self.assertEqual(r.getSeed(), 99)
test4 = [r.getUInt32() for _ in xrange(10)]
self.assertEqual(
test3, test4,
"NuPIC random capnp serialization check didn't work for saving later "
"state.")
self.assertNotEqual(
test1, test3,
"NuPIC random serialization test gave the same result twice?!?")
def testNupicRandomPickling(self):
"""Test pickling / unpickling of NuPIC randomness."""
# Simple test: make sure that dumping / loading works...
r = Random(42)
pickledR = pickle.dumps(r)
test1 = [r.getUInt32() for _ in xrange(10)]
r = pickle.loads(pickledR)
test2 = [r.getUInt32() for _ in xrange(10)]
self.assertEqual(test1, test2,
"Simple NuPIC random pickle/unpickle failed.")
# A little tricker: dump / load _after_ some numbers have been generated
# (in the first test). Things should still work...
# ...the idea of this test is to make sure that the pickle code isn't just
# saving the initial seed...
pickledR = pickle.dumps(r)
test3 = [r.getUInt32() for _ in xrange(10)]
r = pickle.loads(pickledR)
test4 = [r.getUInt32() for _ in xrange(10)]
self.assertEqual(
test3, test4,
"NuPIC random pickle/unpickle didn't work for saving later state.")
self.assertNotEqual(test1, test3,
"NuPIC random gave the same result twice?!?")
def testSample(self):
r = Random(42)
population = numpy.array([1, 2, 3, 4], dtype="uint32")
choices = numpy.zeros([2], dtype="uint32")
r.sample(population, choices)
self.assertEqual(choices[0], 1)
self.assertEqual(choices[1], 3)
def testSampleNone(self):
r = Random(42)
population = numpy.array([1, 2, 3, 4], dtype="uint32")
choices = numpy.zeros([0], dtype="uint32")
# Just make sure there is no exception thrown.
r.sample(population, choices)
self.assertEqual(choices.size, 0)
def testSampleAll(self):
r = Random(42)
population = numpy.array([1, 2, 3, 4], dtype="uint32")
choices = numpy.zeros([4], dtype="uint32")
r.sample(population, choices)
self.assertEqual(choices[0], 1)
self.assertEqual(choices[1], 2)
self.assertEqual(choices[2], 3)
self.assertEqual(choices[3], 4)
def testSampleWrongDimensionsPopulation(self):
"""Check that passing a multi-dimensional array throws a ValueError."""
r = Random(42)
population = numpy.array([[1, 2], [3, 4]], dtype="uint32")
choices = numpy.zeros([2], dtype="uint32")
self.assertRaises(ValueError, r.sample, population, choices)
def testSampleWrongDimensionsChoices(self):
"""Check that passing a multi-dimensional array throws a ValueError."""
r = Random(42)
population = numpy.array([1, 2, 3, 4], dtype="uint32")
choices = numpy.zeros([2, 2], dtype="uint32")
self.assertRaises(ValueError, r.sample, population, choices)
def testSampleSequenceRaisesTypeError(self):
"""Check that passing lists throws a TypeError.
This behavior may change if sample is extended to understand sequences.
"""
r = Random(42)
population = [1, 2, 3, 4]
choices = [0, 0]
self.assertRaises(TypeError, r.sample, population, choices)
def testSampleBadDtype(self):
r = Random(42)
population = numpy.array([1, 2, 3, 4], dtype="int64")
choices = numpy.zeros([2], dtype="int64")
self.assertRaises(TypeError, r.sample, population, choices)
def testSampleDifferentDtypes(self):
r = Random(42)
population = numpy.array([1, 2, 3, 4], dtype="uint32")
choices = numpy.zeros([2], dtype="uint64")
self.assertRaises(ValueError, r.sample, population, choices)
def testSamplePopulationTooSmall(self):
r = Random(42)
population = numpy.array([1, 2, 3, 4], dtype="uint32")
choices = numpy.zeros([5], dtype="uint32")
self.assertRaises(
ValueError, r.sample, population, choices)
def testShuffle(self):
r = Random(42)
arr = numpy.array([1, 2, 3, 4], dtype="uint32")
r.shuffle(arr)
self.assertEqual(arr[0], 1)
self.assertEqual(arr[1], 4)
self.assertEqual(arr[2], 3)
self.assertEqual(arr[3], 2)
def testShuffleEmpty(self):
r = Random(42)
arr = numpy.zeros([0], dtype="uint32")
r.shuffle(arr)
self.assertEqual(arr.size, 0)
def testShuffleEmpty(self):
r = Random(42)
arr = numpy.zeros([2, 2], dtype="uint32")
self.assertRaises(ValueError, r.shuffle, arr)
def testShuffleBadDtype(self):
r = Random(42)
arr = numpy.array([1, 2, 3, 4], dtype="int64")
self.assertRaises(ValueError, r.shuffle, arr)
def testEquals(self):
r1 = Random(42)
v1 = r1.getReal64()
r2 = Random(42)
v2 = r2.getReal64()
self.assertEquals(v1, v2)
self.assertEquals(r1, r2)
if __name__ == "__main__":
unittest.main()
================================================
FILE: bindings/py/tests/pyregion_test.py
================================================
# Copyright 2014-2015 Numenta Inc.
#
# Copyright may exist in Contributors' modifications
# and/or contributions to the work.
#
# Use of this source code is governed by the MIT
# license that can be found in the LICENSE file or at
# https://opensource.org/licenses/MIT.
import unittest
from nupic.bindings.regions.PyRegion import PyRegion
# Classes used for testing
class X(PyRegion):
def __init__(self):
self.x = 5
class Y(PyRegion):
def __init__(self):
self.zzz = 5
self._zzz = 3
def initialize(self): pass
def compute(self): pass
def getOutputElementCount(self): pass
class Z(object):
def __init__(self):
y = Y()
y.setParameter('zzz', 0, 4)
class PyRegionTest(unittest.TestCase):
def testNoInit(self):
"""Test unimplemented init method"""
class NoInit(PyRegion):
pass
with self.assertRaises(TypeError) as cw:
_ni = NoInit()
self.assertEqual(str(cw.exception), "Can't instantiate abstract class " +
"NoInit with abstract methods __init__, compute, initialize")
def testUnimplementedAbstractMethods(self):
"""Test unimplemented abstract methods"""
# Test unimplemented getSpec (results in NotImplementedError)
with self.assertRaises(NotImplementedError):
X.getSpec()
# Test unimplemented abstract methods (x can't be instantiated)
with self.assertRaises(TypeError) as cw:
_x = X()
self.assertEqual(str(cw.exception), "Can't instantiate abstract class " +
"X with abstract methods compute, initialize")
def testUnimplementedNotImplementedMethods(self):
"""Test unimplemented @not_implemented methods"""
# Can instantiate because all abstract methods are implemented
y = Y()
# Can call the default getParameter() from PyRegion
self.assertEqual(y.getParameter('zzz', -1), 5)
# Accessing an attribute whose name starts with '_' via getParameter()
with self.assertRaises(Exception) as cw:
_ = y.getParameter('_zzz', -1) == 5
self.assertEqual(str(cw.exception), "Parameter name must not " +
"start with an underscore")
# Calling not implemented method result in NotImplementedError
with self.assertRaises(NotImplementedError) as cw:
y.setParameter('zzz', 4, 5)
self.assertEqual(str(cw.exception),
"The method setParameter is not implemented.")
def testCallUnimplementedMethod(self):
"""Test calling an unimplemented method"""
with self.assertRaises(NotImplementedError) as cw:
_z = Z()
self.assertEqual(str(cw.exception),
"The method setParameter is not implemented.")
if __name__ == "__main__":
unittest.main()
================================================
FILE: bindings/py/tests/segment_sparse_matrix_test.py
================================================
# Copyright 2016 Numenta Inc.
#
# Copyright may exist in Contributors' modifications
# and/or contributions to the work.
#
# Use of this source code is governed by the MIT
# license that can be found in the LICENSE file or at
# https://opensource.org/licenses/MIT.
"""Unit test for segment sparse matrix."""
import numpy as np
import unittest
from nupic.bindings.math import SegmentSparseMatrix
class SegmentSparseMatrixTest(unittest.TestCase):
def testAddRows(self):
ssm = SegmentSparseMatrix(2048, 1000)
self.assertEqual(0, ssm.matrix.nRows())
ssm.createSegment(42)
self.assertEqual(1, ssm.matrix.nRows())
ssm.createSegments([42, 43, 44])
self.assertEqual(4, ssm.matrix.nRows())
def testNoRowLeaks(self):
ssm = SegmentSparseMatrix(2048, 1000)
created = ssm.createSegments([42, 43, 44, 45, 46])
ssm.destroySegments([created[1], created[2], created[3]])
ssm.createSegments([50, 51, 52, 53])
self.assertEquals(6, ssm.matrix.nRows())
def testGetSegmentCounts(self):
ssm = SegmentSparseMatrix(2048, 1000)
created = ssm.createSegments([42, 42, 43, 44, 45, 43])
ssm.destroySegments([created[2], created[4]])
np.testing.assert_equal(ssm.getSegmentCounts([42, 43, 44, 45, 46]),
[2, 1, 1, 0, 0])
def testSortSegmentsByCell(self):
ssm = SegmentSparseMatrix(2048, 1000)
segments = ssm.createSegments([42, 41, 49, 45, 0, 2047])
segmentsSorted = [segments[4],
segments[1],
segments[0],
segments[3],
segments[2],
segments[5]]
ssm.sortSegmentsByCell(segments)
np.testing.assert_equal(segments, segmentsSorted)
def testFilterSegmentsByCell(self):
ssm = SegmentSparseMatrix(2048, 1000)
# Shuffled [42, 42, 42, 43, 46, 47, 48]
cellsWithSegments = [47, 42, 46, 43, 42, 48, 42]
segments = ssm.createSegments(cellsWithSegments)
ssm.sortSegmentsByCell(segments)
# Include everything
everything = sorted(cellsWithSegments)
np.testing.assert_equal(ssm.filterSegmentsByCell(segments, everything),
segments)
# Subset, one cell with multiple segments
np.testing.assert_equal(ssm.filterSegmentsByCell(segments,
[42, 43, 48]),
[segments[0],
segments[1],
segments[2],
segments[3],
segments[6]])
# Subset, some cells without segments
np.testing.assert_equal(ssm.filterSegmentsByCell(segments,
[43, 44, 45, 48]),
[segments[3],
segments[6]])
def testMapSegmentsToCells(self):
ssm = SegmentSparseMatrix(2048, 1000)
segments = ssm.createSegments([42, 42, 42, 43, 44, 45])
np.testing.assert_equal(
ssm.mapSegmentsToCells(segments),
[42, 42, 42, 43, 44, 45])
np.testing.assert_equal(ssm.mapSegmentsToCells([segments[3],
segments[3],
segments[0]]),
[43, 43, 42])
================================================
FILE: bindings/py/tests/sparse_binary_matrix_test.py
================================================
#!/usr/bin/env python
# Copyright 2013 Numenta Inc.
#
# Copyright may exist in Contributors' modifications
# and/or contributions to the work.
#
# Use of this source code is governed by the MIT
# license that can be found in the LICENSE file or at
# https://opensource.org/licenses/MIT.
"""Unit tests for sparse binary matrix."""
import cPickle
import os
import numpy
import unittest
from nupic.bindings.math import SM32, SM_01_32_32
_RGEN = numpy.random.RandomState(37)
def error(str):
print 'Error:', str
class UnitTests(unittest.TestCase):
def setUp(self):
self.Matrix = SM_01_32_32(1)
def test_construction(self):
a = self.Matrix.__class__(4)
if a.nRows() != 0 or a.nCols() != 4:
error('constructor 1')
b = self.Matrix.__class__(a)
if b.nRows() != 0 or b.nCols() != 4:
error('constructor 2A')
if (a.toDense() != b.toDense()).any():
error('constructor 2B')
m = _RGEN.randint(1,10)
n = _RGEN.randint(5,10)
a = self.Matrix.__class__(n)
x = _RGEN.randint(0,2,(m,n))
x[m/2] = numpy.zeros((n))
for i in range(m):
a.appendSparseRow(numpy.where(x[i] > 0)[0].tolist())
b = self.Matrix.__class__(a)
if (a.toDense() != b.toDense()).any():
error('copy constructor')
c = self.Matrix.__class__(x)
if (c.toDense() != x).any():
error('constructor from numpy array')
s = c.toCSR()
d = self.Matrix.__class__(s)
if (d.toDense() != x).any():
error('constructor from csr string')
# Test construction from a SM
a = _RGEN.randint(0,10,(3,4))
a[2] = 0
a[:,3] = 0
a = SM32(a)
b = SM_01_32_32(a)
a = a.toDense()
w = numpy.where(a > 0)
a[w] = 1
if (a != b.toDense()).any():
error('construction from SM')
def testAccessors(self):
m = _RGEN.randint(1,10)
n = _RGEN.randint(5,10)
x = _RGEN.randint(0,2,(m,n))
x[m/2] = 0
a = self.Matrix.__class__(n)
print a.getVersion(), a.getVersion(True)
if a.nRows() != 0:
error('nRows 1')
if a.nCols() != n:
error('nCols 1')
for i in range(m):
a.appendSparseRow(numpy.where(x[i] > 0)[0].tolist())
if a.nRows() != m:
error('nRows 2')
if a.nCols() != n:
error('nCols 2')
if a.nNonZeros() != len(numpy.where(x > 0)[0]):
error('nNonZeros')
for i in range(m):
if a.nNonZerosOnRow(i) != x.sum(axis=1)[i]:
error('nNonZerosOnRow')
if (a.nNonZerosPerRow() != x.sum(axis=1)).any():
error('nNonZerosPerRow')
if (a.nNonZerosPerCol() != x.sum(axis=0)).any():
error('nNonZerosPerCol')
for i in range(m):
y = numpy.zeros((n))
for j in a.getRowSparse(i):
y[j] = 1
if (y != x[i]).any():
error('getRowSparse')
if a.capacity() < a.nNonZeros():
error('capacity')
m = _RGEN.randint(100,200)
n = _RGEN.randint(100,200)
x = _RGEN.randint(0,2,(m,n))
x[m/2] = 0
a = self.Matrix.__class__(x)
m1 = a.nBytes()
a.compact()
m2 = a.nBytes()
if (m2 > m1):
error('compact')
def testCopy(self):
m = _RGEN.randint(1,10)
n = _RGEN.randint(5,10)
x = _RGEN.randint(0,2,(m,n))
x[m/2] = numpy.zeros((n))
a = self.Matrix.__class__(x)
b = self.Matrix.__class__(1)
b.copy(a)
if a != b:
error('copy')
def testClear(self):
m = _RGEN.randint(1,10)
n = _RGEN.randint(5,10)
x = _RGEN.randint(0,2,(m,n))
x[m/2] = 0
a = self.Matrix.__class__(x)
a.clear()
if a.capacity() != 0:
error('clear /capacity')
if a.nRows() != 0:
error('clear /nRows')
if a.nCols() != 0:
error('clear /nCols')
if a.nNonZeros() != 0:
error('clear /nNonZeros')
def testResize(self):
# 1. Resize to 0,0 (equivalent to clear)
m = _RGEN.randint(4,10)
n = _RGEN.randint(6,10)
x = _RGEN.randint(0,2,(m,n))
x[m/2] = 0
a = self.Matrix.__class__(x)
a.resize(0,0)
if a.capacity() != 0:
error('resize to 0,0 /capacity')
if a.nRows() != 0:
error('resize to 0,0 /nRows')
if a.nCols() != 0:
error('resize to 0,0 /nCols')
if a.nNonZeros() != 0:
error('resize to 0,0 /nNonZeros')
# 2. Resize to larger size
m = _RGEN.randint(4,10)
n = _RGEN.randint(6,10)
x = _RGEN.randint(0,2,(m,n))
x[m/2] = 0
a = self.Matrix.__class__(x)
# 2.1 More rows only
old_nrows = a.nRows()
old_ncols = a.nCols()
old_nnzr = a.nNonZeros()
a.resize(2*a.nRows(),a.nCols())
if a.nRows() != 2*old_nrows or a.nCols() != old_ncols:
error('resize to more rows, 1')
if a.nNonZeros() != old_nnzr:
error('resize to more rows, 2')
# 2.2 More cols only
old_nrows = a.nRows()
a.resize(a.nRows(), 2*a.nCols())
if a.nRows() != old_nrows or a.nCols() != 2*old_ncols:
error('resize to more cols, 1')
if a.nNonZeros() != old_nnzr:
error('resize to more cols, 2')
# 2.3 More rows and cols
m = _RGEN.randint(4,10)
n = _RGEN.randint(6,10)
x = _RGEN.randint(0,2,(m,n))
x[m/2] = 0
a = self.Matrix.__class__(x)
old_nrows = a.nRows()
old_ncols = a.nCols()
old_nnzr = a.nNonZeros()
a.resize(2*a.nRows(),2*a.nCols())
if a.nRows() != 2*old_nrows or a.nCols() != 2*old_ncols:
error('resize to more rows and cols, 1')
if a.nNonZeros() != old_nnzr:
error('resize to more rows and cols, 2')
# 3. Resize to smaller size
m = _RGEN.randint(10,20)
n = _RGEN.randint(10,20)
x = _RGEN.randint(0,2,(m,n))
x[m/2] = 0
a = self.Matrix.__class__(x)
# 3.1 Less rows only
old_nrows = a.nRows()
old_ncols = a.nCols()
old_nnzr = a.nNonZeros()
a.resize(a.nRows()/2,a.nCols())
if a.nRows() != old_nrows/2 or a.nCols() != old_ncols:
error('resize to less rows, 1')
if a.nNonZeros() != numpy.sum(x[:old_nrows/2]):
error('resize to less rows, 2')
# 2.2 Less cols only
old_nrows = a.nRows()
a.resize(a.nRows(), a.nCols()/2)
if a.nRows() != old_nrows or a.nCols() != old_ncols/2:
error('resize to less cols, 1')
if a.nNonZeros() != numpy.sum(x[:a.nRows(),:old_ncols/2]):
error('resize to less cols, 2')
# 2.3 Less rows and cols
m = _RGEN.randint(10,20)
n = _RGEN.randint(10,20)
x = _RGEN.randint(0,2,(m,n))
x[m/2] = 0
a = self.Matrix.__class__(x)
old_nrows = a.nRows()
old_ncols = a.nCols()
old_nnzr = a.nNonZeros()
a.resize(a.nRows()/2,a.nCols()/2)
if a.nRows() != old_nrows/2 or a.nCols() != old_ncols/2:
error('resize to less rows and cols, 1')
if a.nNonZeros() != numpy.sum(x[:old_nrows/2,:old_ncols/2]):
error('resize to less rows and cols, 2')
def testEquals(self):
m = _RGEN.randint(1,10)
n = _RGEN.randint(5,10)
a = self.Matrix.__class__(n)
x = _RGEN.randint(0,2,(m,n))
x[m/2] = numpy.zeros((n))
a = self.Matrix.__class__(x)
b = self.Matrix.__class__(x)
if a != b:
error('equals 1')
b.set(m/2, n/2, 1)
if a == b:
error('equals 2')
def testSet(self):
m = _RGEN.randint(1,10)
n = _RGEN.randint(5,10)
x = _RGEN.randint(0,2,(m,n))
x[m/2] = numpy.zeros((n))
a = self.Matrix.__class__(x)
a.set(m/2, [0, 2, 4], 1)
x[m/2,0] = 1
x[m/2,2] = 1
x[m/2,4] = 1
if (a != x).any():
error('set on row 1')
a.set(m/2, [0,2,4], 0)
x[m/2,0] = 0
x[m/2,2] = 0
x[m/2,4] = 0
if (a != x).any():
error('set on row 1')
m = _RGEN.randint(1,10)
n = _RGEN.randint(5,10)
x = _RGEN.randint(0,2,(m,n))
x[m/2] = numpy.zeros((n))
a = self.Matrix.__class__(x)
a.setForAllRows([0,2,4], 1)
for i in range(m):
x[i,0] = 1
x[i,2] = 1
x[i,4] = 1
if (a != x).any():
error('set for all rows')
def testGetAllNonZeros(self):
for i in range(10):
m = _RGEN.randint(2,10)
n = _RGEN.randint(2,10)
a = _RGEN.randint(0,2,(m,n))
a[_RGEN.randint(0,m)] = 0
a[:,_RGEN.randint(0,n)] = 0
sm = self.Matrix.__class__(a)
ans_ind = numpy.where(a > 0)
ans_val = a[ans_ind]
ans = [(i,j,v) for i,j,v in zip(ans_ind[0], ans_ind[1], ans_val)]
# Returns one list of pairs by default
all_nz = sm.getAllNonZeros()
for x,y in zip(all_nz, ans):
if x[0] != y[0] or x[1] != y[1]:
error('getAllNonZeros 1 list of pairs')
# Test option to return 2 lists instead of 1 list of pairs
all_nz2 = sm.getAllNonZeros(True)
for i in range(len(ans_val)):
if all_nz2[0][i] != ans_ind[0][i] or all_nz2[1][i] != ans_ind[1][i]:
error('getAllNonZeros 2 lists')
def testSetAllNonZeros(self):
for i in range(10):
m = _RGEN.randint(2,10)
n = _RGEN.randint(2,10)
a = _RGEN.randint(0,2,(m,n))
a[_RGEN.randint(0,m)] = 0
a[:,_RGEN.randint(0,n)] = 0
a[0,0] = 1
a[m-1] = 0
a[:,n-1] = 0
nz = numpy.where(a > 0)
sm = self.Matrix.__class__(1)
# Assumes lexicographic order of the indices by default
sm.setAllNonZeros(a.shape[0], a.shape[1], nz[0],nz[1])
if (sm.toDense() != a).any():
error('setAllNonZeros, in order')
# Test when values come in out of (lexicographic) order
# and with duplicates
p = _RGEN.permutation(len(nz[0]))
nz_i2,nz_j2 = [],[]
for i in p:
nz_i2.append(nz[0][i])
nz_j2.append(nz[1][i])
for i in p:
nz_i2.append(nz[0][i])
nz_j2.append(nz[1][i])
sm2 = self.Matrix.__class__(1)
sm2.setAllNonZeros(a.shape[0], a.shape[1], nz_i2,nz_j2, False)
if (sm2.toDense() != a).any():
error('setAllNonZeros, out of order')
def testGetCol(self):
for i in range(10):
m = _RGEN.randint(2,10)
n = _RGEN.randint(2,10)
a = _RGEN.randint(0,2,(m,n)).astype(numpy.float32)
a[_RGEN.randint(0,m)] = 0
a[:,_RGEN.randint(0,n)] = 0
a[0,0] = 1
a[m/2] = 0
a[:,n/2] = 0
sm = self.Matrix.__class__(a)
for j in range(n):
if (sm.getCol(j) != a[:,j]).any():
error('getCol')
def testSetSlice(self):
# With a sparse matrix
for i in range(10):
m = _RGEN.randint(10,20)
n = _RGEN.randint(10,20)
a = _RGEN.randint(0,2,(m,n)).astype(numpy.float32)
a[_RGEN.randint(0,m)] = 0
a[:,_RGEN.randint(0,n)] = 0
a[0,0] = 1
a[m/2] = 0
a[:,n/2] = 0
sm = self.Matrix.__class__(a)
b = _RGEN.randint(0,2,(m/4,n/4)).astype(numpy.float32)
slice = self.Matrix.__class__(b)
x,y = _RGEN.randint(0,m/2), _RGEN.randint(0,n/2)
sm.setSlice(x,y,slice)
ans = numpy.array(a)
for i in range(b.shape[0]):
for j in range(b.shape[1]):
ans[x+i,y+j] = slice.get(i,j)
if (sm.toDense() != ans).any():
error('setSlice')
# With a numpy array
for i in range(10):
m = _RGEN.randint(10,20)
n = _RGEN.randint(10,20)
a = _RGEN.randint(0,2,(m,n)).astype(numpy.float32)
a[_RGEN.randint(0,m)] = 0
a[:,_RGEN.randint(0,n)] = 0
a[numpy.where(a < 25)] = 0
a[0,0] = 1
a[m/2] = 0
a[:,n/2] = 0
sm = self.Matrix.__class__(a)
slice = _RGEN.randint(0,2,(m/4,n/4)).astype(numpy.float32)
x,y = _RGEN.randint(0,m/2), _RGEN.randint(0,n/2)
sm.setSlice(x,y,slice)
ans = numpy.array(a)
for i in range(slice.shape[0]):
for j in range(slice.shape[1]):
ans[x+i,y+j] = slice[i,j]
if (sm.toDense() != ans).any():
error('setSlice/dense')
def testNNonZerosPerBox(self):
for i in range(10):
m = _RGEN.randint(2,10)
n = _RGEN.randint(2,10)
a = _RGEN.randint(0,2,(m,n)).astype(numpy.float32)
a[_RGEN.randint(0,m)] = 0
a[:,_RGEN.randint(0,n)] = 0
a[0,0] = 1
a[m/2] = 0
a[:,n/2] = 0
sm = self.Matrix.__class__(a)
nnzpb = sm.nNonZerosPerBox([m/2, m], [n/2, n])
ans = numpy.zeros((2,2))
ans[0,0] = numpy.sum(a[:m/2,:n/2])
ans[0,1] = numpy.sum(a[:m/2,n/2:])
ans[1,0] = numpy.sum(a[m/2:,:n/2])
ans[1,1] = numpy.sum(a[m/2:,n/2:])
if (nnzpb.toDense() != ans).any():
error('nNonZerosPerBox')
def testAppendSparseRow(self):
m = _RGEN.randint(1,10)
n = _RGEN.randint(5,10)
a = self.Matrix.__class__(n)
x = _RGEN.randint(0,2,(m,n))
x[m/2] = numpy.zeros((n))
for i in range(m):
a.appendSparseRow(numpy.where(x[i] > 0)[0].tolist())
if (a.toDense() != x).any():
error('appendSparseRow')
if a.nRows() != m:
error('appendSparseRow nRows')
if (numpy.array(a.nNonZerosPerRow()) != x.sum(axis=1)).any():
error('appendSparseRow nNonZerosPerRow')
if a.nNonZeros() != len(numpy.where(x > 0)[0]):
error('appendSparseRow nNonZeros')
def testAppendDenseRow(self):
m = _RGEN.randint(1,10)
n = _RGEN.randint(5,10)
a = self.Matrix.__class__(n)
x = _RGEN.randint(0,2,(m,n))
x[m/2] = numpy.zeros((n))
for i in range(m):
a.appendDenseRow(x[i])
if (a.toDense() != x).any():
error('appendDenseRow')
if a.nRows() != m:
error('appendDenseRow nRows')
if (numpy.array(a.nNonZerosPerRow()) != x.sum(axis=1)).any():
error('appendDenseRow nNonZerosPerRow')
if a.nNonZeros() != len(numpy.where(x > 0)[0]):
error('appendDenseRow nNonZeros')
def testReplaceSparseRow(self):
m = _RGEN.randint(1,10)
n = _RGEN.randint(5,10)
a = self.Matrix.__class__(n)
x = _RGEN.randint(0,2,(m,n))
x[m/2] = numpy.zeros((n))
for i in range(m):
a.appendSparseRow(numpy.where(x[i] > 0)[0].tolist())
for i in range(m):
x[i] = _RGEN.randint(0,2,(n))
a.replaceSparseRow(i, numpy.where(x[i] > 0)[0].tolist())
if (a.toDense() != x).any():
error('replaceSparseRow')
if (numpy.array(a.nNonZerosPerRow()) != x.sum(axis=1)).any():
error('replaceSparseRow nNonZerosPerRow')
if a.nNonZeros() != len(numpy.where(x > 0)[0]):
error('replaceSparseRow nNonZeros')
if a.nRows() != m:
error('replaceSparseRow nRows')
def testFindRowSparse(self):
m = _RGEN.randint(1,10)
n = _RGEN.randint(5,10)
a = self.Matrix.__class__(n)
x = _RGEN.randint(0,2,(m,n))
x[m/2] = numpy.zeros((n))
for i in range(m):
a.appendSparseRow(numpy.where(x[i] > 0)[0].tolist())
for i in range(m):
w = a.findRowSparse(numpy.where(x[i] > 0)[0].tolist())
if (x[w] != x[i]).any():
error('findRowSparse')
def testFindRowDense(self):
m = _RGEN.randint(1,10)
n = _RGEN.randint(5,10)
x = _RGEN.randint(0,2,(m,n))
x[m/2] = numpy.zeros((n))
a = self.Matrix.__class__(x)
for i in range(m):
w = a.findRowDense(x[i])
if (x[w] != x[i]).any():
error('findRowDense')
def testGet(self):
m = _RGEN.randint(1,10)
n = _RGEN.randint(5,10)
x = _RGEN.randint(0,2,(m,n))
x[m/2] = numpy.zeros((n))
a = self.Matrix.__class__(n)
a.fromDense(x)
for i in range(m):
for j in range(n):
if a.get(i,j) != x[i,j]:
error('get')
def testSet(self):
m = _RGEN.randint(1,10)
n = _RGEN.randint(5,10)
x = _RGEN.randint(0,2,(m,n))
x[m/2] = 0
a = self.Matrix.__class__(x)
for i in range(m):
for j in range(n):
v = _RGEN.randint(0,2)
a.set(i,j,v)
x[i,j] = v
if (a.toDense() != x).any():
error('set')
a.set(0,n-1,2)
x[0,n-1] = 1
if (a.toDense() != x).any():
error('set 2')
x[m/2] = 0
a.fromDense(x)
for j in range(n):
a.set(m/2,j,1)
x[m/2] = 1
if (a.toDense() != x).any():
error('set 3')
def testSetRangeToZero(self):
m = _RGEN.randint(1,10)
n = _RGEN.randint(5,10)
x = _RGEN.randint(0,2,(m,n))
x[m/2] = 0
a = self.Matrix.__class__(n)
a.fromDense(x)
for i in range(m):
begin = _RGEN.randint(0,n)
end = _RGEN.randint(begin, n+1)
a.setRangeToZero(i, begin, end)
x[i][begin:end] = 0
if (a.toDense() != x).any():
error('setRangeToZero 1')
a.setRangeToZero(0, 0, 0)
if (a.toDense() != x).any():
error('setRangeToZero 2')
a.setRangeToZero(0, n, n)
if (a.toDense() != x).any():
error('setRangeToZero 3')
a.setRangeToZero(0, 3, 3)
if (a.toDense() != x).any():
error('setRangeToZero 4')
a.setRangeToZero(0, 0, n)
x[0] = 0
if (a.toDense() != x).any():
error('setRangeToZero 5')
def testSetRangeToOne(self):
m = _RGEN.randint(1,10)
n = _RGEN.randint(5,10)
x = _RGEN.randint(0,2,(m,n))
x[m/2] = numpy.zeros((n))
a = self.Matrix.__class__(n)
a.fromDense(x)
for i in range(m):
begin = _RGEN.randint(0,n)
end = _RGEN.randint(begin, n+1)
a.setRangeToOne(i, begin, end)
x[i][begin:end] = 1
if (a.toDense() != x).any():
error('setRangeToOne 1')
a.setRangeToOne(0, 0, 0)
if (a.toDense() != x).any():
error('setRangeToOne 2')
a.setRangeToOne(0, n, n)
if (a.toDense() != x).any():
error('setRangeToOne 3')
a.setRangeToOne(0, 3, 3)
if (a.toDense() != x).any():
error('setRangeToOne 4')
a.setRangeToOne(0, 0, n)
x[0] = 1
if (a.toDense() != x).any():
error('setRangeToOne 5')
def testTranspose(self):
for k in range(10):
m = _RGEN.randint(4,10)
n = _RGEN.randint(5,10)
a = self.Matrix.__class__(n)
x = _RGEN.randint(0,2,(m,n))
x[m/2] = 0
x[:n/2] = 0
for i in range(m):
a.appendDenseRow(x[i])
a.transpose()
if (a.toDense() != numpy.transpose(x)).any():
error('numpy.transpose')
if (numpy.array(a.nNonZerosPerRow()) != x.sum(axis=0)).any():
error('numpy.transpose nNonZerosPerRow')
if a.nNonZeros() != len(numpy.where(x > 0)[0]):
error('numpy.transpose nNonZeros')
a.transpose()
if (a.toDense() != x).any():
error('numpy.transpose 2')
if (numpy.array(a.nNonZerosPerRow()) != x.sum(axis=1)).any():
error('numpy.transpose nNonZerosPerRow 2')
if a.nNonZeros() != len(numpy.where(x > 0)[0]):
error('numpy.transpose nNonZeros 2')
def testCSR(self):
m = _RGEN.randint(10,20)
n = _RGEN.randint(10,20)
x = _RGEN.randint(0,2,(m,n))
x[m/2] = 0
x[:,n/2] = 0
a = self.Matrix.__class__(x)
csr = a.toCSR()
b = self.Matrix.__class__(1)
b.fromCSR(csr)
if (a.toDense() != b.toDense()).any():
error('toCSR/fromCSR')
if (numpy.array(a.nNonZerosPerRow()) != numpy.array(b.nNonZerosPerRow())).any():
error('toCSR/fromCSR nNonZerosPerRow')
if b.nNonZeros() != len(numpy.where(x > 0)[0]):
error('toCSR/fromCSR nNonZeros')
def testGetstateSetstate(self):
m = _RGEN.randint(10,20)
n = _RGEN.randint(10,20)
x = _RGEN.randint(0,2,(m,n))
x[m/2] = 0
x[:,n/2] = 0
a = self.Matrix.__class__(x)
s = a.__getstate__()
b = self.Matrix.__class__(1)
b.__setstate__(s)
if a != b:
error('__geststate__/__setstate__')
def testCSRToFromFile(self):
m = _RGEN.randint(10,20)
n = _RGEN.randint(10,20)
x = _RGEN.randint(0,2,(m,n))
x[m/2] = 0
x[:,n/2] = 0
a = self.Matrix.__class__(x)
a.CSRSaveToFile('test_csr2.txt')
b = self.Matrix.__class__(1)
b.CSRLoadFromFile('test_csr2.txt')
if a != b:
error('CSRSaveToFile/CSRLoadFromFile')
os.unlink('test_csr2.txt')
def testCSRSize(self):
for k in range(5):
m = _RGEN.randint(10,100)
n = _RGEN.randint(10,100)
x = _RGEN.randint(0,100,(m,n))
x[m/2] = 0
a = self.Matrix.__class__(x)
for i in range(10):
s_estimated = a.CSRSize()
a.CSRSaveToFile('test_csr.txt')
s_real = os.path.getsize('test_csr.txt')
if s_estimated != s_real:
error('CSRSize')
for j in range(1000):
a.set(_RGEN.randint(0,m),_RGEN.randint(0,n), 0)
os.unlink('test_csr.txt')
def testBinary(self):
m = _RGEN.randint(10,20)
n = _RGEN.randint(10,20)
x = _RGEN.randint(0,2,(m,n))
x[m/2] = 0
x[:,n/2] = 0
a = self.Matrix.__class__(x)
a.binarySaveToFile('test_binary.bin')
b = self.Matrix.__class__(1)
b.binaryLoadFromFile('test_binary.bin')
if a != b:
error('binarySaveToFile/binaryLoadFromFile')
os.unlink('test_binary.bin')
def testToFromSparseVector(self):
m = _RGEN.randint(1,10)
n = _RGEN.randint(5,10)
a = self.Matrix.__class__(1)
x = _RGEN.randint(0,2,(m,n))
x[m/2] = numpy.zeros((n))
x = x.reshape((m*n))
indices = numpy.where(x > 0)[0].tolist()
a.fromSparseVector(m, n, indices)
x = x.reshape((m,n))
if (a.toDense() != x).any():
error('fromSparseVector')
if (numpy.array(a.nNonZerosPerRow()) != x.sum(axis=1)).any():
error('fromSparseVector nNonZerosPerRow')
if a.nNonZeros() != len(numpy.where(x > 0)[0]):
error('fromSparseVector nNonZeros')
x = x.reshape(m*n)
y = a.toSparseVector()
if (y != numpy.where(x > 0)[0].tolist()).any():
error('toSparseVector')
if a.nNonZeros() != len(numpy.where(x > 0)[0]):
error('toSparseVector nNonZeros 2')
# Need to make the same matrix can go through
# fromSparseVector again with a different x
x = _RGEN.randint(0,2,(n,m))
x = x.reshape((m*n))
indices = numpy.where(x > 0)[0].tolist()
a.fromSparseVector(n, m, indices)
x = x.reshape((n, m))
if (a.toDense() != x).any():
error('fromSparseVector 2')
if (numpy.array(a.nNonZerosPerRow()) != x.sum(axis=1)).any():
error('fromSparseVector nNonZerosPerRow 2')
if a.nNonZeros() != len(numpy.where(x > 0)[0]):
error('fromSparseVector nNonZeros 2')
x = x.reshape(m*n)
y = a.toSparseVector()
if (y != numpy.where(x > 0)[0].tolist()).any():
error('toSparseVector 2')
if a.nNonZeros() != len(numpy.where(x > 0)[0]):
error('toSparseVector nNonZeros 2')
def testToFromDense(self):
m = _RGEN.randint(1,10)
n = _RGEN.randint(5,10)
x = _RGEN.randint(0,2,(m,n))
x[m/2] = numpy.zeros((n))
a = self.Matrix.__class__(1)
a.fromDense(x)
if (a.toDense() != x).any():
error('fromDense')
if (numpy.array(a.nNonZerosPerRow()) != x.sum(axis=1)).any():
error('fromDense nNonZerosPerRow')
if a.nNonZeros() != len(numpy.where(x > 0)[0]):
error('fromDense nNonZeros')
# Need to make sure the same matrix can go
# through another fromDense with a different x
x = _RGEN.randint(0,2,(n,m))
a.fromDense(x)
if (a.toDense() != x).any():
error('fromDense 2')
if (numpy.array(a.nNonZerosPerRow()) != x.sum(axis=1)).any():
error('fromDense nNonZerosPerRow 2')
if a.nNonZeros() != len(numpy.where(x > 0)[0]):
error('fromDense nNonZeros 2')
def testRowToFromDense(self):
m = _RGEN.randint(1,10)
n = _RGEN.randint(5,10)
x = _RGEN.randint(0,2,(m,n))
x[m/2] = numpy.zeros((n))
b = numpy.zeros((m,n))
a = self.Matrix.__class__(n)
for i in range(m):
a.appendDenseRow(numpy.zeros((n)))
a.rowFromDense(i, x[i])
if (a.toDense() != x).any():
error('rowFromDense')
for i in range(m):
b[i] = a.rowToDense(i)
if (b != x).any():
error('rowToDense')
def testLogicalNot(self):
m = _RGEN.randint(1,10)
n = _RGEN.randint(5,10)
a = self.Matrix.__class__(n)
x = _RGEN.randint(0,2,(m,n))
x[m/2] = numpy.zeros((n))
for i in range(m):
a.appendSparseRow(numpy.where(x[i] > 0)[0].tolist())
a.logicalNot()
y = 1 - x
if (a.toDense() != y).any():
error('logicalNot')
def testLogicalOr(self):
show = False
a = self.Matrix.__class__(1)
a.fromDense([[0,0,1,1,1,0,0],
[0,1,0,0,0,1,0],
[0,1,0,0,0,1,0],
[0,0,1,1,1,0,0]])
b = self.Matrix.__class__(1)
b.fromDense([[0,0,0,0,0,0,0],
[0,0,1,1,1
Showing preview only (888K chars total). Download the full file or copy to clipboard to get everything.
gitextract_vbrl680u/ ├── .circleci/ │ └── config.yml ├── .clang-format ├── .gitignore ├── .travis.yml ├── CHANGELOG.md ├── CMakeLists.txt ├── CONTRIBUTING.md ├── CommonCompilerConfig.cmake ├── DEPENDENCIES.md ├── Dockerfile ├── LICENSE.txt ├── README.md ├── RELEASE.md ├── VERSION ├── appveyor.yml ├── bindings/ │ └── py/ │ ├── dummy.c │ ├── requirements.txt │ ├── setup.py │ ├── src/ │ │ └── nupic/ │ │ ├── __init__.py │ │ ├── bindings/ │ │ │ ├── regions/ │ │ │ │ ├── PyRegion.py │ │ │ │ ├── TestNode.py │ │ │ │ └── __init__.py │ │ │ └── tools/ │ │ │ ├── SerializationTestPyRegionProto.capnp │ │ │ ├── __init__.py │ │ │ ├── cyclical_serialization_perf.py │ │ │ ├── random_serialization_perf.py │ │ │ └── serialization_test_py_region.py │ │ └── proto/ │ │ ├── .gitignore │ │ └── __init__.py │ └── tests/ │ ├── __init__.py │ ├── algorithms/ │ │ ├── cells4_test.py │ │ └── svm_test.py │ ├── array_algorithms_test.py │ ├── cast_mode_test.py │ ├── check_test.py │ ├── connections_test.py │ ├── network_test.py │ ├── nupic_random_test.py │ ├── pyregion_test.py │ ├── segment_sparse_matrix_test.py │ ├── sparse_binary_matrix_test.py │ ├── sparse_link_test.py │ ├── sparse_matrix_test.py │ └── temporal_memory_test.py ├── ci/ │ ├── appveyor/ │ │ └── install_python_pip.ps1 │ ├── bamboo/ │ │ ├── build-linux-debug.sh │ │ ├── build-linux-release.sh │ │ ├── build-manylinux-debug.sh │ │ ├── build-manylinux-release.sh │ │ ├── build-osx.sh │ │ ├── build-windows.ps1 │ │ ├── check-style.sh │ │ ├── fetch_remote.py │ │ ├── manylinux-build-env.rc │ │ └── setup-dependencies-linux.sh │ ├── build-and-test-nupic-bindings.sh │ ├── deploy-wheel-to-s3.py │ └── travis/ │ ├── README.md │ ├── before_deploy.sh │ └── before_install-osx.sh ├── docs/ │ ├── .gitignore │ ├── Doxyfile │ ├── Makefile │ ├── make.bat │ ├── source/ │ │ ├── algorithms.rst │ │ ├── classifiers.rst │ │ ├── conf.py │ │ ├── connections.rst │ │ ├── encoders.rst │ │ ├── engine.rst │ │ ├── index.rst │ │ ├── math.rst │ │ ├── network-io.rst │ │ ├── network-links.rst │ │ ├── network-network.rst │ │ ├── network-regions.rst │ │ ├── network-sensors.rst │ │ ├── network.rst │ │ ├── spatial-pooler.rst │ │ ├── temporal-memory.rst │ │ ├── types.rst │ │ └── utils.rst │ └── xunit.xslt ├── external/ │ ├── Apr1Lib.cmake │ ├── AprUtil1Lib.cmake │ ├── CMakeLists.txt │ ├── CapnProto.cmake │ ├── MoveFilesToNewDir.cmake │ ├── README.md │ ├── Swig.cmake │ ├── YamlCppLib.cmake │ ├── YamlLib.cmake │ ├── Zlib.cmake │ ├── common/ │ │ ├── include/ │ │ │ ├── CSV_README.md │ │ │ ├── boost/ │ │ │ │ ├── accumulators/ │ │ │ │ │ ├── accumulators.hpp │ │ │ │ │ ├── accumulators_fwd.hpp │ │ │ │ │ ├── framework/ │ │ │ │ │ │ ├── accumulator_base.hpp │ │ │ │ │ │ ├── accumulator_concept.hpp │ │ │ │ │ │ ├── accumulator_set.hpp │ │ │ │ │ │ ├── accumulators/ │ │ │ │ │ │ │ ├── droppable_accumulator.hpp │ │ │ │ │ │ │ ├── external_accumulator.hpp │ │ │ │ │ │ │ ├── reference_accumulator.hpp │ │ │ │ │ │ │ └── value_accumulator.hpp │ │ │ │ │ │ ├── depends_on.hpp │ │ │ │ │ │ ├── external.hpp │ │ │ │ │ │ ├── extractor.hpp │ │ │ │ │ │ ├── features.hpp │ │ │ │ │ │ └── parameters/ │ │ │ │ │ │ ├── accumulator.hpp │ │ │ │ │ │ ├── sample.hpp │ │ │ │ │ │ ├── weight.hpp │ │ │ │ │ │ └── weights.hpp │ │ │ │ │ ├── numeric/ │ │ │ │ │ │ ├── detail/ │ │ │ │ │ │ │ ├── function1.hpp │ │ │ │ │ │ │ ├── function2.hpp │ │ │ │ │ │ │ ├── function3.hpp │ │ │ │ │ │ │ ├── function4.hpp │ │ │ │ │ │ │ ├── function_n.hpp │ │ │ │ │ │ │ └── pod_singleton.hpp │ │ │ │ │ │ ├── functional/ │ │ │ │ │ │ │ ├── complex.hpp │ │ │ │ │ │ │ ├── valarray.hpp │ │ │ │ │ │ │ └── vector.hpp │ │ │ │ │ │ ├── functional.hpp │ │ │ │ │ │ └── functional_fwd.hpp │ │ │ │ │ ├── statistics/ │ │ │ │ │ │ ├── count.hpp │ │ │ │ │ │ ├── covariance.hpp │ │ │ │ │ │ ├── density.hpp │ │ │ │ │ │ ├── error_of.hpp │ │ │ │ │ │ ├── error_of_mean.hpp │ │ │ │ │ │ ├── extended_p_square.hpp │ │ │ │ │ │ ├── extended_p_square_quantile.hpp │ │ │ │ │ │ ├── kurtosis.hpp │ │ │ │ │ │ ├── max.hpp │ │ │ │ │ │ ├── mean.hpp │ │ │ │ │ │ ├── median.hpp │ │ │ │ │ │ ├── min.hpp │ │ │ │ │ │ ├── moment.hpp │ │ │ │ │ │ ├── p_square_cumul_dist.hpp │ │ │ │ │ │ ├── p_square_cumulative_distribution.hpp │ │ │ │ │ │ ├── p_square_quantile.hpp │ │ │ │ │ │ ├── parameters/ │ │ │ │ │ │ │ └── quantile_probability.hpp │ │ │ │ │ │ ├── peaks_over_threshold.hpp │ │ │ │ │ │ ├── pot_quantile.hpp │ │ │ │ │ │ ├── pot_tail_mean.hpp │ │ │ │ │ │ ├── rolling_count.hpp │ │ │ │ │ │ ├── rolling_mean.hpp │ │ │ │ │ │ ├── rolling_moment.hpp │ │ │ │ │ │ ├── rolling_sum.hpp │ │ │ │ │ │ ├── rolling_variance.hpp │ │ │ │ │ │ ├── rolling_window.hpp │ │ │ │ │ │ ├── skewness.hpp │ │ │ │ │ │ ├── stats.hpp │ │ │ │ │ │ ├── sum.hpp │ │ │ │ │ │ ├── sum_kahan.hpp │ │ │ │ │ │ ├── tail.hpp │ │ │ │ │ │ ├── tail_mean.hpp │ │ │ │ │ │ ├── tail_quantile.hpp │ │ │ │ │ │ ├── tail_variate.hpp │ │ │ │ │ │ ├── tail_variate_means.hpp │ │ │ │ │ │ ├── times2_iterator.hpp │ │ │ │ │ │ ├── variance.hpp │ │ │ │ │ │ ├── variates/ │ │ │ │ │ │ │ └── covariate.hpp │ │ │ │ │ │ ├── weighted_covariance.hpp │ │ │ │ │ │ ├── weighted_density.hpp │ │ │ │ │ │ ├── weighted_extended_p_square.hpp │ │ │ │ │ │ ├── weighted_kurtosis.hpp │ │ │ │ │ │ ├── weighted_mean.hpp │ │ │ │ │ │ ├── weighted_median.hpp │ │ │ │ │ │ ├── weighted_moment.hpp │ │ │ │ │ │ ├── weighted_p_square_cumul_dist.hpp │ │ │ │ │ │ ├── weighted_p_square_cumulative_distribution.hpp │ │ │ │ │ │ ├── weighted_p_square_quantile.hpp │ │ │ │ │ │ ├── weighted_peaks_over_threshold.hpp │ │ │ │ │ │ ├── weighted_skewness.hpp │ │ │ │ │ │ ├── weighted_sum.hpp │ │ │ │ │ │ ├── weighted_sum_kahan.hpp │ │ │ │ │ │ ├── weighted_tail_mean.hpp │ │ │ │ │ │ ├── weighted_tail_quantile.hpp │ │ │ │ │ │ ├── weighted_tail_variate_means.hpp │ │ │ │ │ │ ├── weighted_variance.hpp │ │ │ │ │ │ └── with_error.hpp │ │ │ │ │ ├── statistics.hpp │ │ │ │ │ └── statistics_fwd.hpp │ │ │ │ ├── algorithm/ │ │ │ │ │ ├── algorithm.hpp │ │ │ │ │ ├── clamp.hpp │ │ │ │ │ ├── cxx11/ │ │ │ │ │ │ ├── all_of.hpp │ │ │ │ │ │ ├── any_of.hpp │ │ │ │ │ │ ├── copy_if.hpp │ │ │ │ │ │ ├── copy_n.hpp │ │ │ │ │ │ ├── find_if_not.hpp │ │ │ │ │ │ ├── iota.hpp │ │ │ │ │ │ ├── is_partitioned.hpp │ │ │ │ │ │ ├── is_permutation.hpp │ │ │ │ │ │ ├── is_sorted.hpp │ │ │ │ │ │ ├── none_of.hpp │ │ │ │ │ │ ├── one_of.hpp │ │ │ │ │ │ ├── partition_copy.hpp │ │ │ │ │ │ └── partition_point.hpp │ │ │ │ │ ├── cxx14/ │ │ │ │ │ │ ├── equal.hpp │ │ │ │ │ │ ├── is_permutation.hpp │ │ │ │ │ │ └── mismatch.hpp │ │ │ │ │ ├── gather.hpp │ │ │ │ │ ├── hex.hpp │ │ │ │ │ ├── is_palindrome.hpp │ │ │ │ │ ├── minmax.hpp │ │ │ │ │ ├── minmax_element.hpp │ │ │ │ │ ├── searching/ │ │ │ │ │ │ ├── boyer_moore.hpp │ │ │ │ │ │ ├── boyer_moore_horspool.hpp │ │ │ │ │ │ ├── detail/ │ │ │ │ │ │ │ ├── bm_traits.hpp │ │ │ │ │ │ │ └── debugging.hpp │ │ │ │ │ │ └── knuth_morris_pratt.hpp │ │ │ │ │ ├── sort_subrange.hpp │ │ │ │ │ ├── string/ │ │ │ │ │ │ ├── case_conv.hpp │ │ │ │ │ │ ├── classification.hpp │ │ │ │ │ │ ├── compare.hpp │ │ │ │ │ │ ├── concept.hpp │ │ │ │ │ │ ├── config.hpp │ │ │ │ │ │ ├── constants.hpp │ │ │ │ │ │ ├── detail/ │ │ │ │ │ │ │ ├── case_conv.hpp │ │ │ │ │ │ │ ├── classification.hpp │ │ │ │ │ │ │ ├── find_format.hpp │ │ │ │ │ │ │ ├── find_format_all.hpp │ │ │ │ │ │ │ ├── find_format_store.hpp │ │ │ │ │ │ │ ├── find_iterator.hpp │ │ │ │ │ │ │ ├── finder.hpp │ │ │ │ │ │ │ ├── finder_regex.hpp │ │ │ │ │ │ │ ├── formatter.hpp │ │ │ │ │ │ │ ├── formatter_regex.hpp │ │ │ │ │ │ │ ├── predicate.hpp │ │ │ │ │ │ │ ├── replace_storage.hpp │ │ │ │ │ │ │ ├── sequence.hpp │ │ │ │ │ │ │ ├── trim.hpp │ │ │ │ │ │ │ └── util.hpp │ │ │ │ │ │ ├── erase.hpp │ │ │ │ │ │ ├── find.hpp │ │ │ │ │ │ ├── find_format.hpp │ │ │ │ │ │ ├── find_iterator.hpp │ │ │ │ │ │ ├── finder.hpp │ │ │ │ │ │ ├── formatter.hpp │ │ │ │ │ │ ├── iter_find.hpp │ │ │ │ │ │ ├── join.hpp │ │ │ │ │ │ ├── predicate.hpp │ │ │ │ │ │ ├── predicate_facade.hpp │ │ │ │ │ │ ├── regex.hpp │ │ │ │ │ │ ├── regex_find_format.hpp │ │ │ │ │ │ ├── replace.hpp │ │ │ │ │ │ ├── sequence_traits.hpp │ │ │ │ │ │ ├── split.hpp │ │ │ │ │ │ ├── std/ │ │ │ │ │ │ │ ├── list_traits.hpp │ │ │ │ │ │ │ ├── rope_traits.hpp │ │ │ │ │ │ │ ├── slist_traits.hpp │ │ │ │ │ │ │ └── string_traits.hpp │ │ │ │ │ │ ├── std_containers_traits.hpp │ │ │ │ │ │ ├── trim.hpp │ │ │ │ │ │ ├── trim_all.hpp │ │ │ │ │ │ └── yes_no_type.hpp │ │ │ │ │ ├── string.hpp │ │ │ │ │ └── string_regex.hpp │ │ │ │ ├── align/ │ │ │ │ │ ├── align.hpp │ │ │ │ │ ├── align_down.hpp │ │ │ │ │ ├── align_up.hpp │ │ │ │ │ ├── aligned_alloc.hpp │ │ │ │ │ ├── aligned_allocator.hpp │ │ │ │ │ ├── aligned_allocator_adaptor.hpp │ │ │ │ │ ├── aligned_allocator_adaptor_forward.hpp │ │ │ │ │ ├── aligned_allocator_forward.hpp │ │ │ │ │ ├── aligned_delete.hpp │ │ │ │ │ ├── aligned_delete_forward.hpp │ │ │ │ │ ├── alignment_of.hpp │ │ │ │ │ ├── alignment_of_forward.hpp │ │ │ │ │ ├── assume_aligned.hpp │ │ │ │ │ ├── detail/ │ │ │ │ │ │ ├── addressof.hpp │ │ │ │ │ │ ├── align.hpp │ │ │ │ │ │ ├── align_cxx11.hpp │ │ │ │ │ │ ├── align_down.hpp │ │ │ │ │ │ ├── align_up.hpp │ │ │ │ │ │ ├── aligned_alloc.hpp │ │ │ │ │ │ ├── aligned_alloc_android.hpp │ │ │ │ │ │ ├── aligned_alloc_macos.hpp │ │ │ │ │ │ ├── aligned_alloc_msvc.hpp │ │ │ │ │ │ ├── aligned_alloc_posix.hpp │ │ │ │ │ │ ├── aligned_alloc_sunos.hpp │ │ │ │ │ │ ├── alignment_of.hpp │ │ │ │ │ │ ├── alignment_of_clang.hpp │ │ │ │ │ │ ├── alignment_of_codegear.hpp │ │ │ │ │ │ ├── alignment_of_cxx11.hpp │ │ │ │ │ │ ├── alignment_of_gcc.hpp │ │ │ │ │ │ ├── alignment_of_msvc.hpp │ │ │ │ │ │ ├── assume_aligned.hpp │ │ │ │ │ │ ├── assume_aligned_clang.hpp │ │ │ │ │ │ ├── assume_aligned_gcc.hpp │ │ │ │ │ │ ├── assume_aligned_intel.hpp │ │ │ │ │ │ ├── assume_aligned_msvc.hpp │ │ │ │ │ │ ├── element_type.hpp │ │ │ │ │ │ ├── integral_constant.hpp │ │ │ │ │ │ ├── is_aligned.hpp │ │ │ │ │ │ ├── is_alignment.hpp │ │ │ │ │ │ ├── is_alignment_constant.hpp │ │ │ │ │ │ ├── max_align.hpp │ │ │ │ │ │ ├── max_objects.hpp │ │ │ │ │ │ ├── max_size.hpp │ │ │ │ │ │ └── min_size.hpp │ │ │ │ │ └── is_aligned.hpp │ │ │ │ ├── align.hpp │ │ │ │ ├── aligned_storage.hpp │ │ │ │ ├── any.hpp │ │ │ │ ├── archive/ │ │ │ │ │ ├── archive_exception.hpp │ │ │ │ │ ├── basic_archive.hpp │ │ │ │ │ ├── basic_binary_iarchive.hpp │ │ │ │ │ ├── basic_binary_iprimitive.hpp │ │ │ │ │ ├── basic_binary_oarchive.hpp │ │ │ │ │ ├── basic_binary_oprimitive.hpp │ │ │ │ │ ├── basic_streambuf_locale_saver.hpp │ │ │ │ │ ├── basic_text_iarchive.hpp │ │ │ │ │ ├── basic_text_iprimitive.hpp │ │ │ │ │ ├── basic_text_oarchive.hpp │ │ │ │ │ ├── basic_text_oprimitive.hpp │ │ │ │ │ ├── basic_xml_archive.hpp │ │ │ │ │ ├── basic_xml_iarchive.hpp │ │ │ │ │ ├── basic_xml_oarchive.hpp │ │ │ │ │ ├── binary_iarchive.hpp │ │ │ │ │ ├── binary_iarchive_impl.hpp │ │ │ │ │ ├── binary_oarchive.hpp │ │ │ │ │ ├── binary_oarchive_impl.hpp │ │ │ │ │ ├── binary_wiarchive.hpp │ │ │ │ │ ├── binary_woarchive.hpp │ │ │ │ │ ├── codecvt_null.hpp │ │ │ │ │ ├── detail/ │ │ │ │ │ │ ├── abi_prefix.hpp │ │ │ │ │ │ ├── abi_suffix.hpp │ │ │ │ │ │ ├── archive_serializer_map.hpp │ │ │ │ │ │ ├── auto_link_archive.hpp │ │ │ │ │ │ ├── auto_link_warchive.hpp │ │ │ │ │ │ ├── basic_iarchive.hpp │ │ │ │ │ │ ├── basic_iserializer.hpp │ │ │ │ │ │ ├── basic_oarchive.hpp │ │ │ │ │ │ ├── basic_oserializer.hpp │ │ │ │ │ │ ├── basic_pointer_iserializer.hpp │ │ │ │ │ │ ├── basic_pointer_oserializer.hpp │ │ │ │ │ │ ├── basic_serializer.hpp │ │ │ │ │ │ ├── basic_serializer_map.hpp │ │ │ │ │ │ ├── check.hpp │ │ │ │ │ │ ├── common_iarchive.hpp │ │ │ │ │ │ ├── common_oarchive.hpp │ │ │ │ │ │ ├── decl.hpp │ │ │ │ │ │ ├── helper_collection.hpp │ │ │ │ │ │ ├── interface_iarchive.hpp │ │ │ │ │ │ ├── interface_oarchive.hpp │ │ │ │ │ │ ├── iserializer.hpp │ │ │ │ │ │ ├── oserializer.hpp │ │ │ │ │ │ ├── polymorphic_iarchive_route.hpp │ │ │ │ │ │ ├── polymorphic_oarchive_route.hpp │ │ │ │ │ │ ├── register_archive.hpp │ │ │ │ │ │ └── utf8_codecvt_facet.hpp │ │ │ │ │ ├── dinkumware.hpp │ │ │ │ │ ├── impl/ │ │ │ │ │ │ ├── archive_serializer_map.ipp │ │ │ │ │ │ ├── basic_binary_iarchive.ipp │ │ │ │ │ │ ├── basic_binary_iprimitive.ipp │ │ │ │ │ │ ├── basic_binary_oarchive.ipp │ │ │ │ │ │ ├── basic_binary_oprimitive.ipp │ │ │ │ │ │ ├── basic_text_iarchive.ipp │ │ │ │ │ │ ├── basic_text_iprimitive.ipp │ │ │ │ │ │ ├── basic_text_oarchive.ipp │ │ │ │ │ │ ├── basic_text_oprimitive.ipp │ │ │ │ │ │ ├── basic_xml_grammar.hpp │ │ │ │ │ │ ├── basic_xml_iarchive.ipp │ │ │ │ │ │ ├── basic_xml_oarchive.ipp │ │ │ │ │ │ ├── text_iarchive_impl.ipp │ │ │ │ │ │ ├── text_oarchive_impl.ipp │ │ │ │ │ │ ├── text_wiarchive_impl.ipp │ │ │ │ │ │ ├── text_woarchive_impl.ipp │ │ │ │ │ │ ├── xml_iarchive_impl.ipp │ │ │ │ │ │ ├── xml_oarchive_impl.ipp │ │ │ │ │ │ ├── xml_wiarchive_impl.ipp │ │ │ │ │ │ └── xml_woarchive_impl.ipp │ │ │ │ │ ├── iterators/ │ │ │ │ │ │ ├── base64_exception.hpp │ │ │ │ │ │ ├── base64_from_binary.hpp │ │ │ │ │ │ ├── binary_from_base64.hpp │ │ │ │ │ │ ├── dataflow.hpp │ │ │ │ │ │ ├── dataflow_exception.hpp │ │ │ │ │ │ ├── escape.hpp │ │ │ │ │ │ ├── insert_linebreaks.hpp │ │ │ │ │ │ ├── istream_iterator.hpp │ │ │ │ │ │ ├── mb_from_wchar.hpp │ │ │ │ │ │ ├── ostream_iterator.hpp │ │ │ │ │ │ ├── remove_whitespace.hpp │ │ │ │ │ │ ├── transform_width.hpp │ │ │ │ │ │ ├── unescape.hpp │ │ │ │ │ │ ├── wchar_from_mb.hpp │ │ │ │ │ │ ├── xml_escape.hpp │ │ │ │ │ │ ├── xml_unescape.hpp │ │ │ │ │ │ └── xml_unescape_exception.hpp │ │ │ │ │ ├── polymorphic_binary_iarchive.hpp │ │ │ │ │ ├── polymorphic_binary_oarchive.hpp │ │ │ │ │ ├── polymorphic_iarchive.hpp │ │ │ │ │ ├── polymorphic_oarchive.hpp │ │ │ │ │ ├── polymorphic_text_iarchive.hpp │ │ │ │ │ ├── polymorphic_text_oarchive.hpp │ │ │ │ │ ├── polymorphic_text_wiarchive.hpp │ │ │ │ │ ├── polymorphic_text_woarchive.hpp │ │ │ │ │ ├── polymorphic_xml_iarchive.hpp │ │ │ │ │ ├── polymorphic_xml_oarchive.hpp │ │ │ │ │ ├── polymorphic_xml_wiarchive.hpp │ │ │ │ │ ├── polymorphic_xml_woarchive.hpp │ │ │ │ │ ├── text_iarchive.hpp │ │ │ │ │ ├── text_oarchive.hpp │ │ │ │ │ ├── text_wiarchive.hpp │ │ │ │ │ ├── text_woarchive.hpp │ │ │ │ │ ├── tmpdir.hpp │ │ │ │ │ ├── wcslen.hpp │ │ │ │ │ ├── xml_archive_exception.hpp │ │ │ │ │ ├── xml_iarchive.hpp │ │ │ │ │ ├── xml_oarchive.hpp │ │ │ │ │ ├── xml_wiarchive.hpp │ │ │ │ │ └── xml_woarchive.hpp │ │ │ │ ├── array.hpp │ │ │ │ ├── asio/ │ │ │ │ │ ├── async_result.hpp │ │ │ │ │ ├── basic_datagram_socket.hpp │ │ │ │ │ ├── basic_deadline_timer.hpp │ │ │ │ │ ├── basic_io_object.hpp │ │ │ │ │ ├── basic_raw_socket.hpp │ │ │ │ │ ├── basic_seq_packet_socket.hpp │ │ │ │ │ ├── basic_serial_port.hpp │ │ │ │ │ ├── basic_signal_set.hpp │ │ │ │ │ ├── basic_socket.hpp │ │ │ │ │ ├── basic_socket_acceptor.hpp │ │ │ │ │ ├── basic_socket_iostream.hpp │ │ │ │ │ ├── basic_socket_streambuf.hpp │ │ │ │ │ ├── basic_stream_socket.hpp │ │ │ │ │ ├── basic_streambuf.hpp │ │ │ │ │ ├── basic_streambuf_fwd.hpp │ │ │ │ │ ├── basic_waitable_timer.hpp │ │ │ │ │ ├── buffer.hpp │ │ │ │ │ ├── buffered_read_stream.hpp │ │ │ │ │ ├── buffered_read_stream_fwd.hpp │ │ │ │ │ ├── buffered_stream.hpp │ │ │ │ │ ├── buffered_stream_fwd.hpp │ │ │ │ │ ├── buffered_write_stream.hpp │ │ │ │ │ ├── buffered_write_stream_fwd.hpp │ │ │ │ │ ├── buffers_iterator.hpp │ │ │ │ │ ├── completion_condition.hpp │ │ │ │ │ ├── connect.hpp │ │ │ │ │ ├── coroutine.hpp │ │ │ │ │ ├── datagram_socket_service.hpp │ │ │ │ │ ├── deadline_timer.hpp │ │ │ │ │ ├── deadline_timer_service.hpp │ │ │ │ │ ├── detail/ │ │ │ │ │ │ ├── addressof.hpp │ │ │ │ │ │ ├── array.hpp │ │ │ │ │ │ ├── array_fwd.hpp │ │ │ │ │ │ ├── assert.hpp │ │ │ │ │ │ ├── atomic_count.hpp │ │ │ │ │ │ ├── base_from_completion_cond.hpp │ │ │ │ │ │ ├── bind_handler.hpp │ │ │ │ │ │ ├── buffer_resize_guard.hpp │ │ │ │ │ │ ├── buffer_sequence_adapter.hpp │ │ │ │ │ │ ├── buffered_stream_storage.hpp │ │ │ │ │ │ ├── call_stack.hpp │ │ │ │ │ │ ├── chrono_time_traits.hpp │ │ │ │ │ │ ├── completion_handler.hpp │ │ │ │ │ │ ├── config.hpp │ │ │ │ │ │ ├── consuming_buffers.hpp │ │ │ │ │ │ ├── cstdint.hpp │ │ │ │ │ │ ├── date_time_fwd.hpp │ │ │ │ │ │ ├── deadline_timer_service.hpp │ │ │ │ │ │ ├── dependent_type.hpp │ │ │ │ │ │ ├── descriptor_ops.hpp │ │ │ │ │ │ ├── descriptor_read_op.hpp │ │ │ │ │ │ ├── descriptor_write_op.hpp │ │ │ │ │ │ ├── dev_poll_reactor.hpp │ │ │ │ │ │ ├── epoll_reactor.hpp │ │ │ │ │ │ ├── event.hpp │ │ │ │ │ │ ├── eventfd_select_interrupter.hpp │ │ │ │ │ │ ├── fd_set_adapter.hpp │ │ │ │ │ │ ├── fenced_block.hpp │ │ │ │ │ │ ├── function.hpp │ │ │ │ │ │ ├── gcc_arm_fenced_block.hpp │ │ │ │ │ │ ├── gcc_hppa_fenced_block.hpp │ │ │ │ │ │ ├── gcc_sync_fenced_block.hpp │ │ │ │ │ │ ├── gcc_x86_fenced_block.hpp │ │ │ │ │ │ ├── handler_alloc_helpers.hpp │ │ │ │ │ │ ├── handler_cont_helpers.hpp │ │ │ │ │ │ ├── handler_invoke_helpers.hpp │ │ │ │ │ │ ├── handler_tracking.hpp │ │ │ │ │ │ ├── handler_type_requirements.hpp │ │ │ │ │ │ ├── hash_map.hpp │ │ │ │ │ │ ├── impl/ │ │ │ │ │ │ │ ├── buffer_sequence_adapter.ipp │ │ │ │ │ │ │ ├── descriptor_ops.ipp │ │ │ │ │ │ │ ├── dev_poll_reactor.hpp │ │ │ │ │ │ │ ├── dev_poll_reactor.ipp │ │ │ │ │ │ │ ├── epoll_reactor.hpp │ │ │ │ │ │ │ ├── epoll_reactor.ipp │ │ │ │ │ │ │ ├── eventfd_select_interrupter.ipp │ │ │ │ │ │ │ ├── handler_tracking.ipp │ │ │ │ │ │ │ ├── kqueue_reactor.hpp │ │ │ │ │ │ │ ├── kqueue_reactor.ipp │ │ │ │ │ │ │ ├── pipe_select_interrupter.ipp │ │ │ │ │ │ │ ├── posix_event.ipp │ │ │ │ │ │ │ ├── posix_mutex.ipp │ │ │ │ │ │ │ ├── posix_thread.ipp │ │ │ │ │ │ │ ├── posix_tss_ptr.ipp │ │ │ │ │ │ │ ├── reactive_descriptor_service.ipp │ │ │ │ │ │ │ ├── reactive_serial_port_service.ipp │ │ │ │ │ │ │ ├── reactive_socket_service_base.ipp │ │ │ │ │ │ │ ├── resolver_service_base.ipp │ │ │ │ │ │ │ ├── select_reactor.hpp │ │ │ │ │ │ │ ├── select_reactor.ipp │ │ │ │ │ │ │ ├── service_registry.hpp │ │ │ │ │ │ │ ├── service_registry.ipp │ │ │ │ │ │ │ ├── signal_set_service.ipp │ │ │ │ │ │ │ ├── socket_ops.ipp │ │ │ │ │ │ │ ├── socket_select_interrupter.ipp │ │ │ │ │ │ │ ├── strand_service.hpp │ │ │ │ │ │ │ ├── strand_service.ipp │ │ │ │ │ │ │ ├── task_io_service.hpp │ │ │ │ │ │ │ ├── task_io_service.ipp │ │ │ │ │ │ │ ├── throw_error.ipp │ │ │ │ │ │ │ ├── timer_queue_ptime.ipp │ │ │ │ │ │ │ ├── timer_queue_set.ipp │ │ │ │ │ │ │ ├── win_event.ipp │ │ │ │ │ │ │ ├── win_iocp_handle_service.ipp │ │ │ │ │ │ │ ├── win_iocp_io_service.hpp │ │ │ │ │ │ │ ├── win_iocp_io_service.ipp │ │ │ │ │ │ │ ├── win_iocp_serial_port_service.ipp │ │ │ │ │ │ │ ├── win_iocp_socket_service_base.ipp │ │ │ │ │ │ │ ├── win_mutex.ipp │ │ │ │ │ │ │ ├── win_object_handle_service.ipp │ │ │ │ │ │ │ ├── win_static_mutex.ipp │ │ │ │ │ │ │ ├── win_thread.ipp │ │ │ │ │ │ │ ├── win_tss_ptr.ipp │ │ │ │ │ │ │ ├── winrt_ssocket_service_base.ipp │ │ │ │ │ │ │ ├── winrt_timer_scheduler.hpp │ │ │ │ │ │ │ ├── winrt_timer_scheduler.ipp │ │ │ │ │ │ │ └── winsock_init.ipp │ │ │ │ │ │ ├── io_control.hpp │ │ │ │ │ │ ├── keyword_tss_ptr.hpp │ │ │ │ │ │ ├── kqueue_reactor.hpp │ │ │ │ │ │ ├── limits.hpp │ │ │ │ │ │ ├── local_free_on_block_exit.hpp │ │ │ │ │ │ ├── macos_fenced_block.hpp │ │ │ │ │ │ ├── memory.hpp │ │ │ │ │ │ ├── mutex.hpp │ │ │ │ │ │ ├── noncopyable.hpp │ │ │ │ │ │ ├── null_event.hpp │ │ │ │ │ │ ├── null_fenced_block.hpp │ │ │ │ │ │ ├── null_mutex.hpp │ │ │ │ │ │ ├── null_reactor.hpp │ │ │ │ │ │ ├── null_signal_blocker.hpp │ │ │ │ │ │ ├── null_socket_service.hpp │ │ │ │ │ │ ├── null_static_mutex.hpp │ │ │ │ │ │ ├── null_thread.hpp │ │ │ │ │ │ ├── null_tss_ptr.hpp │ │ │ │ │ │ ├── object_pool.hpp │ │ │ │ │ │ ├── old_win_sdk_compat.hpp │ │ │ │ │ │ ├── op_queue.hpp │ │ │ │ │ │ ├── operation.hpp │ │ │ │ │ │ ├── pipe_select_interrupter.hpp │ │ │ │ │ │ ├── pop_options.hpp │ │ │ │ │ │ ├── posix_event.hpp │ │ │ │ │ │ ├── posix_fd_set_adapter.hpp │ │ │ │ │ │ ├── posix_mutex.hpp │ │ │ │ │ │ ├── posix_signal_blocker.hpp │ │ │ │ │ │ ├── posix_static_mutex.hpp │ │ │ │ │ │ ├── posix_thread.hpp │ │ │ │ │ │ ├── posix_tss_ptr.hpp │ │ │ │ │ │ ├── push_options.hpp │ │ │ │ │ │ ├── reactive_descriptor_service.hpp │ │ │ │ │ │ ├── reactive_null_buffers_op.hpp │ │ │ │ │ │ ├── reactive_serial_port_service.hpp │ │ │ │ │ │ ├── reactive_socket_accept_op.hpp │ │ │ │ │ │ ├── reactive_socket_connect_op.hpp │ │ │ │ │ │ ├── reactive_socket_recv_op.hpp │ │ │ │ │ │ ├── reactive_socket_recvfrom_op.hpp │ │ │ │ │ │ ├── reactive_socket_recvmsg_op.hpp │ │ │ │ │ │ ├── reactive_socket_send_op.hpp │ │ │ │ │ │ ├── reactive_socket_sendto_op.hpp │ │ │ │ │ │ ├── reactive_socket_service.hpp │ │ │ │ │ │ ├── reactive_socket_service_base.hpp │ │ │ │ │ │ ├── reactor.hpp │ │ │ │ │ │ ├── reactor_fwd.hpp │ │ │ │ │ │ ├── reactor_op.hpp │ │ │ │ │ │ ├── reactor_op_queue.hpp │ │ │ │ │ │ ├── regex_fwd.hpp │ │ │ │ │ │ ├── resolve_endpoint_op.hpp │ │ │ │ │ │ ├── resolve_op.hpp │ │ │ │ │ │ ├── resolver_service.hpp │ │ │ │ │ │ ├── resolver_service_base.hpp │ │ │ │ │ │ ├── scoped_lock.hpp │ │ │ │ │ │ ├── scoped_ptr.hpp │ │ │ │ │ │ ├── select_interrupter.hpp │ │ │ │ │ │ ├── select_reactor.hpp │ │ │ │ │ │ ├── service_registry.hpp │ │ │ │ │ │ ├── shared_ptr.hpp │ │ │ │ │ │ ├── signal_blocker.hpp │ │ │ │ │ │ ├── signal_handler.hpp │ │ │ │ │ │ ├── signal_init.hpp │ │ │ │ │ │ ├── signal_op.hpp │ │ │ │ │ │ ├── signal_set_service.hpp │ │ │ │ │ │ ├── socket_holder.hpp │ │ │ │ │ │ ├── socket_ops.hpp │ │ │ │ │ │ ├── socket_option.hpp │ │ │ │ │ │ ├── socket_select_interrupter.hpp │ │ │ │ │ │ ├── socket_types.hpp │ │ │ │ │ │ ├── solaris_fenced_block.hpp │ │ │ │ │ │ ├── static_mutex.hpp │ │ │ │ │ │ ├── std_event.hpp │ │ │ │ │ │ ├── std_fenced_block.hpp │ │ │ │ │ │ ├── std_mutex.hpp │ │ │ │ │ │ ├── std_static_mutex.hpp │ │ │ │ │ │ ├── std_thread.hpp │ │ │ │ │ │ ├── strand_service.hpp │ │ │ │ │ │ ├── task_io_service.hpp │ │ │ │ │ │ ├── task_io_service_operation.hpp │ │ │ │ │ │ ├── task_io_service_thread_info.hpp │ │ │ │ │ │ ├── thread.hpp │ │ │ │ │ │ ├── thread_info_base.hpp │ │ │ │ │ │ ├── throw_error.hpp │ │ │ │ │ │ ├── throw_exception.hpp │ │ │ │ │ │ ├── timer_queue.hpp │ │ │ │ │ │ ├── timer_queue_base.hpp │ │ │ │ │ │ ├── timer_queue_ptime.hpp │ │ │ │ │ │ ├── timer_queue_set.hpp │ │ │ │ │ │ ├── timer_scheduler.hpp │ │ │ │ │ │ ├── timer_scheduler_fwd.hpp │ │ │ │ │ │ ├── tss_ptr.hpp │ │ │ │ │ │ ├── type_traits.hpp │ │ │ │ │ │ ├── variadic_templates.hpp │ │ │ │ │ │ ├── wait_handler.hpp │ │ │ │ │ │ ├── wait_op.hpp │ │ │ │ │ │ ├── weak_ptr.hpp │ │ │ │ │ │ ├── win_event.hpp │ │ │ │ │ │ ├── win_fd_set_adapter.hpp │ │ │ │ │ │ ├── win_fenced_block.hpp │ │ │ │ │ │ ├── win_iocp_handle_read_op.hpp │ │ │ │ │ │ ├── win_iocp_handle_service.hpp │ │ │ │ │ │ ├── win_iocp_handle_write_op.hpp │ │ │ │ │ │ ├── win_iocp_io_service.hpp │ │ │ │ │ │ ├── win_iocp_null_buffers_op.hpp │ │ │ │ │ │ ├── win_iocp_operation.hpp │ │ │ │ │ │ ├── win_iocp_overlapped_op.hpp │ │ │ │ │ │ ├── win_iocp_overlapped_ptr.hpp │ │ │ │ │ │ ├── win_iocp_serial_port_service.hpp │ │ │ │ │ │ ├── win_iocp_socket_accept_op.hpp │ │ │ │ │ │ ├── win_iocp_socket_connect_op.hpp │ │ │ │ │ │ ├── win_iocp_socket_recv_op.hpp │ │ │ │ │ │ ├── win_iocp_socket_recvfrom_op.hpp │ │ │ │ │ │ ├── win_iocp_socket_recvmsg_op.hpp │ │ │ │ │ │ ├── win_iocp_socket_send_op.hpp │ │ │ │ │ │ ├── win_iocp_socket_service.hpp │ │ │ │ │ │ ├── win_iocp_socket_service_base.hpp │ │ │ │ │ │ ├── win_iocp_thread_info.hpp │ │ │ │ │ │ ├── win_mutex.hpp │ │ │ │ │ │ ├── win_object_handle_service.hpp │ │ │ │ │ │ ├── win_static_mutex.hpp │ │ │ │ │ │ ├── win_thread.hpp │ │ │ │ │ │ ├── win_tss_ptr.hpp │ │ │ │ │ │ ├── winapi_thread.hpp │ │ │ │ │ │ ├── winrt_async_manager.hpp │ │ │ │ │ │ ├── winrt_async_op.hpp │ │ │ │ │ │ ├── winrt_resolve_op.hpp │ │ │ │ │ │ ├── winrt_resolver_service.hpp │ │ │ │ │ │ ├── winrt_socket_connect_op.hpp │ │ │ │ │ │ ├── winrt_socket_recv_op.hpp │ │ │ │ │ │ ├── winrt_socket_send_op.hpp │ │ │ │ │ │ ├── winrt_ssocket_service.hpp │ │ │ │ │ │ ├── winrt_ssocket_service_base.hpp │ │ │ │ │ │ ├── winrt_timer_scheduler.hpp │ │ │ │ │ │ ├── winrt_utils.hpp │ │ │ │ │ │ ├── winsock_init.hpp │ │ │ │ │ │ └── wrapped_handler.hpp │ │ │ │ │ ├── error.hpp │ │ │ │ │ ├── generic/ │ │ │ │ │ │ ├── basic_endpoint.hpp │ │ │ │ │ │ ├── datagram_protocol.hpp │ │ │ │ │ │ ├── detail/ │ │ │ │ │ │ │ ├── endpoint.hpp │ │ │ │ │ │ │ └── impl/ │ │ │ │ │ │ │ └── endpoint.ipp │ │ │ │ │ │ ├── raw_protocol.hpp │ │ │ │ │ │ ├── seq_packet_protocol.hpp │ │ │ │ │ │ └── stream_protocol.hpp │ │ │ │ │ ├── handler_alloc_hook.hpp │ │ │ │ │ ├── handler_continuation_hook.hpp │ │ │ │ │ ├── handler_invoke_hook.hpp │ │ │ │ │ ├── handler_type.hpp │ │ │ │ │ ├── high_resolution_timer.hpp │ │ │ │ │ ├── impl/ │ │ │ │ │ │ ├── buffered_read_stream.hpp │ │ │ │ │ │ ├── buffered_write_stream.hpp │ │ │ │ │ │ ├── connect.hpp │ │ │ │ │ │ ├── error.ipp │ │ │ │ │ │ ├── handler_alloc_hook.ipp │ │ │ │ │ │ ├── io_service.hpp │ │ │ │ │ │ ├── io_service.ipp │ │ │ │ │ │ ├── read.hpp │ │ │ │ │ │ ├── read_at.hpp │ │ │ │ │ │ ├── read_until.hpp │ │ │ │ │ │ ├── serial_port_base.hpp │ │ │ │ │ │ ├── serial_port_base.ipp │ │ │ │ │ │ ├── spawn.hpp │ │ │ │ │ │ ├── src.cpp │ │ │ │ │ │ ├── src.hpp │ │ │ │ │ │ ├── use_future.hpp │ │ │ │ │ │ ├── write.hpp │ │ │ │ │ │ └── write_at.hpp │ │ │ │ │ ├── io_service.hpp │ │ │ │ │ ├── ip/ │ │ │ │ │ │ ├── address.hpp │ │ │ │ │ │ ├── address_v4.hpp │ │ │ │ │ │ ├── address_v6.hpp │ │ │ │ │ │ ├── basic_endpoint.hpp │ │ │ │ │ │ ├── basic_resolver.hpp │ │ │ │ │ │ ├── basic_resolver_entry.hpp │ │ │ │ │ │ ├── basic_resolver_iterator.hpp │ │ │ │ │ │ ├── basic_resolver_query.hpp │ │ │ │ │ │ ├── detail/ │ │ │ │ │ │ │ ├── endpoint.hpp │ │ │ │ │ │ │ ├── impl/ │ │ │ │ │ │ │ │ └── endpoint.ipp │ │ │ │ │ │ │ └── socket_option.hpp │ │ │ │ │ │ ├── host_name.hpp │ │ │ │ │ │ ├── icmp.hpp │ │ │ │ │ │ ├── impl/ │ │ │ │ │ │ │ ├── address.hpp │ │ │ │ │ │ │ ├── address.ipp │ │ │ │ │ │ │ ├── address_v4.hpp │ │ │ │ │ │ │ ├── address_v4.ipp │ │ │ │ │ │ │ ├── address_v6.hpp │ │ │ │ │ │ │ ├── address_v6.ipp │ │ │ │ │ │ │ ├── basic_endpoint.hpp │ │ │ │ │ │ │ └── host_name.ipp │ │ │ │ │ │ ├── multicast.hpp │ │ │ │ │ │ ├── resolver_query_base.hpp │ │ │ │ │ │ ├── resolver_service.hpp │ │ │ │ │ │ ├── tcp.hpp │ │ │ │ │ │ ├── udp.hpp │ │ │ │ │ │ ├── unicast.hpp │ │ │ │ │ │ └── v6_only.hpp │ │ │ │ │ ├── is_read_buffered.hpp │ │ │ │ │ ├── is_write_buffered.hpp │ │ │ │ │ ├── local/ │ │ │ │ │ │ ├── basic_endpoint.hpp │ │ │ │ │ │ ├── connect_pair.hpp │ │ │ │ │ │ ├── datagram_protocol.hpp │ │ │ │ │ │ ├── detail/ │ │ │ │ │ │ │ ├── endpoint.hpp │ │ │ │ │ │ │ └── impl/ │ │ │ │ │ │ │ └── endpoint.ipp │ │ │ │ │ │ └── stream_protocol.hpp │ │ │ │ │ ├── placeholders.hpp │ │ │ │ │ ├── posix/ │ │ │ │ │ │ ├── basic_descriptor.hpp │ │ │ │ │ │ ├── basic_stream_descriptor.hpp │ │ │ │ │ │ ├── descriptor_base.hpp │ │ │ │ │ │ ├── stream_descriptor.hpp │ │ │ │ │ │ └── stream_descriptor_service.hpp │ │ │ │ │ ├── raw_socket_service.hpp │ │ │ │ │ ├── read.hpp │ │ │ │ │ ├── read_at.hpp │ │ │ │ │ ├── read_until.hpp │ │ │ │ │ ├── seq_packet_socket_service.hpp │ │ │ │ │ ├── serial_port.hpp │ │ │ │ │ ├── serial_port_base.hpp │ │ │ │ │ ├── serial_port_service.hpp │ │ │ │ │ ├── signal_set.hpp │ │ │ │ │ ├── signal_set_service.hpp │ │ │ │ │ ├── socket_acceptor_service.hpp │ │ │ │ │ ├── socket_base.hpp │ │ │ │ │ ├── spawn.hpp │ │ │ │ │ ├── ssl/ │ │ │ │ │ │ ├── basic_context.hpp │ │ │ │ │ │ ├── context.hpp │ │ │ │ │ │ ├── context_base.hpp │ │ │ │ │ │ ├── context_service.hpp │ │ │ │ │ │ ├── detail/ │ │ │ │ │ │ │ ├── buffered_handshake_op.hpp │ │ │ │ │ │ │ ├── engine.hpp │ │ │ │ │ │ │ ├── handshake_op.hpp │ │ │ │ │ │ │ ├── impl/ │ │ │ │ │ │ │ │ ├── engine.ipp │ │ │ │ │ │ │ │ └── openssl_init.ipp │ │ │ │ │ │ │ ├── io.hpp │ │ │ │ │ │ │ ├── openssl_init.hpp │ │ │ │ │ │ │ ├── openssl_types.hpp │ │ │ │ │ │ │ ├── password_callback.hpp │ │ │ │ │ │ │ ├── read_op.hpp │ │ │ │ │ │ │ ├── shutdown_op.hpp │ │ │ │ │ │ │ ├── stream_core.hpp │ │ │ │ │ │ │ ├── verify_callback.hpp │ │ │ │ │ │ │ └── write_op.hpp │ │ │ │ │ │ ├── error.hpp │ │ │ │ │ │ ├── impl/ │ │ │ │ │ │ │ ├── context.hpp │ │ │ │ │ │ │ ├── context.ipp │ │ │ │ │ │ │ ├── error.ipp │ │ │ │ │ │ │ ├── rfc2818_verification.ipp │ │ │ │ │ │ │ └── src.hpp │ │ │ │ │ │ ├── old/ │ │ │ │ │ │ │ ├── basic_context.hpp │ │ │ │ │ │ │ ├── context_service.hpp │ │ │ │ │ │ │ ├── detail/ │ │ │ │ │ │ │ │ ├── openssl_context_service.hpp │ │ │ │ │ │ │ │ ├── openssl_operation.hpp │ │ │ │ │ │ │ │ └── openssl_stream_service.hpp │ │ │ │ │ │ │ ├── stream.hpp │ │ │ │ │ │ │ └── stream_service.hpp │ │ │ │ │ │ ├── rfc2818_verification.hpp │ │ │ │ │ │ ├── stream.hpp │ │ │ │ │ │ ├── stream_base.hpp │ │ │ │ │ │ ├── stream_service.hpp │ │ │ │ │ │ ├── verify_context.hpp │ │ │ │ │ │ └── verify_mode.hpp │ │ │ │ │ ├── ssl.hpp │ │ │ │ │ ├── steady_timer.hpp │ │ │ │ │ ├── strand.hpp │ │ │ │ │ ├── stream_socket_service.hpp │ │ │ │ │ ├── streambuf.hpp │ │ │ │ │ ├── system_timer.hpp │ │ │ │ │ ├── time_traits.hpp │ │ │ │ │ ├── unyield.hpp │ │ │ │ │ ├── use_future.hpp │ │ │ │ │ ├── version.hpp │ │ │ │ │ ├── wait_traits.hpp │ │ │ │ │ ├── waitable_timer_service.hpp │ │ │ │ │ ├── windows/ │ │ │ │ │ │ ├── basic_handle.hpp │ │ │ │ │ │ ├── basic_object_handle.hpp │ │ │ │ │ │ ├── basic_random_access_handle.hpp │ │ │ │ │ │ ├── basic_stream_handle.hpp │ │ │ │ │ │ ├── object_handle.hpp │ │ │ │ │ │ ├── object_handle_service.hpp │ │ │ │ │ │ ├── overlapped_ptr.hpp │ │ │ │ │ │ ├── random_access_handle.hpp │ │ │ │ │ │ ├── random_access_handle_service.hpp │ │ │ │ │ │ ├── stream_handle.hpp │ │ │ │ │ │ └── stream_handle_service.hpp │ │ │ │ │ ├── write.hpp │ │ │ │ │ ├── write_at.hpp │ │ │ │ │ └── yield.hpp │ │ │ │ ├── asio.hpp │ │ │ │ ├── assert.hpp │ │ │ │ ├── assign/ │ │ │ │ │ ├── assignment_exception.hpp │ │ │ │ │ ├── list_inserter.hpp │ │ │ │ │ ├── list_of.hpp │ │ │ │ │ ├── ptr_list_inserter.hpp │ │ │ │ │ ├── ptr_list_of.hpp │ │ │ │ │ ├── ptr_map_inserter.hpp │ │ │ │ │ ├── std/ │ │ │ │ │ │ ├── deque.hpp │ │ │ │ │ │ ├── list.hpp │ │ │ │ │ │ ├── map.hpp │ │ │ │ │ │ ├── queue.hpp │ │ │ │ │ │ ├── set.hpp │ │ │ │ │ │ ├── slist.hpp │ │ │ │ │ │ ├── stack.hpp │ │ │ │ │ │ └── vector.hpp │ │ │ │ │ └── std.hpp │ │ │ │ ├── assign.hpp │ │ │ │ ├── atomic/ │ │ │ │ │ ├── atomic.hpp │ │ │ │ │ ├── atomic_flag.hpp │ │ │ │ │ ├── capabilities.hpp │ │ │ │ │ ├── detail/ │ │ │ │ │ │ ├── atomic_flag.hpp │ │ │ │ │ │ ├── atomic_template.hpp │ │ │ │ │ │ ├── bitwise_cast.hpp │ │ │ │ │ │ ├── caps_gcc_alpha.hpp │ │ │ │ │ │ ├── caps_gcc_arm.hpp │ │ │ │ │ │ ├── caps_gcc_atomic.hpp │ │ │ │ │ │ ├── caps_gcc_ppc.hpp │ │ │ │ │ │ ├── caps_gcc_sparc.hpp │ │ │ │ │ │ ├── caps_gcc_sync.hpp │ │ │ │ │ │ ├── caps_gcc_x86.hpp │ │ │ │ │ │ ├── caps_linux_arm.hpp │ │ │ │ │ │ ├── caps_msvc_arm.hpp │ │ │ │ │ │ ├── caps_msvc_x86.hpp │ │ │ │ │ │ ├── caps_windows.hpp │ │ │ │ │ │ ├── config.hpp │ │ │ │ │ │ ├── int_sizes.hpp │ │ │ │ │ │ ├── interlocked.hpp │ │ │ │ │ │ ├── link.hpp │ │ │ │ │ │ ├── lockpool.hpp │ │ │ │ │ │ ├── operations.hpp │ │ │ │ │ │ ├── operations_fwd.hpp │ │ │ │ │ │ ├── operations_lockfree.hpp │ │ │ │ │ │ ├── ops_cas_based.hpp │ │ │ │ │ │ ├── ops_emulated.hpp │ │ │ │ │ │ ├── ops_extending_cas_based.hpp │ │ │ │ │ │ ├── ops_gcc_alpha.hpp │ │ │ │ │ │ ├── ops_gcc_arm.hpp │ │ │ │ │ │ ├── ops_gcc_atomic.hpp │ │ │ │ │ │ ├── ops_gcc_ppc.hpp │ │ │ │ │ │ ├── ops_gcc_sparc.hpp │ │ │ │ │ │ ├── ops_gcc_sync.hpp │ │ │ │ │ │ ├── ops_gcc_x86.hpp │ │ │ │ │ │ ├── ops_gcc_x86_dcas.hpp │ │ │ │ │ │ ├── ops_linux_arm.hpp │ │ │ │ │ │ ├── ops_msvc_arm.hpp │ │ │ │ │ │ ├── ops_msvc_common.hpp │ │ │ │ │ │ ├── ops_msvc_x86.hpp │ │ │ │ │ │ ├── ops_windows.hpp │ │ │ │ │ │ ├── pause.hpp │ │ │ │ │ │ ├── platform.hpp │ │ │ │ │ │ └── storage_type.hpp │ │ │ │ │ └── fences.hpp │ │ │ │ ├── atomic.hpp │ │ │ │ ├── bimap/ │ │ │ │ │ ├── bimap.hpp │ │ │ │ │ ├── container_adaptor/ │ │ │ │ │ │ ├── associative_container_adaptor.hpp │ │ │ │ │ │ ├── container_adaptor.hpp │ │ │ │ │ │ ├── detail/ │ │ │ │ │ │ │ ├── comparison_adaptor.hpp │ │ │ │ │ │ │ ├── functor_bag.hpp │ │ │ │ │ │ │ ├── identity_converters.hpp │ │ │ │ │ │ │ ├── key_extractor.hpp │ │ │ │ │ │ │ └── non_unique_container_helper.hpp │ │ │ │ │ │ ├── list_adaptor.hpp │ │ │ │ │ │ ├── list_map_adaptor.hpp │ │ │ │ │ │ ├── map_adaptor.hpp │ │ │ │ │ │ ├── multimap_adaptor.hpp │ │ │ │ │ │ ├── multiset_adaptor.hpp │ │ │ │ │ │ ├── ordered_associative_container_adaptor.hpp │ │ │ │ │ │ ├── sequence_container_adaptor.hpp │ │ │ │ │ │ ├── set_adaptor.hpp │ │ │ │ │ │ ├── support/ │ │ │ │ │ │ │ └── iterator_facade_converters.hpp │ │ │ │ │ │ ├── unordered_associative_container_adaptor.hpp │ │ │ │ │ │ ├── unordered_map_adaptor.hpp │ │ │ │ │ │ ├── unordered_multimap_adaptor.hpp │ │ │ │ │ │ ├── unordered_multiset_adaptor.hpp │ │ │ │ │ │ ├── unordered_set_adaptor.hpp │ │ │ │ │ │ ├── vector_adaptor.hpp │ │ │ │ │ │ └── vector_map_adaptor.hpp │ │ │ │ │ ├── detail/ │ │ │ │ │ │ ├── bimap_core.hpp │ │ │ │ │ │ ├── concept_tags.hpp │ │ │ │ │ │ ├── debug/ │ │ │ │ │ │ │ └── static_error.hpp │ │ │ │ │ │ ├── generate_index_binder.hpp │ │ │ │ │ │ ├── generate_relation_binder.hpp │ │ │ │ │ │ ├── generate_view_binder.hpp │ │ │ │ │ │ ├── is_set_type_of.hpp │ │ │ │ │ │ ├── manage_additional_parameters.hpp │ │ │ │ │ │ ├── manage_bimap_key.hpp │ │ │ │ │ │ ├── map_view_base.hpp │ │ │ │ │ │ ├── map_view_iterator.hpp │ │ │ │ │ │ ├── modifier_adaptor.hpp │ │ │ │ │ │ ├── non_unique_views_helper.hpp │ │ │ │ │ │ ├── set_view_base.hpp │ │ │ │ │ │ ├── set_view_iterator.hpp │ │ │ │ │ │ ├── test/ │ │ │ │ │ │ │ └── check_metadata.hpp │ │ │ │ │ │ └── user_interface_config.hpp │ │ │ │ │ ├── list_of.hpp │ │ │ │ │ ├── multiset_of.hpp │ │ │ │ │ ├── property_map/ │ │ │ │ │ │ ├── set_support.hpp │ │ │ │ │ │ └── unordered_set_support.hpp │ │ │ │ │ ├── relation/ │ │ │ │ │ │ ├── detail/ │ │ │ │ │ │ │ ├── access_builder.hpp │ │ │ │ │ │ │ ├── metadata_access_builder.hpp │ │ │ │ │ │ │ ├── mutant.hpp │ │ │ │ │ │ │ ├── static_access_builder.hpp │ │ │ │ │ │ │ └── to_mutable_relation_functor.hpp │ │ │ │ │ │ ├── member_at.hpp │ │ │ │ │ │ ├── mutant_relation.hpp │ │ │ │ │ │ ├── pair_layout.hpp │ │ │ │ │ │ ├── structured_pair.hpp │ │ │ │ │ │ ├── support/ │ │ │ │ │ │ │ ├── data_extractor.hpp │ │ │ │ │ │ │ ├── get.hpp │ │ │ │ │ │ │ ├── get_pair_functor.hpp │ │ │ │ │ │ │ ├── is_tag_of_member_at.hpp │ │ │ │ │ │ │ ├── member_with_tag.hpp │ │ │ │ │ │ │ ├── opposite_tag.hpp │ │ │ │ │ │ │ ├── pair_by.hpp │ │ │ │ │ │ │ ├── pair_type_by.hpp │ │ │ │ │ │ │ └── value_type_of.hpp │ │ │ │ │ │ └── symmetrical_base.hpp │ │ │ │ │ ├── set_of.hpp │ │ │ │ │ ├── support/ │ │ │ │ │ │ ├── data_type_by.hpp │ │ │ │ │ │ ├── iterator_type_by.hpp │ │ │ │ │ │ ├── key_type_by.hpp │ │ │ │ │ │ ├── lambda.hpp │ │ │ │ │ │ ├── map_by.hpp │ │ │ │ │ │ ├── map_type_by.hpp │ │ │ │ │ │ └── value_type_by.hpp │ │ │ │ │ ├── tags/ │ │ │ │ │ │ ├── support/ │ │ │ │ │ │ │ ├── apply_to_value_type.hpp │ │ │ │ │ │ │ ├── default_tagged.hpp │ │ │ │ │ │ │ ├── is_tagged.hpp │ │ │ │ │ │ │ ├── overwrite_tagged.hpp │ │ │ │ │ │ │ ├── tag_of.hpp │ │ │ │ │ │ │ └── value_type_of.hpp │ │ │ │ │ │ └── tagged.hpp │ │ │ │ │ ├── unconstrained_set_of.hpp │ │ │ │ │ ├── unordered_multiset_of.hpp │ │ │ │ │ ├── unordered_set_of.hpp │ │ │ │ │ ├── vector_of.hpp │ │ │ │ │ └── views/ │ │ │ │ │ ├── list_map_view.hpp │ │ │ │ │ ├── list_set_view.hpp │ │ │ │ │ ├── map_view.hpp │ │ │ │ │ ├── multimap_view.hpp │ │ │ │ │ ├── multiset_view.hpp │ │ │ │ │ ├── set_view.hpp │ │ │ │ │ ├── unconstrained_map_view.hpp │ │ │ │ │ ├── unconstrained_set_view.hpp │ │ │ │ │ ├── unordered_map_view.hpp │ │ │ │ │ ├── unordered_multimap_view.hpp │ │ │ │ │ ├── unordered_multiset_view.hpp │ │ │ │ │ ├── unordered_set_view.hpp │ │ │ │ │ ├── vector_map_view.hpp │ │ │ │ │ └── vector_set_view.hpp │ │ │ │ ├── bimap.hpp │ │ │ │ ├── bind/ │ │ │ │ │ ├── apply.hpp │ │ │ │ │ ├── arg.hpp │ │ │ │ │ ├── bind.hpp │ │ │ │ │ ├── bind_cc.hpp │ │ │ │ │ ├── bind_mf2_cc.hpp │ │ │ │ │ ├── bind_mf_cc.hpp │ │ │ │ │ ├── bind_template.hpp │ │ │ │ │ ├── make_adaptable.hpp │ │ │ │ │ ├── mem_fn.hpp │ │ │ │ │ ├── mem_fn_cc.hpp │ │ │ │ │ ├── mem_fn_template.hpp │ │ │ │ │ ├── mem_fn_vw.hpp │ │ │ │ │ ├── placeholders.hpp │ │ │ │ │ ├── protect.hpp │ │ │ │ │ └── storage.hpp │ │ │ │ ├── bind.hpp │ │ │ │ ├── blank.hpp │ │ │ │ ├── blank_fwd.hpp │ │ │ │ ├── call_traits.hpp │ │ │ │ ├── cast.hpp │ │ │ │ ├── cerrno.hpp │ │ │ │ ├── checked_delete.hpp │ │ │ │ ├── chrono/ │ │ │ │ │ ├── ceil.hpp │ │ │ │ │ ├── chrono.hpp │ │ │ │ │ ├── chrono_io.hpp │ │ │ │ │ ├── clock_string.hpp │ │ │ │ │ ├── config.hpp │ │ │ │ │ ├── detail/ │ │ │ │ │ │ ├── inlined/ │ │ │ │ │ │ │ ├── chrono.hpp │ │ │ │ │ │ │ ├── mac/ │ │ │ │ │ │ │ │ ├── chrono.hpp │ │ │ │ │ │ │ │ ├── process_cpu_clocks.hpp │ │ │ │ │ │ │ │ └── thread_clock.hpp │ │ │ │ │ │ │ ├── posix/ │ │ │ │ │ │ │ │ ├── chrono.hpp │ │ │ │ │ │ │ │ ├── process_cpu_clocks.hpp │ │ │ │ │ │ │ │ └── thread_clock.hpp │ │ │ │ │ │ │ ├── process_cpu_clocks.hpp │ │ │ │ │ │ │ ├── thread_clock.hpp │ │ │ │ │ │ │ └── win/ │ │ │ │ │ │ │ ├── chrono.hpp │ │ │ │ │ │ │ ├── process_cpu_clocks.hpp │ │ │ │ │ │ │ └── thread_clock.hpp │ │ │ │ │ │ ├── is_evenly_divisible_by.hpp │ │ │ │ │ │ ├── no_warning/ │ │ │ │ │ │ │ └── signed_unsigned_cmp.hpp │ │ │ │ │ │ ├── scan_keyword.hpp │ │ │ │ │ │ ├── static_assert.hpp │ │ │ │ │ │ └── system.hpp │ │ │ │ │ ├── duration.hpp │ │ │ │ │ ├── floor.hpp │ │ │ │ │ ├── include.hpp │ │ │ │ │ ├── io/ │ │ │ │ │ │ ├── duration_get.hpp │ │ │ │ │ │ ├── duration_io.hpp │ │ │ │ │ │ ├── duration_put.hpp │ │ │ │ │ │ ├── duration_style.hpp │ │ │ │ │ │ ├── duration_units.hpp │ │ │ │ │ │ ├── ios_base_state.hpp │ │ │ │ │ │ ├── time_point_get.hpp │ │ │ │ │ │ ├── time_point_io.hpp │ │ │ │ │ │ ├── time_point_put.hpp │ │ │ │ │ │ ├── time_point_units.hpp │ │ │ │ │ │ ├── timezone.hpp │ │ │ │ │ │ └── utility/ │ │ │ │ │ │ ├── ios_base_state_ptr.hpp │ │ │ │ │ │ ├── manip_base.hpp │ │ │ │ │ │ └── to_string.hpp │ │ │ │ │ ├── io_v1/ │ │ │ │ │ │ └── chrono_io.hpp │ │ │ │ │ ├── process_cpu_clocks.hpp │ │ │ │ │ ├── round.hpp │ │ │ │ │ ├── system_clocks.hpp │ │ │ │ │ ├── thread_clock.hpp │ │ │ │ │ ├── time_point.hpp │ │ │ │ │ └── typeof/ │ │ │ │ │ └── boost/ │ │ │ │ │ ├── chrono/ │ │ │ │ │ │ └── chrono.hpp │ │ │ │ │ └── ratio.hpp │ │ │ │ ├── chrono.hpp │ │ │ │ ├── circular_buffer/ │ │ │ │ │ ├── base.hpp │ │ │ │ │ ├── debug.hpp │ │ │ │ │ ├── details.hpp │ │ │ │ │ └── space_optimized.hpp │ │ │ │ ├── circular_buffer.hpp │ │ │ │ ├── circular_buffer_fwd.hpp │ │ │ │ ├── compatibility/ │ │ │ │ │ └── cpp_c_headers/ │ │ │ │ │ ├── cassert │ │ │ │ │ ├── cctype │ │ │ │ │ ├── cerrno │ │ │ │ │ ├── cfloat │ │ │ │ │ ├── climits │ │ │ │ │ ├── clocale │ │ │ │ │ ├── cmath │ │ │ │ │ ├── csetjmp │ │ │ │ │ ├── csignal │ │ │ │ │ ├── cstdarg │ │ │ │ │ ├── cstddef │ │ │ │ │ ├── cstdio │ │ │ │ │ ├── cstdlib │ │ │ │ │ ├── cstring │ │ │ │ │ ├── ctime │ │ │ │ │ ├── cwchar │ │ │ │ │ └── cwctype │ │ │ │ ├── compressed_pair.hpp │ │ │ │ ├── compute/ │ │ │ │ │ ├── algorithm/ │ │ │ │ │ │ ├── accumulate.hpp │ │ │ │ │ │ ├── adjacent_difference.hpp │ │ │ │ │ │ ├── adjacent_find.hpp │ │ │ │ │ │ ├── all_of.hpp │ │ │ │ │ │ ├── any_of.hpp │ │ │ │ │ │ ├── binary_search.hpp │ │ │ │ │ │ ├── copy.hpp │ │ │ │ │ │ ├── copy_if.hpp │ │ │ │ │ │ ├── copy_n.hpp │ │ │ │ │ │ ├── count.hpp │ │ │ │ │ │ ├── count_if.hpp │ │ │ │ │ │ ├── detail/ │ │ │ │ │ │ │ ├── balanced_path.hpp │ │ │ │ │ │ │ ├── binary_find.hpp │ │ │ │ │ │ │ ├── compact.hpp │ │ │ │ │ │ │ ├── copy_on_device.hpp │ │ │ │ │ │ │ ├── copy_to_device.hpp │ │ │ │ │ │ │ ├── copy_to_host.hpp │ │ │ │ │ │ │ ├── count_if_with_ballot.hpp │ │ │ │ │ │ │ ├── count_if_with_reduce.hpp │ │ │ │ │ │ │ ├── count_if_with_threads.hpp │ │ │ │ │ │ │ ├── find_extrema.hpp │ │ │ │ │ │ │ ├── find_extrema_on_cpu.hpp │ │ │ │ │ │ │ ├── find_extrema_with_atomics.hpp │ │ │ │ │ │ │ ├── find_extrema_with_reduce.hpp │ │ │ │ │ │ │ ├── find_if_with_atomics.hpp │ │ │ │ │ │ │ ├── inplace_reduce.hpp │ │ │ │ │ │ │ ├── insertion_sort.hpp │ │ │ │ │ │ │ ├── merge_path.hpp │ │ │ │ │ │ │ ├── merge_sort_on_cpu.hpp │ │ │ │ │ │ │ ├── merge_sort_on_gpu.hpp │ │ │ │ │ │ │ ├── merge_with_merge_path.hpp │ │ │ │ │ │ │ ├── radix_sort.hpp │ │ │ │ │ │ │ ├── random_fill.hpp │ │ │ │ │ │ │ ├── reduce_by_key.hpp │ │ │ │ │ │ │ ├── reduce_by_key_with_scan.hpp │ │ │ │ │ │ │ ├── reduce_on_cpu.hpp │ │ │ │ │ │ │ ├── reduce_on_gpu.hpp │ │ │ │ │ │ │ ├── scan.hpp │ │ │ │ │ │ │ ├── scan_on_cpu.hpp │ │ │ │ │ │ │ ├── scan_on_gpu.hpp │ │ │ │ │ │ │ ├── search_all.hpp │ │ │ │ │ │ │ ├── serial_accumulate.hpp │ │ │ │ │ │ │ ├── serial_count_if.hpp │ │ │ │ │ │ │ ├── serial_find_extrema.hpp │ │ │ │ │ │ │ ├── serial_merge.hpp │ │ │ │ │ │ │ ├── serial_reduce.hpp │ │ │ │ │ │ │ ├── serial_reduce_by_key.hpp │ │ │ │ │ │ │ └── serial_scan.hpp │ │ │ │ │ │ ├── equal.hpp │ │ │ │ │ │ ├── equal_range.hpp │ │ │ │ │ │ ├── exclusive_scan.hpp │ │ │ │ │ │ ├── fill.hpp │ │ │ │ │ │ ├── fill_n.hpp │ │ │ │ │ │ ├── find.hpp │ │ │ │ │ │ ├── find_end.hpp │ │ │ │ │ │ ├── find_if.hpp │ │ │ │ │ │ ├── find_if_not.hpp │ │ │ │ │ │ ├── for_each.hpp │ │ │ │ │ │ ├── for_each_n.hpp │ │ │ │ │ │ ├── gather.hpp │ │ │ │ │ │ ├── generate.hpp │ │ │ │ │ │ ├── generate_n.hpp │ │ │ │ │ │ ├── includes.hpp │ │ │ │ │ │ ├── inclusive_scan.hpp │ │ │ │ │ │ ├── inner_product.hpp │ │ │ │ │ │ ├── inplace_merge.hpp │ │ │ │ │ │ ├── iota.hpp │ │ │ │ │ │ ├── is_partitioned.hpp │ │ │ │ │ │ ├── is_permutation.hpp │ │ │ │ │ │ ├── is_sorted.hpp │ │ │ │ │ │ ├── lexicographical_compare.hpp │ │ │ │ │ │ ├── lower_bound.hpp │ │ │ │ │ │ ├── max_element.hpp │ │ │ │ │ │ ├── merge.hpp │ │ │ │ │ │ ├── min_element.hpp │ │ │ │ │ │ ├── minmax_element.hpp │ │ │ │ │ │ ├── mismatch.hpp │ │ │ │ │ │ ├── next_permutation.hpp │ │ │ │ │ │ ├── none_of.hpp │ │ │ │ │ │ ├── nth_element.hpp │ │ │ │ │ │ ├── partial_sum.hpp │ │ │ │ │ │ ├── partition.hpp │ │ │ │ │ │ ├── partition_copy.hpp │ │ │ │ │ │ ├── partition_point.hpp │ │ │ │ │ │ ├── prev_permutation.hpp │ │ │ │ │ │ ├── random_shuffle.hpp │ │ │ │ │ │ ├── reduce.hpp │ │ │ │ │ │ ├── reduce_by_key.hpp │ │ │ │ │ │ ├── remove.hpp │ │ │ │ │ │ ├── remove_if.hpp │ │ │ │ │ │ ├── replace.hpp │ │ │ │ │ │ ├── replace_copy.hpp │ │ │ │ │ │ ├── reverse.hpp │ │ │ │ │ │ ├── reverse_copy.hpp │ │ │ │ │ │ ├── rotate.hpp │ │ │ │ │ │ ├── rotate_copy.hpp │ │ │ │ │ │ ├── scatter.hpp │ │ │ │ │ │ ├── scatter_if.hpp │ │ │ │ │ │ ├── search.hpp │ │ │ │ │ │ ├── search_n.hpp │ │ │ │ │ │ ├── set_difference.hpp │ │ │ │ │ │ ├── set_intersection.hpp │ │ │ │ │ │ ├── set_symmetric_difference.hpp │ │ │ │ │ │ ├── set_union.hpp │ │ │ │ │ │ ├── sort.hpp │ │ │ │ │ │ ├── sort_by_key.hpp │ │ │ │ │ │ ├── stable_partition.hpp │ │ │ │ │ │ ├── stable_sort.hpp │ │ │ │ │ │ ├── stable_sort_by_key.hpp │ │ │ │ │ │ ├── swap_ranges.hpp │ │ │ │ │ │ ├── transform.hpp │ │ │ │ │ │ ├── transform_if.hpp │ │ │ │ │ │ ├── transform_reduce.hpp │ │ │ │ │ │ ├── unique.hpp │ │ │ │ │ │ ├── unique_copy.hpp │ │ │ │ │ │ └── upper_bound.hpp │ │ │ │ │ ├── algorithm.hpp │ │ │ │ │ ├── allocator/ │ │ │ │ │ │ ├── buffer_allocator.hpp │ │ │ │ │ │ └── pinned_allocator.hpp │ │ │ │ │ ├── allocator.hpp │ │ │ │ │ ├── async/ │ │ │ │ │ │ ├── future.hpp │ │ │ │ │ │ ├── wait.hpp │ │ │ │ │ │ └── wait_guard.hpp │ │ │ │ │ ├── async.hpp │ │ │ │ │ ├── buffer.hpp │ │ │ │ │ ├── cl.hpp │ │ │ │ │ ├── cl_ext.hpp │ │ │ │ │ ├── closure.hpp │ │ │ │ │ ├── command_queue.hpp │ │ │ │ │ ├── config.hpp │ │ │ │ │ ├── container/ │ │ │ │ │ │ ├── array.hpp │ │ │ │ │ │ ├── basic_string.hpp │ │ │ │ │ │ ├── detail/ │ │ │ │ │ │ │ └── scalar.hpp │ │ │ │ │ │ ├── dynamic_bitset.hpp │ │ │ │ │ │ ├── flat_map.hpp │ │ │ │ │ │ ├── flat_set.hpp │ │ │ │ │ │ ├── mapped_view.hpp │ │ │ │ │ │ ├── stack.hpp │ │ │ │ │ │ ├── string.hpp │ │ │ │ │ │ ├── valarray.hpp │ │ │ │ │ │ └── vector.hpp │ │ │ │ │ ├── container.hpp │ │ │ │ │ ├── context.hpp │ │ │ │ │ ├── core.hpp │ │ │ │ │ ├── detail/ │ │ │ │ │ │ ├── assert_cl_success.hpp │ │ │ │ │ │ ├── buffer_value.hpp │ │ │ │ │ │ ├── device_ptr.hpp │ │ │ │ │ │ ├── diagnostic.hpp │ │ │ │ │ │ ├── duration.hpp │ │ │ │ │ │ ├── get_object_info.hpp │ │ │ │ │ │ ├── getenv.hpp │ │ │ │ │ │ ├── global_static.hpp │ │ │ │ │ │ ├── is_buffer_iterator.hpp │ │ │ │ │ │ ├── is_contiguous_iterator.hpp │ │ │ │ │ │ ├── iterator_plus_distance.hpp │ │ │ │ │ │ ├── iterator_range_size.hpp │ │ │ │ │ │ ├── iterator_traits.hpp │ │ │ │ │ │ ├── literal.hpp │ │ │ │ │ │ ├── lru_cache.hpp │ │ │ │ │ │ ├── meta_kernel.hpp │ │ │ │ │ │ ├── mpl_vector_to_tuple.hpp │ │ │ │ │ │ ├── nvidia_compute_capability.hpp │ │ │ │ │ │ ├── parameter_cache.hpp │ │ │ │ │ │ ├── path.hpp │ │ │ │ │ │ ├── print_range.hpp │ │ │ │ │ │ ├── read_write_single_value.hpp │ │ │ │ │ │ ├── sha1.hpp │ │ │ │ │ │ ├── variadic_macros.hpp │ │ │ │ │ │ ├── vendor.hpp │ │ │ │ │ │ └── work_size.hpp │ │ │ │ │ ├── device.hpp │ │ │ │ │ ├── event.hpp │ │ │ │ │ ├── exception/ │ │ │ │ │ │ ├── context_error.hpp │ │ │ │ │ │ ├── no_device_found.hpp │ │ │ │ │ │ ├── opencl_error.hpp │ │ │ │ │ │ └── unsupported_extension_error.hpp │ │ │ │ │ ├── exception.hpp │ │ │ │ │ ├── experimental/ │ │ │ │ │ │ ├── clamp_range.hpp │ │ │ │ │ │ ├── malloc.hpp │ │ │ │ │ │ ├── sort_by_transform.hpp │ │ │ │ │ │ └── tabulate.hpp │ │ │ │ │ ├── function.hpp │ │ │ │ │ ├── functional/ │ │ │ │ │ │ ├── as.hpp │ │ │ │ │ │ ├── atomic.hpp │ │ │ │ │ │ ├── bind.hpp │ │ │ │ │ │ ├── common.hpp │ │ │ │ │ │ ├── convert.hpp │ │ │ │ │ │ ├── detail/ │ │ │ │ │ │ │ ├── macros.hpp │ │ │ │ │ │ │ ├── nvidia_ballot.hpp │ │ │ │ │ │ │ ├── nvidia_popcount.hpp │ │ │ │ │ │ │ └── unpack.hpp │ │ │ │ │ │ ├── field.hpp │ │ │ │ │ │ ├── geometry.hpp │ │ │ │ │ │ ├── get.hpp │ │ │ │ │ │ ├── hash.hpp │ │ │ │ │ │ ├── identity.hpp │ │ │ │ │ │ ├── integer.hpp │ │ │ │ │ │ ├── logical.hpp │ │ │ │ │ │ ├── math.hpp │ │ │ │ │ │ ├── operator.hpp │ │ │ │ │ │ ├── popcount.hpp │ │ │ │ │ │ └── relational.hpp │ │ │ │ │ ├── functional.hpp │ │ │ │ │ ├── image/ │ │ │ │ │ │ ├── image1d.hpp │ │ │ │ │ │ ├── image2d.hpp │ │ │ │ │ │ ├── image3d.hpp │ │ │ │ │ │ ├── image_format.hpp │ │ │ │ │ │ ├── image_object.hpp │ │ │ │ │ │ └── image_sampler.hpp │ │ │ │ │ ├── image.hpp │ │ │ │ │ ├── image2d.hpp │ │ │ │ │ ├── image3d.hpp │ │ │ │ │ ├── image_format.hpp │ │ │ │ │ ├── image_sampler.hpp │ │ │ │ │ ├── interop/ │ │ │ │ │ │ ├── eigen/ │ │ │ │ │ │ │ └── core.hpp │ │ │ │ │ │ ├── eigen.hpp │ │ │ │ │ │ ├── opencv/ │ │ │ │ │ │ │ ├── core.hpp │ │ │ │ │ │ │ ├── highgui.hpp │ │ │ │ │ │ │ └── ocl.hpp │ │ │ │ │ │ ├── opencv.hpp │ │ │ │ │ │ ├── opengl/ │ │ │ │ │ │ │ ├── acquire.hpp │ │ │ │ │ │ │ ├── cl_gl.hpp │ │ │ │ │ │ │ ├── cl_gl_ext.hpp │ │ │ │ │ │ │ ├── context.hpp │ │ │ │ │ │ │ ├── gl.hpp │ │ │ │ │ │ │ ├── opengl_buffer.hpp │ │ │ │ │ │ │ ├── opengl_renderbuffer.hpp │ │ │ │ │ │ │ └── opengl_texture.hpp │ │ │ │ │ │ ├── opengl.hpp │ │ │ │ │ │ ├── qt/ │ │ │ │ │ │ │ ├── qimage.hpp │ │ │ │ │ │ │ ├── qpoint.hpp │ │ │ │ │ │ │ ├── qpointf.hpp │ │ │ │ │ │ │ ├── qtcore.hpp │ │ │ │ │ │ │ ├── qtgui.hpp │ │ │ │ │ │ │ └── qvector.hpp │ │ │ │ │ │ ├── qt.hpp │ │ │ │ │ │ ├── vtk/ │ │ │ │ │ │ │ ├── bounds.hpp │ │ │ │ │ │ │ ├── data_array.hpp │ │ │ │ │ │ │ ├── matrix4x4.hpp │ │ │ │ │ │ │ └── points.hpp │ │ │ │ │ │ └── vtk.hpp │ │ │ │ │ ├── iterator/ │ │ │ │ │ │ ├── buffer_iterator.hpp │ │ │ │ │ │ ├── constant_buffer_iterator.hpp │ │ │ │ │ │ ├── constant_iterator.hpp │ │ │ │ │ │ ├── counting_iterator.hpp │ │ │ │ │ │ ├── detail/ │ │ │ │ │ │ │ ├── get_base_iterator_buffer.hpp │ │ │ │ │ │ │ └── swizzle_iterator.hpp │ │ │ │ │ │ ├── discard_iterator.hpp │ │ │ │ │ │ ├── function_input_iterator.hpp │ │ │ │ │ │ ├── permutation_iterator.hpp │ │ │ │ │ │ ├── strided_iterator.hpp │ │ │ │ │ │ ├── transform_iterator.hpp │ │ │ │ │ │ └── zip_iterator.hpp │ │ │ │ │ ├── iterator.hpp │ │ │ │ │ ├── kernel.hpp │ │ │ │ │ ├── lambda/ │ │ │ │ │ │ ├── context.hpp │ │ │ │ │ │ ├── functional.hpp │ │ │ │ │ │ ├── get.hpp │ │ │ │ │ │ ├── make_pair.hpp │ │ │ │ │ │ ├── make_tuple.hpp │ │ │ │ │ │ ├── placeholder.hpp │ │ │ │ │ │ ├── placeholders.hpp │ │ │ │ │ │ └── result_of.hpp │ │ │ │ │ ├── lambda.hpp │ │ │ │ │ ├── memory/ │ │ │ │ │ │ ├── local_buffer.hpp │ │ │ │ │ │ └── svm_ptr.hpp │ │ │ │ │ ├── memory.hpp │ │ │ │ │ ├── memory_object.hpp │ │ │ │ │ ├── pipe.hpp │ │ │ │ │ ├── platform.hpp │ │ │ │ │ ├── program.hpp │ │ │ │ │ ├── random/ │ │ │ │ │ │ ├── bernoulli_distribution.hpp │ │ │ │ │ │ ├── default_random_engine.hpp │ │ │ │ │ │ ├── discrete_distribution.hpp │ │ │ │ │ │ ├── linear_congruential_engine.hpp │ │ │ │ │ │ ├── mersenne_twister_engine.hpp │ │ │ │ │ │ ├── normal_distribution.hpp │ │ │ │ │ │ ├── threefry_engine.hpp │ │ │ │ │ │ ├── uniform_int_distribution.hpp │ │ │ │ │ │ └── uniform_real_distribution.hpp │ │ │ │ │ ├── random.hpp │ │ │ │ │ ├── source.hpp │ │ │ │ │ ├── svm.hpp │ │ │ │ │ ├── system.hpp │ │ │ │ │ ├── type_traits/ │ │ │ │ │ │ ├── common_type.hpp │ │ │ │ │ │ ├── detail/ │ │ │ │ │ │ │ └── capture_traits.hpp │ │ │ │ │ │ ├── is_device_iterator.hpp │ │ │ │ │ │ ├── is_fundamental.hpp │ │ │ │ │ │ ├── is_vector_type.hpp │ │ │ │ │ │ ├── make_vector_type.hpp │ │ │ │ │ │ ├── result_of.hpp │ │ │ │ │ │ ├── scalar_type.hpp │ │ │ │ │ │ ├── type_definition.hpp │ │ │ │ │ │ ├── type_name.hpp │ │ │ │ │ │ └── vector_size.hpp │ │ │ │ │ ├── type_traits.hpp │ │ │ │ │ ├── types/ │ │ │ │ │ │ ├── builtin.hpp │ │ │ │ │ │ ├── complex.hpp │ │ │ │ │ │ ├── fundamental.hpp │ │ │ │ │ │ ├── pair.hpp │ │ │ │ │ │ ├── struct.hpp │ │ │ │ │ │ └── tuple.hpp │ │ │ │ │ ├── types.hpp │ │ │ │ │ ├── user_event.hpp │ │ │ │ │ ├── utility/ │ │ │ │ │ │ ├── dim.hpp │ │ │ │ │ │ ├── extents.hpp │ │ │ │ │ │ ├── invoke.hpp │ │ │ │ │ │ ├── program_cache.hpp │ │ │ │ │ │ ├── source.hpp │ │ │ │ │ │ └── wait_list.hpp │ │ │ │ │ ├── utility.hpp │ │ │ │ │ ├── version.hpp │ │ │ │ │ └── wait_list.hpp │ │ │ │ ├── compute.hpp │ │ │ │ ├── concept/ │ │ │ │ │ ├── assert.hpp │ │ │ │ │ ├── detail/ │ │ │ │ │ │ ├── backward_compatibility.hpp │ │ │ │ │ │ ├── borland.hpp │ │ │ │ │ │ ├── concept_def.hpp │ │ │ │ │ │ ├── concept_undef.hpp │ │ │ │ │ │ ├── general.hpp │ │ │ │ │ │ ├── has_constraints.hpp │ │ │ │ │ │ └── msvc.hpp │ │ │ │ │ ├── requires.hpp │ │ │ │ │ └── usage.hpp │ │ │ │ ├── concept_archetype.hpp │ │ │ │ ├── concept_check/ │ │ │ │ │ ├── borland.hpp │ │ │ │ │ ├── general.hpp │ │ │ │ │ ├── has_constraints.hpp │ │ │ │ │ └── msvc.hpp │ │ │ │ ├── concept_check.hpp │ │ │ │ ├── config/ │ │ │ │ │ ├── abi/ │ │ │ │ │ │ ├── borland_prefix.hpp │ │ │ │ │ │ ├── borland_suffix.hpp │ │ │ │ │ │ ├── msvc_prefix.hpp │ │ │ │ │ │ └── msvc_suffix.hpp │ │ │ │ │ ├── abi_prefix.hpp │ │ │ │ │ ├── abi_suffix.hpp │ │ │ │ │ ├── auto_link.hpp │ │ │ │ │ ├── compiler/ │ │ │ │ │ │ ├── borland.hpp │ │ │ │ │ │ ├── clang.hpp │ │ │ │ │ │ ├── codegear.hpp │ │ │ │ │ │ ├── comeau.hpp │ │ │ │ │ │ ├── common_edg.hpp │ │ │ │ │ │ ├── compaq_cxx.hpp │ │ │ │ │ │ ├── cray.hpp │ │ │ │ │ │ ├── digitalmars.hpp │ │ │ │ │ │ ├── gcc.hpp │ │ │ │ │ │ ├── gcc_xml.hpp │ │ │ │ │ │ ├── greenhills.hpp │ │ │ │ │ │ ├── hp_acc.hpp │ │ │ │ │ │ ├── intel.hpp │ │ │ │ │ │ ├── kai.hpp │ │ │ │ │ │ ├── metrowerks.hpp │ │ │ │ │ │ ├── mpw.hpp │ │ │ │ │ │ ├── nvcc.hpp │ │ │ │ │ │ ├── pathscale.hpp │ │ │ │ │ │ ├── pgi.hpp │ │ │ │ │ │ ├── sgi_mipspro.hpp │ │ │ │ │ │ ├── sunpro_cc.hpp │ │ │ │ │ │ ├── vacpp.hpp │ │ │ │ │ │ ├── visualc.hpp │ │ │ │ │ │ └── xlcpp.hpp │ │ │ │ │ ├── no_tr1/ │ │ │ │ │ │ ├── cmath.hpp │ │ │ │ │ │ ├── complex.hpp │ │ │ │ │ │ ├── functional.hpp │ │ │ │ │ │ ├── memory.hpp │ │ │ │ │ │ └── utility.hpp │ │ │ │ │ ├── platform/ │ │ │ │ │ │ ├── aix.hpp │ │ │ │ │ │ ├── amigaos.hpp │ │ │ │ │ │ ├── beos.hpp │ │ │ │ │ │ ├── bsd.hpp │ │ │ │ │ │ ├── cloudabi.hpp │ │ │ │ │ │ ├── cray.hpp │ │ │ │ │ │ ├── cygwin.hpp │ │ │ │ │ │ ├── haiku.hpp │ │ │ │ │ │ ├── hpux.hpp │ │ │ │ │ │ ├── irix.hpp │ │ │ │ │ │ ├── linux.hpp │ │ │ │ │ │ ├── macos.hpp │ │ │ │ │ │ ├── qnxnto.hpp │ │ │ │ │ │ ├── solaris.hpp │ │ │ │ │ │ ├── symbian.hpp │ │ │ │ │ │ ├── vms.hpp │ │ │ │ │ │ ├── vxworks.hpp │ │ │ │ │ │ └── win32.hpp │ │ │ │ │ ├── posix_features.hpp │ │ │ │ │ ├── requires_threads.hpp │ │ │ │ │ ├── select_compiler_config.hpp │ │ │ │ │ ├── select_platform_config.hpp │ │ │ │ │ ├── select_stdlib_config.hpp │ │ │ │ │ ├── stdlib/ │ │ │ │ │ │ ├── dinkumware.hpp │ │ │ │ │ │ ├── libcomo.hpp │ │ │ │ │ │ ├── libcpp.hpp │ │ │ │ │ │ ├── libstdcpp3.hpp │ │ │ │ │ │ ├── modena.hpp │ │ │ │ │ │ ├── msl.hpp │ │ │ │ │ │ ├── roguewave.hpp │ │ │ │ │ │ ├── sgi.hpp │ │ │ │ │ │ ├── stlport.hpp │ │ │ │ │ │ └── vacpp.hpp │ │ │ │ │ ├── suffix.hpp │ │ │ │ │ ├── user.hpp │ │ │ │ │ └── warning_disable.hpp │ │ │ │ ├── config.hpp │ │ │ │ ├── container/ │ │ │ │ │ ├── adaptive_pool.hpp │ │ │ │ │ ├── allocator.hpp │ │ │ │ │ ├── allocator_traits.hpp │ │ │ │ │ ├── container_fwd.hpp │ │ │ │ │ ├── deque.hpp │ │ │ │ │ ├── detail/ │ │ │ │ │ │ ├── adaptive_node_pool.hpp │ │ │ │ │ │ ├── adaptive_node_pool_impl.hpp │ │ │ │ │ │ ├── addressof.hpp │ │ │ │ │ │ ├── advanced_insert_int.hpp │ │ │ │ │ │ ├── algorithm.hpp │ │ │ │ │ │ ├── alloc_helpers.hpp │ │ │ │ │ │ ├── alloc_lib.h │ │ │ │ │ │ ├── allocation_type.hpp │ │ │ │ │ │ ├── allocator_version_traits.hpp │ │ │ │ │ │ ├── auto_link.hpp │ │ │ │ │ │ ├── block_list.hpp │ │ │ │ │ │ ├── block_slist.hpp │ │ │ │ │ │ ├── compare_functors.hpp │ │ │ │ │ │ ├── config_begin.hpp │ │ │ │ │ │ ├── config_end.hpp │ │ │ │ │ │ ├── construct_in_place.hpp │ │ │ │ │ │ ├── copy_move_algo.hpp │ │ │ │ │ │ ├── destroyers.hpp │ │ │ │ │ │ ├── dispatch_uses_allocator.hpp │ │ │ │ │ │ ├── dlmalloc.hpp │ │ │ │ │ │ ├── flat_tree.hpp │ │ │ │ │ │ ├── function_detector.hpp │ │ │ │ │ │ ├── is_sorted.hpp │ │ │ │ │ │ ├── iterator.hpp │ │ │ │ │ │ ├── iterator_to_raw_pointer.hpp │ │ │ │ │ │ ├── iterators.hpp │ │ │ │ │ │ ├── math_functions.hpp │ │ │ │ │ │ ├── min_max.hpp │ │ │ │ │ │ ├── minimal_char_traits_header.hpp │ │ │ │ │ │ ├── mpl.hpp │ │ │ │ │ │ ├── multiallocation_chain.hpp │ │ │ │ │ │ ├── mutex.hpp │ │ │ │ │ │ ├── next_capacity.hpp │ │ │ │ │ │ ├── node_alloc_holder.hpp │ │ │ │ │ │ ├── node_pool.hpp │ │ │ │ │ │ ├── node_pool_impl.hpp │ │ │ │ │ │ ├── pair.hpp │ │ │ │ │ │ ├── placement_new.hpp │ │ │ │ │ │ ├── pool_common.hpp │ │ │ │ │ │ ├── pool_common_alloc.hpp │ │ │ │ │ │ ├── pool_resource.hpp │ │ │ │ │ │ ├── singleton.hpp │ │ │ │ │ │ ├── std_fwd.hpp │ │ │ │ │ │ ├── to_raw_pointer.hpp │ │ │ │ │ │ ├── transform_iterator.hpp │ │ │ │ │ │ ├── tree.hpp │ │ │ │ │ │ ├── type_traits.hpp │ │ │ │ │ │ ├── value_init.hpp │ │ │ │ │ │ ├── variadic_templates_tools.hpp │ │ │ │ │ │ ├── version_type.hpp │ │ │ │ │ │ └── workaround.hpp │ │ │ │ │ ├── flat_map.hpp │ │ │ │ │ ├── flat_set.hpp │ │ │ │ │ ├── list.hpp │ │ │ │ │ ├── map.hpp │ │ │ │ │ ├── new_allocator.hpp │ │ │ │ │ ├── node_allocator.hpp │ │ │ │ │ ├── node_handle.hpp │ │ │ │ │ ├── options.hpp │ │ │ │ │ ├── pmr/ │ │ │ │ │ │ ├── deque.hpp │ │ │ │ │ │ ├── flat_map.hpp │ │ │ │ │ │ ├── flat_set.hpp │ │ │ │ │ │ ├── global_resource.hpp │ │ │ │ │ │ ├── list.hpp │ │ │ │ │ │ ├── map.hpp │ │ │ │ │ │ ├── memory_resource.hpp │ │ │ │ │ │ ├── monotonic_buffer_resource.hpp │ │ │ │ │ │ ├── polymorphic_allocator.hpp │ │ │ │ │ │ ├── pool_options.hpp │ │ │ │ │ │ ├── resource_adaptor.hpp │ │ │ │ │ │ ├── set.hpp │ │ │ │ │ │ ├── slist.hpp │ │ │ │ │ │ ├── small_vector.hpp │ │ │ │ │ │ ├── stable_vector.hpp │ │ │ │ │ │ ├── string.hpp │ │ │ │ │ │ ├── synchronized_pool_resource.hpp │ │ │ │ │ │ ├── unsynchronized_pool_resource.hpp │ │ │ │ │ │ └── vector.hpp │ │ │ │ │ ├── scoped_allocator.hpp │ │ │ │ │ ├── scoped_allocator_fwd.hpp │ │ │ │ │ ├── set.hpp │ │ │ │ │ ├── slist.hpp │ │ │ │ │ ├── small_vector.hpp │ │ │ │ │ ├── stable_vector.hpp │ │ │ │ │ ├── static_vector.hpp │ │ │ │ │ ├── string.hpp │ │ │ │ │ ├── throw_exception.hpp │ │ │ │ │ ├── uses_allocator.hpp │ │ │ │ │ ├── uses_allocator_fwd.hpp │ │ │ │ │ └── vector.hpp │ │ │ │ ├── context/ │ │ │ │ │ ├── all.hpp │ │ │ │ │ ├── continuation.hpp │ │ │ │ │ ├── detail/ │ │ │ │ │ │ ├── apply.hpp │ │ │ │ │ │ ├── config.hpp │ │ │ │ │ │ ├── disable_overload.hpp │ │ │ │ │ │ ├── exception.hpp │ │ │ │ │ │ ├── exchange.hpp │ │ │ │ │ │ ├── fcontext.hpp │ │ │ │ │ │ ├── fcontext_arm.hpp │ │ │ │ │ │ ├── fcontext_arm_mac.hpp │ │ │ │ │ │ ├── fcontext_arm_win.hpp │ │ │ │ │ │ ├── fcontext_i386.hpp │ │ │ │ │ │ ├── fcontext_i386_win.hpp │ │ │ │ │ │ ├── fcontext_mips.hpp │ │ │ │ │ │ ├── fcontext_ppc.hpp │ │ │ │ │ │ ├── fcontext_sparc.hpp │ │ │ │ │ │ ├── fcontext_x86_64.hpp │ │ │ │ │ │ ├── fcontext_x86_64_win.hpp │ │ │ │ │ │ ├── index_sequence.hpp │ │ │ │ │ │ ├── invoke.hpp │ │ │ │ │ │ └── tuple.hpp │ │ │ │ │ ├── execution_context.hpp │ │ │ │ │ ├── execution_context_v1.hpp │ │ │ │ │ ├── execution_context_v2.hpp │ │ │ │ │ ├── execution_context_v2_void.ipp │ │ │ │ │ ├── fixedsize_stack.hpp │ │ │ │ │ ├── flags.hpp │ │ │ │ │ ├── pooled_fixedsize_stack.hpp │ │ │ │ │ ├── posix/ │ │ │ │ │ │ ├── fixedsize_stack.hpp │ │ │ │ │ │ ├── protected_fixedsize_stack.hpp │ │ │ │ │ │ └── segmented_stack.hpp │ │ │ │ │ ├── preallocated.hpp │ │ │ │ │ ├── protected_fixedsize_stack.hpp │ │ │ │ │ ├── segmented_stack.hpp │ │ │ │ │ ├── stack_context.hpp │ │ │ │ │ ├── stack_traits.hpp │ │ │ │ │ └── windows/ │ │ │ │ │ ├── fixedsize_stack.hpp │ │ │ │ │ └── protected_fixedsize_stack.hpp │ │ │ │ ├── convert/ │ │ │ │ │ ├── base.hpp │ │ │ │ │ ├── detail/ │ │ │ │ │ │ ├── boost_parameter_ext.hpp │ │ │ │ │ │ ├── char.hpp │ │ │ │ │ │ ├── forward.hpp │ │ │ │ │ │ ├── has_member.hpp │ │ │ │ │ │ ├── is_callable.hpp │ │ │ │ │ │ ├── is_converter.hpp │ │ │ │ │ │ ├── is_fun.hpp │ │ │ │ │ │ ├── is_string.hpp │ │ │ │ │ │ └── range.hpp │ │ │ │ │ ├── lexical_cast.hpp │ │ │ │ │ ├── parameters.hpp │ │ │ │ │ ├── printf.hpp │ │ │ │ │ ├── spirit.hpp │ │ │ │ │ ├── stream.hpp │ │ │ │ │ └── strtol.hpp │ │ │ │ ├── convert.hpp │ │ │ │ ├── core/ │ │ │ │ │ ├── addressof.hpp │ │ │ │ │ ├── checked_delete.hpp │ │ │ │ │ ├── demangle.hpp │ │ │ │ │ ├── enable_if.hpp │ │ │ │ │ ├── explicit_operator_bool.hpp │ │ │ │ │ ├── ignore_unused.hpp │ │ │ │ │ ├── is_same.hpp │ │ │ │ │ ├── lightweight_test.hpp │ │ │ │ │ ├── lightweight_test_trait.hpp │ │ │ │ │ ├── no_exceptions_support.hpp │ │ │ │ │ ├── noncopyable.hpp │ │ │ │ │ ├── null_deleter.hpp │ │ │ │ │ ├── ref.hpp │ │ │ │ │ ├── scoped_enum.hpp │ │ │ │ │ ├── swap.hpp │ │ │ │ │ ├── typeinfo.hpp │ │ │ │ │ └── underlying_type.hpp │ │ │ │ ├── coroutine/ │ │ │ │ │ ├── all.hpp │ │ │ │ │ ├── asymmetric_coroutine.hpp │ │ │ │ │ ├── attributes.hpp │ │ │ │ │ ├── coroutine.hpp │ │ │ │ │ ├── detail/ │ │ │ │ │ │ ├── config.hpp │ │ │ │ │ │ ├── coroutine_context.hpp │ │ │ │ │ │ ├── data.hpp │ │ │ │ │ │ ├── flags.hpp │ │ │ │ │ │ ├── parameters.hpp │ │ │ │ │ │ ├── preallocated.hpp │ │ │ │ │ │ ├── pull_coroutine_impl.hpp │ │ │ │ │ │ ├── pull_coroutine_object.hpp │ │ │ │ │ │ ├── pull_coroutine_synthesized.hpp │ │ │ │ │ │ ├── push_coroutine_impl.hpp │ │ │ │ │ │ ├── push_coroutine_object.hpp │ │ │ │ │ │ ├── push_coroutine_synthesized.hpp │ │ │ │ │ │ ├── setup.hpp │ │ │ │ │ │ ├── symmetric_coroutine_call.hpp │ │ │ │ │ │ ├── symmetric_coroutine_impl.hpp │ │ │ │ │ │ ├── symmetric_coroutine_object.hpp │ │ │ │ │ │ ├── symmetric_coroutine_yield.hpp │ │ │ │ │ │ ├── trampoline.hpp │ │ │ │ │ │ ├── trampoline_pull.hpp │ │ │ │ │ │ └── trampoline_push.hpp │ │ │ │ │ ├── exceptions.hpp │ │ │ │ │ ├── flags.hpp │ │ │ │ │ ├── posix/ │ │ │ │ │ │ ├── protected_stack_allocator.hpp │ │ │ │ │ │ └── segmented_stack_allocator.hpp │ │ │ │ │ ├── protected_stack_allocator.hpp │ │ │ │ │ ├── segmented_stack_allocator.hpp │ │ │ │ │ ├── stack_allocator.hpp │ │ │ │ │ ├── stack_context.hpp │ │ │ │ │ ├── stack_traits.hpp │ │ │ │ │ ├── standard_stack_allocator.hpp │ │ │ │ │ ├── symmetric_coroutine.hpp │ │ │ │ │ └── windows/ │ │ │ │ │ └── protected_stack_allocator.hpp │ │ │ │ ├── coroutine2/ │ │ │ │ │ ├── all.hpp │ │ │ │ │ ├── coroutine.hpp │ │ │ │ │ ├── detail/ │ │ │ │ │ │ ├── config.hpp │ │ │ │ │ │ ├── coroutine.hpp │ │ │ │ │ │ ├── create_control_block.ipp │ │ │ │ │ │ ├── decay_copy.hpp │ │ │ │ │ │ ├── disable_overload.hpp │ │ │ │ │ │ ├── forced_unwind.hpp │ │ │ │ │ │ ├── pull_control_block_cc.hpp │ │ │ │ │ │ ├── pull_control_block_cc.ipp │ │ │ │ │ │ ├── pull_control_block_ecv1.hpp │ │ │ │ │ │ ├── pull_control_block_ecv1.ipp │ │ │ │ │ │ ├── pull_coroutine.hpp │ │ │ │ │ │ ├── pull_coroutine.ipp │ │ │ │ │ │ ├── push_control_block_cc.hpp │ │ │ │ │ │ ├── push_control_block_cc.ipp │ │ │ │ │ │ ├── push_control_block_ecv1.hpp │ │ │ │ │ │ ├── push_control_block_ecv1.ipp │ │ │ │ │ │ ├── push_coroutine.hpp │ │ │ │ │ │ ├── push_coroutine.ipp │ │ │ │ │ │ ├── state.hpp │ │ │ │ │ │ └── wrap.hpp │ │ │ │ │ ├── fixedsize_stack.hpp │ │ │ │ │ ├── pooled_fixedsize_stack.hpp │ │ │ │ │ ├── protected_fixedsize_stack.hpp │ │ │ │ │ └── segmented_stack.hpp │ │ │ │ ├── crc.hpp │ │ │ │ ├── cregex.hpp │ │ │ │ ├── cstdfloat.hpp │ │ │ │ ├── cstdint.hpp │ │ │ │ ├── cstdlib.hpp │ │ │ │ ├── current_function.hpp │ │ │ │ ├── cxx11_char_types.hpp │ │ │ │ ├── date_time/ │ │ │ │ │ ├── adjust_functors.hpp │ │ │ │ │ ├── c_local_time_adjustor.hpp │ │ │ │ │ ├── c_time.hpp │ │ │ │ │ ├── compiler_config.hpp │ │ │ │ │ ├── constrained_value.hpp │ │ │ │ │ ├── date.hpp │ │ │ │ │ ├── date_clock_device.hpp │ │ │ │ │ ├── date_defs.hpp │ │ │ │ │ ├── date_duration.hpp │ │ │ │ │ ├── date_duration_types.hpp │ │ │ │ │ ├── date_facet.hpp │ │ │ │ │ ├── date_format_simple.hpp │ │ │ │ │ ├── date_formatting.hpp │ │ │ │ │ ├── date_formatting_limited.hpp │ │ │ │ │ ├── date_formatting_locales.hpp │ │ │ │ │ ├── date_generator_formatter.hpp │ │ │ │ │ ├── date_generator_parser.hpp │ │ │ │ │ ├── date_generators.hpp │ │ │ │ │ ├── date_iterator.hpp │ │ │ │ │ ├── date_names_put.hpp │ │ │ │ │ ├── date_parsing.hpp │ │ │ │ │ ├── dst_rules.hpp │ │ │ │ │ ├── dst_transition_generators.hpp │ │ │ │ │ ├── filetime_functions.hpp │ │ │ │ │ ├── format_date_parser.hpp │ │ │ │ │ ├── gregorian/ │ │ │ │ │ │ ├── conversion.hpp │ │ │ │ │ │ ├── formatters.hpp │ │ │ │ │ │ ├── formatters_limited.hpp │ │ │ │ │ │ ├── greg_calendar.hpp │ │ │ │ │ │ ├── greg_date.hpp │ │ │ │ │ │ ├── greg_day.hpp │ │ │ │ │ │ ├── greg_day_of_year.hpp │ │ │ │ │ │ ├── greg_duration.hpp │ │ │ │ │ │ ├── greg_duration_types.hpp │ │ │ │ │ │ ├── greg_facet.hpp │ │ │ │ │ │ ├── greg_month.hpp │ │ │ │ │ │ ├── greg_serialize.hpp │ │ │ │ │ │ ├── greg_weekday.hpp │ │ │ │ │ │ ├── greg_year.hpp │ │ │ │ │ │ ├── greg_ymd.hpp │ │ │ │ │ │ ├── gregorian.hpp │ │ │ │ │ │ ├── gregorian_io.hpp │ │ │ │ │ │ ├── gregorian_types.hpp │ │ │ │ │ │ └── parsers.hpp │ │ │ │ │ ├── gregorian_calendar.hpp │ │ │ │ │ ├── gregorian_calendar.ipp │ │ │ │ │ ├── int_adapter.hpp │ │ │ │ │ ├── iso_format.hpp │ │ │ │ │ ├── local_time/ │ │ │ │ │ │ ├── conversion.hpp │ │ │ │ │ │ ├── custom_time_zone.hpp │ │ │ │ │ │ ├── date_duration_operators.hpp │ │ │ │ │ │ ├── dst_transition_day_rules.hpp │ │ │ │ │ │ ├── local_date_time.hpp │ │ │ │ │ │ ├── local_time.hpp │ │ │ │ │ │ ├── local_time_io.hpp │ │ │ │ │ │ ├── local_time_types.hpp │ │ │ │ │ │ ├── posix_time_zone.hpp │ │ │ │ │ │ └── tz_database.hpp │ │ │ │ │ ├── local_time_adjustor.hpp │ │ │ │ │ ├── local_timezone_defs.hpp │ │ │ │ │ ├── locale_config.hpp │ │ │ │ │ ├── microsec_time_clock.hpp │ │ │ │ │ ├── parse_format_base.hpp │ │ │ │ │ ├── period.hpp │ │ │ │ │ ├── period_formatter.hpp │ │ │ │ │ ├── period_parser.hpp │ │ │ │ │ ├── posix_time/ │ │ │ │ │ │ ├── conversion.hpp │ │ │ │ │ │ ├── date_duration_operators.hpp │ │ │ │ │ │ ├── posix_time.hpp │ │ │ │ │ │ ├── posix_time_config.hpp │ │ │ │ │ │ ├── posix_time_duration.hpp │ │ │ │ │ │ ├── posix_time_io.hpp │ │ │ │ │ │ ├── posix_time_legacy_io.hpp │ │ │ │ │ │ ├── posix_time_system.hpp │ │ │ │ │ │ ├── posix_time_types.hpp │ │ │ │ │ │ ├── ptime.hpp │ │ │ │ │ │ ├── time_formatters.hpp │ │ │ │ │ │ ├── time_formatters_limited.hpp │ │ │ │ │ │ ├── time_parsers.hpp │ │ │ │ │ │ ├── time_period.hpp │ │ │ │ │ │ └── time_serialize.hpp │ │ │ │ │ ├── special_defs.hpp │ │ │ │ │ ├── special_values_formatter.hpp │ │ │ │ │ ├── special_values_parser.hpp │ │ │ │ │ ├── string_convert.hpp │ │ │ │ │ ├── string_parse_tree.hpp │ │ │ │ │ ├── strings_from_facet.hpp │ │ │ │ │ ├── time.hpp │ │ │ │ │ ├── time_clock.hpp │ │ │ │ │ ├── time_defs.hpp │ │ │ │ │ ├── time_duration.hpp │ │ │ │ │ ├── time_facet.hpp │ │ │ │ │ ├── time_formatting_streams.hpp │ │ │ │ │ ├── time_iterator.hpp │ │ │ │ │ ├── time_parsing.hpp │ │ │ │ │ ├── time_resolution_traits.hpp │ │ │ │ │ ├── time_system_counted.hpp │ │ │ │ │ ├── time_system_split.hpp │ │ │ │ │ ├── time_zone_base.hpp │ │ │ │ │ ├── time_zone_names.hpp │ │ │ │ │ ├── tz_db_base.hpp │ │ │ │ │ ├── wrapping_int.hpp │ │ │ │ │ └── year_month_day.hpp │ │ │ │ ├── date_time.hpp │ │ │ │ ├── detail/ │ │ │ │ │ ├── algorithm.hpp │ │ │ │ │ ├── allocator_utilities.hpp │ │ │ │ │ ├── atomic_count.hpp │ │ │ │ │ ├── atomic_redef_macros.hpp │ │ │ │ │ ├── atomic_undef_macros.hpp │ │ │ │ │ ├── basic_pointerbuf.hpp │ │ │ │ │ ├── binary_search.hpp │ │ │ │ │ ├── bitmask.hpp │ │ │ │ │ ├── call_traits.hpp │ │ │ │ │ ├── catch_exceptions.hpp │ │ │ │ │ ├── compressed_pair.hpp │ │ │ │ │ ├── container_fwd.hpp │ │ │ │ │ ├── dynamic_bitset.hpp │ │ │ │ │ ├── endian.hpp │ │ │ │ │ ├── fenv.hpp │ │ │ │ │ ├── has_default_constructor.hpp │ │ │ │ │ ├── identifier.hpp │ │ │ │ │ ├── indirect_traits.hpp │ │ │ │ │ ├── interlocked.hpp │ │ │ │ │ ├── is_incrementable.hpp │ │ │ │ │ ├── is_sorted.hpp │ │ │ │ │ ├── is_xxx.hpp │ │ │ │ │ ├── iterator.hpp │ │ │ │ │ ├── lcast_precision.hpp │ │ │ │ │ ├── lightweight_main.hpp │ │ │ │ │ ├── lightweight_mutex.hpp │ │ │ │ │ ├── lightweight_test.hpp │ │ │ │ │ ├── lightweight_test_report.hpp │ │ │ │ │ ├── lightweight_thread.hpp │ │ │ │ │ ├── named_template_params.hpp │ │ │ │ │ ├── no_exceptions_support.hpp │ │ │ │ │ ├── numeric_traits.hpp │ │ │ │ │ ├── ob_compressed_pair.hpp │ │ │ │ │ ├── quick_allocator.hpp │ │ │ │ │ ├── reference_content.hpp │ │ │ │ │ ├── scoped_enum_emulation.hpp │ │ │ │ │ ├── select_type.hpp │ │ │ │ │ ├── sp_typeinfo.hpp │ │ │ │ │ ├── templated_streams.hpp │ │ │ │ │ ├── utf8_codecvt_facet.hpp │ │ │ │ │ ├── utf8_codecvt_facet.ipp │ │ │ │ │ ├── winapi/ │ │ │ │ │ │ ├── GetCurrentProcess.hpp │ │ │ │ │ │ ├── GetCurrentThread.hpp │ │ │ │ │ │ ├── GetLastError.hpp │ │ │ │ │ │ ├── GetProcessTimes.hpp │ │ │ │ │ │ ├── GetThreadTimes.hpp │ │ │ │ │ │ ├── access_rights.hpp │ │ │ │ │ │ ├── apc.hpp │ │ │ │ │ │ ├── basic_types.hpp │ │ │ │ │ │ ├── character_code_conversion.hpp │ │ │ │ │ │ ├── condition_variable.hpp │ │ │ │ │ │ ├── config.hpp │ │ │ │ │ │ ├── critical_section.hpp │ │ │ │ │ │ ├── crypt.hpp │ │ │ │ │ │ ├── dbghelp.hpp │ │ │ │ │ │ ├── detail/ │ │ │ │ │ │ │ └── cast_ptr.hpp │ │ │ │ │ │ ├── directory_management.hpp │ │ │ │ │ │ ├── dll.hpp │ │ │ │ │ │ ├── environment.hpp │ │ │ │ │ │ ├── error_codes.hpp │ │ │ │ │ │ ├── error_handling.hpp │ │ │ │ │ │ ├── event.hpp │ │ │ │ │ │ ├── file_management.hpp │ │ │ │ │ │ ├── file_mapping.hpp │ │ │ │ │ │ ├── get_current_process.hpp │ │ │ │ │ │ ├── get_current_process_id.hpp │ │ │ │ │ │ ├── get_current_thread.hpp │ │ │ │ │ │ ├── get_current_thread_id.hpp │ │ │ │ │ │ ├── get_last_error.hpp │ │ │ │ │ │ ├── get_process_times.hpp │ │ │ │ │ │ ├── get_system_directory.hpp │ │ │ │ │ │ ├── get_thread_times.hpp │ │ │ │ │ │ ├── handle_info.hpp │ │ │ │ │ │ ├── handles.hpp │ │ │ │ │ │ ├── heap_memory.hpp │ │ │ │ │ │ ├── init_once.hpp │ │ │ │ │ │ ├── jobs.hpp │ │ │ │ │ │ ├── limits.hpp │ │ │ │ │ │ ├── local_memory.hpp │ │ │ │ │ │ ├── memory.hpp │ │ │ │ │ │ ├── mutex.hpp │ │ │ │ │ │ ├── overlapped.hpp │ │ │ │ │ │ ├── page_protection_flags.hpp │ │ │ │ │ │ ├── pipes.hpp │ │ │ │ │ │ ├── priority_class.hpp │ │ │ │ │ │ ├── process.hpp │ │ │ │ │ │ ├── security.hpp │ │ │ │ │ │ ├── semaphore.hpp │ │ │ │ │ │ ├── shell.hpp │ │ │ │ │ │ ├── show_window.hpp │ │ │ │ │ │ ├── srw_lock.hpp │ │ │ │ │ │ ├── synchronization.hpp │ │ │ │ │ │ ├── system.hpp │ │ │ │ │ │ ├── thread.hpp │ │ │ │ │ │ ├── thread_pool.hpp │ │ │ │ │ │ ├── time.hpp │ │ │ │ │ │ ├── timers.hpp │ │ │ │ │ │ ├── tls.hpp │ │ │ │ │ │ ├── wait.hpp │ │ │ │ │ │ └── waitable_timer.hpp │ │ │ │ │ └── workaround.hpp │ │ │ │ ├── dll/ │ │ │ │ │ ├── alias.hpp │ │ │ │ │ ├── detail/ │ │ │ │ │ │ ├── aggressive_ptr_cast.hpp │ │ │ │ │ │ ├── ctor_dtor.hpp │ │ │ │ │ │ ├── demangling/ │ │ │ │ │ │ │ ├── demangle_symbol.hpp │ │ │ │ │ │ │ ├── itanium.hpp │ │ │ │ │ │ │ ├── mangled_storage_base.hpp │ │ │ │ │ │ │ └── msvc.hpp │ │ │ │ │ │ ├── elf_info.hpp │ │ │ │ │ │ ├── get_mem_fn_type.hpp │ │ │ │ │ │ ├── import_mangled_helpers.hpp │ │ │ │ │ │ ├── macho_info.hpp │ │ │ │ │ │ ├── pe_info.hpp │ │ │ │ │ │ ├── posix/ │ │ │ │ │ │ │ ├── path_from_handle.hpp │ │ │ │ │ │ │ ├── program_location_impl.hpp │ │ │ │ │ │ │ └── shared_library_impl.hpp │ │ │ │ │ │ ├── system_error.hpp │ │ │ │ │ │ ├── type_info.hpp │ │ │ │ │ │ ├── windows/ │ │ │ │ │ │ │ ├── path_from_handle.hpp │ │ │ │ │ │ │ └── shared_library_impl.hpp │ │ │ │ │ │ └── x_info_interface.hpp │ │ │ │ │ ├── import.hpp │ │ │ │ │ ├── import_class.hpp │ │ │ │ │ ├── import_mangled.hpp │ │ │ │ │ ├── library_info.hpp │ │ │ │ │ ├── runtime_symbol_info.hpp │ │ │ │ │ ├── shared_library.hpp │ │ │ │ │ ├── shared_library_load_mode.hpp │ │ │ │ │ └── smart_library.hpp │ │ │ │ ├── dll.hpp │ │ │ │ ├── dynamic_bitset/ │ │ │ │ │ ├── config.hpp │ │ │ │ │ ├── dynamic_bitset.hpp │ │ │ │ │ └── serialization.hpp │ │ │ │ ├── dynamic_bitset.hpp │ │ │ │ ├── dynamic_bitset_fwd.hpp │ │ │ │ ├── enable_shared_from_this.hpp │ │ │ │ ├── endian/ │ │ │ │ │ ├── arithmetic.hpp │ │ │ │ │ ├── buffers.hpp │ │ │ │ │ ├── conversion.hpp │ │ │ │ │ ├── detail/ │ │ │ │ │ │ ├── config.hpp │ │ │ │ │ │ ├── cover_operators.hpp │ │ │ │ │ │ ├── disable_warnings.hpp │ │ │ │ │ │ ├── disable_warnings_pop.hpp │ │ │ │ │ │ ├── intrinsic.hpp │ │ │ │ │ │ └── lightweight_test.hpp │ │ │ │ │ ├── endian.hpp │ │ │ │ │ └── std_pair.hpp │ │ │ │ ├── exception/ │ │ │ │ │ ├── N3757.hpp │ │ │ │ │ ├── all.hpp │ │ │ │ │ ├── current_exception_cast.hpp │ │ │ │ │ ├── detail/ │ │ │ │ │ │ ├── clone_current_exception.hpp │ │ │ │ │ │ ├── error_info_impl.hpp │ │ │ │ │ │ ├── exception_ptr.hpp │ │ │ │ │ │ ├── is_output_streamable.hpp │ │ │ │ │ │ ├── object_hex_dump.hpp │ │ │ │ │ │ ├── shared_ptr.hpp │ │ │ │ │ │ └── type_info.hpp │ │ │ │ │ ├── diagnostic_information.hpp │ │ │ │ │ ├── enable_current_exception.hpp │ │ │ │ │ ├── enable_error_info.hpp │ │ │ │ │ ├── errinfo_api_function.hpp │ │ │ │ │ ├── errinfo_at_line.hpp │ │ │ │ │ ├── errinfo_errno.hpp │ │ │ │ │ ├── errinfo_file_handle.hpp │ │ │ │ │ ├── errinfo_file_name.hpp │ │ │ │ │ ├── errinfo_file_open_mode.hpp │ │ │ │ │ ├── errinfo_nested_exception.hpp │ │ │ │ │ ├── errinfo_type_info_name.hpp │ │ │ │ │ ├── error_info.hpp │ │ │ │ │ ├── exception.hpp │ │ │ │ │ ├── get_error_info.hpp │ │ │ │ │ ├── info.hpp │ │ │ │ │ ├── info_tuple.hpp │ │ │ │ │ ├── to_string.hpp │ │ │ │ │ └── to_string_stub.hpp │ │ │ │ ├── exception_ptr.hpp │ │ │ │ ├── fiber/ │ │ │ │ │ ├── algo/ │ │ │ │ │ │ ├── algorithm.hpp │ │ │ │ │ │ ├── round_robin.hpp │ │ │ │ │ │ ├── shared_work.hpp │ │ │ │ │ │ └── work_stealing.hpp │ │ │ │ │ ├── all.hpp │ │ │ │ │ ├── barrier.hpp │ │ │ │ │ ├── buffered_channel.hpp │ │ │ │ │ ├── channel_op_status.hpp │ │ │ │ │ ├── condition_variable.hpp │ │ │ │ │ ├── context.hpp │ │ │ │ │ ├── detail/ │ │ │ │ │ │ ├── config.hpp │ │ │ │ │ │ ├── context_spinlock_queue.hpp │ │ │ │ │ │ ├── context_spmc_queue.hpp │ │ │ │ │ │ ├── convert.hpp │ │ │ │ │ │ ├── cpu_relax.hpp │ │ │ │ │ │ ├── data.hpp │ │ │ │ │ │ ├── decay_copy.hpp │ │ │ │ │ │ ├── disable_overload.hpp │ │ │ │ │ │ ├── fss.hpp │ │ │ │ │ │ ├── futex.hpp │ │ │ │ │ │ ├── spinlock.hpp │ │ │ │ │ │ ├── spinlock_ttas.hpp │ │ │ │ │ │ ├── spinlock_ttas_adaptive.hpp │ │ │ │ │ │ ├── spinlock_ttas_adaptive_futex.hpp │ │ │ │ │ │ ├── spinlock_ttas_futex.hpp │ │ │ │ │ │ └── wrap.hpp │ │ │ │ │ ├── exceptions.hpp │ │ │ │ │ ├── fiber.hpp │ │ │ │ │ ├── fixedsize_stack.hpp │ │ │ │ │ ├── fss.hpp │ │ │ │ │ ├── future/ │ │ │ │ │ │ ├── async.hpp │ │ │ │ │ │ ├── detail/ │ │ │ │ │ │ │ ├── shared_state.hpp │ │ │ │ │ │ │ ├── shared_state_object.hpp │ │ │ │ │ │ │ ├── task_base.hpp │ │ │ │ │ │ │ └── task_object.hpp │ │ │ │ │ │ ├── future.hpp │ │ │ │ │ │ ├── future_status.hpp │ │ │ │ │ │ ├── packaged_task.hpp │ │ │ │ │ │ └── promise.hpp │ │ │ │ │ ├── future.hpp │ │ │ │ │ ├── mutex.hpp │ │ │ │ │ ├── operations.hpp │ │ │ │ │ ├── policy.hpp │ │ │ │ │ ├── pooled_fixedsize_stack.hpp │ │ │ │ │ ├── properties.hpp │ │ │ │ │ ├── protected_fixedsize_stack.hpp │ │ │ │ │ ├── recursive_mutex.hpp │ │ │ │ │ ├── recursive_timed_mutex.hpp │ │ │ │ │ ├── scheduler.hpp │ │ │ │ │ ├── segmented_stack.hpp │ │ │ │ │ ├── timed_mutex.hpp │ │ │ │ │ ├── type.hpp │ │ │ │ │ └── unbuffered_channel.hpp │ │ │ │ ├── filesystem/ │ │ │ │ │ ├── config.hpp │ │ │ │ │ ├── convenience.hpp │ │ │ │ │ ├── detail/ │ │ │ │ │ │ ├── macro_value.hpp │ │ │ │ │ │ └── utf8_codecvt_facet.hpp │ │ │ │ │ ├── exception.hpp │ │ │ │ │ ├── fstream.hpp │ │ │ │ │ ├── operations.hpp │ │ │ │ │ ├── path.hpp │ │ │ │ │ ├── path_traits.hpp │ │ │ │ │ └── string_file.hpp │ │ │ │ ├── filesystem.hpp │ │ │ │ ├── flyweight/ │ │ │ │ │ ├── assoc_container_factory.hpp │ │ │ │ │ ├── assoc_container_factory_fwd.hpp │ │ │ │ │ ├── detail/ │ │ │ │ │ │ ├── archive_constructed.hpp │ │ │ │ │ │ ├── default_value_policy.hpp │ │ │ │ │ │ ├── dyn_perfect_fwd.hpp │ │ │ │ │ │ ├── flyweight_core.hpp │ │ │ │ │ │ ├── is_placeholder_expr.hpp │ │ │ │ │ │ ├── nested_xxx_if_not_ph.hpp │ │ │ │ │ │ ├── not_placeholder_expr.hpp │ │ │ │ │ │ ├── perfect_fwd.hpp │ │ │ │ │ │ ├── pp_perfect_fwd.hpp │ │ │ │ │ │ ├── recursive_lw_mutex.hpp │ │ │ │ │ │ ├── serialization_helper.hpp │ │ │ │ │ │ └── value_tag.hpp │ │ │ │ │ ├── factory_tag.hpp │ │ │ │ │ ├── flyweight.hpp │ │ │ │ │ ├── flyweight_fwd.hpp │ │ │ │ │ ├── hashed_factory.hpp │ │ │ │ │ ├── hashed_factory_fwd.hpp │ │ │ │ │ ├── holder_tag.hpp │ │ │ │ │ ├── intermodule_holder.hpp │ │ │ │ │ ├── intermodule_holder_fwd.hpp │ │ │ │ │ ├── key_value.hpp │ │ │ │ │ ├── key_value_fwd.hpp │ │ │ │ │ ├── locking_tag.hpp │ │ │ │ │ ├── no_locking.hpp │ │ │ │ │ ├── no_locking_fwd.hpp │ │ │ │ │ ├── no_tracking.hpp │ │ │ │ │ ├── no_tracking_fwd.hpp │ │ │ │ │ ├── refcounted.hpp │ │ │ │ │ ├── refcounted_fwd.hpp │ │ │ │ │ ├── serialize.hpp │ │ │ │ │ ├── set_factory.hpp │ │ │ │ │ ├── set_factory_fwd.hpp │ │ │ │ │ ├── simple_locking.hpp │ │ │ │ │ ├── simple_locking_fwd.hpp │ │ │ │ │ ├── static_holder.hpp │ │ │ │ │ ├── static_holder_fwd.hpp │ │ │ │ │ ├── tag.hpp │ │ │ │ │ └── tracking_tag.hpp │ │ │ │ ├── flyweight.hpp │ │ │ │ ├── foreach.hpp │ │ │ │ ├── foreach_fwd.hpp │ │ │ │ ├── format/ │ │ │ │ │ ├── alt_sstream.hpp │ │ │ │ │ ├── alt_sstream_impl.hpp │ │ │ │ │ ├── detail/ │ │ │ │ │ │ ├── compat_workarounds.hpp │ │ │ │ │ │ ├── config_macros.hpp │ │ │ │ │ │ ├── msvc_disambiguater.hpp │ │ │ │ │ │ ├── unset_macros.hpp │ │ │ │ │ │ ├── workarounds_gcc-2_95.hpp │ │ │ │ │ │ └── workarounds_stlport.hpp │ │ │ │ │ ├── exceptions.hpp │ │ │ │ │ ├── feed_args.hpp │ │ │ │ │ ├── format_class.hpp │ │ │ │ │ ├── format_fwd.hpp │ │ │ │ │ ├── format_implementation.hpp │ │ │ │ │ ├── free_funcs.hpp │ │ │ │ │ ├── group.hpp │ │ │ │ │ ├── internals.hpp │ │ │ │ │ ├── internals_fwd.hpp │ │ │ │ │ └── parsing.hpp │ │ │ │ ├── format.hpp │ │ │ │ ├── function/ │ │ │ │ │ ├── detail/ │ │ │ │ │ │ ├── function_iterate.hpp │ │ │ │ │ │ ├── gen_maybe_include.pl │ │ │ │ │ │ ├── maybe_include.hpp │ │ │ │ │ │ └── prologue.hpp │ │ │ │ │ ├── function0.hpp │ │ │ │ │ ├── function1.hpp │ │ │ │ │ ├── function10.hpp │ │ │ │ │ ├── function2.hpp │ │ │ │ │ ├── function3.hpp │ │ │ │ │ ├── function4.hpp │ │ │ │ │ ├── function5.hpp │ │ │ │ │ ├── function6.hpp │ │ │ │ │ ├── function7.hpp │ │ │ │ │ ├── function8.hpp │ │ │ │ │ ├── function9.hpp │ │ │ │ │ ├── function_base.hpp │ │ │ │ │ ├── function_fwd.hpp │ │ │ │ │ ├── function_template.hpp │ │ │ │ │ ├── function_typeof.hpp │ │ │ │ │ └── gen_function_N.pl │ │ │ │ ├── function.hpp │ │ │ │ ├── function_equal.hpp │ │ │ │ ├── function_output_iterator.hpp │ │ │ │ ├── function_types/ │ │ │ │ │ ├── components.hpp │ │ │ │ │ ├── config/ │ │ │ │ │ │ ├── cc_names.hpp │ │ │ │ │ │ ├── compiler.hpp │ │ │ │ │ │ └── config.hpp │ │ │ │ │ ├── detail/ │ │ │ │ │ │ ├── class_transform.hpp │ │ │ │ │ │ ├── classifier.hpp │ │ │ │ │ │ ├── classifier_impl/ │ │ │ │ │ │ │ ├── arity10_0.hpp │ │ │ │ │ │ │ ├── arity10_1.hpp │ │ │ │ │ │ │ ├── arity20_0.hpp │ │ │ │ │ │ │ ├── arity20_1.hpp │ │ │ │ │ │ │ ├── arity30_0.hpp │ │ │ │ │ │ │ ├── arity30_1.hpp │ │ │ │ │ │ │ ├── arity40_0.hpp │ │ │ │ │ │ │ ├── arity40_1.hpp │ │ │ │ │ │ │ ├── arity50_0.hpp │ │ │ │ │ │ │ ├── arity50_1.hpp │ │ │ │ │ │ │ └── master.hpp │ │ │ │ │ │ ├── components_as_mpl_sequence.hpp │ │ │ │ │ │ ├── components_impl/ │ │ │ │ │ │ │ ├── arity10_0.hpp │ │ │ │ │ │ │ ├── arity10_1.hpp │ │ │ │ │ │ │ ├── arity20_0.hpp │ │ │ │ │ │ │ ├── arity20_1.hpp │ │ │ │ │ │ │ ├── arity30_0.hpp │ │ │ │ │ │ │ ├── arity30_1.hpp │ │ │ │ │ │ │ ├── arity40_0.hpp │ │ │ │ │ │ │ ├── arity40_1.hpp │ │ │ │ │ │ │ ├── arity50_0.hpp │ │ │ │ │ │ │ ├── arity50_1.hpp │ │ │ │ │ │ │ └── master.hpp │ │ │ │ │ │ ├── cv_traits.hpp │ │ │ │ │ │ ├── encoding/ │ │ │ │ │ │ │ ├── aliases_def.hpp │ │ │ │ │ │ │ ├── aliases_undef.hpp │ │ │ │ │ │ │ ├── def.hpp │ │ │ │ │ │ │ └── undef.hpp │ │ │ │ │ │ ├── pp_arity_loop.hpp │ │ │ │ │ │ ├── pp_cc_loop/ │ │ │ │ │ │ │ ├── master.hpp │ │ │ │ │ │ │ └── preprocessed.hpp │ │ │ │ │ │ ├── pp_loop.hpp │ │ │ │ │ │ ├── pp_retag_default_cc/ │ │ │ │ │ │ │ ├── master.hpp │ │ │ │ │ │ │ └── preprocessed.hpp │ │ │ │ │ │ ├── pp_tags/ │ │ │ │ │ │ │ ├── cc_tag.hpp │ │ │ │ │ │ │ ├── master.hpp │ │ │ │ │ │ │ └── preprocessed.hpp │ │ │ │ │ │ ├── pp_variate_loop/ │ │ │ │ │ │ │ ├── master.hpp │ │ │ │ │ │ │ └── preprocessed.hpp │ │ │ │ │ │ ├── retag_default_cc.hpp │ │ │ │ │ │ ├── synthesize.hpp │ │ │ │ │ │ ├── synthesize_impl/ │ │ │ │ │ │ │ ├── arity10_0.hpp │ │ │ │ │ │ │ ├── arity10_1.hpp │ │ │ │ │ │ │ ├── arity20_0.hpp │ │ │ │ │ │ │ ├── arity20_1.hpp │ │ │ │ │ │ │ ├── arity30_0.hpp │ │ │ │ │ │ │ ├── arity30_1.hpp │ │ │ │ │ │ │ ├── arity40_0.hpp │ │ │ │ │ │ │ ├── arity40_1.hpp │ │ │ │ │ │ │ ├── arity50_0.hpp │ │ │ │ │ │ │ ├── arity50_1.hpp │ │ │ │ │ │ │ └── master.hpp │ │ │ │ │ │ └── to_sequence.hpp │ │ │ │ │ ├── function_arity.hpp │ │ │ │ │ ├── function_pointer.hpp │ │ │ │ │ ├── function_reference.hpp │ │ │ │ │ ├── function_type.hpp │ │ │ │ │ ├── is_callable_builtin.hpp │ │ │ │ │ ├── is_function.hpp │ │ │ │ │ ├── is_function_pointer.hpp │ │ │ │ │ ├── is_function_reference.hpp │ │ │ │ │ ├── is_member_function_pointer.hpp │ │ │ │ │ ├── is_member_object_pointer.hpp │ │ │ │ │ ├── is_member_pointer.hpp │ │ │ │ │ ├── is_nonmember_callable_builtin.hpp │ │ │ │ │ ├── member_function_pointer.hpp │ │ │ │ │ ├── member_object_pointer.hpp │ │ │ │ │ ├── parameter_types.hpp │ │ │ │ │ ├── property_tags.hpp │ │ │ │ │ └── result_type.hpp │ │ │ │ ├── functional/ │ │ │ │ │ ├── factory.hpp │ │ │ │ │ ├── forward_adapter.hpp │ │ │ │ │ ├── hash/ │ │ │ │ │ │ ├── detail/ │ │ │ │ │ │ │ ├── float_functions.hpp │ │ │ │ │ │ │ ├── hash_float.hpp │ │ │ │ │ │ │ └── limits.hpp │ │ │ │ │ │ ├── extensions.hpp │ │ │ │ │ │ ├── hash.hpp │ │ │ │ │ │ └── hash_fwd.hpp │ │ │ │ │ ├── hash.hpp │ │ │ │ │ ├── hash_fwd.hpp │ │ │ │ │ ├── lightweight_forward_adapter.hpp │ │ │ │ │ ├── overloaded_function/ │ │ │ │ │ │ ├── config.hpp │ │ │ │ │ │ └── detail/ │ │ │ │ │ │ ├── base.hpp │ │ │ │ │ │ └── function_type.hpp │ │ │ │ │ ├── overloaded_function.hpp │ │ │ │ │ └── value_factory.hpp │ │ │ │ ├── functional.hpp │ │ │ │ ├── fusion/ │ │ │ │ │ ├── adapted/ │ │ │ │ │ │ ├── adt/ │ │ │ │ │ │ │ ├── adapt_adt.hpp │ │ │ │ │ │ │ ├── adapt_adt_named.hpp │ │ │ │ │ │ │ ├── adapt_assoc_adt.hpp │ │ │ │ │ │ │ ├── adapt_assoc_adt_named.hpp │ │ │ │ │ │ │ └── detail/ │ │ │ │ │ │ │ ├── adapt_base.hpp │ │ │ │ │ │ │ ├── adapt_base_assoc_attr_filler.hpp │ │ │ │ │ │ │ ├── adapt_base_attr_filler.hpp │ │ │ │ │ │ │ └── extension.hpp │ │ │ │ │ │ ├── adt.hpp │ │ │ │ │ │ ├── array/ │ │ │ │ │ │ │ ├── at_impl.hpp │ │ │ │ │ │ │ ├── begin_impl.hpp │ │ │ │ │ │ │ ├── category_of_impl.hpp │ │ │ │ │ │ │ ├── deref_impl.hpp │ │ │ │ │ │ │ ├── end_impl.hpp │ │ │ │ │ │ │ ├── is_sequence_impl.hpp │ │ │ │ │ │ │ ├── is_view_impl.hpp │ │ │ │ │ │ │ ├── size_impl.hpp │ │ │ │ │ │ │ ├── tag_of.hpp │ │ │ │ │ │ │ ├── value_at_impl.hpp │ │ │ │ │ │ │ └── value_of_impl.hpp │ │ │ │ │ │ ├── array.hpp │ │ │ │ │ │ ├── boost_array/ │ │ │ │ │ │ │ ├── array_iterator.hpp │ │ │ │ │ │ │ ├── detail/ │ │ │ │ │ │ │ │ ├── at_impl.hpp │ │ │ │ │ │ │ │ ├── begin_impl.hpp │ │ │ │ │ │ │ │ ├── category_of_impl.hpp │ │ │ │ │ │ │ │ ├── end_impl.hpp │ │ │ │ │ │ │ │ ├── is_sequence_impl.hpp │ │ │ │ │ │ │ │ ├── is_view_impl.hpp │ │ │ │ │ │ │ │ ├── size_impl.hpp │ │ │ │ │ │ │ │ └── value_at_impl.hpp │ │ │ │ │ │ │ └── tag_of.hpp │ │ │ │ │ │ ├── boost_array.hpp │ │ │ │ │ │ ├── boost_tuple/ │ │ │ │ │ │ │ ├── boost_tuple_iterator.hpp │ │ │ │ │ │ │ ├── detail/ │ │ │ │ │ │ │ │ ├── at_impl.hpp │ │ │ │ │ │ │ │ ├── begin_impl.hpp │ │ │ │ │ │ │ │ ├── build_cons.hpp │ │ │ │ │ │ │ │ ├── category_of_impl.hpp │ │ │ │ │ │ │ │ ├── convert_impl.hpp │ │ │ │ │ │ │ │ ├── end_impl.hpp │ │ │ │ │ │ │ │ ├── is_sequence_impl.hpp │ │ │ │ │ │ │ │ ├── is_view_impl.hpp │ │ │ │ │ │ │ │ ├── size_impl.hpp │ │ │ │ │ │ │ │ └── value_at_impl.hpp │ │ │ │ │ │ │ ├── mpl/ │ │ │ │ │ │ │ │ └── clear.hpp │ │ │ │ │ │ │ └── tag_of.hpp │ │ │ │ │ │ ├── boost_tuple.hpp │ │ │ │ │ │ ├── mpl/ │ │ │ │ │ │ │ ├── detail/ │ │ │ │ │ │ │ │ ├── at_impl.hpp │ │ │ │ │ │ │ │ ├── begin_impl.hpp │ │ │ │ │ │ │ │ ├── category_of_impl.hpp │ │ │ │ │ │ │ │ ├── empty_impl.hpp │ │ │ │ │ │ │ │ ├── end_impl.hpp │ │ │ │ │ │ │ │ ├── has_key_impl.hpp │ │ │ │ │ │ │ │ ├── is_sequence_impl.hpp │ │ │ │ │ │ │ │ ├── is_view_impl.hpp │ │ │ │ │ │ │ │ ├── size_impl.hpp │ │ │ │ │ │ │ │ └── value_at_impl.hpp │ │ │ │ │ │ │ └── mpl_iterator.hpp │ │ │ │ │ │ ├── mpl.hpp │ │ │ │ │ │ ├── std_array/ │ │ │ │ │ │ │ ├── detail/ │ │ │ │ │ │ │ │ ├── array_size.hpp │ │ │ │ │ │ │ │ ├── at_impl.hpp │ │ │ │ │ │ │ │ ├── begin_impl.hpp │ │ │ │ │ │ │ │ ├── category_of_impl.hpp │ │ │ │ │ │ │ │ ├── end_impl.hpp │ │ │ │ │ │ │ │ ├── is_sequence_impl.hpp │ │ │ │ │ │ │ │ ├── is_view_impl.hpp │ │ │ │ │ │ │ │ ├── size_impl.hpp │ │ │ │ │ │ │ │ └── value_at_impl.hpp │ │ │ │ │ │ │ ├── std_array_iterator.hpp │ │ │ │ │ │ │ └── tag_of.hpp │ │ │ │ │ │ ├── std_array.hpp │ │ │ │ │ │ ├── std_pair.hpp │ │ │ │ │ │ ├── std_tuple/ │ │ │ │ │ │ │ ├── detail/ │ │ │ │ │ │ │ │ ├── at_impl.hpp │ │ │ │ │ │ │ │ ├── begin_impl.hpp │ │ │ │ │ │ │ │ ├── build_std_tuple.hpp │ │ │ │ │ │ │ │ ├── category_of_impl.hpp │ │ │ │ │ │ │ │ ├── convert_impl.hpp │ │ │ │ │ │ │ │ ├── end_impl.hpp │ │ │ │ │ │ │ │ ├── is_sequence_impl.hpp │ │ │ │ │ │ │ │ ├── is_view_impl.hpp │ │ │ │ │ │ │ │ ├── size_impl.hpp │ │ │ │ │ │ │ │ └── value_at_impl.hpp │ │ │ │ │ │ │ ├── mpl/ │ │ │ │ │ │ │ │ └── clear.hpp │ │ │ │ │ │ │ ├── std_tuple_iterator.hpp │ │ │ │ │ │ │ └── tag_of.hpp │ │ │ │ │ │ ├── std_tuple.hpp │ │ │ │ │ │ ├── struct/ │ │ │ │ │ │ │ ├── adapt_assoc_struct.hpp │ │ │ │ │ │ │ ├── adapt_assoc_struct_named.hpp │ │ │ │ │ │ │ ├── adapt_struct.hpp │ │ │ │ │ │ │ ├── adapt_struct_named.hpp │ │ │ │ │ │ │ ├── define_assoc_struct.hpp │ │ │ │ │ │ │ ├── define_struct.hpp │ │ │ │ │ │ │ ├── define_struct_inline.hpp │ │ │ │ │ │ │ └── detail/ │ │ │ │ │ │ │ ├── adapt_auto.hpp │ │ │ │ │ │ │ ├── adapt_base.hpp │ │ │ │ │ │ │ ├── adapt_base_assoc_attr_filler.hpp │ │ │ │ │ │ │ ├── adapt_base_attr_filler.hpp │ │ │ │ │ │ │ ├── adapt_is_tpl.hpp │ │ │ │ │ │ │ ├── at_impl.hpp │ │ │ │ │ │ │ ├── begin_impl.hpp │ │ │ │ │ │ │ ├── category_of_impl.hpp │ │ │ │ │ │ │ ├── define_struct.hpp │ │ │ │ │ │ │ ├── define_struct_inline.hpp │ │ │ │ │ │ │ ├── deref_data_impl.hpp │ │ │ │ │ │ │ ├── deref_impl.hpp │ │ │ │ │ │ │ ├── end_impl.hpp │ │ │ │ │ │ │ ├── extension.hpp │ │ │ │ │ │ │ ├── is_sequence_impl.hpp │ │ │ │ │ │ │ ├── is_view_impl.hpp │ │ │ │ │ │ │ ├── key_of_impl.hpp │ │ │ │ │ │ │ ├── namespace.hpp │ │ │ │ │ │ │ ├── preprocessor/ │ │ │ │ │ │ │ │ └── is_seq.hpp │ │ │ │ │ │ │ ├── proxy_type.hpp │ │ │ │ │ │ │ ├── size_impl.hpp │ │ │ │ │ │ │ ├── value_at_impl.hpp │ │ │ │ │ │ │ ├── value_of_data_impl.hpp │ │ │ │ │ │ │ └── value_of_impl.hpp │ │ │ │ │ │ └── struct.hpp │ │ │ │ │ ├── adapted.hpp │ │ │ │ │ ├── algorithm/ │ │ │ │ │ │ ├── auxiliary/ │ │ │ │ │ │ │ ├── copy.hpp │ │ │ │ │ │ │ └── move.hpp │ │ │ │ │ │ ├── auxiliary.hpp │ │ │ │ │ │ ├── iteration/ │ │ │ │ │ │ │ ├── accumulate.hpp │ │ │ │ │ │ │ ├── accumulate_fwd.hpp │ │ │ │ │ │ │ ├── detail/ │ │ │ │ │ │ │ │ ├── fold.hpp │ │ │ │ │ │ │ │ ├── for_each.hpp │ │ │ │ │ │ │ │ ├── preprocessed/ │ │ │ │ │ │ │ │ │ ├── fold.hpp │ │ │ │ │ │ │ │ │ ├── iter_fold.hpp │ │ │ │ │ │ │ │ │ ├── reverse_fold.hpp │ │ │ │ │ │ │ │ │ └── reverse_iter_fold.hpp │ │ │ │ │ │ │ │ ├── segmented_fold.hpp │ │ │ │ │ │ │ │ └── segmented_for_each.hpp │ │ │ │ │ │ │ ├── fold.hpp │ │ │ │ │ │ │ ├── fold_fwd.hpp │ │ │ │ │ │ │ ├── for_each.hpp │ │ │ │ │ │ │ ├── for_each_fwd.hpp │ │ │ │ │ │ │ ├── iter_fold.hpp │ │ │ │ │ │ │ ├── iter_fold_fwd.hpp │ │ │ │ │ │ │ ├── reverse_fold.hpp │ │ │ │ │ │ │ ├── reverse_fold_fwd.hpp │ │ │ │ │ │ │ ├── reverse_iter_fold.hpp │ │ │ │ │ │ │ └── reverse_iter_fold_fwd.hpp │ │ │ │ │ │ ├── iteration.hpp │ │ │ │ │ │ ├── query/ │ │ │ │ │ │ │ ├── all.hpp │ │ │ │ │ │ │ ├── any.hpp │ │ │ │ │ │ │ ├── count.hpp │ │ │ │ │ │ │ ├── count_if.hpp │ │ │ │ │ │ │ ├── detail/ │ │ │ │ │ │ │ │ ├── all.hpp │ │ │ │ │ │ │ │ ├── any.hpp │ │ │ │ │ │ │ │ ├── count.hpp │ │ │ │ │ │ │ │ ├── count_if.hpp │ │ │ │ │ │ │ │ ├── find_if.hpp │ │ │ │ │ │ │ │ ├── segmented_find.hpp │ │ │ │ │ │ │ │ └── segmented_find_if.hpp │ │ │ │ │ │ │ ├── find.hpp │ │ │ │ │ │ │ ├── find_fwd.hpp │ │ │ │ │ │ │ ├── find_if.hpp │ │ │ │ │ │ │ ├── find_if_fwd.hpp │ │ │ │ │ │ │ └── none.hpp │ │ │ │ │ │ ├── query.hpp │ │ │ │ │ │ ├── transformation/ │ │ │ │ │ │ │ ├── clear.hpp │ │ │ │ │ │ │ ├── detail/ │ │ │ │ │ │ │ │ ├── preprocessed/ │ │ │ │ │ │ │ │ │ ├── zip.hpp │ │ │ │ │ │ │ │ │ ├── zip10.hpp │ │ │ │ │ │ │ │ │ ├── zip20.hpp │ │ │ │ │ │ │ │ │ ├── zip30.hpp │ │ │ │ │ │ │ │ │ ├── zip40.hpp │ │ │ │ │ │ │ │ │ └── zip50.hpp │ │ │ │ │ │ │ │ ├── replace.hpp │ │ │ │ │ │ │ │ └── replace_if.hpp │ │ │ │ │ │ │ ├── erase.hpp │ │ │ │ │ │ │ ├── erase_key.hpp │ │ │ │ │ │ │ ├── filter.hpp │ │ │ │ │ │ │ ├── filter_if.hpp │ │ │ │ │ │ │ ├── flatten.hpp │ │ │ │ │ │ │ ├── insert.hpp │ │ │ │ │ │ │ ├── insert_range.hpp │ │ │ │ │ │ │ ├── join.hpp │ │ │ │ │ │ │ ├── pop_back.hpp │ │ │ │ │ │ │ ├── pop_front.hpp │ │ │ │ │ │ │ ├── push_back.hpp │ │ │ │ │ │ │ ├── push_front.hpp │ │ │ │ │ │ │ ├── remove.hpp │ │ │ │ │ │ │ ├── remove_if.hpp │ │ │ │ │ │ │ ├── replace.hpp │ │ │ │ │ │ │ ├── replace_if.hpp │ │ │ │ │ │ │ ├── reverse.hpp │ │ │ │ │ │ │ ├── transform.hpp │ │ │ │ │ │ │ └── zip.hpp │ │ │ │ │ │ └── transformation.hpp │ │ │ │ │ ├── algorithm.hpp │ │ │ │ │ ├── container/ │ │ │ │ │ │ ├── deque/ │ │ │ │ │ │ │ ├── back_extended_deque.hpp │ │ │ │ │ │ │ ├── convert.hpp │ │ │ │ │ │ │ ├── deque.hpp │ │ │ │ │ │ │ ├── deque_fwd.hpp │ │ │ │ │ │ │ ├── deque_iterator.hpp │ │ │ │ │ │ │ ├── detail/ │ │ │ │ │ │ │ │ ├── at_impl.hpp │ │ │ │ │ │ │ │ ├── begin_impl.hpp │ │ │ │ │ │ │ │ ├── build_deque.hpp │ │ │ │ │ │ │ │ ├── convert_impl.hpp │ │ │ │ │ │ │ │ ├── cpp03/ │ │ │ │ │ │ │ │ │ ├── as_deque.hpp │ │ │ │ │ │ │ │ │ ├── build_deque.hpp │ │ │ │ │ │ │ │ │ ├── deque.hpp │ │ │ │ │ │ │ │ │ ├── deque_forward_ctor.hpp │ │ │ │ │ │ │ │ │ ├── deque_fwd.hpp │ │ │ │ │ │ │ │ │ ├── deque_initial_size.hpp │ │ │ │ │ │ │ │ │ ├── deque_keyed_values.hpp │ │ │ │ │ │ │ │ │ ├── deque_keyed_values_call.hpp │ │ │ │ │ │ │ │ │ ├── limits.hpp │ │ │ │ │ │ │ │ │ └── preprocessed/ │ │ │ │ │ │ │ │ │ ├── as_deque.hpp │ │ │ │ │ │ │ │ │ ├── as_deque10.hpp │ │ │ │ │ │ │ │ │ ├── as_deque20.hpp │ │ │ │ │ │ │ │ │ ├── as_deque30.hpp │ │ │ │ │ │ │ │ │ ├── as_deque40.hpp │ │ │ │ │ │ │ │ │ ├── as_deque50.hpp │ │ │ │ │ │ │ │ │ ├── deque.hpp │ │ │ │ │ │ │ │ │ ├── deque10.hpp │ │ │ │ │ │ │ │ │ ├── deque10_fwd.hpp │ │ │ │ │ │ │ │ │ ├── deque20.hpp │ │ │ │ │ │ │ │ │ ├── deque20_fwd.hpp │ │ │ │ │ │ │ │ │ ├── deque30.hpp │ │ │ │ │ │ │ │ │ ├── deque30_fwd.hpp │ │ │ │ │ │ │ │ │ ├── deque40.hpp │ │ │ │ │ │ │ │ │ ├── deque40_fwd.hpp │ │ │ │ │ │ │ │ │ ├── deque50.hpp │ │ │ │ │ │ │ │ │ ├── deque50_fwd.hpp │ │ │ │ │ │ │ │ │ ├── deque_fwd.hpp │ │ │ │ │ │ │ │ │ ├── deque_initial_size.hpp │ │ │ │ │ │ │ │ │ ├── deque_initial_size10.hpp │ │ │ │ │ │ │ │ │ ├── deque_initial_size20.hpp │ │ │ │ │ │ │ │ │ ├── deque_initial_size30.hpp │ │ │ │ │ │ │ │ │ ├── deque_initial_size40.hpp │ │ │ │ │ │ │ │ │ ├── deque_initial_size50.hpp │ │ │ │ │ │ │ │ │ ├── deque_keyed_values.hpp │ │ │ │ │ │ │ │ │ ├── deque_keyed_values10.hpp │ │ │ │ │ │ │ │ │ ├── deque_keyed_values20.hpp │ │ │ │ │ │ │ │ │ ├── deque_keyed_values30.hpp │ │ │ │ │ │ │ │ │ ├── deque_keyed_values40.hpp │ │ │ │ │ │ │ │ │ └── deque_keyed_values50.hpp │ │ │ │ │ │ │ │ ├── deque_keyed_values.hpp │ │ │ │ │ │ │ │ ├── end_impl.hpp │ │ │ │ │ │ │ │ ├── is_sequence_impl.hpp │ │ │ │ │ │ │ │ ├── keyed_element.hpp │ │ │ │ │ │ │ │ └── value_at_impl.hpp │ │ │ │ │ │ │ └── front_extended_deque.hpp │ │ │ │ │ │ ├── deque.hpp │ │ │ │ │ │ ├── generation/ │ │ │ │ │ │ │ ├── cons_tie.hpp │ │ │ │ │ │ │ ├── deque_tie.hpp │ │ │ │ │ │ │ ├── detail/ │ │ │ │ │ │ │ │ ├── pp_deque_tie.hpp │ │ │ │ │ │ │ │ ├── pp_list_tie.hpp │ │ │ │ │ │ │ │ ├── pp_make_deque.hpp │ │ │ │ │ │ │ │ ├── pp_make_list.hpp │ │ │ │ │ │ │ │ ├── pp_make_map.hpp │ │ │ │ │ │ │ │ ├── pp_make_set.hpp │ │ │ │ │ │ │ │ ├── pp_make_vector.hpp │ │ │ │ │ │ │ │ ├── pp_map_tie.hpp │ │ │ │ │ │ │ │ ├── pp_vector_tie.hpp │ │ │ │ │ │ │ │ └── preprocessed/ │ │ │ │ │ │ │ │ ├── deque_tie.hpp │ │ │ │ │ │ │ │ ├── deque_tie10.hpp │ │ │ │ │ │ │ │ ├── deque_tie20.hpp │ │ │ │ │ │ │ │ ├── deque_tie30.hpp │ │ │ │ │ │ │ │ ├── deque_tie40.hpp │ │ │ │ │ │ │ │ ├── deque_tie50.hpp │ │ │ │ │ │ │ │ ├── list_tie.hpp │ │ │ │ │ │ │ │ ├── list_tie10.hpp │ │ │ │ │ │ │ │ ├── list_tie20.hpp │ │ │ │ │ │ │ │ ├── list_tie30.hpp │ │ │ │ │ │ │ │ ├── list_tie40.hpp │ │ │ │ │ │ │ │ ├── list_tie50.hpp │ │ │ │ │ │ │ │ ├── make_deque.hpp │ │ │ │ │ │ │ │ ├── make_deque10.hpp │ │ │ │ │ │ │ │ ├── make_deque20.hpp │ │ │ │ │ │ │ │ ├── make_deque30.hpp │ │ │ │ │ │ │ │ ├── make_deque40.hpp │ │ │ │ │ │ │ │ ├── make_deque50.hpp │ │ │ │ │ │ │ │ ├── make_list.hpp │ │ │ │ │ │ │ │ ├── make_list10.hpp │ │ │ │ │ │ │ │ ├── make_list20.hpp │ │ │ │ │ │ │ │ ├── make_list30.hpp │ │ │ │ │ │ │ │ ├── make_list40.hpp │ │ │ │ │ │ │ │ ├── make_list50.hpp │ │ │ │ │ │ │ │ ├── make_map.hpp │ │ │ │ │ │ │ │ ├── make_map10.hpp │ │ │ │ │ │ │ │ ├── make_map20.hpp │ │ │ │ │ │ │ │ ├── make_map30.hpp │ │ │ │ │ │ │ │ ├── make_map40.hpp │ │ │ │ │ │ │ │ ├── make_map50.hpp │ │ │ │ │ │ │ │ ├── make_set.hpp │ │ │ │ │ │ │ │ ├── make_set10.hpp │ │ │ │ │ │ │ │ ├── make_set20.hpp │ │ │ │ │ │ │ │ ├── make_set30.hpp │ │ │ │ │ │ │ │ ├── make_set40.hpp │ │ │ │ │ │ │ │ ├── make_set50.hpp │ │ │ │ │ │ │ │ ├── make_vector.hpp │ │ │ │ │ │ │ │ ├── make_vector10.hpp │ │ │ │ │ │ │ │ ├── make_vector20.hpp │ │ │ │ │ │ │ │ ├── make_vector30.hpp │ │ │ │ │ │ │ │ ├── make_vector40.hpp │ │ │ │ │ │ │ │ ├── make_vector50.hpp │ │ │ │ │ │ │ │ ├── map_tie.hpp │ │ │ │ │ │ │ │ ├── map_tie10.hpp │ │ │ │ │ │ │ │ ├── map_tie20.hpp │ │ │ │ │ │ │ │ ├── map_tie30.hpp │ │ │ │ │ │ │ │ ├── map_tie40.hpp │ │ │ │ │ │ │ │ ├── map_tie50.hpp │ │ │ │ │ │ │ │ ├── vector_tie.hpp │ │ │ │ │ │ │ │ ├── vector_tie10.hpp │ │ │ │ │ │ │ │ ├── vector_tie20.hpp │ │ │ │ │ │ │ │ ├── vector_tie30.hpp │ │ │ │ │ │ │ │ ├── vector_tie40.hpp │ │ │ │ │ │ │ │ └── vector_tie50.hpp │ │ │ │ │ │ │ ├── ignore.hpp │ │ │ │ │ │ │ ├── list_tie.hpp │ │ │ │ │ │ │ ├── make_cons.hpp │ │ │ │ │ │ │ ├── make_deque.hpp │ │ │ │ │ │ │ ├── make_list.hpp │ │ │ │ │ │ │ ├── make_map.hpp │ │ │ │ │ │ │ ├── make_set.hpp │ │ │ │ │ │ │ ├── make_vector.hpp │ │ │ │ │ │ │ ├── map_tie.hpp │ │ │ │ │ │ │ ├── pair_tie.hpp │ │ │ │ │ │ │ └── vector_tie.hpp │ │ │ │ │ │ ├── generation.hpp │ │ │ │ │ │ ├── list/ │ │ │ │ │ │ │ ├── cons.hpp │ │ │ │ │ │ │ ├── cons_fwd.hpp │ │ │ │ │ │ │ ├── cons_iterator.hpp │ │ │ │ │ │ │ ├── convert.hpp │ │ │ │ │ │ │ ├── detail/ │ │ │ │ │ │ │ │ ├── at_impl.hpp │ │ │ │ │ │ │ │ ├── begin_impl.hpp │ │ │ │ │ │ │ │ ├── build_cons.hpp │ │ │ │ │ │ │ │ ├── convert_impl.hpp │ │ │ │ │ │ │ │ ├── cpp03/ │ │ │ │ │ │ │ │ │ ├── limits.hpp │ │ │ │ │ │ │ │ │ ├── list.hpp │ │ │ │ │ │ │ │ │ ├── list_forward_ctor.hpp │ │ │ │ │ │ │ │ │ ├── list_fwd.hpp │ │ │ │ │ │ │ │ │ ├── list_to_cons.hpp │ │ │ │ │ │ │ │ │ ├── list_to_cons_call.hpp │ │ │ │ │ │ │ │ │ └── preprocessed/ │ │ │ │ │ │ │ │ │ ├── list.hpp │ │ │ │ │ │ │ │ │ ├── list10.hpp │ │ │ │ │ │ │ │ │ ├── list10_fwd.hpp │ │ │ │ │ │ │ │ │ ├── list20.hpp │ │ │ │ │ │ │ │ │ ├── list20_fwd.hpp │ │ │ │ │ │ │ │ │ ├── list30.hpp │ │ │ │ │ │ │ │ │ ├── list30_fwd.hpp │ │ │ │ │ │ │ │ │ ├── list40.hpp │ │ │ │ │ │ │ │ │ ├── list40_fwd.hpp │ │ │ │ │ │ │ │ │ ├── list50.hpp │ │ │ │ │ │ │ │ │ ├── list50_fwd.hpp │ │ │ │ │ │ │ │ │ ├── list_fwd.hpp │ │ │ │ │ │ │ │ │ ├── list_to_cons.hpp │ │ │ │ │ │ │ │ │ ├── list_to_cons10.hpp │ │ │ │ │ │ │ │ │ ├── list_to_cons20.hpp │ │ │ │ │ │ │ │ │ ├── list_to_cons30.hpp │ │ │ │ │ │ │ │ │ ├── list_to_cons40.hpp │ │ │ │ │ │ │ │ │ └── list_to_cons50.hpp │ │ │ │ │ │ │ │ ├── deref_impl.hpp │ │ │ │ │ │ │ │ ├── empty_impl.hpp │ │ │ │ │ │ │ │ ├── end_impl.hpp │ │ │ │ │ │ │ │ ├── equal_to_impl.hpp │ │ │ │ │ │ │ │ ├── list_to_cons.hpp │ │ │ │ │ │ │ │ ├── next_impl.hpp │ │ │ │ │ │ │ │ ├── reverse_cons.hpp │ │ │ │ │ │ │ │ ├── value_at_impl.hpp │ │ │ │ │ │ │ │ └── value_of_impl.hpp │ │ │ │ │ │ │ ├── list.hpp │ │ │ │ │ │ │ ├── list_fwd.hpp │ │ │ │ │ │ │ └── nil.hpp │ │ │ │ │ │ ├── list.hpp │ │ │ │ │ │ ├── map/ │ │ │ │ │ │ │ ├── convert.hpp │ │ │ │ │ │ │ ├── detail/ │ │ │ │ │ │ │ │ ├── at_impl.hpp │ │ │ │ │ │ │ │ ├── at_key_impl.hpp │ │ │ │ │ │ │ │ ├── begin_impl.hpp │ │ │ │ │ │ │ │ ├── build_map.hpp │ │ │ │ │ │ │ │ ├── cpp03/ │ │ │ │ │ │ │ │ │ ├── as_map.hpp │ │ │ │ │ │ │ │ │ ├── at_impl.hpp │ │ │ │ │ │ │ │ │ ├── begin_impl.hpp │ │ │ │ │ │ │ │ │ ├── convert.hpp │ │ │ │ │ │ │ │ │ ├── convert_impl.hpp │ │ │ │ │ │ │ │ │ ├── deref_data_impl.hpp │ │ │ │ │ │ │ │ │ ├── deref_impl.hpp │ │ │ │ │ │ │ │ │ ├── end_impl.hpp │ │ │ │ │ │ │ │ │ ├── key_of_impl.hpp │ │ │ │ │ │ │ │ │ ├── limits.hpp │ │ │ │ │ │ │ │ │ ├── map.hpp │ │ │ │ │ │ │ │ │ ├── map_forward_ctor.hpp │ │ │ │ │ │ │ │ │ ├── map_fwd.hpp │ │ │ │ │ │ │ │ │ ├── preprocessed/ │ │ │ │ │ │ │ │ │ │ ├── as_map.hpp │ │ │ │ │ │ │ │ │ │ ├── as_map10.hpp │ │ │ │ │ │ │ │ │ │ ├── as_map20.hpp │ │ │ │ │ │ │ │ │ │ ├── as_map30.hpp │ │ │ │ │ │ │ │ │ │ ├── as_map40.hpp │ │ │ │ │ │ │ │ │ │ ├── as_map50.hpp │ │ │ │ │ │ │ │ │ │ ├── map.hpp │ │ │ │ │ │ │ │ │ │ ├── map10.hpp │ │ │ │ │ │ │ │ │ │ ├── map10_fwd.hpp │ │ │ │ │ │ │ │ │ │ ├── map20.hpp │ │ │ │ │ │ │ │ │ │ ├── map20_fwd.hpp │ │ │ │ │ │ │ │ │ │ ├── map30.hpp │ │ │ │ │ │ │ │ │ │ ├── map30_fwd.hpp │ │ │ │ │ │ │ │ │ │ ├── map40.hpp │ │ │ │ │ │ │ │ │ │ ├── map40_fwd.hpp │ │ │ │ │ │ │ │ │ │ ├── map50.hpp │ │ │ │ │ │ │ │ │ │ ├── map50_fwd.hpp │ │ │ │ │ │ │ │ │ │ └── map_fwd.hpp │ │ │ │ │ │ │ │ │ ├── value_at_impl.hpp │ │ │ │ │ │ │ │ │ ├── value_of_data_impl.hpp │ │ │ │ │ │ │ │ │ └── value_of_impl.hpp │ │ │ │ │ │ │ │ ├── end_impl.hpp │ │ │ │ │ │ │ │ ├── map_impl.hpp │ │ │ │ │ │ │ │ ├── map_index.hpp │ │ │ │ │ │ │ │ ├── value_at_impl.hpp │ │ │ │ │ │ │ │ └── value_at_key_impl.hpp │ │ │ │ │ │ │ ├── map.hpp │ │ │ │ │ │ │ ├── map_fwd.hpp │ │ │ │ │ │ │ └── map_iterator.hpp │ │ │ │ │ │ ├── map.hpp │ │ │ │ │ │ ├── set/ │ │ │ │ │ │ │ ├── convert.hpp │ │ │ │ │ │ │ ├── detail/ │ │ │ │ │ │ │ │ ├── as_set.hpp │ │ │ │ │ │ │ │ ├── begin_impl.hpp │ │ │ │ │ │ │ │ ├── convert_impl.hpp │ │ │ │ │ │ │ │ ├── cpp03/ │ │ │ │ │ │ │ │ │ ├── as_set.hpp │ │ │ │ │ │ │ │ │ ├── limits.hpp │ │ │ │ │ │ │ │ │ ├── preprocessed/ │ │ │ │ │ │ │ │ │ │ ├── as_set.hpp │ │ │ │ │ │ │ │ │ │ ├── as_set10.hpp │ │ │ │ │ │ │ │ │ │ ├── as_set20.hpp │ │ │ │ │ │ │ │ │ │ ├── as_set30.hpp │ │ │ │ │ │ │ │ │ │ ├── as_set40.hpp │ │ │ │ │ │ │ │ │ │ ├── as_set50.hpp │ │ │ │ │ │ │ │ │ │ ├── set.hpp │ │ │ │ │ │ │ │ │ │ ├── set10.hpp │ │ │ │ │ │ │ │ │ │ ├── set10_fwd.hpp │ │ │ │ │ │ │ │ │ │ ├── set20.hpp │ │ │ │ │ │ │ │ │ │ ├── set20_fwd.hpp │ │ │ │ │ │ │ │ │ │ ├── set30.hpp │ │ │ │ │ │ │ │ │ │ ├── set30_fwd.hpp │ │ │ │ │ │ │ │ │ │ ├── set40.hpp │ │ │ │ │ │ │ │ │ │ ├── set40_fwd.hpp │ │ │ │ │ │ │ │ │ │ ├── set50.hpp │ │ │ │ │ │ │ │ │ │ ├── set50_fwd.hpp │ │ │ │ │ │ │ │ │ │ └── set_fwd.hpp │ │ │ │ │ │ │ │ │ ├── set.hpp │ │ │ │ │ │ │ │ │ ├── set_forward_ctor.hpp │ │ │ │ │ │ │ │ │ └── set_fwd.hpp │ │ │ │ │ │ │ │ ├── deref_data_impl.hpp │ │ │ │ │ │ │ │ ├── deref_impl.hpp │ │ │ │ │ │ │ │ ├── end_impl.hpp │ │ │ │ │ │ │ │ ├── key_of_impl.hpp │ │ │ │ │ │ │ │ ├── value_of_data_impl.hpp │ │ │ │ │ │ │ │ └── value_of_impl.hpp │ │ │ │ │ │ │ ├── set.hpp │ │ │ │ │ │ │ └── set_fwd.hpp │ │ │ │ │ │ ├── set.hpp │ │ │ │ │ │ ├── vector/ │ │ │ │ │ │ │ ├── convert.hpp │ │ │ │ │ │ │ ├── detail/ │ │ │ │ │ │ │ │ ├── advance_impl.hpp │ │ │ │ │ │ │ │ ├── as_vector.hpp │ │ │ │ │ │ │ │ ├── at_impl.hpp │ │ │ │ │ │ │ │ ├── begin_impl.hpp │ │ │ │ │ │ │ │ ├── config.hpp │ │ │ │ │ │ │ │ ├── convert_impl.hpp │ │ │ │ │ │ │ │ ├── cpp03/ │ │ │ │ │ │ │ │ │ ├── as_vector.hpp │ │ │ │ │ │ │ │ │ ├── limits.hpp │ │ │ │ │ │ │ │ │ ├── preprocessed/ │ │ │ │ │ │ │ │ │ │ ├── as_vector.hpp │ │ │ │ │ │ │ │ │ │ ├── as_vector10.hpp │ │ │ │ │ │ │ │ │ │ ├── as_vector20.hpp │ │ │ │ │ │ │ │ │ │ ├── as_vector30.hpp │ │ │ │ │ │ │ │ │ │ ├── as_vector40.hpp │ │ │ │ │ │ │ │ │ │ ├── as_vector50.hpp │ │ │ │ │ │ │ │ │ │ ├── vector.hpp │ │ │ │ │ │ │ │ │ │ ├── vector10.hpp │ │ │ │ │ │ │ │ │ │ ├── vector10_fwd.hpp │ │ │ │ │ │ │ │ │ │ ├── vector20.hpp │ │ │ │ │ │ │ │ │ │ ├── vector20_fwd.hpp │ │ │ │ │ │ │ │ │ │ ├── vector30.hpp │ │ │ │ │ │ │ │ │ │ ├── vector30_fwd.hpp │ │ │ │ │ │ │ │ │ │ ├── vector40.hpp │ │ │ │ │ │ │ │ │ │ ├── vector40_fwd.hpp │ │ │ │ │ │ │ │ │ │ ├── vector50.hpp │ │ │ │ │ │ │ │ │ │ ├── vector50_fwd.hpp │ │ │ │ │ │ │ │ │ │ ├── vector_chooser.hpp │ │ │ │ │ │ │ │ │ │ ├── vector_chooser10.hpp │ │ │ │ │ │ │ │ │ │ ├── vector_chooser20.hpp │ │ │ │ │ │ │ │ │ │ ├── vector_chooser30.hpp │ │ │ │ │ │ │ │ │ │ ├── vector_chooser40.hpp │ │ │ │ │ │ │ │ │ │ ├── vector_chooser50.hpp │ │ │ │ │ │ │ │ │ │ ├── vector_fwd.hpp │ │ │ │ │ │ │ │ │ │ ├── vvector10.hpp │ │ │ │ │ │ │ │ │ │ ├── vvector10_fwd.hpp │ │ │ │ │ │ │ │ │ │ ├── vvector20.hpp │ │ │ │ │ │ │ │ │ │ ├── vvector20_fwd.hpp │ │ │ │ │ │ │ │ │ │ ├── vvector30.hpp │ │ │ │ │ │ │ │ │ │ ├── vvector30_fwd.hpp │ │ │ │ │ │ │ │ │ │ ├── vvector40.hpp │ │ │ │ │ │ │ │ │ │ ├── vvector40_fwd.hpp │ │ │ │ │ │ │ │ │ │ ├── vvector50.hpp │ │ │ │ │ │ │ │ │ │ └── vvector50_fwd.hpp │ │ │ │ │ │ │ │ │ ├── value_at_impl.hpp │ │ │ │ │ │ │ │ │ ├── vector.hpp │ │ │ │ │ │ │ │ │ ├── vector10.hpp │ │ │ │ │ │ │ │ │ ├── vector10_fwd.hpp │ │ │ │ │ │ │ │ │ ├── vector20.hpp │ │ │ │ │ │ │ │ │ ├── vector20_fwd.hpp │ │ │ │ │ │ │ │ │ ├── vector30.hpp │ │ │ │ │ │ │ │ │ ├── vector30_fwd.hpp │ │ │ │ │ │ │ │ │ ├── vector40.hpp │ │ │ │ │ │ │ │ │ ├── vector40_fwd.hpp │ │ │ │ │ │ │ │ │ ├── vector50.hpp │ │ │ │ │ │ │ │ │ ├── vector50_fwd.hpp │ │ │ │ │ │ │ │ │ ├── vector_forward_ctor.hpp │ │ │ │ │ │ │ │ │ ├── vector_fwd.hpp │ │ │ │ │ │ │ │ │ ├── vector_n.hpp │ │ │ │ │ │ │ │ │ └── vector_n_chooser.hpp │ │ │ │ │ │ │ │ ├── deref_impl.hpp │ │ │ │ │ │ │ │ ├── distance_impl.hpp │ │ │ │ │ │ │ │ ├── end_impl.hpp │ │ │ │ │ │ │ │ ├── equal_to_impl.hpp │ │ │ │ │ │ │ │ ├── next_impl.hpp │ │ │ │ │ │ │ │ ├── prior_impl.hpp │ │ │ │ │ │ │ │ ├── value_at_impl.hpp │ │ │ │ │ │ │ │ └── value_of_impl.hpp │ │ │ │ │ │ │ ├── vector.hpp │ │ │ │ │ │ │ ├── vector10.hpp │ │ │ │ │ │ │ ├── vector20.hpp │ │ │ │ │ │ │ ├── vector30.hpp │ │ │ │ │ │ │ ├── vector40.hpp │ │ │ │ │ │ │ ├── vector50.hpp │ │ │ │ │ │ │ ├── vector_fwd.hpp │ │ │ │ │ │ │ └── vector_iterator.hpp │ │ │ │ │ │ └── vector.hpp │ │ │ │ │ ├── container.hpp │ │ │ │ │ ├── functional/ │ │ │ │ │ │ ├── adapter/ │ │ │ │ │ │ │ ├── detail/ │ │ │ │ │ │ │ │ └── access.hpp │ │ │ │ │ │ │ ├── fused.hpp │ │ │ │ │ │ │ ├── fused_function_object.hpp │ │ │ │ │ │ │ ├── fused_procedure.hpp │ │ │ │ │ │ │ ├── limits.hpp │ │ │ │ │ │ │ ├── unfused.hpp │ │ │ │ │ │ │ └── unfused_typed.hpp │ │ │ │ │ │ ├── adapter.hpp │ │ │ │ │ │ ├── generation/ │ │ │ │ │ │ │ ├── detail/ │ │ │ │ │ │ │ │ └── gen_make_adapter.hpp │ │ │ │ │ │ │ ├── make_fused.hpp │ │ │ │ │ │ │ ├── make_fused_function_object.hpp │ │ │ │ │ │ │ ├── make_fused_procedure.hpp │ │ │ │ │ │ │ └── make_unfused.hpp │ │ │ │ │ │ ├── generation.hpp │ │ │ │ │ │ ├── invocation/ │ │ │ │ │ │ │ ├── detail/ │ │ │ │ │ │ │ │ └── that_ptr.hpp │ │ │ │ │ │ │ ├── invoke.hpp │ │ │ │ │ │ │ ├── invoke_function_object.hpp │ │ │ │ │ │ │ ├── invoke_procedure.hpp │ │ │ │ │ │ │ └── limits.hpp │ │ │ │ │ │ └── invocation.hpp │ │ │ │ │ ├── functional.hpp │ │ │ │ │ ├── include/ │ │ │ │ │ │ ├── accumulate.hpp │ │ │ │ │ │ ├── adapt_adt.hpp │ │ │ │ │ │ ├── adapt_adt_named.cpp │ │ │ │ │ │ ├── adapt_adt_named.hpp │ │ │ │ │ │ ├── adapt_assoc_adt.hpp │ │ │ │ │ │ ├── adapt_assoc_adt_named.hpp │ │ │ │ │ │ ├── adapt_assoc_struct.hpp │ │ │ │ │ │ ├── adapt_assoc_struct_named.hpp │ │ │ │ │ │ ├── adapt_struct.hpp │ │ │ │ │ │ ├── adapt_struct_named.hpp │ │ │ │ │ │ ├── adapted.hpp │ │ │ │ │ │ ├── adapter.hpp │ │ │ │ │ │ ├── advance.hpp │ │ │ │ │ │ ├── algorithm.hpp │ │ │ │ │ │ ├── all.hpp │ │ │ │ │ │ ├── any.hpp │ │ │ │ │ │ ├── array.hpp │ │ │ │ │ │ ├── as_deque.hpp │ │ │ │ │ │ ├── as_list.hpp │ │ │ │ │ │ ├── as_map.hpp │ │ │ │ │ │ ├── as_set.hpp │ │ │ │ │ │ ├── as_vector.hpp │ │ │ │ │ │ ├── at.hpp │ │ │ │ │ │ ├── at_c.hpp │ │ │ │ │ │ ├── at_key.hpp │ │ │ │ │ │ ├── auxiliary.hpp │ │ │ │ │ │ ├── back.hpp │ │ │ │ │ │ ├── begin.hpp │ │ │ │ │ │ ├── boost_array.hpp │ │ │ │ │ │ ├── boost_tuple.hpp │ │ │ │ │ │ ├── category_of.hpp │ │ │ │ │ │ ├── clear.hpp │ │ │ │ │ │ ├── comparison.hpp │ │ │ │ │ │ ├── cons.hpp │ │ │ │ │ │ ├── cons_tie.hpp │ │ │ │ │ │ ├── container.hpp │ │ │ │ │ │ ├── convert.hpp │ │ │ │ │ │ ├── copy.hpp │ │ │ │ │ │ ├── count.hpp │ │ │ │ │ │ ├── count_if.hpp │ │ │ │ │ │ ├── deduce.hpp │ │ │ │ │ │ ├── deduce_sequence.hpp │ │ │ │ │ │ ├── define_assoc_struct.hpp │ │ │ │ │ │ ├── define_struct.hpp │ │ │ │ │ │ ├── define_struct_inline.hpp │ │ │ │ │ │ ├── deque.hpp │ │ │ │ │ │ ├── deque_fwd.hpp │ │ │ │ │ │ ├── deque_tie.hpp │ │ │ │ │ │ ├── deref.hpp │ │ │ │ │ │ ├── deref_data.hpp │ │ │ │ │ │ ├── distance.hpp │ │ │ │ │ │ ├── empty.hpp │ │ │ │ │ │ ├── end.hpp │ │ │ │ │ │ ├── equal_to.hpp │ │ │ │ │ │ ├── erase.hpp │ │ │ │ │ │ ├── erase_key.hpp │ │ │ │ │ │ ├── filter.hpp │ │ │ │ │ │ ├── filter_if.hpp │ │ │ │ │ │ ├── filter_view.hpp │ │ │ │ │ │ ├── find.hpp │ │ │ │ │ │ ├── find_if.hpp │ │ │ │ │ │ ├── flatten.hpp │ │ │ │ │ │ ├── flatten_view.hpp │ │ │ │ │ │ ├── fold.hpp │ │ │ │ │ │ ├── for_each.hpp │ │ │ │ │ │ ├── front.hpp │ │ │ │ │ │ ├── functional.hpp │ │ │ │ │ │ ├── fused.hpp │ │ │ │ │ │ ├── fused_function_object.hpp │ │ │ │ │ │ ├── fused_procedure.hpp │ │ │ │ │ │ ├── generation.hpp │ │ │ │ │ │ ├── greater.hpp │ │ │ │ │ │ ├── greater_equal.hpp │ │ │ │ │ │ ├── has_key.hpp │ │ │ │ │ │ ├── hash.hpp │ │ │ │ │ │ ├── ignore.hpp │ │ │ │ │ │ ├── in.hpp │ │ │ │ │ │ ├── insert.hpp │ │ │ │ │ │ ├── insert_range.hpp │ │ │ │ │ │ ├── intrinsic.hpp │ │ │ │ │ │ ├── invocation.hpp │ │ │ │ │ │ ├── invoke.hpp │ │ │ │ │ │ ├── invoke_function_object.hpp │ │ │ │ │ │ ├── invoke_procedure.hpp │ │ │ │ │ │ ├── io.hpp │ │ │ │ │ │ ├── is_iterator.hpp │ │ │ │ │ │ ├── is_segmented.hpp │ │ │ │ │ │ ├── is_sequence.hpp │ │ │ │ │ │ ├── is_view.hpp │ │ │ │ │ │ ├── iter_fold.hpp │ │ │ │ │ │ ├── iteration.hpp │ │ │ │ │ │ ├── iterator.hpp │ │ │ │ │ │ ├── iterator_adapter.hpp │ │ │ │ │ │ ├── iterator_base.hpp │ │ │ │ │ │ ├── iterator_facade.hpp │ │ │ │ │ │ ├── iterator_range.hpp │ │ │ │ │ │ ├── join.hpp │ │ │ │ │ │ ├── joint_view.hpp │ │ │ │ │ │ ├── key_of.hpp │ │ │ │ │ │ ├── less.hpp │ │ │ │ │ │ ├── less_equal.hpp │ │ │ │ │ │ ├── list.hpp │ │ │ │ │ │ ├── list_fwd.hpp │ │ │ │ │ │ ├── list_tie.hpp │ │ │ │ │ │ ├── make_cons.hpp │ │ │ │ │ │ ├── make_deque.hpp │ │ │ │ │ │ ├── make_fused.hpp │ │ │ │ │ │ ├── make_fused_function_object.hpp │ │ │ │ │ │ ├── make_fused_procedure.hpp │ │ │ │ │ │ ├── make_list.hpp │ │ │ │ │ │ ├── make_map.hpp │ │ │ │ │ │ ├── make_set.hpp │ │ │ │ │ │ ├── make_tuple.hpp │ │ │ │ │ │ ├── make_unfused.hpp │ │ │ │ │ │ ├── make_vector.hpp │ │ │ │ │ │ ├── map.hpp │ │ │ │ │ │ ├── map_fwd.hpp │ │ │ │ │ │ ├── map_tie.hpp │ │ │ │ │ │ ├── move.hpp │ │ │ │ │ │ ├── mpl.hpp │ │ │ │ │ │ ├── next.hpp │ │ │ │ │ │ ├── nil.hpp │ │ │ │ │ │ ├── none.hpp │ │ │ │ │ │ ├── not_equal_to.hpp │ │ │ │ │ │ ├── nview.hpp │ │ │ │ │ │ ├── out.hpp │ │ │ │ │ │ ├── pair.hpp │ │ │ │ │ │ ├── pair_tie.hpp │ │ │ │ │ │ ├── pop_back.hpp │ │ │ │ │ │ ├── pop_front.hpp │ │ │ │ │ │ ├── prior.hpp │ │ │ │ │ │ ├── proxy_type.hpp │ │ │ │ │ │ ├── push_back.hpp │ │ │ │ │ │ ├── push_front.hpp │ │ │ │ │ │ ├── query.hpp │ │ │ │ │ │ ├── remove.hpp │ │ │ │ │ │ ├── remove_if.hpp │ │ │ │ │ │ ├── repetitive_view.hpp │ │ │ │ │ │ ├── replace.hpp │ │ │ │ │ │ ├── replace_if.hpp │ │ │ │ │ │ ├── reverse.hpp │ │ │ │ │ │ ├── reverse_fold.hpp │ │ │ │ │ │ ├── reverse_iter_fold.hpp │ │ │ │ │ │ ├── reverse_view.hpp │ │ │ │ │ │ ├── segmented_fold_until.hpp │ │ │ │ │ │ ├── segmented_iterator.hpp │ │ │ │ │ │ ├── segments.hpp │ │ │ │ │ │ ├── sequence.hpp │ │ │ │ │ │ ├── sequence_base.hpp │ │ │ │ │ │ ├── sequence_facade.hpp │ │ │ │ │ │ ├── set.hpp │ │ │ │ │ │ ├── set_fwd.hpp │ │ │ │ │ │ ├── single_view.hpp │ │ │ │ │ │ ├── size.hpp │ │ │ │ │ │ ├── std_pair.hpp │ │ │ │ │ │ ├── std_tuple.hpp │ │ │ │ │ │ ├── struct.hpp │ │ │ │ │ │ ├── support.hpp │ │ │ │ │ │ ├── swap.hpp │ │ │ │ │ │ ├── tag_of.hpp │ │ │ │ │ │ ├── tag_of_fwd.hpp │ │ │ │ │ │ ├── transform.hpp │ │ │ │ │ │ ├── transform_view.hpp │ │ │ │ │ │ ├── transformation.hpp │ │ │ │ │ │ ├── tuple.hpp │ │ │ │ │ │ ├── tuple_fwd.hpp │ │ │ │ │ │ ├── tuple_tie.hpp │ │ │ │ │ │ ├── unfused.hpp │ │ │ │ │ │ ├── unfused_typed.hpp │ │ │ │ │ │ ├── unused.hpp │ │ │ │ │ │ ├── value_at.hpp │ │ │ │ │ │ ├── value_at_key.hpp │ │ │ │ │ │ ├── value_of.hpp │ │ │ │ │ │ ├── value_of_data.hpp │ │ │ │ │ │ ├── vector.hpp │ │ │ │ │ │ ├── vector10.hpp │ │ │ │ │ │ ├── vector20.hpp │ │ │ │ │ │ ├── vector30.hpp │ │ │ │ │ │ ├── vector40.hpp │ │ │ │ │ │ ├── vector50.hpp │ │ │ │ │ │ ├── vector_fwd.hpp │ │ │ │ │ │ ├── vector_tie.hpp │ │ │ │ │ │ ├── view.hpp │ │ │ │ │ │ ├── void.hpp │ │ │ │ │ │ ├── zip.hpp │ │ │ │ │ │ └── zip_view.hpp │ │ │ │ │ ├── iterator/ │ │ │ │ │ │ ├── advance.hpp │ │ │ │ │ │ ├── basic_iterator.hpp │ │ │ │ │ │ ├── deref.hpp │ │ │ │ │ │ ├── deref_data.hpp │ │ │ │ │ │ ├── detail/ │ │ │ │ │ │ │ ├── adapt_deref_traits.hpp │ │ │ │ │ │ │ ├── adapt_value_traits.hpp │ │ │ │ │ │ │ ├── advance.hpp │ │ │ │ │ │ │ ├── distance.hpp │ │ │ │ │ │ │ ├── segment_sequence.hpp │ │ │ │ │ │ │ ├── segmented_equal_to.hpp │ │ │ │ │ │ │ ├── segmented_iterator.hpp │ │ │ │ │ │ │ └── segmented_next_impl.hpp │ │ │ │ │ │ ├── distance.hpp │ │ │ │ │ │ ├── equal_to.hpp │ │ │ │ │ │ ├── iterator_adapter.hpp │ │ │ │ │ │ ├── iterator_facade.hpp │ │ │ │ │ │ ├── key_of.hpp │ │ │ │ │ │ ├── mpl/ │ │ │ │ │ │ │ ├── convert_iterator.hpp │ │ │ │ │ │ │ └── fusion_iterator.hpp │ │ │ │ │ │ ├── mpl.hpp │ │ │ │ │ │ ├── next.hpp │ │ │ │ │ │ ├── prior.hpp │ │ │ │ │ │ ├── segmented_iterator.hpp │ │ │ │ │ │ ├── value_of.hpp │ │ │ │ │ │ └── value_of_data.hpp │ │ │ │ │ ├── iterator.hpp │ │ │ │ │ ├── mpl/ │ │ │ │ │ │ ├── at.hpp │ │ │ │ │ │ ├── back.hpp │ │ │ │ │ │ ├── begin.hpp │ │ │ │ │ │ ├── clear.hpp │ │ │ │ │ │ ├── detail/ │ │ │ │ │ │ │ └── clear.hpp │ │ │ │ │ │ ├── empty.hpp │ │ │ │ │ │ ├── end.hpp │ │ │ │ │ │ ├── erase.hpp │ │ │ │ │ │ ├── erase_key.hpp │ │ │ │ │ │ ├── front.hpp │ │ │ │ │ │ ├── has_key.hpp │ │ │ │ │ │ ├── insert.hpp │ │ │ │ │ │ ├── insert_range.hpp │ │ │ │ │ │ ├── pop_back.hpp │ │ │ │ │ │ ├── pop_front.hpp │ │ │ │ │ │ ├── push_back.hpp │ │ │ │ │ │ ├── push_front.hpp │ │ │ │ │ │ └── size.hpp │ │ │ │ │ ├── mpl.hpp │ │ │ │ │ ├── sequence/ │ │ │ │ │ │ ├── comparison/ │ │ │ │ │ │ │ ├── detail/ │ │ │ │ │ │ │ │ ├── equal_to.hpp │ │ │ │ │ │ │ │ ├── greater.hpp │ │ │ │ │ │ │ │ ├── greater_equal.hpp │ │ │ │ │ │ │ │ ├── less.hpp │ │ │ │ │ │ │ │ ├── less_equal.hpp │ │ │ │ │ │ │ │ └── not_equal_to.hpp │ │ │ │ │ │ │ ├── enable_comparison.hpp │ │ │ │ │ │ │ ├── equal_to.hpp │ │ │ │ │ │ │ ├── greater.hpp │ │ │ │ │ │ │ ├── greater_equal.hpp │ │ │ │ │ │ │ ├── less.hpp │ │ │ │ │ │ │ ├── less_equal.hpp │ │ │ │ │ │ │ └── not_equal_to.hpp │ │ │ │ │ │ ├── comparison.hpp │ │ │ │ │ │ ├── convert.hpp │ │ │ │ │ │ ├── hash.hpp │ │ │ │ │ │ ├── intrinsic/ │ │ │ │ │ │ │ ├── at.hpp │ │ │ │ │ │ │ ├── at_c.hpp │ │ │ │ │ │ │ ├── at_key.hpp │ │ │ │ │ │ │ ├── back.hpp │ │ │ │ │ │ │ ├── begin.hpp │ │ │ │ │ │ │ ├── detail/ │ │ │ │ │ │ │ │ ├── segmented_begin.hpp │ │ │ │ │ │ │ │ ├── segmented_begin_impl.hpp │ │ │ │ │ │ │ │ ├── segmented_end.hpp │ │ │ │ │ │ │ │ ├── segmented_end_impl.hpp │ │ │ │ │ │ │ │ └── segmented_size.hpp │ │ │ │ │ │ │ ├── empty.hpp │ │ │ │ │ │ │ ├── end.hpp │ │ │ │ │ │ │ ├── front.hpp │ │ │ │ │ │ │ ├── has_key.hpp │ │ │ │ │ │ │ ├── segments.hpp │ │ │ │ │ │ │ ├── size.hpp │ │ │ │ │ │ │ ├── swap.hpp │ │ │ │ │ │ │ ├── value_at.hpp │ │ │ │ │ │ │ └── value_at_key.hpp │ │ │ │ │ │ ├── intrinsic.hpp │ │ │ │ │ │ ├── intrinsic_fwd.hpp │ │ │ │ │ │ ├── io/ │ │ │ │ │ │ │ ├── detail/ │ │ │ │ │ │ │ │ ├── in.hpp │ │ │ │ │ │ │ │ ├── manip.hpp │ │ │ │ │ │ │ │ └── out.hpp │ │ │ │ │ │ │ ├── in.hpp │ │ │ │ │ │ │ └── out.hpp │ │ │ │ │ │ ├── io.hpp │ │ │ │ │ │ └── sequence_facade.hpp │ │ │ │ │ ├── sequence.hpp │ │ │ │ │ ├── support/ │ │ │ │ │ │ ├── as_const.hpp │ │ │ │ │ │ ├── category_of.hpp │ │ │ │ │ │ ├── config.hpp │ │ │ │ │ │ ├── deduce.hpp │ │ │ │ │ │ ├── deduce_sequence.hpp │ │ │ │ │ │ ├── detail/ │ │ │ │ │ │ │ ├── access.hpp │ │ │ │ │ │ │ ├── and.hpp │ │ │ │ │ │ │ ├── as_fusion_element.hpp │ │ │ │ │ │ │ ├── category_of.hpp │ │ │ │ │ │ │ ├── enabler.hpp │ │ │ │ │ │ │ ├── index_sequence.hpp │ │ │ │ │ │ │ ├── is_mpl_sequence.hpp │ │ │ │ │ │ │ ├── is_same_size.hpp │ │ │ │ │ │ │ ├── is_view.hpp │ │ │ │ │ │ │ ├── mpl_iterator_category.hpp │ │ │ │ │ │ │ ├── pp_round.hpp │ │ │ │ │ │ │ ├── segmented_fold_until_impl.hpp │ │ │ │ │ │ │ └── unknown_key.hpp │ │ │ │ │ │ ├── is_iterator.hpp │ │ │ │ │ │ ├── is_segmented.hpp │ │ │ │ │ │ ├── is_sequence.hpp │ │ │ │ │ │ ├── is_view.hpp │ │ │ │ │ │ ├── iterator_base.hpp │ │ │ │ │ │ ├── pair.hpp │ │ │ │ │ │ ├── segmented_fold_until.hpp │ │ │ │ │ │ ├── sequence_base.hpp │ │ │ │ │ │ ├── tag_of.hpp │ │ │ │ │ │ ├── tag_of_fwd.hpp │ │ │ │ │ │ ├── unused.hpp │ │ │ │ │ │ └── void.hpp │ │ │ │ │ ├── support.hpp │ │ │ │ │ ├── tuple/ │ │ │ │ │ │ ├── detail/ │ │ │ │ │ │ │ ├── make_tuple.hpp │ │ │ │ │ │ │ ├── preprocessed/ │ │ │ │ │ │ │ │ ├── make_tuple.hpp │ │ │ │ │ │ │ │ ├── make_tuple10.hpp │ │ │ │ │ │ │ │ ├── make_tuple20.hpp │ │ │ │ │ │ │ │ ├── make_tuple30.hpp │ │ │ │ │ │ │ │ ├── make_tuple40.hpp │ │ │ │ │ │ │ │ ├── make_tuple50.hpp │ │ │ │ │ │ │ │ ├── tuple.hpp │ │ │ │ │ │ │ │ ├── tuple10.hpp │ │ │ │ │ │ │ │ ├── tuple10_fwd.hpp │ │ │ │ │ │ │ │ ├── tuple20.hpp │ │ │ │ │ │ │ │ ├── tuple20_fwd.hpp │ │ │ │ │ │ │ │ ├── tuple30.hpp │ │ │ │ │ │ │ │ ├── tuple30_fwd.hpp │ │ │ │ │ │ │ │ ├── tuple40.hpp │ │ │ │ │ │ │ │ ├── tuple40_fwd.hpp │ │ │ │ │ │ │ │ ├── tuple50.hpp │ │ │ │ │ │ │ │ ├── tuple50_fwd.hpp │ │ │ │ │ │ │ │ ├── tuple_fwd.hpp │ │ │ │ │ │ │ │ ├── tuple_tie.hpp │ │ │ │ │ │ │ │ ├── tuple_tie10.hpp │ │ │ │ │ │ │ │ ├── tuple_tie20.hpp │ │ │ │ │ │ │ │ ├── tuple_tie30.hpp │ │ │ │ │ │ │ │ ├── tuple_tie40.hpp │ │ │ │ │ │ │ │ └── tuple_tie50.hpp │ │ │ │ │ │ │ ├── tuple.hpp │ │ │ │ │ │ │ ├── tuple_expand.hpp │ │ │ │ │ │ │ ├── tuple_fwd.hpp │ │ │ │ │ │ │ └── tuple_tie.hpp │ │ │ │ │ │ ├── make_tuple.hpp │ │ │ │ │ │ ├── tuple.hpp │ │ │ │ │ │ ├── tuple_fwd.hpp │ │ │ │ │ │ └── tuple_tie.hpp │ │ │ │ │ ├── tuple.hpp │ │ │ │ │ ├── view/ │ │ │ │ │ │ ├── detail/ │ │ │ │ │ │ │ └── strictest_traversal.hpp │ │ │ │ │ │ ├── filter_view/ │ │ │ │ │ │ │ ├── detail/ │ │ │ │ │ │ │ │ ├── begin_impl.hpp │ │ │ │ │ │ │ │ ├── deref_data_impl.hpp │ │ │ │ │ │ │ │ ├── deref_impl.hpp │ │ │ │ │ │ │ │ ├── end_impl.hpp │ │ │ │ │ │ │ │ ├── equal_to_impl.hpp │ │ │ │ │ │ │ │ ├── key_of_impl.hpp │ │ │ │ │ │ │ │ ├── next_impl.hpp │ │ │ │ │ │ │ │ ├── size_impl.hpp │ │ │ │ │ │ │ │ ├── value_of_data_impl.hpp │ │ │ │ │ │ │ │ └── value_of_impl.hpp │ │ │ │ │ │ │ ├── filter_view.hpp │ │ │ │ │ │ │ └── filter_view_iterator.hpp │ │ │ │ │ │ ├── filter_view.hpp │ │ │ │ │ │ ├── flatten_view/ │ │ │ │ │ │ │ ├── flatten_view.hpp │ │ │ │ │ │ │ └── flatten_view_iterator.hpp │ │ │ │ │ │ ├── flatten_view.hpp │ │ │ │ │ │ ├── iterator_range/ │ │ │ │ │ │ │ ├── detail/ │ │ │ │ │ │ │ │ ├── at_impl.hpp │ │ │ │ │ │ │ │ ├── begin_impl.hpp │ │ │ │ │ │ │ │ ├── end_impl.hpp │ │ │ │ │ │ │ │ ├── is_segmented_impl.hpp │ │ │ │ │ │ │ │ ├── segmented_iterator_range.hpp │ │ │ │ │ │ │ │ ├── segments_impl.hpp │ │ │ │ │ │ │ │ ├── size_impl.hpp │ │ │ │ │ │ │ │ └── value_at_impl.hpp │ │ │ │ │ │ │ └── iterator_range.hpp │ │ │ │ │ │ ├── iterator_range.hpp │ │ │ │ │ │ ├── joint_view/ │ │ │ │ │ │ │ ├── detail/ │ │ │ │ │ │ │ │ ├── begin_impl.hpp │ │ │ │ │ │ │ │ ├── deref_data_impl.hpp │ │ │ │ │ │ │ │ ├── deref_impl.hpp │ │ │ │ │ │ │ │ ├── end_impl.hpp │ │ │ │ │ │ │ │ ├── key_of_impl.hpp │ │ │ │ │ │ │ │ ├── next_impl.hpp │ │ │ │ │ │ │ │ ├── value_of_data_impl.hpp │ │ │ │ │ │ │ │ └── value_of_impl.hpp │ │ │ │ │ │ │ ├── joint_view.hpp │ │ │ │ │ │ │ ├── joint_view_fwd.hpp │ │ │ │ │ │ │ └── joint_view_iterator.hpp │ │ │ │ │ │ ├── joint_view.hpp │ │ │ │ │ │ ├── nview/ │ │ │ │ │ │ │ ├── detail/ │ │ │ │ │ │ │ │ ├── advance_impl.hpp │ │ │ │ │ │ │ │ ├── at_impl.hpp │ │ │ │ │ │ │ │ ├── begin_impl.hpp │ │ │ │ │ │ │ │ ├── cpp03/ │ │ │ │ │ │ │ │ │ └── nview_impl.hpp │ │ │ │ │ │ │ │ ├── deref_impl.hpp │ │ │ │ │ │ │ │ ├── distance_impl.hpp │ │ │ │ │ │ │ │ ├── end_impl.hpp │ │ │ │ │ │ │ │ ├── equal_to_impl.hpp │ │ │ │ │ │ │ │ ├── next_impl.hpp │ │ │ │ │ │ │ │ ├── nview_impl.hpp │ │ │ │ │ │ │ │ ├── prior_impl.hpp │ │ │ │ │ │ │ │ ├── size_impl.hpp │ │ │ │ │ │ │ │ ├── value_at_impl.hpp │ │ │ │ │ │ │ │ └── value_of_impl.hpp │ │ │ │ │ │ │ ├── nview.hpp │ │ │ │ │ │ │ └── nview_iterator.hpp │ │ │ │ │ │ ├── nview.hpp │ │ │ │ │ │ ├── repetitive_view/ │ │ │ │ │ │ │ ├── detail/ │ │ │ │ │ │ │ │ ├── begin_impl.hpp │ │ │ │ │ │ │ │ ├── deref_impl.hpp │ │ │ │ │ │ │ │ ├── end_impl.hpp │ │ │ │ │ │ │ │ ├── next_impl.hpp │ │ │ │ │ │ │ │ └── value_of_impl.hpp │ │ │ │ │ │ │ ├── repetitive_view.hpp │ │ │ │ │ │ │ ├── repetitive_view_fwd.hpp │ │ │ │ │ │ │ └── repetitive_view_iterator.hpp │ │ │ │ │ │ ├── repetitive_view.hpp │ │ │ │ │ │ ├── reverse_view/ │ │ │ │ │ │ │ ├── detail/ │ │ │ │ │ │ │ │ ├── advance_impl.hpp │ │ │ │ │ │ │ │ ├── at_impl.hpp │ │ │ │ │ │ │ │ ├── begin_impl.hpp │ │ │ │ │ │ │ │ ├── deref_data_impl.hpp │ │ │ │ │ │ │ │ ├── deref_impl.hpp │ │ │ │ │ │ │ │ ├── distance_impl.hpp │ │ │ │ │ │ │ │ ├── end_impl.hpp │ │ │ │ │ │ │ │ ├── key_of_impl.hpp │ │ │ │ │ │ │ │ ├── next_impl.hpp │ │ │ │ │ │ │ │ ├── prior_impl.hpp │ │ │ │ │ │ │ │ ├── value_at_impl.hpp │ │ │ │ │ │ │ │ ├── value_of_data_impl.hpp │ │ │ │ │ │ │ │ └── value_of_impl.hpp │ │ │ │ │ │ │ ├── reverse_view.hpp │ │ │ │ │ │ │ └── reverse_view_iterator.hpp │ │ │ │ │ │ ├── reverse_view.hpp │ │ │ │ │ │ ├── single_view/ │ │ │ │ │ │ │ ├── detail/ │ │ │ │ │ │ │ │ ├── advance_impl.hpp │ │ │ │ │ │ │ │ ├── at_impl.hpp │ │ │ │ │ │ │ │ ├── begin_impl.hpp │ │ │ │ │ │ │ │ ├── deref_impl.hpp │ │ │ │ │ │ │ │ ├── distance_impl.hpp │ │ │ │ │ │ │ │ ├── end_impl.hpp │ │ │ │ │ │ │ │ ├── equal_to_impl.hpp │ │ │ │ │ │ │ │ ├── next_impl.hpp │ │ │ │ │ │ │ │ ├── prior_impl.hpp │ │ │ │ │ │ │ │ ├── size_impl.hpp │ │ │ │ │ │ │ │ ├── value_at_impl.hpp │ │ │ │ │ │ │ │ └── value_of_impl.hpp │ │ │ │ │ │ │ ├── single_view.hpp │ │ │ │ │ │ │ └── single_view_iterator.hpp │ │ │ │ │ │ ├── single_view.hpp │ │ │ │ │ │ ├── transform_view/ │ │ │ │ │ │ │ ├── detail/ │ │ │ │ │ │ │ │ ├── advance_impl.hpp │ │ │ │ │ │ │ │ ├── apply_transform_result.hpp │ │ │ │ │ │ │ │ ├── at_impl.hpp │ │ │ │ │ │ │ │ ├── begin_impl.hpp │ │ │ │ │ │ │ │ ├── deref_impl.hpp │ │ │ │ │ │ │ │ ├── distance_impl.hpp │ │ │ │ │ │ │ │ ├── end_impl.hpp │ │ │ │ │ │ │ │ ├── equal_to_impl.hpp │ │ │ │ │ │ │ │ ├── next_impl.hpp │ │ │ │ │ │ │ │ ├── prior_impl.hpp │ │ │ │ │ │ │ │ ├── value_at_impl.hpp │ │ │ │ │ │ │ │ └── value_of_impl.hpp │ │ │ │ │ │ │ ├── transform_view.hpp │ │ │ │ │ │ │ ├── transform_view_fwd.hpp │ │ │ │ │ │ │ └── transform_view_iterator.hpp │ │ │ │ │ │ ├── transform_view.hpp │ │ │ │ │ │ ├── zip_view/ │ │ │ │ │ │ │ ├── detail/ │ │ │ │ │ │ │ │ ├── advance_impl.hpp │ │ │ │ │ │ │ │ ├── at_impl.hpp │ │ │ │ │ │ │ │ ├── begin_impl.hpp │ │ │ │ │ │ │ │ ├── deref_impl.hpp │ │ │ │ │ │ │ │ ├── distance_impl.hpp │ │ │ │ │ │ │ │ ├── end_impl.hpp │ │ │ │ │ │ │ │ ├── equal_to_impl.hpp │ │ │ │ │ │ │ │ ├── next_impl.hpp │ │ │ │ │ │ │ │ ├── prior_impl.hpp │ │ │ │ │ │ │ │ ├── size_impl.hpp │ │ │ │ │ │ │ │ ├── value_at_impl.hpp │ │ │ │ │ │ │ │ └── value_of_impl.hpp │ │ │ │ │ │ │ ├── zip_view.hpp │ │ │ │ │ │ │ ├── zip_view_iterator.hpp │ │ │ │ │ │ │ └── zip_view_iterator_fwd.hpp │ │ │ │ │ │ └── zip_view.hpp │ │ │ │ │ └── view.hpp │ │ │ │ ├── generator_iterator.hpp │ │ │ │ ├── geometry/ │ │ │ │ │ ├── algorithms/ │ │ │ │ │ │ ├── append.hpp │ │ │ │ │ │ ├── area.hpp │ │ │ │ │ │ ├── assign.hpp │ │ │ │ │ │ ├── buffer.hpp │ │ │ │ │ │ ├── centroid.hpp │ │ │ │ │ │ ├── clear.hpp │ │ │ │ │ │ ├── comparable_distance.hpp │ │ │ │ │ │ ├── convert.hpp │ │ │ │ │ │ ├── convex_hull.hpp │ │ │ │ │ │ ├── correct.hpp │ │ │ │ │ │ ├── covered_by.hpp │ │ │ │ │ │ ├── crosses.hpp │ │ │ │ │ │ ├── detail/ │ │ │ │ │ │ │ ├── as_range.hpp │ │ │ │ │ │ │ ├── assign_box_corners.hpp │ │ │ │ │ │ │ ├── assign_indexed_point.hpp │ │ │ │ │ │ │ ├── assign_values.hpp │ │ │ │ │ │ │ ├── azimuth.hpp │ │ │ │ │ │ │ ├── buffer/ │ │ │ │ │ │ │ │ ├── buffer_inserter.hpp │ │ │ │ │ │ │ │ ├── buffer_policies.hpp │ │ │ │ │ │ │ │ ├── buffered_piece_collection.hpp │ │ │ │ │ │ │ │ ├── buffered_ring.hpp │ │ │ │ │ │ │ │ ├── get_piece_turns.hpp │ │ │ │ │ │ │ │ ├── line_line_intersection.hpp │ │ │ │ │ │ │ │ ├── parallel_continue.hpp │ │ │ │ │ │ │ │ ├── turn_in_original_visitor.hpp │ │ │ │ │ │ │ │ └── turn_in_piece_visitor.hpp │ │ │ │ │ │ │ ├── calculate_null.hpp │ │ │ │ │ │ │ ├── calculate_sum.hpp │ │ │ │ │ │ │ ├── centroid/ │ │ │ │ │ │ │ │ └── translating_transformer.hpp │ │ │ │ │ │ │ ├── check_iterator_range.hpp │ │ │ │ │ │ │ ├── closest_feature/ │ │ │ │ │ │ │ │ ├── geometry_to_range.hpp │ │ │ │ │ │ │ │ ├── point_to_range.hpp │ │ │ │ │ │ │ │ └── range_to_range.hpp │ │ │ │ │ │ │ ├── comparable_distance/ │ │ │ │ │ │ │ │ ├── implementation.hpp │ │ │ │ │ │ │ │ └── interface.hpp │ │ │ │ │ │ │ ├── convert_indexed_to_indexed.hpp │ │ │ │ │ │ │ ├── convert_point_to_point.hpp │ │ │ │ │ │ │ ├── counting.hpp │ │ │ │ │ │ │ ├── course.hpp │ │ │ │ │ │ │ ├── direction_code.hpp │ │ │ │ │ │ │ ├── disjoint/ │ │ │ │ │ │ │ │ ├── areal_areal.hpp │ │ │ │ │ │ │ │ ├── box_box.hpp │ │ │ │ │ │ │ │ ├── implementation.hpp │ │ │ │ │ │ │ │ ├── interface.hpp │ │ │ │ │ │ │ │ ├── linear_areal.hpp │ │ │ │ │ │ │ │ ├── linear_linear.hpp │ │ │ │ │ │ │ │ ├── linear_segment_or_box.hpp │ │ │ │ │ │ │ │ ├── multipoint_geometry.hpp │ │ │ │ │ │ │ │ ├── multirange_geometry.hpp │ │ │ │ │ │ │ │ ├── point_box.hpp │ │ │ │ │ │ │ │ ├── point_geometry.hpp │ │ │ │ │ │ │ │ ├── point_point.hpp │ │ │ │ │ │ │ │ └── segment_box.hpp │ │ │ │ │ │ │ ├── distance/ │ │ │ │ │ │ │ │ ├── backward_compatibility.hpp │ │ │ │ │ │ │ │ ├── box_to_box.hpp │ │ │ │ │ │ │ │ ├── default_strategies.hpp │ │ │ │ │ │ │ │ ├── geometry_to_segment_or_box.hpp │ │ │ │ │ │ │ │ ├── implementation.hpp │ │ │ │ │ │ │ │ ├── interface.hpp │ │ │ │ │ │ │ │ ├── is_comparable.hpp │ │ │ │ │ │ │ │ ├── iterator_selector.hpp │ │ │ │ │ │ │ │ ├── linear_or_areal_to_areal.hpp │ │ │ │ │ │ │ │ ├── linear_to_linear.hpp │ │ │ │ │ │ │ │ ├── multipoint_to_geometry.hpp │ │ │ │ │ │ │ │ ├── point_to_geometry.hpp │ │ │ │ │ │ │ │ ├── range_to_geometry_rtree.hpp │ │ │ │ │ │ │ │ ├── segment_to_box.hpp │ │ │ │ │ │ │ │ └── segment_to_segment.hpp │ │ │ │ │ │ │ ├── envelope/ │ │ │ │ │ │ │ │ ├── box.hpp │ │ │ │ │ │ │ │ ├── implementation.hpp │ │ │ │ │ │ │ │ ├── initialize.hpp │ │ │ │ │ │ │ │ ├── interface.hpp │ │ │ │ │ │ │ │ ├── intersects_antimeridian.hpp │ │ │ │ │ │ │ │ ├── linear.hpp │ │ │ │ │ │ │ │ ├── multipoint.hpp │ │ │ │ │ │ │ │ ├── point.hpp │ │ │ │ │ │ │ │ ├── range.hpp │ │ │ │ │ │ │ │ ├── range_of_boxes.hpp │ │ │ │ │ │ │ │ ├── segment.hpp │ │ │ │ │ │ │ │ └── transform_units.hpp │ │ │ │ │ │ │ ├── equals/ │ │ │ │ │ │ │ │ ├── collect_vectors.hpp │ │ │ │ │ │ │ │ └── point_point.hpp │ │ │ │ │ │ │ ├── expand/ │ │ │ │ │ │ │ │ ├── box.hpp │ │ │ │ │ │ │ │ ├── implementation.hpp │ │ │ │ │ │ │ │ ├── indexed.hpp │ │ │ │ │ │ │ │ ├── interface.hpp │ │ │ │ │ │ │ │ ├── point.hpp │ │ │ │ │ │ │ │ └── segment.hpp │ │ │ │ │ │ │ ├── expand_by_epsilon.hpp │ │ │ │ │ │ │ ├── extreme_points.hpp │ │ │ │ │ │ │ ├── for_each_range.hpp │ │ │ │ │ │ │ ├── get_left_turns.hpp │ │ │ │ │ │ │ ├── get_max_size.hpp │ │ │ │ │ │ │ ├── has_self_intersections.hpp │ │ │ │ │ │ │ ├── interior_iterator.hpp │ │ │ │ │ │ │ ├── intersection/ │ │ │ │ │ │ │ │ ├── box_box.hpp │ │ │ │ │ │ │ │ ├── implementation.hpp │ │ │ │ │ │ │ │ ├── interface.hpp │ │ │ │ │ │ │ │ └── multi.hpp │ │ │ │ │ │ │ ├── is_simple/ │ │ │ │ │ │ │ │ ├── always_simple.hpp │ │ │ │ │ │ │ │ ├── areal.hpp │ │ │ │ │ │ │ │ ├── debug_print_boundary_points.hpp │ │ │ │ │ │ │ │ ├── failure_policy.hpp │ │ │ │ │ │ │ │ ├── implementation.hpp │ │ │ │ │ │ │ │ ├── interface.hpp │ │ │ │ │ │ │ │ ├── linear.hpp │ │ │ │ │ │ │ │ └── multipoint.hpp │ │ │ │ │ │ │ ├── is_valid/ │ │ │ │ │ │ │ │ ├── box.hpp │ │ │ │ │ │ │ │ ├── complement_graph.hpp │ │ │ │ │ │ │ │ ├── debug_complement_graph.hpp │ │ │ │ │ │ │ │ ├── debug_print_turns.hpp │ │ │ │ │ │ │ │ ├── debug_validity_phase.hpp │ │ │ │ │ │ │ │ ├── has_duplicates.hpp │ │ │ │ │ │ │ │ ├── has_invalid_coordinate.hpp │ │ │ │ │ │ │ │ ├── has_spikes.hpp │ │ │ │ │ │ │ │ ├── has_valid_self_turns.hpp │ │ │ │ │ │ │ │ ├── implementation.hpp │ │ │ │ │ │ │ │ ├── interface.hpp │ │ │ │ │ │ │ │ ├── is_acceptable_turn.hpp │ │ │ │ │ │ │ │ ├── linear.hpp │ │ │ │ │ │ │ │ ├── multipolygon.hpp │ │ │ │ │ │ │ │ ├── pointlike.hpp │ │ │ │ │ │ │ │ ├── polygon.hpp │ │ │ │ │ │ │ │ ├── ring.hpp │ │ │ │ │ │ │ │ └── segment.hpp │ │ │ │ │ │ │ ├── max_interval_gap.hpp │ │ │ │ │ │ │ ├── multi_modify.hpp │ │ │ │ │ │ │ ├── multi_modify_with_predicate.hpp │ │ │ │ │ │ │ ├── multi_sum.hpp │ │ │ │ │ │ │ ├── normalize.hpp │ │ │ │ │ │ │ ├── not.hpp │ │ │ │ │ │ │ ├── num_distinct_consecutive_points.hpp │ │ │ │ │ │ │ ├── occupation_info.hpp │ │ │ │ │ │ │ ├── overlay/ │ │ │ │ │ │ │ │ ├── add_rings.hpp │ │ │ │ │ │ │ │ ├── aggregate_operations.hpp │ │ │ │ │ │ │ │ ├── append_no_duplicates.hpp │ │ │ │ │ │ │ │ ├── append_no_dups_or_spikes.hpp │ │ │ │ │ │ │ │ ├── assign_parents.hpp │ │ │ │ │ │ │ │ ├── backtrack_check_si.hpp │ │ │ │ │ │ │ │ ├── check_enrich.hpp │ │ │ │ │ │ │ │ ├── clip_linestring.hpp │ │ │ │ │ │ │ │ ├── cluster_info.hpp │ │ │ │ │ │ │ │ ├── convert_ring.hpp │ │ │ │ │ │ │ │ ├── copy_segment_point.hpp │ │ │ │ │ │ │ │ ├── copy_segments.hpp │ │ │ │ │ │ │ │ ├── debug_turn_info.hpp │ │ │ │ │ │ │ │ ├── do_reverse.hpp │ │ │ │ │ │ │ │ ├── enrich_intersection_points.hpp │ │ │ │ │ │ │ │ ├── enrichment_info.hpp │ │ │ │ │ │ │ │ ├── follow.hpp │ │ │ │ │ │ │ │ ├── follow_linear_linear.hpp │ │ │ │ │ │ │ │ ├── get_intersection_points.hpp │ │ │ │ │ │ │ │ ├── get_relative_order.hpp │ │ │ │ │ │ │ │ ├── get_ring.hpp │ │ │ │ │ │ │ │ ├── get_turn_info.hpp │ │ │ │ │ │ │ │ ├── get_turn_info_for_endpoint.hpp │ │ │ │ │ │ │ │ ├── get_turn_info_helpers.hpp │ │ │ │ │ │ │ │ ├── get_turn_info_la.hpp │ │ │ │ │ │ │ │ ├── get_turn_info_ll.hpp │ │ │ │ │ │ │ │ ├── get_turns.hpp │ │ │ │ │ │ │ │ ├── handle_colocations.hpp │ │ │ │ │ │ │ │ ├── inconsistent_turns_exception.hpp │ │ │ │ │ │ │ │ ├── intersection_box_box.hpp │ │ │ │ │ │ │ │ ├── intersection_insert.hpp │ │ │ │ │ │ │ │ ├── less_by_segment_ratio.hpp │ │ │ │ │ │ │ │ ├── linear_linear.hpp │ │ │ │ │ │ │ │ ├── overlay.hpp │ │ │ │ │ │ │ │ ├── overlay_type.hpp │ │ │ │ │ │ │ │ ├── pointlike_linear.hpp │ │ │ │ │ │ │ │ ├── pointlike_pointlike.hpp │ │ │ │ │ │ │ │ ├── ring_properties.hpp │ │ │ │ │ │ │ │ ├── segment_identifier.hpp │ │ │ │ │ │ │ │ ├── select_rings.hpp │ │ │ │ │ │ │ │ ├── self_turn_points.hpp │ │ │ │ │ │ │ │ ├── sort_by_side.hpp │ │ │ │ │ │ │ │ ├── stream_info.hpp │ │ │ │ │ │ │ │ ├── traversal.hpp │ │ │ │ │ │ │ │ ├── traversal_info.hpp │ │ │ │ │ │ │ │ ├── traversal_ring_creator.hpp │ │ │ │ │ │ │ │ ├── traversal_switch_detector.hpp │ │ │ │ │ │ │ │ ├── traverse.hpp │ │ │ │ │ │ │ │ ├── turn_info.hpp │ │ │ │ │ │ │ │ └── visit_info.hpp │ │ │ │ │ │ │ ├── partition.hpp │ │ │ │ │ │ │ ├── point_is_spike_or_equal.hpp │ │ │ │ │ │ │ ├── point_on_border.hpp │ │ │ │ │ │ │ ├── recalculate.hpp │ │ │ │ │ │ │ ├── relate/ │ │ │ │ │ │ │ │ ├── areal_areal.hpp │ │ │ │ │ │ │ │ ├── boundary_checker.hpp │ │ │ │ │ │ │ │ ├── de9im.hpp │ │ │ │ │ │ │ │ ├── follow_helpers.hpp │ │ │ │ │ │ │ │ ├── implementation.hpp │ │ │ │ │ │ │ │ ├── interface.hpp │ │ │ │ │ │ │ │ ├── less.hpp │ │ │ │ │ │ │ │ ├── linear_areal.hpp │ │ │ │ │ │ │ │ ├── linear_linear.hpp │ │ │ │ │ │ │ │ ├── point_geometry.hpp │ │ │ │ │ │ │ │ ├── point_point.hpp │ │ │ │ │ │ │ │ ├── relate_impl.hpp │ │ │ │ │ │ │ │ ├── result.hpp │ │ │ │ │ │ │ │ ├── topology_check.hpp │ │ │ │ │ │ │ │ └── turns.hpp │ │ │ │ │ │ │ ├── relation/ │ │ │ │ │ │ │ │ ├── implementation.hpp │ │ │ │ │ │ │ │ └── interface.hpp │ │ │ │ │ │ │ ├── ring_identifier.hpp │ │ │ │ │ │ │ ├── sections/ │ │ │ │ │ │ │ │ ├── range_by_section.hpp │ │ │ │ │ │ │ │ ├── section_box_policies.hpp │ │ │ │ │ │ │ │ ├── section_functions.hpp │ │ │ │ │ │ │ │ └── sectionalize.hpp │ │ │ │ │ │ │ ├── signed_size_type.hpp │ │ │ │ │ │ │ ├── single_geometry.hpp │ │ │ │ │ │ │ ├── sub_range.hpp │ │ │ │ │ │ │ ├── sweep.hpp │ │ │ │ │ │ │ ├── throw_on_empty_input.hpp │ │ │ │ │ │ │ ├── turns/ │ │ │ │ │ │ │ │ ├── compare_turns.hpp │ │ │ │ │ │ │ │ ├── debug_turn.hpp │ │ │ │ │ │ │ │ ├── filter_continue_turns.hpp │ │ │ │ │ │ │ │ ├── print_turns.hpp │ │ │ │ │ │ │ │ └── remove_duplicate_turns.hpp │ │ │ │ │ │ │ └── within/ │ │ │ │ │ │ │ ├── point_in_geometry.hpp │ │ │ │ │ │ │ └── within_no_turns.hpp │ │ │ │ │ │ ├── difference.hpp │ │ │ │ │ │ ├── disjoint.hpp │ │ │ │ │ │ ├── dispatch/ │ │ │ │ │ │ │ ├── disjoint.hpp │ │ │ │ │ │ │ ├── distance.hpp │ │ │ │ │ │ │ ├── envelope.hpp │ │ │ │ │ │ │ ├── expand.hpp │ │ │ │ │ │ │ ├── is_simple.hpp │ │ │ │ │ │ │ └── is_valid.hpp │ │ │ │ │ │ ├── distance.hpp │ │ │ │ │ │ ├── envelope.hpp │ │ │ │ │ │ ├── equals.hpp │ │ │ │ │ │ ├── expand.hpp │ │ │ │ │ │ ├── for_each.hpp │ │ │ │ │ │ ├── intersection.hpp │ │ │ │ │ │ ├── intersects.hpp │ │ │ │ │ │ ├── is_convex.hpp │ │ │ │ │ │ ├── is_empty.hpp │ │ │ │ │ │ ├── is_simple.hpp │ │ │ │ │ │ ├── is_valid.hpp │ │ │ │ │ │ ├── length.hpp │ │ │ │ │ │ ├── make.hpp │ │ │ │ │ │ ├── not_implemented.hpp │ │ │ │ │ │ ├── num_geometries.hpp │ │ │ │ │ │ ├── num_interior_rings.hpp │ │ │ │ │ │ ├── num_points.hpp │ │ │ │ │ │ ├── num_segments.hpp │ │ │ │ │ │ ├── overlaps.hpp │ │ │ │ │ │ ├── perimeter.hpp │ │ │ │ │ │ ├── point_on_surface.hpp │ │ │ │ │ │ ├── relate.hpp │ │ │ │ │ │ ├── relation.hpp │ │ │ │ │ │ ├── remove_spikes.hpp │ │ │ │ │ │ ├── reverse.hpp │ │ │ │ │ │ ├── simplify.hpp │ │ │ │ │ │ ├── sym_difference.hpp │ │ │ │ │ │ ├── touches.hpp │ │ │ │ │ │ ├── transform.hpp │ │ │ │ │ │ ├── union.hpp │ │ │ │ │ │ ├── unique.hpp │ │ │ │ │ │ ├── validity_failure_type.hpp │ │ │ │ │ │ └── within.hpp │ │ │ │ │ ├── arithmetic/ │ │ │ │ │ │ ├── arithmetic.hpp │ │ │ │ │ │ ├── cross_product.hpp │ │ │ │ │ │ ├── determinant.hpp │ │ │ │ │ │ ├── dot_product.hpp │ │ │ │ │ │ └── normalize.hpp │ │ │ │ │ ├── core/ │ │ │ │ │ │ ├── access.hpp │ │ │ │ │ │ ├── assert.hpp │ │ │ │ │ │ ├── closure.hpp │ │ │ │ │ │ ├── coordinate_dimension.hpp │ │ │ │ │ │ ├── coordinate_system.hpp │ │ │ │ │ │ ├── coordinate_type.hpp │ │ │ │ │ │ ├── cs.hpp │ │ │ │ │ │ ├── exception.hpp │ │ │ │ │ │ ├── exterior_ring.hpp │ │ │ │ │ │ ├── geometry_id.hpp │ │ │ │ │ │ ├── interior_rings.hpp │ │ │ │ │ │ ├── interior_type.hpp │ │ │ │ │ │ ├── is_areal.hpp │ │ │ │ │ │ ├── mutable_range.hpp │ │ │ │ │ │ ├── point_order.hpp │ │ │ │ │ │ ├── point_type.hpp │ │ │ │ │ │ ├── radian_access.hpp │ │ │ │ │ │ ├── radius.hpp │ │ │ │ │ │ ├── reverse_dispatch.hpp │ │ │ │ │ │ ├── ring_type.hpp │ │ │ │ │ │ ├── srs.hpp │ │ │ │ │ │ ├── tag.hpp │ │ │ │ │ │ ├── tag_cast.hpp │ │ │ │ │ │ ├── tags.hpp │ │ │ │ │ │ └── topological_dimension.hpp │ │ │ │ │ ├── formulas/ │ │ │ │ │ │ ├── andoyer_inverse.hpp │ │ │ │ │ │ ├── area_formulas.hpp │ │ │ │ │ │ ├── differential_quantities.hpp │ │ │ │ │ │ ├── eccentricity_sqr.hpp │ │ │ │ │ │ ├── flattening.hpp │ │ │ │ │ │ ├── geographic.hpp │ │ │ │ │ │ ├── gnomonic_intersection.hpp │ │ │ │ │ │ ├── gnomonic_spheroid.hpp │ │ │ │ │ │ ├── result_direct.hpp │ │ │ │ │ │ ├── result_inverse.hpp │ │ │ │ │ │ ├── sjoberg_intersection.hpp │ │ │ │ │ │ ├── spherical.hpp │ │ │ │ │ │ ├── thomas_direct.hpp │ │ │ │ │ │ ├── thomas_inverse.hpp │ │ │ │ │ │ ├── vertex_latitude.hpp │ │ │ │ │ │ ├── vincenty_direct.hpp │ │ │ │ │ │ └── vincenty_inverse.hpp │ │ │ │ │ ├── geometries/ │ │ │ │ │ │ ├── adapted/ │ │ │ │ │ │ │ ├── boost_array.hpp │ │ │ │ │ │ │ ├── boost_fusion.hpp │ │ │ │ │ │ │ ├── boost_polygon/ │ │ │ │ │ │ │ │ ├── box.hpp │ │ │ │ │ │ │ │ ├── hole_iterator.hpp │ │ │ │ │ │ │ │ ├── holes_proxy.hpp │ │ │ │ │ │ │ │ ├── point.hpp │ │ │ │ │ │ │ │ ├── polygon.hpp │ │ │ │ │ │ │ │ ├── ring.hpp │ │ │ │ │ │ │ │ └── ring_proxy.hpp │ │ │ │ │ │ │ ├── boost_polygon.hpp │ │ │ │ │ │ │ ├── boost_range/ │ │ │ │ │ │ │ │ ├── adjacent_filtered.hpp │ │ │ │ │ │ │ │ ├── filtered.hpp │ │ │ │ │ │ │ │ ├── reversed.hpp │ │ │ │ │ │ │ │ ├── sliced.hpp │ │ │ │ │ │ │ │ ├── strided.hpp │ │ │ │ │ │ │ │ └── uniqued.hpp │ │ │ │ │ │ │ ├── boost_tuple.hpp │ │ │ │ │ │ │ ├── c_array.hpp │ │ │ │ │ │ │ ├── std_array.hpp │ │ │ │ │ │ │ └── std_pair_as_segment.hpp │ │ │ │ │ │ ├── box.hpp │ │ │ │ │ │ ├── concepts/ │ │ │ │ │ │ │ ├── box_concept.hpp │ │ │ │ │ │ │ ├── check.hpp │ │ │ │ │ │ │ ├── linestring_concept.hpp │ │ │ │ │ │ │ ├── multi_linestring_concept.hpp │ │ │ │ │ │ │ ├── multi_point_concept.hpp │ │ │ │ │ │ │ ├── multi_polygon_concept.hpp │ │ │ │ │ │ │ ├── point_concept.hpp │ │ │ │ │ │ │ ├── polygon_concept.hpp │ │ │ │ │ │ │ ├── ring_concept.hpp │ │ │ │ │ │ │ └── segment_concept.hpp │ │ │ │ │ │ ├── geometries.hpp │ │ │ │ │ │ ├── helper_geometry.hpp │ │ │ │ │ │ ├── linestring.hpp │ │ │ │ │ │ ├── multi_linestring.hpp │ │ │ │ │ │ ├── multi_point.hpp │ │ │ │ │ │ ├── multi_polygon.hpp │ │ │ │ │ │ ├── point.hpp │ │ │ │ │ │ ├── point_xy.hpp │ │ │ │ │ │ ├── pointing_segment.hpp │ │ │ │ │ │ ├── polygon.hpp │ │ │ │ │ │ ├── register/ │ │ │ │ │ │ │ ├── box.hpp │ │ │ │ │ │ │ ├── linestring.hpp │ │ │ │ │ │ │ ├── multi_linestring.hpp │ │ │ │ │ │ │ ├── multi_point.hpp │ │ │ │ │ │ │ ├── multi_polygon.hpp │ │ │ │ │ │ │ ├── point.hpp │ │ │ │ │ │ │ ├── ring.hpp │ │ │ │ │ │ │ └── segment.hpp │ │ │ │ │ │ ├── ring.hpp │ │ │ │ │ │ ├── segment.hpp │ │ │ │ │ │ └── variant.hpp │ │ │ │ │ ├── geometry.hpp │ │ │ │ │ ├── index/ │ │ │ │ │ │ ├── adaptors/ │ │ │ │ │ │ │ └── query.hpp │ │ │ │ │ │ ├── detail/ │ │ │ │ │ │ │ ├── algorithms/ │ │ │ │ │ │ │ │ ├── bounds.hpp │ │ │ │ │ │ │ │ ├── comparable_distance_centroid.hpp │ │ │ │ │ │ │ │ ├── comparable_distance_far.hpp │ │ │ │ │ │ │ │ ├── comparable_distance_near.hpp │ │ │ │ │ │ │ │ ├── content.hpp │ │ │ │ │ │ │ │ ├── diff_abs.hpp │ │ │ │ │ │ │ │ ├── intersection_content.hpp │ │ │ │ │ │ │ │ ├── is_valid.hpp │ │ │ │ │ │ │ │ ├── margin.hpp │ │ │ │ │ │ │ │ ├── minmaxdist.hpp │ │ │ │ │ │ │ │ ├── nth_element.hpp │ │ │ │ │ │ │ │ ├── path_intersection.hpp │ │ │ │ │ │ │ │ ├── segment_intersection.hpp │ │ │ │ │ │ │ │ ├── smallest_for_indexable.hpp │ │ │ │ │ │ │ │ ├── sum_for_indexable.hpp │ │ │ │ │ │ │ │ └── union_content.hpp │ │ │ │ │ │ │ ├── assert.hpp │ │ │ │ │ │ │ ├── bounded_view.hpp │ │ │ │ │ │ │ ├── config_begin.hpp │ │ │ │ │ │ │ ├── config_end.hpp │ │ │ │ │ │ │ ├── distance_predicates.hpp │ │ │ │ │ │ │ ├── exception.hpp │ │ │ │ │ │ │ ├── is_bounding_geometry.hpp │ │ │ │ │ │ │ ├── is_indexable.hpp │ │ │ │ │ │ │ ├── meta.hpp │ │ │ │ │ │ │ ├── predicates.hpp │ │ │ │ │ │ │ ├── rtree/ │ │ │ │ │ │ │ │ ├── adaptors.hpp │ │ │ │ │ │ │ │ ├── iterators.hpp │ │ │ │ │ │ │ │ ├── kmeans/ │ │ │ │ │ │ │ │ │ ├── kmeans.hpp │ │ │ │ │ │ │ │ │ └── split.hpp │ │ │ │ │ │ │ │ ├── linear/ │ │ │ │ │ │ │ │ │ ├── linear.hpp │ │ │ │ │ │ │ │ │ └── redistribute_elements.hpp │ │ │ │ │ │ │ │ ├── node/ │ │ │ │ │ │ │ │ │ ├── concept.hpp │ │ │ │ │ │ │ │ │ ├── node.hpp │ │ │ │ │ │ │ │ │ ├── node_elements.hpp │ │ │ │ │ │ │ │ │ ├── pairs.hpp │ │ │ │ │ │ │ │ │ ├── scoped_deallocator.hpp │ │ │ │ │ │ │ │ │ ├── subtree_destroyer.hpp │ │ │ │ │ │ │ │ │ ├── variant_dynamic.hpp │ │ │ │ │ │ │ │ │ ├── variant_static.hpp │ │ │ │ │ │ │ │ │ ├── variant_visitor.hpp │ │ │ │ │ │ │ │ │ ├── weak_dynamic.hpp │ │ │ │ │ │ │ │ │ ├── weak_static.hpp │ │ │ │ │ │ │ │ │ └── weak_visitor.hpp │ │ │ │ │ │ │ │ ├── options.hpp │ │ │ │ │ │ │ │ ├── pack_create.hpp │ │ │ │ │ │ │ │ ├── quadratic/ │ │ │ │ │ │ │ │ │ ├── quadratic.hpp │ │ │ │ │ │ │ │ │ └── redistribute_elements.hpp │ │ │ │ │ │ │ │ ├── query_iterators.hpp │ │ │ │ │ │ │ │ ├── rstar/ │ │ │ │ │ │ │ │ │ ├── choose_next_node.hpp │ │ │ │ │ │ │ │ │ ├── insert.hpp │ │ │ │ │ │ │ │ │ ├── redistribute_elements.hpp │ │ │ │ │ │ │ │ │ └── rstar.hpp │ │ │ │ │ │ │ │ ├── utilities/ │ │ │ │ │ │ │ │ │ ├── are_boxes_ok.hpp │ │ │ │ │ │ │ │ │ ├── are_counts_ok.hpp │ │ │ │ │ │ │ │ │ ├── are_levels_ok.hpp │ │ │ │ │ │ │ │ │ ├── gl_draw.hpp │ │ │ │ │ │ │ │ │ ├── print.hpp │ │ │ │ │ │ │ │ │ ├── statistics.hpp │ │ │ │ │ │ │ │ │ └── view.hpp │ │ │ │ │ │ │ │ └── visitors/ │ │ │ │ │ │ │ │ ├── children_box.hpp │ │ │ │ │ │ │ │ ├── copy.hpp │ │ │ │ │ │ │ │ ├── count.hpp │ │ │ │ │ │ │ │ ├── destroy.hpp │ │ │ │ │ │ │ │ ├── distance_query.hpp │ │ │ │ │ │ │ │ ├── insert.hpp │ │ │ │ │ │ │ │ ├── is_leaf.hpp │ │ │ │ │ │ │ │ ├── iterator.hpp │ │ │ │ │ │ │ │ ├── remove.hpp │ │ │ │ │ │ │ │ └── spatial_query.hpp │ │ │ │ │ │ │ ├── serialization.hpp │ │ │ │ │ │ │ ├── tags.hpp │ │ │ │ │ │ │ ├── translator.hpp │ │ │ │ │ │ │ ├── tuples.hpp │ │ │ │ │ │ │ ├── utilities.hpp │ │ │ │ │ │ │ ├── varray.hpp │ │ │ │ │ │ │ └── varray_detail.hpp │ │ │ │ │ │ ├── distance_predicates.hpp │ │ │ │ │ │ ├── equal_to.hpp │ │ │ │ │ │ ├── indexable.hpp │ │ │ │ │ │ ├── inserter.hpp │ │ │ │ │ │ ├── parameters.hpp │ │ │ │ │ │ ├── predicates.hpp │ │ │ │ │ │ └── rtree.hpp │ │ │ │ │ ├── io/ │ │ │ │ │ │ ├── dsv/ │ │ │ │ │ │ │ └── write.hpp │ │ │ │ │ │ ├── io.hpp │ │ │ │ │ │ ├── svg/ │ │ │ │ │ │ │ ├── svg_mapper.hpp │ │ │ │ │ │ │ ├── write.hpp │ │ │ │ │ │ │ ├── write_svg.hpp │ │ │ │ │ │ │ └── write_svg_multi.hpp │ │ │ │ │ │ └── wkt/ │ │ │ │ │ │ ├── detail/ │ │ │ │ │ │ │ ├── prefix.hpp │ │ │ │ │ │ │ └── wkt_multi.hpp │ │ │ │ │ │ ├── read.hpp │ │ │ │ │ │ ├── stream.hpp │ │ │ │ │ │ ├── wkt.hpp │ │ │ │ │ │ └── write.hpp │ │ │ │ │ ├── iterators/ │ │ │ │ │ │ ├── base.hpp │ │ │ │ │ │ ├── closing_iterator.hpp │ │ │ │ │ │ ├── concatenate_iterator.hpp │ │ │ │ │ │ ├── detail/ │ │ │ │ │ │ │ ├── point_iterator/ │ │ │ │ │ │ │ │ ├── inner_range_type.hpp │ │ │ │ │ │ │ │ ├── iterator_type.hpp │ │ │ │ │ │ │ │ └── value_type.hpp │ │ │ │ │ │ │ └── segment_iterator/ │ │ │ │ │ │ │ ├── iterator_type.hpp │ │ │ │ │ │ │ ├── range_segment_iterator.hpp │ │ │ │ │ │ │ └── value_type.hpp │ │ │ │ │ │ ├── dispatch/ │ │ │ │ │ │ │ ├── point_iterator.hpp │ │ │ │ │ │ │ └── segment_iterator.hpp │ │ │ │ │ │ ├── ever_circling_iterator.hpp │ │ │ │ │ │ ├── flatten_iterator.hpp │ │ │ │ │ │ ├── has_one_element.hpp │ │ │ │ │ │ ├── point_iterator.hpp │ │ │ │ │ │ ├── point_reverse_iterator.hpp │ │ │ │ │ │ └── segment_iterator.hpp │ │ │ │ │ ├── multi/ │ │ │ │ │ │ ├── algorithms/ │ │ │ │ │ │ │ ├── append.hpp │ │ │ │ │ │ │ ├── area.hpp │ │ │ │ │ │ │ ├── centroid.hpp │ │ │ │ │ │ │ ├── clear.hpp │ │ │ │ │ │ │ ├── convert.hpp │ │ │ │ │ │ │ ├── correct.hpp │ │ │ │ │ │ │ ├── covered_by.hpp │ │ │ │ │ │ │ ├── detail/ │ │ │ │ │ │ │ │ ├── extreme_points.hpp │ │ │ │ │ │ │ │ ├── for_each_range.hpp │ │ │ │ │ │ │ │ ├── modify.hpp │ │ │ │ │ │ │ │ ├── modify_with_predicate.hpp │ │ │ │ │ │ │ │ ├── multi_sum.hpp │ │ │ │ │ │ │ │ ├── overlay/ │ │ │ │ │ │ │ │ │ ├── copy_segment_point.hpp │ │ │ │ │ │ │ │ │ ├── copy_segments.hpp │ │ │ │ │ │ │ │ │ ├── get_ring.hpp │ │ │ │ │ │ │ │ │ ├── get_turns.hpp │ │ │ │ │ │ │ │ │ └── self_turn_points.hpp │ │ │ │ │ │ │ │ ├── point_on_border.hpp │ │ │ │ │ │ │ │ └── sections/ │ │ │ │ │ │ │ │ ├── range_by_section.hpp │ │ │ │ │ │ │ │ └── sectionalize.hpp │ │ │ │ │ │ │ ├── disjoint.hpp │ │ │ │ │ │ │ ├── distance.hpp │ │ │ │ │ │ │ ├── envelope.hpp │ │ │ │ │ │ │ ├── equals.hpp │ │ │ │ │ │ │ ├── for_each.hpp │ │ │ │ │ │ │ ├── intersection.hpp │ │ │ │ │ │ │ ├── length.hpp │ │ │ │ │ │ │ ├── num_geometries.hpp │ │ │ │ │ │ │ ├── num_interior_rings.hpp │ │ │ │ │ │ │ ├── num_points.hpp │ │ │ │ │ │ │ ├── perimeter.hpp │ │ │ │ │ │ │ ├── remove_spikes.hpp │ │ │ │ │ │ │ ├── reverse.hpp │ │ │ │ │ │ │ ├── simplify.hpp │ │ │ │ │ │ │ ├── transform.hpp │ │ │ │ │ │ │ ├── unique.hpp │ │ │ │ │ │ │ └── within.hpp │ │ │ │ │ │ ├── core/ │ │ │ │ │ │ │ ├── closure.hpp │ │ │ │ │ │ │ ├── geometry_id.hpp │ │ │ │ │ │ │ ├── interior_rings.hpp │ │ │ │ │ │ │ ├── is_areal.hpp │ │ │ │ │ │ │ ├── point_order.hpp │ │ │ │ │ │ │ ├── point_type.hpp │ │ │ │ │ │ │ ├── ring_type.hpp │ │ │ │ │ │ │ ├── tags.hpp │ │ │ │ │ │ │ └── topological_dimension.hpp │ │ │ │ │ │ ├── geometries/ │ │ │ │ │ │ │ ├── concepts/ │ │ │ │ │ │ │ │ ├── check.hpp │ │ │ │ │ │ │ │ ├── multi_linestring_concept.hpp │ │ │ │ │ │ │ │ ├── multi_point_concept.hpp │ │ │ │ │ │ │ │ └── multi_polygon_concept.hpp │ │ │ │ │ │ │ ├── multi_geometries.hpp │ │ │ │ │ │ │ ├── multi_linestring.hpp │ │ │ │ │ │ │ ├── multi_point.hpp │ │ │ │ │ │ │ ├── multi_polygon.hpp │ │ │ │ │ │ │ └── register/ │ │ │ │ │ │ │ ├── multi_linestring.hpp │ │ │ │ │ │ │ ├── multi_point.hpp │ │ │ │ │ │ │ └── multi_polygon.hpp │ │ │ │ │ │ ├── io/ │ │ │ │ │ │ │ ├── dsv/ │ │ │ │ │ │ │ │ └── write.hpp │ │ │ │ │ │ │ └── wkt/ │ │ │ │ │ │ │ ├── detail/ │ │ │ │ │ │ │ │ └── prefix.hpp │ │ │ │ │ │ │ ├── read.hpp │ │ │ │ │ │ │ ├── wkt.hpp │ │ │ │ │ │ │ └── write.hpp │ │ │ │ │ │ ├── multi.hpp │ │ │ │ │ │ ├── strategies/ │ │ │ │ │ │ │ └── cartesian/ │ │ │ │ │ │ │ └── centroid_average.hpp │ │ │ │ │ │ └── views/ │ │ │ │ │ │ └── detail/ │ │ │ │ │ │ └── range_type.hpp │ │ │ │ │ ├── policies/ │ │ │ │ │ │ ├── compare.hpp │ │ │ │ │ │ ├── disjoint_interrupt_policy.hpp │ │ │ │ │ │ ├── is_valid/ │ │ │ │ │ │ │ ├── default_policy.hpp │ │ │ │ │ │ │ ├── failing_reason_policy.hpp │ │ │ │ │ │ │ └── failure_type_policy.hpp │ │ │ │ │ │ ├── predicate_based_interrupt_policy.hpp │ │ │ │ │ │ ├── relate/ │ │ │ │ │ │ │ ├── direction.hpp │ │ │ │ │ │ │ ├── intersection_points.hpp │ │ │ │ │ │ │ ├── intersection_ratios.hpp │ │ │ │ │ │ │ └── tupled.hpp │ │ │ │ │ │ └── robustness/ │ │ │ │ │ │ ├── get_rescale_policy.hpp │ │ │ │ │ │ ├── no_rescale_policy.hpp │ │ │ │ │ │ ├── rescale_policy.hpp │ │ │ │ │ │ ├── robust_point_type.hpp │ │ │ │ │ │ ├── robust_type.hpp │ │ │ │ │ │ ├── segment_ratio.hpp │ │ │ │ │ │ └── segment_ratio_type.hpp │ │ │ │ │ ├── strategies/ │ │ │ │ │ │ ├── agnostic/ │ │ │ │ │ │ │ ├── buffer_distance_asymmetric.hpp │ │ │ │ │ │ │ ├── buffer_distance_symmetric.hpp │ │ │ │ │ │ │ ├── hull_graham_andrew.hpp │ │ │ │ │ │ │ ├── point_in_box_by_side.hpp │ │ │ │ │ │ │ ├── point_in_point.hpp │ │ │ │ │ │ │ ├── point_in_poly_oriented_winding.hpp │ │ │ │ │ │ │ ├── point_in_poly_winding.hpp │ │ │ │ │ │ │ └── simplify_douglas_peucker.hpp │ │ │ │ │ │ ├── area.hpp │ │ │ │ │ │ ├── azimuth.hpp │ │ │ │ │ │ ├── buffer.hpp │ │ │ │ │ │ ├── cartesian/ │ │ │ │ │ │ │ ├── area_surveyor.hpp │ │ │ │ │ │ │ ├── azimuth.hpp │ │ │ │ │ │ │ ├── box_in_box.hpp │ │ │ │ │ │ │ ├── buffer_end_flat.hpp │ │ │ │ │ │ │ ├── buffer_end_round.hpp │ │ │ │ │ │ │ ├── buffer_join_miter.hpp │ │ │ │ │ │ │ ├── buffer_join_round.hpp │ │ │ │ │ │ │ ├── buffer_join_round_by_divide.hpp │ │ │ │ │ │ │ ├── buffer_point_circle.hpp │ │ │ │ │ │ │ ├── buffer_point_square.hpp │ │ │ │ │ │ │ ├── buffer_side_straight.hpp │ │ │ │ │ │ │ ├── centroid_average.hpp │ │ │ │ │ │ │ ├── centroid_bashein_detmer.hpp │ │ │ │ │ │ │ ├── centroid_weighted_length.hpp │ │ │ │ │ │ │ ├── disjoint_segment_box.hpp │ │ │ │ │ │ │ ├── distance_projected_point.hpp │ │ │ │ │ │ │ ├── distance_projected_point_ax.hpp │ │ │ │ │ │ │ ├── distance_pythagoras.hpp │ │ │ │ │ │ │ ├── distance_pythagoras_box_box.hpp │ │ │ │ │ │ │ ├── distance_pythagoras_point_box.hpp │ │ │ │ │ │ │ ├── envelope_segment.hpp │ │ │ │ │ │ │ ├── intersection.hpp │ │ │ │ │ │ │ ├── point_in_box.hpp │ │ │ │ │ │ │ ├── point_in_poly_crossings_multiply.hpp │ │ │ │ │ │ │ ├── point_in_poly_franklin.hpp │ │ │ │ │ │ │ ├── side_by_triangle.hpp │ │ │ │ │ │ │ └── side_of_intersection.hpp │ │ │ │ │ │ ├── centroid.hpp │ │ │ │ │ │ ├── comparable_distance_result.hpp │ │ │ │ │ │ ├── compare.hpp │ │ │ │ │ │ ├── concepts/ │ │ │ │ │ │ │ ├── area_concept.hpp │ │ │ │ │ │ │ ├── centroid_concept.hpp │ │ │ │ │ │ │ ├── convex_hull_concept.hpp │ │ │ │ │ │ │ ├── distance_concept.hpp │ │ │ │ │ │ │ ├── segment_intersect_concept.hpp │ │ │ │ │ │ │ ├── simplify_concept.hpp │ │ │ │ │ │ │ └── within_concept.hpp │ │ │ │ │ │ ├── convex_hull.hpp │ │ │ │ │ │ ├── covered_by.hpp │ │ │ │ │ │ ├── default_area_result.hpp │ │ │ │ │ │ ├── default_comparable_distance_result.hpp │ │ │ │ │ │ ├── default_distance_result.hpp │ │ │ │ │ │ ├── default_length_result.hpp │ │ │ │ │ │ ├── default_strategy.hpp │ │ │ │ │ │ ├── disjoint.hpp │ │ │ │ │ │ ├── distance.hpp │ │ │ │ │ │ ├── distance_result.hpp │ │ │ │ │ │ ├── envelope.hpp │ │ │ │ │ │ ├── geographic/ │ │ │ │ │ │ │ ├── area.hpp │ │ │ │ │ │ │ ├── azimuth.hpp │ │ │ │ │ │ │ ├── distance.hpp │ │ │ │ │ │ │ ├── distance_andoyer.hpp │ │ │ │ │ │ │ ├── distance_thomas.hpp │ │ │ │ │ │ │ ├── distance_vincenty.hpp │ │ │ │ │ │ │ ├── envelope_segment.hpp │ │ │ │ │ │ │ ├── intersection.hpp │ │ │ │ │ │ │ ├── intersection_elliptic.hpp │ │ │ │ │ │ │ ├── mapping_ssf.hpp │ │ │ │ │ │ │ ├── parameters.hpp │ │ │ │ │ │ │ ├── side.hpp │ │ │ │ │ │ │ ├── side_andoyer.hpp │ │ │ │ │ │ │ ├── side_thomas.hpp │ │ │ │ │ │ │ └── side_vincenty.hpp │ │ │ │ │ │ ├── intersection.hpp │ │ │ │ │ │ ├── intersection_result.hpp │ │ │ │ │ │ ├── intersection_strategies.hpp │ │ │ │ │ │ ├── relate.hpp │ │ │ │ │ │ ├── side.hpp │ │ │ │ │ │ ├── side_info.hpp │ │ │ │ │ │ ├── spherical/ │ │ │ │ │ │ │ ├── area.hpp │ │ │ │ │ │ │ ├── azimuth.hpp │ │ │ │ │ │ │ ├── compare_circular.hpp │ │ │ │ │ │ │ ├── distance_cross_track.hpp │ │ │ │ │ │ │ ├── distance_cross_track_point_box.hpp │ │ │ │ │ │ │ ├── distance_haversine.hpp │ │ │ │ │ │ │ ├── envelope_segment.hpp │ │ │ │ │ │ │ ├── intersection.hpp │ │ │ │ │ │ │ ├── side_by_cross_track.hpp │ │ │ │ │ │ │ └── ssf.hpp │ │ │ │ │ │ ├── strategies.hpp │ │ │ │ │ │ ├── strategy_transform.hpp │ │ │ │ │ │ ├── tags.hpp │ │ │ │ │ │ ├── transform/ │ │ │ │ │ │ │ ├── inverse_transformer.hpp │ │ │ │ │ │ │ ├── map_transformer.hpp │ │ │ │ │ │ │ └── matrix_transformers.hpp │ │ │ │ │ │ ├── transform.hpp │ │ │ │ │ │ └── within.hpp │ │ │ │ │ ├── util/ │ │ │ │ │ │ ├── add_const_if_c.hpp │ │ │ │ │ │ ├── bare_type.hpp │ │ │ │ │ │ ├── calculation_type.hpp │ │ │ │ │ │ ├── closure_as_bool.hpp │ │ │ │ │ │ ├── combine_if.hpp │ │ │ │ │ │ ├── compress_variant.hpp │ │ │ │ │ │ ├── condition.hpp │ │ │ │ │ │ ├── coordinate_cast.hpp │ │ │ │ │ │ ├── for_each_coordinate.hpp │ │ │ │ │ │ ├── has_infinite_coordinate.hpp │ │ │ │ │ │ ├── has_nan_coordinate.hpp │ │ │ │ │ │ ├── has_non_finite_coordinate.hpp │ │ │ │ │ │ ├── math.hpp │ │ │ │ │ │ ├── normalize_spheroidal_box_coordinates.hpp │ │ │ │ │ │ ├── normalize_spheroidal_coordinates.hpp │ │ │ │ │ │ ├── order_as_direction.hpp │ │ │ │ │ │ ├── parameter_type_of.hpp │ │ │ │ │ │ ├── promote_floating_point.hpp │ │ │ │ │ │ ├── promote_integral.hpp │ │ │ │ │ │ ├── range.hpp │ │ │ │ │ │ ├── rational.hpp │ │ │ │ │ │ ├── readme.txt │ │ │ │ │ │ ├── select_calculation_type.hpp │ │ │ │ │ │ ├── select_coordinate_type.hpp │ │ │ │ │ │ ├── select_most_precise.hpp │ │ │ │ │ │ └── transform_variant.hpp │ │ │ │ │ └── views/ │ │ │ │ │ ├── box_view.hpp │ │ │ │ │ ├── closeable_view.hpp │ │ │ │ │ ├── detail/ │ │ │ │ │ │ ├── boundary_view/ │ │ │ │ │ │ │ ├── implementation.hpp │ │ │ │ │ │ │ └── interface.hpp │ │ │ │ │ │ ├── boundary_view.hpp │ │ │ │ │ │ ├── indexed_point_view.hpp │ │ │ │ │ │ ├── normalized_view.hpp │ │ │ │ │ │ ├── points_view.hpp │ │ │ │ │ │ ├── range_type.hpp │ │ │ │ │ │ └── two_dimensional_view.hpp │ │ │ │ │ ├── identity_view.hpp │ │ │ │ │ ├── reversible_view.hpp │ │ │ │ │ └── segment_view.hpp │ │ │ │ ├── geometry.hpp │ │ │ │ ├── get_pointer.hpp │ │ │ │ ├── gil/ │ │ │ │ │ ├── algorithm.hpp │ │ │ │ │ ├── bit_aligned_pixel_iterator.hpp │ │ │ │ │ ├── bit_aligned_pixel_reference.hpp │ │ │ │ │ ├── channel.hpp │ │ │ │ │ ├── channel_algorithm.hpp │ │ │ │ │ ├── cmyk.hpp │ │ │ │ │ ├── color_base.hpp │ │ │ │ │ ├── color_base_algorithm.hpp │ │ │ │ │ ├── color_convert.hpp │ │ │ │ │ ├── deprecated.hpp │ │ │ │ │ ├── device_n.hpp │ │ │ │ │ ├── extension/ │ │ │ │ │ │ ├── dynamic_image/ │ │ │ │ │ │ │ ├── algorithm.hpp │ │ │ │ │ │ │ ├── any_image.hpp │ │ │ │ │ │ │ ├── any_image_view.hpp │ │ │ │ │ │ │ ├── apply_operation.hpp │ │ │ │ │ │ │ ├── apply_operation_base.hpp │ │ │ │ │ │ │ ├── dynamic_at_c.hpp │ │ │ │ │ │ │ ├── dynamic_image_all.hpp │ │ │ │ │ │ │ ├── image_view_factory.hpp │ │ │ │ │ │ │ ├── reduce.hpp │ │ │ │ │ │ │ └── va
Copy disabled (too large)
Download .txt
Showing preview only (122,927K chars total). Download the full file to get everything.
SYMBOL INDEX (167594 symbols across 9007 files)
FILE: bindings/py/dummy.c
function main (line 3) | int main()
function initdummy (line 8) | void initdummy() {}
FILE: bindings/py/setup.py
function getVersion (line 32) | def getVersion():
class CleanCommand (line 41) | class CleanCommand(Command):
method initialize_options (line 48) | def initialize_options(self):
method finalize_options (line 52) | def finalize_options(self):
method run (line 56) | def run(self):
function fixPath (line 67) | def fixPath(path):
function findRequirements (line 79) | def findRequirements(platform):
class TestCommand (line 94) | class TestCommand(BaseTestCommand):
method initialize_options (line 98) | def initialize_options(self):
method finalize_options (line 103) | def finalize_options(self):
method run_tests (line 109) | def run_tests(self):
function getPlatformInfo (line 121) | def getPlatformInfo():
function getExtensionFileNames (line 136) | def getExtensionFileNames(platform):
function getExtensionFiles (line 150) | def getExtensionFiles(platform):
function generateExtensions (line 161) | def generateExtensions():
FILE: bindings/py/src/nupic/bindings/regions/PyRegion.py
class DictReadOnlyWrapper (line 20) | class DictReadOnlyWrapper(collections.Mapping):
method __init__ (line 26) | def __init__(self, d):
method __iter__ (line 29) | def __iter__(self):
method __len__ (line 32) | def __len__(self):
method __getitem__ (line 35) | def __getitem__(self, key):
class PyRegion (line 38) | class PyRegion(object):
method getSpec (line 93) | def getSpec(cls):
method __init__ (line 139) | def __init__(self, *args, **kwars):
method initialize (line 147) | def initialize(self):
method compute (line 158) | def compute(self, inputs, outputs):
method guardedCompute (line 168) | def guardedCompute(self, inputs, outputs):
method getOutputElementCount (line 177) | def getOutputElementCount(self, name):
method getParameter (line 189) | def getParameter(self, name, index):
method getParameterArrayCount (line 213) | def getParameterArrayCount(self, name, index):
method getParameterArray (line 234) | def getParameterArray(self, name, index, array):
method setParameter (line 267) | def setParameter(self, name, index, value):
method setParameterArray (line 282) | def setParameterArray(self, name, index, array):
method serializeExtraData (line 297) | def serializeExtraData(self, filePath):
method deSerializeExtraData (line 306) | def deSerializeExtraData(self, filePath):
method getSchema (line 316) | def getSchema():
method write (line 328) | def write(self, proto):
method read (line 341) | def read(cls, proto):
method writeToProto (line 353) | def writeToProto(self, proto):
method readFromProto (line 365) | def readFromProto(cls, proto):
method executeMethod (line 376) | def executeMethod(self, methodName, args):
method setSparseOutput (line 399) | def setSparseOutput(outputs, name, value):
FILE: bindings/py/src/nupic/bindings/regions/TestNode.py
class TestNode (line 22) | class TestNode(PyRegion):
method getSpec (line 26) | def getSpec(cls):
method __init__ (line 165) | def __init__(self, *args, **kwargs):
method getParameter (line 203) | def getParameter(self, name, index):
method setParameter (line 208) | def setParameter(self, name, index, value):
method initialize (line 213) | def initialize(self):
method compute (line 217) | def compute(self, inputs, outputs):
method getOutputElementCount (line 222) | def getOutputElementCount(self, name):
method getParameterArrayCount (line 227) | def getParameterArrayCount(self, name, index):
method getParameterArray (line 233) | def getParameterArray(self, name, index, array):
method setParameterArray (line 242) | def setParameterArray(self, name, index, array):
method getSchema (line 249) | def getSchema():
method writeArray (line 253) | def writeArray(self, regionImpl, name, dtype, castFn):
method write (line 262) | def write(self, proto):
method readArray (line 280) | def readArray(self, regionImpl, name, dtype):
method read (line 290) | def read(cls, proto):
FILE: bindings/py/src/nupic/bindings/tools/cyclical_serialization_perf.py
function _runTest (line 45) | def _runTest():
function main (line 101) | def main():
FILE: bindings/py/src/nupic/bindings/tools/random_serialization_perf.py
function main (line 42) | def main():
FILE: bindings/py/src/nupic/bindings/tools/serialization_test_py_region.py
class SerializationTestPyRegion (line 31) | class SerializationTestPyRegion(PyRegion):
method __init__ (line 38) | def __init__(self, dataWidth, randomSeed):
method dataWidth (line 51) | def dataWidth(self):
method randomSeed (line 56) | def randomSeed(self):
method getSchema (line 61) | def getSchema():
method writeToProto (line 70) | def writeToProto(self, proto):
method readFromProto (line 80) | def readFromProto(cls, proto):
method initialize (line 95) | def initialize(self, dims=None, splitterMaps=None):
method compute (line 99) | def compute(self, inputs, outputs):
method getSpec (line 107) | def getSpec(cls):
method getOutputElementCount (line 152) | def getOutputElementCount(self, name):
FILE: bindings/py/tests/algorithms/cells4_test.py
function createCells4 (line 23) | def createCells4(nCols=8,
class Cells4Test (line 71) | class Cells4Test(unittest.TestCase):
method _cellsDiff (line 75) | def _cellsDiff(cell1, cell2):
method _testPersistence (line 117) | def _testPersistence(self, cells):
method testLearn (line 168) | def testLearn(self):
method testEquals (line 243) | def testEquals(self):
FILE: bindings/py/tests/algorithms/svm_test.py
class SVMTest (line 29) | class SVMTest(unittest.TestCase):
method testGetstateSetstate (line 33) | def testGetstateSetstate(self):
method testPersistentSize (line 78) | def testPersistentSize(self):
method testScalability (line 118) | def testScalability(self):
FILE: bindings/py/tests/array_algorithms_test.py
class TestArrayAlgos (line 21) | class TestArrayAlgos(unittest.TestCase):
method setUp (line 24) | def setUp(self):
method testNearlyZeroRange1 (line 28) | def testNearlyZeroRange1(self):
method testNearlyZeroRange2 (line 32) | def testNearlyZeroRange2(self):
method testNearlyZeroRange3 (line 36) | def testNearlyZeroRange3(self):
FILE: bindings/py/tests/cast_mode_test.py
class TestCastMode (line 22) | class TestCastMode(unittest.TestCase):
method testCastMode (line 27) | def testCastMode(self):
FILE: bindings/py/tests/check_test.py
class LoadBindingsTest (line 15) | class LoadBindingsTest(unittest.TestCase):
method testImportBindingsInstalled (line 18) | def testImportBindingsInstalled(self):
method testImportBindingsExtensions (line 23) | def testImportBindingsExtensions(self):
FILE: bindings/py/tests/connections_test.py
class ConnectionsTest (line 18) | class ConnectionsTest(unittest.TestCase):
method test_computeActivity (line 20) | def test_computeActivity(self):
method test_computeActivity_thresholded (line 49) | def test_computeActivity_thresholded(self):
method test_adjustSynapses (line 78) | def test_adjustSynapses(self):
method test_adjustActiveSynapses (line 122) | def test_adjustActiveSynapses(self):
method test_adjustInactiveSynapses (line 166) | def test_adjustInactiveSynapses(self):
method test_whenPermanenceFallsBelowZero (line 210) | def test_whenPermanenceFallsBelowZero(self):
method test_growSynapses (line 236) | def test_growSynapses(self):
method test_growSynapsesToSample_single (line 270) | def test_growSynapsesToSample_single(self):
method test_growSynapsesToSample_multi (line 357) | def test_growSynapsesToSample_multi(self):
method test_clipPermanences (line 448) | def test_clipPermanences(self):
method test_mapSegmentsToSynapseCounts (line 473) | def test_mapSegmentsToSynapseCounts(self):
FILE: bindings/py/tests/network_test.py
class TestLinks (line 30) | class TestLinks(PyRegion):
method __init__ (line 34) | def __init__(self): pass
method initialize (line 35) | def initialize(self): pass
method compute (line 36) | def compute(self): pass
method getOutputElementCount (line 37) | def getOutputElementCount(self): pass
method getSpec (line 39) | def getSpec(cls):
class NetworkTest (line 78) | class NetworkTest(unittest.TestCase):
method setUp (line 80) | def setUp(self):
method testCapnpSerializationWithPyRegion (line 87) | def testCapnpSerializationWithPyRegion(self):
method testSimpleTwoRegionNetworkIntrospection (line 120) | def testSimpleTwoRegionNetworkIntrospection(self):
method testNetworkLinkTypeValidation (line 151) | def testNetworkLinkTypeValidation(self):
method testParameters (line 169) | def testParameters(self):
FILE: bindings/py/tests/nupic_random_test.py
class TestNupicRandom (line 32) | class TestNupicRandom(unittest.TestCase):
method testCapnpSerialization (line 37) | def testCapnpSerialization(self):
method testNupicRandomPickling (line 80) | def testNupicRandomPickling(self):
method testSample (line 112) | def testSample(self):
method testSampleNone (line 123) | def testSampleNone(self):
method testSampleAll (line 134) | def testSampleAll(self):
method testSampleWrongDimensionsPopulation (line 147) | def testSampleWrongDimensionsPopulation(self):
method testSampleWrongDimensionsChoices (line 156) | def testSampleWrongDimensionsChoices(self):
method testSampleSequenceRaisesTypeError (line 165) | def testSampleSequenceRaisesTypeError(self):
method testSampleBadDtype (line 177) | def testSampleBadDtype(self):
method testSampleDifferentDtypes (line 185) | def testSampleDifferentDtypes(self):
method testSamplePopulationTooSmall (line 193) | def testSamplePopulationTooSmall(self):
method testShuffle (line 202) | def testShuffle(self):
method testShuffleEmpty (line 214) | def testShuffleEmpty(self):
method testShuffleEmpty (line 223) | def testShuffleEmpty(self):
method testShuffleBadDtype (line 230) | def testShuffleBadDtype(self):
method testEquals (line 237) | def testEquals(self):
FILE: bindings/py/tests/pyregion_test.py
class X (line 18) | class X(PyRegion):
method __init__ (line 19) | def __init__(self):
class Y (line 24) | class Y(PyRegion):
method __init__ (line 25) | def __init__(self):
method initialize (line 28) | def initialize(self): pass
method compute (line 29) | def compute(self): pass
method getOutputElementCount (line 30) | def getOutputElementCount(self): pass
class Z (line 34) | class Z(object):
method __init__ (line 35) | def __init__(self):
class PyRegionTest (line 41) | class PyRegionTest(unittest.TestCase):
method testNoInit (line 44) | def testNoInit(self):
method testUnimplementedAbstractMethods (line 56) | def testUnimplementedAbstractMethods(self):
method testUnimplementedNotImplementedMethods (line 69) | def testUnimplementedNotImplementedMethods(self):
method testCallUnimplementedMethod (line 91) | def testCallUnimplementedMethod(self):
FILE: bindings/py/tests/segment_sparse_matrix_test.py
class SegmentSparseMatrixTest (line 18) | class SegmentSparseMatrixTest(unittest.TestCase):
method testAddRows (line 19) | def testAddRows(self):
method testNoRowLeaks (line 31) | def testNoRowLeaks(self):
method testGetSegmentCounts (line 41) | def testGetSegmentCounts(self):
method testSortSegmentsByCell (line 51) | def testSortSegmentsByCell(self):
method testFilterSegmentsByCell (line 67) | def testFilterSegmentsByCell(self):
method testMapSegmentsToCells (line 97) | def testMapSegmentsToCells(self):
FILE: bindings/py/tests/sparse_binary_matrix_test.py
function error (line 25) | def error(str):
class UnitTests (line 30) | class UnitTests(unittest.TestCase):
method setUp (line 33) | def setUp(self):
method test_construction (line 37) | def test_construction(self):
method testAccessors (line 85) | def testAccessors(self):
method testCopy (line 145) | def testCopy(self):
method testClear (line 159) | def testClear(self):
method testResize (line 182) | def testResize(self):
method testEquals (line 305) | def testEquals(self):
method testSet (line 324) | def testSet(self):
method testGetAllNonZeros (line 362) | def testGetAllNonZeros(self):
method testSetAllNonZeros (line 390) | def testSetAllNonZeros(self):
method testGetCol (line 429) | def testGetCol(self):
method testSetSlice (line 448) | def testSetSlice(self):
method testNNonZerosPerBox (line 506) | def testNNonZerosPerBox(self):
method testAppendSparseRow (line 529) | def testAppendSparseRow(self):
method testAppendDenseRow (line 552) | def testAppendDenseRow(self):
method testReplaceSparseRow (line 575) | def testReplaceSparseRow(self):
method testFindRowSparse (line 602) | def testFindRowSparse(self):
method testFindRowDense (line 618) | def testFindRowDense(self):
method testGet (line 631) | def testGet(self):
method testSet (line 646) | def testSet(self):
method testSetRangeToZero (line 677) | def testSetRangeToZero(self):
method testSetRangeToOne (line 714) | def testSetRangeToOne(self):
method testTranspose (line 751) | def testTranspose(self):
method testCSR (line 786) | def testCSR(self):
method testGetstateSetstate (line 808) | def testGetstateSetstate(self):
method testCSRToFromFile (line 824) | def testCSRToFromFile(self):
method testCSRSize (line 842) | def testCSRSize(self):
method testBinary (line 864) | def testBinary(self):
method testToFromSparseVector (line 883) | def testToFromSparseVector(self):
method testToFromDense (line 944) | def testToFromDense(self):
method testRowToFromDense (line 977) | def testRowToFromDense(self):
method testLogicalNot (line 1000) | def testLogicalNot(self):
method testLogicalOr (line 1017) | def testLogicalOr(self):
method testLogicalAnd (line 1078) | def testLogicalAnd(self):
method testOverlap (line 1116) | def testOverlap(self):
method testMaxAllowedOverlap (line 1142) | def testMaxAllowedOverlap(self):
method testSubtract (line 1166) | def testSubtract(self):
method testInsideAndEdges (line 1185) | def testInsideAndEdges(self):
method testRightVecSumAtNZ (line 1405) | def testRightVecSumAtNZ(self):
method testRightVecArgMaxAtNZ (line 1434) | def testRightVecArgMaxAtNZ(self):
method testLeftVecSumAtNZ (line 1461) | def testLeftVecSumAtNZ(self):
method testCompact (line 1490) | def testCompact(self):
method testPickling (line 1505) | def testPickling(self):
method testMinHammingDistance (line 1523) | def testMinHammingDistance(self):
method testFirstRowCloserThan (line 1556) | def testFirstRowCloserThan(self):
method testVecMaxProd (line 1589) | def testVecMaxProd(self):
method testLeftDenseMatSumAtNZ (line 1614) | def testLeftDenseMatSumAtNZ(self):
method testLeftDenseMatMaxAtNZ (line 1629) | def testLeftDenseMatMaxAtNZ(self):
method testZeroRowsIndicator (line 1646) | def testZeroRowsIndicator(self):
method testNonZeroRowsIndicator (line 1677) | def testNonZeroRowsIndicator(self):
method testAppendSparseCol (line 1708) | def testAppendSparseCol(self):
method testScalability (line 1724) | def testScalability(self):
FILE: bindings/py/tests/sparse_link_test.py
class SparseRegion (line 23) | class SparseRegion(PyRegion):
method __init__ (line 31) | def __init__(self, maxActive, outputWidth, **kwargs):
method getSpec (line 38) | def getSpec(cls):
method compute (line 79) | def compute(self, inputs, outputs):
method initialize (line 85) | def initialize(self):
method getOutputElementCount (line 88) | def getOutputElementCount(self, name):
class DenseRegion (line 92) | class DenseRegion(PyRegion):
method __init__ (line 100) | def __init__(self, maxActive, outputWidth, **kwargs):
method getSpec (line 107) | def getSpec(cls):
method compute (line 146) | def compute(self, inputs, outputs):
method initialize (line 152) | def initialize(self):
method getOutputElementCount (line 155) | def getOutputElementCount(self, name):
function createSimpleNetwork (line 159) | def createSimpleNetwork(region1, region2):
function createDelayedNetwork (line 170) | def createDelayedNetwork(region1, region2, region3, propagationDelay=1):
class SparseLinkTest (line 188) | class SparseLinkTest(unittest.TestCase):
method setUp (line 192) | def setUp(self):
method testSparseToSparse (line 199) | def testSparseToSparse(self):
method testSparseToDense (line 209) | def testSparseToDense(self):
method testDenseToSparse (line 219) | def testDenseToSparse(self):
method testDenseToDense (line 229) | def testDenseToDense(self):
method testDenseToDenseToDenseDelay (line 239) | def testDenseToDenseToDenseDelay(self):
method testSparseToSparseToSparseDelay (line 256) | def testSparseToSparseToSparseDelay(self):
method testDenseToDenseToSparseDelay (line 273) | def testDenseToDenseToSparseDelay(self):
method testSparseToSparseToDenseDelay (line 290) | def testSparseToSparseToDenseDelay(self):
FILE: bindings/py/tests/sparse_matrix_test.py
function error (line 30) | def error(str):
class SparseMatrixTest (line 37) | class SparseMatrixTest(unittest.TestCase):
method test_construction (line 40) | def test_construction(self):
method test_getAllNonZeros (line 72) | def test_getAllNonZeros(self):
method test_setAllNonZeros (line 107) | def test_setAllNonZeros(self):
method test_nNonZerosPerRow_allRows (line 153) | def test_nNonZerosPerRow_allRows(self):
method test_nNonZerosPerRow_subset (line 176) | def test_nNonZerosPerRow_subset(self):
method test_nNonZerosPerRowOnCols (line 198) | def test_nNonZerosPerRowOnCols(self):
method test_nNonZerosPerBox (line 236) | def test_nNonZerosPerBox(self):
method test_getCol (line 263) | def test_getCol(self):
method test_setSlice (line 286) | def test_setSlice(self):
method test_kthroot_product (line 349) | def test_kthroot_product(self):
method test_transpose (line 426) | def test_transpose(self):
method test_aX_plus_bXY (line 465) | def test_aX_plus_bXY(self):
method test_mat_prod (line 491) | def test_mat_prod(self):
method test_leftDenseMatMaxAtNZ (line 511) | def test_leftDenseMatMaxAtNZ(self):
method test_rightDenseMatProdAtNZ (line 536) | def test_rightDenseMatProdAtNZ(self):
method test_denseMatExtract (line 549) | def test_denseMatExtract(self):
method test_threshold (line 562) | def test_threshold(self):
method test_clip (line 585) | def test_clip(self):
method test_increment (line 688) | def test_increment(self):
method test_incrementOnOuterWNZ (line 702) | def test_incrementOnOuterWNZ(self):
method test_incrementNonZerosOnOuter (line 717) | def test_incrementNonZerosOnOuter(self):
method test_incrementNonZerosOnRowsExcludingCols (line 768) | def test_incrementNonZerosOnRowsExcludingCols(self):
method test_setZerosOnOuter (line 819) | def test_setZerosOnOuter(self):
method test_setRandomZerosOnOuter_single (line 861) | def test_setRandomZerosOnOuter_single(self):
method test_setRandomZerosOnOuter_multi (line 963) | def test_setRandomZerosOnOuter_multi(self):
method test_increaseRowNonZeroCountsOnOuterTo (line 1065) | def test_increaseRowNonZeroCountsOnOuterTo(self):
method test_clipRowsBelowAndAbove (line 1174) | def test_clipRowsBelowAndAbove(self):
method test_boxMin_boxMax (line 1192) | def test_boxMin_boxMax(self):
method test_getSlice (line 1225) | def test_getSlice(self):
method test_addTwoRows (line 1252) | def test_addTwoRows(self):
method test_setRowFromDense (line 1268) | def test_setRowFromDense(self):
method test_setRowFromSparse (line 1284) | def test_setRowFromSparse(self):
method test_copyRow (line 1304) | def test_copyRow(self):
method test_zeroRowAndCol (line 1322) | def test_zeroRowAndCol(self):
method test_setColsToZero (line 1339) | def test_setColsToZero(self):
method test_leftDenseMatSumAtNZ (line 1356) | def test_leftDenseMatSumAtNZ(self):
method test_elementRowMultiply (line 1376) | def test_elementRowMultiply(self):
method test_elementColMultiply (line 1392) | def test_elementColMultiply(self):
method test_scaleRows (line 1408) | def test_scaleRows(self):
method test_scaleCols (line 1424) | def test_scaleCols(self):
method test_setDiagonalToZero (line 1440) | def test_setDiagonalToZero(self):
method test_setDiagonalToVal (line 1456) | def test_setDiagonalToVal(self):
method test_setDiagonal (line 1472) | def test_setDiagonal(self):
method test_rightVecProd (line 1489) | def test_rightVecProd(self):
method test_rightVecProd_fast (line 1527) | def test_rightVecProd_fast(self):
method test_leftVecProd (line 1553) | def test_leftVecProd(self):
method test_rightVecSumAtNZ (line 1587) | def test_rightVecSumAtNZ(self):
method test_rightVecSumAtNZSparse (line 1619) | def test_rightVecSumAtNZSparse(self):
method test_rightVecSumAtNZGtThreshold (line 1649) | def test_rightVecSumAtNZGtThreshold(self):
method test_rightVecSumAtNZGtThresholdSparse (line 1684) | def test_rightVecSumAtNZGtThresholdSparse(self):
method test_rightVecSumAtNZGteThreshold (line 1720) | def test_rightVecSumAtNZGteThreshold(self):
method test_rightVecSumAtNZGteThresholdSparse (line 1755) | def test_rightVecSumAtNZGteThresholdSparse(self):
method test_leftVecSumAtNZ (line 1791) | def test_leftVecSumAtNZ(self):
method test_multiply (line 1823) | def test_multiply(self):
method test_elementMultiply (line 1848) | def test_elementMultiply(self):
method test_incrementWithOuterProduct (line 1873) | def test_incrementWithOuterProduct(self):
method test_incrementOnOuterProductVal (line 1896) | def test_incrementOnOuterProductVal(self):
method test_setFromOuter (line 1922) | def test_setFromOuter(self):
method test_setFromElementMultiplyWithOuter (line 1960) | def test_setFromElementMultiplyWithOuter(self):
method test_add (line 1981) | def test_add(self):
method test_vecMaxAtNZ (line 2003) | def test_vecMaxAtNZ(self):
method test_vecArgMaxAtNZ (line 2036) | def test_vecArgMaxAtNZ(self):
method test_vecArgMaxProd (line 2069) | def test_vecArgMaxProd(self):
method test_setBoxToZero (line 2103) | def test_setBoxToZero(self):
method test_setBox (line 2125) | def test_setBox(self):
method test_nNonZerosInRowRange (line 2148) | def test_nNonZerosInRowRange(self):
method test_nNonZerosInBox (line 2172) | def test_nNonZerosInBox(self):
method test_getNonZerosInBox (line 2200) | def test_getNonZerosInBox(self):
method test_getNonZerosSorted (line 2233) | def test_getNonZerosSorted(self):
method test_smoothVecMaxProd (line 2255) | def test_smoothVecMaxProd(self):
method test_smoothVecArgMaxProd (line 2281) | def test_smoothVecArgMaxProd(self):
method test_shiftRows (line 2313) | def test_shiftRows(self):
method test_shiftCols (line 2332) | def test_shiftCols(self):
method test_logRowSums (line 2369) | def test_logRowSums(self):
method test_logColSums (line 2392) | def test_logColSums(self):
method test_addRows (line 2415) | def test_addRows(self):
method test_CSRSize (line 2443) | def test_CSRSize(self):
method test_getstate_setstate (line 2461) | def test_getstate_setstate(self):
method test_sameRowNonZeroIndices (line 2483) | def test_sameRowNonZeroIndices(self):
method test_nonZeroIndicesIncluded (line 2526) | def test_nonZeroIndicesIncluded(self):
method test_subtractNoAlloc (line 2577) | def test_subtractNoAlloc(self):
method test_addToNZOnly (line 2608) | def test_addToNZOnly(self):
method test_assignNoAlloc (line 2658) | def test_assignNoAlloc(self):
method test_assignNoAllocFromBinary (line 2690) | def test_assignNoAllocFromBinary(self):
method test_binaryLoadSave (line 2719) | def test_binaryLoadSave(self):
method test_logSumNoAlloc (line 2747) | def test_logSumNoAlloc(self):
method test_logAddValNoAlloc (line 2832) | def test_logAddValNoAlloc(self):
method test_logDiffNoAlloc (line 2864) | def test_logDiffNoAlloc(self):
method test_addToNZDownCols (line 2959) | def test_addToNZDownCols(self):
method test_addToNZAcrossRows (line 3024) | def test_addToNZAcrossRows(self):
method test_LBP_piPrime (line 3089) | def test_LBP_piPrime(self):
method test_matrix_entropy (line 3119) | def test_matrix_entropy(self):
method test_LogSumApprox (line 3168) | def test_LogSumApprox(self):
method test_LogDiffApprox (line 3205) | def test_LogDiffApprox(self):
method test_binarize_with_threshold (line 3246) | def test_binarize_with_threshold(self):
method test_nonZeroRowsIndicator_01 (line 3265) | def test_nonZeroRowsIndicator_01(self):
method test_nonZeroColsIndicator_01 (line 3289) | def test_nonZeroColsIndicator_01(self):
method test_nNonZeroRows_01 (line 3313) | def test_nNonZeroRows_01(self):
method test_nNonZeroCols_01 (line 3337) | def test_nNonZeroCols_01(self):
method test_logicalAnd (line 3361) | def test_logicalAnd(self):
method test_logicalAnd2 (line 3392) | def test_logicalAnd2(self):
method test_isZero_01 (line 3427) | def test_isZero_01(self):
method test_sum (line 3462) | def test_sum(self):
method test_initialize_random_01 (line 3519) | def test_initialize_random_01(self):
method test_partial_argsort (line 3550) | def test_partial_argsort(self):
method test_count_gt (line 3591) | def test_count_gt(self):
method test_count_lt (line 3627) | def test_count_lt(self):
method test_test_nta_set (line 3658) | def test_test_nta_set(self):
FILE: bindings/py/tests/temporal_memory_test.py
class TemporalMemoryBindingsTest (line 12) | class TemporalMemoryBindingsTest(unittest.TestCase):
method testIssue807 (line 14) | def testIssue807():
FILE: ci/bamboo/fetch_remote.py
class _Status (line 34) | class _Status(object):
function _downloadArtifacts (line 43) | def _downloadArtifacts(artifacts, artifactDir):
function _checkStatus (line 60) | def _checkStatus(platform, sha):
function _parseArgs (line 78) | def _parseArgs():
function main (line 93) | def main():
FILE: ci/deploy-wheel-to-s3.py
function upload (line 26) | def upload(artifactsBucket, wheelFileName, wheelPath):
function run (line 34) | def run(wheelPath):
FILE: external/common/include/boost/accumulators/accumulators_fwd.hpp
type boost (line 55) | namespace boost { namespace accumulators
type accumulators (line 55) | namespace accumulators
type tag (line 61) | namespace tag
type sample (line 63) | struct sample
type weight (line 64) | struct weight
type accumulator (line 65) | struct accumulator
type weights (line 66) | struct weights
type value (line 75) | struct value
type value_tag (line 78) | struct value_tag
type reference (line 81) | struct reference
type reference_tag (line 84) | struct reference_tag
type external (line 87) | struct external
type droppable (line 90) | struct droppable
type tag (line 72) | namespace tag
type sample (line 63) | struct sample
type weight (line 64) | struct weight
type accumulator (line 65) | struct accumulator
type weights (line 66) | struct weights
type value (line 75) | struct value
type value_tag (line 78) | struct value_tag
type reference (line 81) | struct reference
type reference_tag (line 84) | struct reference_tag
type external (line 87) | struct external
type droppable (line 90) | struct droppable
type droppable_accumulator_base (line 94) | struct droppable_accumulator_base
type droppable_accumulator (line 97) | struct droppable_accumulator
type with_cached_result (line 100) | struct with_cached_result
type accumulator_set (line 103) | struct accumulator_set
type extractor (line 106) | struct extractor
type feature_of (line 109) | struct feature_of
type as_feature (line 112) | struct as_feature
type as_weighted_feature (line 115) | struct as_weighted_feature
type depends_on (line 118) | struct depends_on
type features (line 121) | struct features
type impl (line 166) | namespace impl
type external_impl (line 171) | struct external_impl
type detail (line 174) | namespace detail
type feature_tag (line 177) | struct feature_tag
type to_accumulator (line 180) | struct to_accumulator
type accumulator_set_base (line 182) | struct accumulator_set_base
type is_accumulator_set (line 185) | struct is_accumulator_set
function ignore_variable (line 187) | inline void ignore_variable(void const *) {}
FILE: external/common/include/boost/accumulators/framework/accumulator_base.hpp
type boost (line 19) | namespace boost { namespace accumulators
type accumulators (line 19) | namespace accumulators
type detail (line 22) | namespace detail
type dont_care (line 30) | struct dont_care
method dont_care (line 33) | dont_care(Args const &)
type accumulator_base (line 41) | struct accumulator_base
method add_ref (line 50) | detail::void_ add_ref(dont_care)
method drop (line 54) | detail::void_ drop(dont_care)
method on_drop (line 58) | detail::void_ on_drop(dont_care)
FILE: external/common/include/boost/accumulators/framework/accumulator_concept.hpp
type boost (line 13) | namespace boost { namespace accumulators
type accumulators (line 13) | namespace accumulators
type accumulator_concept (line 17) | struct accumulator_concept
method constraints (line 19) | void constraints()
FILE: external/common/include/boost/accumulators/framework/accumulator_set.hpp
type boost (line 34) | namespace boost { namespace accumulators
type accumulators (line 34) | namespace accumulators
type detail (line 37) | namespace detail
type accumulator_visitor (line 43) | struct accumulator_visitor
method accumulator_visitor (line 45) | explicit accumulator_visitor(Args const &a)
function make_accumulator_visitor (line 62) | inline accumulator_visitor<Args> const make_accumulator_visitor(Ar...
type accumulator_set_base (line 77) | struct accumulator_set_base
type is_accumulator_set (line 84) | struct is_accumulator_set
type accumulator_set (line 107) | struct accumulator_set
method accumulator_set (line 139) | accumulator_set()
method accumulator_set (line 157) | explicit accumulator_set(A1 const &a1)
method visit (line 215) | void visit(UnaryFunction const &func)
method visit_if (line 225) | void visit_if(UnaryFunction const &func)
type apply (line 293) | struct apply
method drop (line 321) | void drop()
FILE: external/common/include/boost/accumulators/framework/accumulators/droppable_accumulator.hpp
type boost (line 18) | namespace boost { namespace accumulators
type accumulators (line 18) | namespace accumulators
type droppable_accumulator (line 22) | struct droppable_accumulator
method droppable_accumulator (line 167) | droppable_accumulator(Args const &args)
method droppable_accumulator (line 172) | droppable_accumulator(droppable_accumulator const &that)
type detail (line 24) | namespace detail
type add_ref_visitor (line 30) | struct add_ref_visitor
method add_ref_visitor (line 32) | explicit add_ref_visitor(Args const &args)
function make_add_ref_visitor (line 57) | add_ref_visitor<Args> make_add_ref_visitor(Args const &args)
type drop_visitor (line 66) | struct drop_visitor
method drop_visitor (line 68) | explicit drop_visitor(Args const &args)
function make_drop_visitor (line 95) | drop_visitor<Args> make_drop_visitor(Args const &args)
type droppable_accumulator_base (line 104) | struct droppable_accumulator_base
method droppable_accumulator_base (line 112) | droppable_accumulator_base(Args const &args)
method droppable_accumulator_base (line 118) | droppable_accumulator_base(droppable_accumulator_base const &that)
method add_ref (line 134) | void add_ref(Args const &)
method drop (line 140) | void drop(Args const &args)
method is_dropped (line 150) | bool is_dropped() const
type droppable_accumulator (line 163) | struct droppable_accumulator
method droppable_accumulator (line 167) | droppable_accumulator(Args const &args)
method droppable_accumulator (line 172) | droppable_accumulator(droppable_accumulator const &that)
type with_cached_result (line 181) | struct with_cached_result
method with_cached_result (line 187) | with_cached_result(Args const &args)
method with_cached_result (line 193) | with_cached_result(with_cached_result const &that)
method on_drop (line 216) | void on_drop(Args const &args)
method result_type (line 224) | result_type result(Args const &args) const
method set (line 232) | void set(result_type const &r)
method result_type (line 237) | result_type const &get() const
method has_result (line 242) | bool has_result() const
type tag (line 252) | namespace tag
type as_droppable (line 255) | struct as_droppable
type as_droppable<droppable<Feature> > (line 261) | struct as_droppable<droppable<Feature> >
type droppable (line 269) | struct droppable
type impl (line 282) | struct impl
type apply (line 285) | struct apply
type as_feature<tag::droppable<Feature> > (line 299) | struct as_feature<tag::droppable<Feature> >
type as_weighted_feature<tag::droppable<Feature> > (line 307) | struct as_weighted_feature<tag::droppable<Feature> >
type feature_of<tag::droppable<Feature> > (line 315) | struct feature_of<tag::droppable<Feature> >
FILE: external/common/include/boost/accumulators/framework/accumulators/external_accumulator.hpp
type boost (line 18) | namespace boost { namespace accumulators { namespace impl
type accumulators (line 18) | namespace accumulators { namespace impl
type impl (line 18) | namespace impl
type external_impl (line 26) | struct external_impl
method external_impl (line 32) | external_impl(dont_care) {}
method result_type (line 35) | result_type result(Args const &args) const
method result_type (line 43) | static result_type extract_(Args const &args, int)
method result_type (line 52) | static result_type extract_(Args const &, AccumulatorSet const &...
type tag (line 63) | namespace tag
type external (line 68) | struct external
type external<Feature, Tag, void> (line 80) | struct external<Feature, Tag, void>
type feature_of<tag::external<Feature, Tag, AccumulatorSet> > (line 95) | struct feature_of<tag::external<Feature, Tag, AccumulatorSet> >
FILE: external/common/include/boost/accumulators/framework/accumulators/reference_accumulator.hpp
type accumulators (line 18) | namespace accumulators
type impl (line 21) | namespace impl
type reference_accumulator_impl (line 27) | struct reference_accumulator_impl
method reference_accumulator_impl (line 33) | reference_accumulator_impl(Args const &args)
method result_type (line 38) | result_type result(dont_care) const
type tag (line 48) | namespace tag
type reference_tag (line 53) | struct reference_tag
type reference (line 60) | struct reference
type extract (line 69) | namespace extract
type feature_of<tag::reference<ValueType, Tag> > (line 82) | struct feature_of<tag::reference<ValueType, Tag> >
FILE: external/common/include/boost/accumulators/framework/accumulators/value_accumulator.hpp
type accumulators (line 17) | namespace accumulators
type impl (line 20) | namespace impl
type value_accumulator_impl (line 26) | struct value_accumulator_impl
method value_accumulator_impl (line 32) | value_accumulator_impl(Args const &args)
method result_type (line 37) | result_type result(dont_care) const
type tag (line 48) | namespace tag
type value_tag (line 53) | struct value_tag
type value (line 60) | struct value
type extract (line 69) | namespace extract
type feature_of<tag::value<ValueType, Tag> > (line 82) | struct feature_of<tag::value<ValueType, Tag> >
FILE: external/common/include/boost/accumulators/framework/depends_on.hpp
type boost (line 47) | namespace boost { namespace accumulators
type accumulators (line 47) | namespace accumulators
type as_feature (line 52) | struct as_feature
type as_weighted_feature (line 60) | struct as_weighted_feature
type feature_of (line 68) | struct feature_of
type detail (line 73) | namespace detail
type feature_tag (line 78) | struct feature_tag
type undroppable (line 84) | struct undroppable
type undroppable<tag::droppable<Feature> > (line 90) | struct undroppable<tag::droppable<Feature> >
type is_dependent_on (line 98) | struct is_dependent_on
type dependencies_of (line 106) | struct dependencies_of
type set_insert_range (line 113) | struct set_insert_range
type collect_abstract_features (line 122) | struct collect_abstract_features
type depends_on_base (line 134) | struct depends_on_base
type matches_feature (line 177) | struct matches_feature
type apply (line 180) | struct apply
type contains_feature_of (line 189) | struct contains_feature_of
type contains_feature_of_ (line 208) | struct contains_feature_of_
type apply (line 211) | struct apply
type build_acc_list (line 221) | struct build_acc_list
type build_acc_list<First, Last, true> (line 224) | struct build_acc_list<First, Last, true>
method call (line 229) | static fusion::nil_
type build_acc_list<First, Last, false> (line 237) | struct build_acc_list<First, Last, false>
method type (line 249) | static type
type meta (line 256) | namespace meta
type make_acc_list (line 259) | struct make_acc_list
function make_acc_list (line 268) | typename meta::make_acc_list<Sequence>::type
type checked_as_weighted_feature (line 277) | struct checked_as_weighted_feature
type as_feature_list (line 293) | struct as_feature_list
type as_feature_list<Features, void> (line 299) | struct as_feature_list<Features, void>
type accumulator_wrapper (line 307) | struct accumulator_wrapper
method accumulator_wrapper (line 312) | accumulator_wrapper(accumulator_wrapper const &that)
method accumulator_wrapper (line 318) | accumulator_wrapper(Args const &args)
type to_accumulator (line 327) | struct to_accumulator
type to_accumulator<Feature, Sample, tag::external<Weight, Tag, AccumulatorSet> > (line 338) | struct to_accumulator<Feature, Sample, tag::external<Weight, Tag, ...
type insert_feature (line 361) | struct insert_feature
type insert_dependencies (line 371) | struct insert_dependencies
type insert_sequence (line 385) | struct insert_sequence
type make_accumulator_tuple (line 395) | struct make_accumulator_tuple
type depends_on (line 157) | struct depends_on
type detail (line 174) | namespace detail
type feature_tag (line 78) | struct feature_tag
type undroppable (line 84) | struct undroppable
type undroppable<tag::droppable<Feature> > (line 90) | struct undroppable<tag::droppable<Feature> >
type is_dependent_on (line 98) | struct is_dependent_on
type dependencies_of (line 106) | struct dependencies_of
type set_insert_range (line 113) | struct set_insert_range
type collect_abstract_features (line 122) | struct collect_abstract_features
type depends_on_base (line 134) | struct depends_on_base
type matches_feature (line 177) | struct matches_feature
type apply (line 180) | struct apply
type contains_feature_of (line 189) | struct contains_feature_of
type contains_feature_of_ (line 208) | struct contains_feature_of_
type apply (line 211) | struct apply
type build_acc_list (line 221) | struct build_acc_list
type build_acc_list<First, Last, true> (line 224) | struct build_acc_list<First, Last, true>
method call (line 229) | static fusion::nil_
type build_acc_list<First, Last, false> (line 237) | struct build_acc_list<First, Last, false>
method type (line 249) | static type
type meta (line 256) | namespace meta
type make_acc_list (line 259) | struct make_acc_list
function make_acc_list (line 268) | typename meta::make_acc_list<Sequence>::type
type checked_as_weighted_feature (line 277) | struct checked_as_weighted_feature
type as_feature_list (line 293) | struct as_feature_list
type as_feature_list<Features, void> (line 299) | struct as_feature_list<Features, void>
type accumulator_wrapper (line 307) | struct accumulator_wrapper
method accumulator_wrapper (line 312) | accumulator_wrapper(accumulator_wrapper const &that)
method accumulator_wrapper (line 318) | accumulator_wrapper(Args const &args)
type to_accumulator (line 327) | struct to_accumulator
type to_accumulator<Feature, Sample, tag::external<Weight, Tag, AccumulatorSet> > (line 338) | struct to_accumulator<Feature, Sample, tag::external<Weight, Tag, ...
type insert_feature (line 361) | struct insert_feature
type insert_dependencies (line 371) | struct insert_dependencies
type insert_sequence (line 385) | struct insert_sequence
type make_accumulator_tuple (line 395) | struct make_accumulator_tuple
FILE: external/common/include/boost/accumulators/framework/extractor.hpp
type boost (line 27) | namespace boost { namespace accumulators
type accumulators (line 27) | namespace accumulators
type detail (line 30) | namespace detail
type accumulator_set_result (line 33) | struct accumulator_set_result
type argument_pack_result (line 40) | struct argument_pack_result
type extractor_result (line 51) | struct extractor_result
function do_extract (line 61) | typename extractor_result<AccumulatorSet, Feature>::type
function do_extract (line 69) | typename extractor_result<Args, Feature>::type
type extractor (line 82) | struct extractor
type result (line 88) | struct result
type result<this_type(A1)> (line 91) | struct result<this_type(A1)>
FILE: external/common/include/boost/accumulators/framework/features.hpp
type boost (line 15) | namespace boost { namespace accumulators
type accumulators (line 15) | namespace accumulators
type features (line 22) | struct features
FILE: external/common/include/boost/accumulators/framework/parameters/accumulator.hpp
type boost (line 14) | namespace boost { namespace accumulators
type accumulators (line 14) | namespace accumulators
FILE: external/common/include/boost/accumulators/framework/parameters/sample.hpp
type boost (line 14) | namespace boost { namespace accumulators
type accumulators (line 14) | namespace accumulators
FILE: external/common/include/boost/accumulators/framework/parameters/weight.hpp
type boost (line 14) | namespace boost { namespace accumulators
type accumulators (line 14) | namespace accumulators
FILE: external/common/include/boost/accumulators/framework/parameters/weights.hpp
type boost (line 14) | namespace boost { namespace accumulators
type accumulators (line 14) | namespace accumulators
FILE: external/common/include/boost/accumulators/numeric/detail/function1.hpp
type boost (line 12) | namespace boost { namespace detail {
type detail (line 12) | namespace detail {
type function1 (line 21) | struct function1
type result (line 24) | struct result
type result<This(A0)> (line 28) | struct result<This(A0)>
FILE: external/common/include/boost/accumulators/numeric/detail/function_n.hpp
type boost (line 27) | namespace boost { namespace detail {
type detail (line 27) | namespace detail {
type function_name (line 54) | struct function_name
type result (line 63) | struct result {}
FILE: external/common/include/boost/accumulators/numeric/detail/pod_singleton.hpp
type boost (line 7) | namespace boost { namespace detail {
type detail (line 7) | namespace detail {
type pod_singleton (line 10) | struct pod_singleton
FILE: external/common/include/boost/accumulators/numeric/functional.hpp
type std (line 49) | namespace std
type unary_function (line 53) | struct unary_function {}
type binary_function (line 56) | struct binary_function {}
type functional (line 62) | namespace functional
type are_integral (line 67) | struct are_integral
type left_ref (line 72) | struct left_ref
type detail (line 77) | namespace detail
FILE: external/common/include/boost/accumulators/numeric/functional/complex.hpp
type boost (line 22) | namespace boost { namespace numeric { namespace operators
type numeric (line 22) | namespace numeric { namespace operators
type operators (line 22) | namespace operators
type detail (line 53) | namespace detail
type one_complex (line 56) | struct one_complex
type one<std::complex<T> > (line 69) | struct one<std::complex<T> >
type numeric (line 51) | namespace numeric
type operators (line 22) | namespace operators
type detail (line 53) | namespace detail
type one_complex (line 56) | struct one_complex
type one<std::complex<T> > (line 69) | struct one<std::complex<T> >
type boost (line 51) | namespace boost { namespace numeric
type numeric (line 22) | namespace numeric { namespace operators
type operators (line 22) | namespace operators
type detail (line 53) | namespace detail
type one_complex (line 56) | struct one_complex
type one<std::complex<T> > (line 69) | struct one<std::complex<T> >
type numeric (line 51) | namespace numeric
type operators (line 22) | namespace operators
type detail (line 53) | namespace detail
type one_complex (line 56) | struct one_complex
type one<std::complex<T> > (line 69) | struct one<std::complex<T> >
FILE: external/common/include/boost/accumulators/numeric/functional/valarray.hpp
type operators (line 30) | namespace operators
type acc_detail (line 32) | namespace acc_detail
type make_valarray (line 35) | struct make_valarray
type std_valarray_tag (line 98) | struct std_valarray_tag
type tag<std::valarray<T> > (line 101) | struct tag<std::valarray<T> >
type tag<std::_Expr<T, U> > (line 108) | struct tag<std::_Expr<T, U> >
FILE: external/common/include/boost/accumulators/numeric/functional/vector.hpp
type boost (line 27) | namespace boost { namespace numeric
type numeric (line 27) | namespace numeric
type operators (line 29) | namespace operators
type acc_detail (line 31) | namespace acc_detail
type make_vector (line 34) | struct make_vector
type functional (line 184) | namespace functional
type std_vector_tag (line 186) | struct std_vector_tag
type tag<std::vector<T, Al> > (line 189) | struct tag<std::vector<T, Al> >
type min_assign<Left, Right, std_vector_tag, std_vector_tag> (line 197) | struct min_assign<Left, Right, std_vector_tag, std_vector_tag>
type max_assign<Left, Right, std_vector_tag, std_vector_tag> (line 216) | struct max_assign<Left, Right, std_vector_tag, std_vector_tag>
type fdiv<Left, Right, std_vector_tag, void> (line 234) | struct fdiv<Left, Right, std_vector_tag, void>
type promote<To, From, std_vector_tag, std_vector_tag> (line 244) | struct promote<To, From, std_vector_tag, std_vector_tag>
method To (line 247) | To operator ()(From &arr) const
type promote<ToFrom, ToFrom, std_vector_tag, std_vector_tag> (line 259) | struct promote<ToFrom, ToFrom, std_vector_tag, std_vector_tag>
method ToFrom (line 262) | ToFrom &operator ()(ToFrom &tofrom) const
type as_min<T, std_vector_tag> (line 271) | struct as_min<T, std_vector_tag>
type as_max<T, std_vector_tag> (line 285) | struct as_max<T, std_vector_tag>
type as_zero<T, std_vector_tag> (line 299) | struct as_zero<T, std_vector_tag>
type as_one<T, std_vector_tag> (line 313) | struct as_one<T, std_vector_tag>
FILE: external/common/include/boost/accumulators/numeric/functional_fwd.hpp
type operators (line 20) | namespace operators
type op (line 23) | namespace op
type functional (line 30) | namespace functional
type tag (line 35) | struct tag
type tag<T const> (line 41) | struct tag<T const>
type tag<T volatile> (line 46) | struct tag<T volatile>
type tag<T const volatile> (line 51) | struct tag<T const volatile>
type static_ (line 56) | struct static_
type are_integral (line 59) | struct are_integral
FILE: external/common/include/boost/accumulators/statistics/count.hpp
type boost (line 17) | namespace boost { namespace accumulators
type accumulators (line 17) | namespace accumulators
type impl (line 20) | namespace impl
type count_impl (line 25) | struct count_impl
method count_impl (line 31) | count_impl(dont_care)
method result_type (line 41) | result_type result(dont_care) const
type tag (line 55) | namespace tag
type count (line 57) | struct count
type extract (line 69) | namespace extract
FILE: external/common/include/boost/accumulators/statistics/covariance.hpp
type boost (line 33) | namespace boost { namespace numeric
type numeric (line 33) | namespace numeric
type functional (line 35) | namespace functional
type std_vector_tag (line 37) | struct std_vector_tag
type outer_product_base (line 42) | struct outer_product_base
type outer_product (line 47) | struct outer_product
type outer_product<Left, Right, std_vector_tag, std_vector_tag> (line 52) | struct outer_product<Left, Right, std_vector_tag, std_vector_tag>
method result_type (line 73) | result_type
type op (line 87) | namespace op
type outer_product (line 89) | struct outer_product
type accumulators (line 101) | namespace accumulators
type impl (line 104) | namespace impl
type covariance_impl (line 122) | struct covariance_impl
method covariance_impl (line 131) | covariance_impl(Args const &args)
method result_type (line 158) | result_type result(dont_care) const
type tag (line 172) | namespace tag
type covariance (line 175) | struct covariance
type abstract_covariance (line 181) | struct abstract_covariance
type extract (line 190) | namespace extract
type feature_of<tag::covariance<VariateType, VariateTag> > (line 200) | struct feature_of<tag::covariance<VariateType, VariateTag> >
type as_weighted_feature<tag::covariance<VariateType, VariateTag> > (line 208) | struct as_weighted_feature<tag::covariance<VariateType, VariateTag> >
type feature_of<tag::weighted_covariance<VariateType, VariateTag> > (line 214) | struct feature_of<tag::weighted_covariance<VariateType, VariateTag> >
type boost (line 101) | namespace boost { namespace accumulators
type numeric (line 33) | namespace numeric
type functional (line 35) | namespace functional
type std_vector_tag (line 37) | struct std_vector_tag
type outer_product_base (line 42) | struct outer_product_base
type outer_product (line 47) | struct outer_product
type outer_product<Left, Right, std_vector_tag, std_vector_tag> (line 52) | struct outer_product<Left, Right, std_vector_tag, std_vector_tag>
method result_type (line 73) | result_type
type op (line 87) | namespace op
type outer_product (line 89) | struct outer_product
type accumulators (line 101) | namespace accumulators
type impl (line 104) | namespace impl
type covariance_impl (line 122) | struct covariance_impl
method covariance_impl (line 131) | covariance_impl(Args const &args)
method result_type (line 158) | result_type result(dont_care) const
type tag (line 172) | namespace tag
type covariance (line 175) | struct covariance
type abstract_covariance (line 181) | struct abstract_covariance
type extract (line 190) | namespace extract
type feature_of<tag::covariance<VariateType, VariateTag> > (line 200) | struct feature_of<tag::covariance<VariateType, VariateTag> >
type as_weighted_feature<tag::covariance<VariateType, VariateTag> > (line 208) | struct as_weighted_feature<tag::covariance<VariateType, VariateTag> >
type feature_of<tag::weighted_covariance<VariateType, VariateTag> > (line 214) | struct feature_of<tag::weighted_covariance<VariateType, VariateTag> >
FILE: external/common/include/boost/accumulators/statistics/density.hpp
type boost (line 29) | namespace boost { namespace accumulators
type accumulators (line 29) | namespace accumulators
type impl (line 41) | namespace impl
type density_impl (line 61) | struct density_impl
method density_impl (line 71) | density_impl(Args const &args)
method result_type (line 168) | result_type result(Args const &args) const
type tag (line 202) | namespace tag
type density (line 204) | struct density
type extract (line 225) | namespace extract
type as_weighted_feature<tag::density> (line 237) | struct as_weighted_feature<tag::density>
type feature_of<tag::weighted_density> (line 243) | struct feature_of<tag::weighted_density>
FILE: external/common/include/boost/accumulators/statistics/error_of.hpp
type accumulators (line 17) | namespace accumulators
type impl (line 20) | namespace impl
type this_feature_has_no_error_calculation (line 25) | struct this_feature_has_no_error_calculation
type error_of_impl (line 35) | struct error_of_impl
method error_of_impl (line 45) | error_of_impl(dont_care)
method result_type (line 49) | result_type result(dont_care) const
type tag (line 60) | namespace tag
type error_of (line 63) | struct error_of
type extract (line 75) | namespace extract
type as_feature<tag::error_of<Feature> > (line 84) | struct as_feature<tag::error_of<Feature> >
type as_weighted_feature<tag::error_of<Feature> > (line 92) | struct as_weighted_feature<tag::error_of<Feature> >
FILE: external/common/include/boost/accumulators/statistics/error_of_mean.hpp
type boost (line 20) | namespace boost { namespace accumulators
type accumulators (line 20) | namespace accumulators
type impl (line 23) | namespace impl
type error_of_mean_impl (line 28) | struct error_of_mean_impl
method error_of_mean_impl (line 34) | error_of_mean_impl(dont_care) {}
method result_type (line 37) | result_type result(Args const &args) const
type tag (line 50) | namespace tag
type error_of<mean> (line 53) | struct error_of<mean>
type error_of<immediate_mean> (line 62) | struct error_of<immediate_mean>
FILE: external/common/include/boost/accumulators/statistics/extended_p_square.hpp
type boost (line 30) | namespace boost { namespace accumulators
type accumulators (line 30) | namespace accumulators
type impl (line 39) | namespace impl
type extended_p_square_impl (line 69) | struct extended_p_square_impl
method extended_p_square_impl (line 85) | extended_p_square_impl(Args const &args)
method result_type (line 227) | result_type result(dont_care) const
type tag (line 252) | namespace tag
type extended_p_square (line 254) | struct extended_p_square
type extract (line 270) | namespace extract
type as_weighted_feature<tag::extended_p_square> (line 282) | struct as_weighted_feature<tag::extended_p_square>
type feature_of<tag::weighted_extended_p_square> (line 288) | struct feature_of<tag::weighted_extended_p_square>
FILE: external/common/include/boost/accumulators/statistics/extended_p_square_quantile.hpp
type boost (line 40) | namespace boost { namespace accumulators
type accumulators (line 40) | namespace accumulators
type impl (line 43) | namespace impl
type extended_p_square_quantile_impl (line 57) | struct extended_p_square_quantile_impl
method extended_p_square_quantile_impl (line 74) | extended_p_square_quantile_impl(Args const &args)
method result_type (line 83) | result_type result(Args const &args) const
type tag (line 200) | namespace tag
type extended_p_square_quantile (line 202) | struct extended_p_square_quantile
type extended_p_square_quantile_quadratic (line 207) | struct extended_p_square_quantile_quadratic
type weighted_extended_p_square_quantile (line 212) | struct weighted_extended_p_square_quantile
type weighted_extended_p_square_quantile_quadratic (line 217) | struct weighted_extended_p_square_quantile_quadratic
type extract (line 228) | namespace extract
type as_feature<tag::extended_p_square_quantile(linear)> (line 248) | struct as_feature<tag::extended_p_square_quantile(linear)>
type as_feature<tag::extended_p_square_quantile(quadratic)> (line 255) | struct as_feature<tag::extended_p_square_quantile(quadratic)>
type as_feature<tag::weighted_extended_p_square_quantile(linear)> (line 262) | struct as_feature<tag::weighted_extended_p_square_quantile(linear)>
type as_feature<tag::weighted_extended_p_square_quantile(quadratic)> (line 269) | struct as_feature<tag::weighted_extended_p_square_quantile(quadratic)>
type feature_of<tag::extended_p_square_quantile> (line 278) | struct feature_of<tag::extended_p_square_quantile>
type feature_of<tag::extended_p_square_quantile_quadratic> (line 283) | struct feature_of<tag::extended_p_square_quantile_quadratic>
type as_weighted_feature<tag::extended_p_square_quantile> (line 290) | struct as_weighted_feature<tag::extended_p_square_quantile>
type feature_of<tag::weighted_extended_p_square_quantile> (line 296) | struct feature_of<tag::weighted_extended_p_square_quantile>
type as_weighted_feature<tag::extended_p_square_quantile_quadratic> (line 304) | struct as_weighted_feature<tag::extended_p_square_quantile_quadratic>
type feature_of<tag::weighted_extended_p_square_quantile_quadratic> (line 309) | struct feature_of<tag::weighted_extended_p_square_quantile_quadratic>
FILE: external/common/include/boost/accumulators/statistics/kurtosis.hpp
type boost (line 21) | namespace boost { namespace accumulators
type accumulators (line 21) | namespace accumulators
type impl (line 24) | namespace impl
type kurtosis_impl (line 46) | struct kurtosis_impl
method kurtosis_impl (line 52) | kurtosis_impl(dont_care) {}
method result_type (line 55) | result_type result(Args const &args) const
type tag (line 73) | namespace tag
type kurtosis (line 75) | struct kurtosis
type extract (line 87) | namespace extract
type as_weighted_feature<tag::kurtosis> (line 99) | struct as_weighted_feature<tag::kurtosis>
type feature_of<tag::weighted_kurtosis> (line 105) | struct feature_of<tag::weighted_kurtosis>
FILE: external/common/include/boost/accumulators/statistics/max.hpp
type boost (line 20) | namespace boost { namespace accumulators
type accumulators (line 20) | namespace accumulators
type impl (line 23) | namespace impl
type max_impl (line 28) | struct max_impl
method max_impl (line 35) | max_impl(Args const &args)
method result_type (line 46) | result_type result(dont_care) const
type tag (line 60) | namespace tag
type max (line 62) | struct max
type extract (line 74) | namespace extract
FILE: external/common/include/boost/accumulators/statistics/mean.hpp
type impl (line 24) | namespace impl
type mean_impl (line 30) | struct mean_impl
method mean_impl (line 36) | mean_impl(dont_care) {}
method result_type (line 39) | result_type result(Args const &args) const
type immediate_mean_impl (line 47) | struct immediate_mean_impl
method immediate_mean_impl (line 54) | immediate_mean_impl(Args const &args)
method result_type (line 69) | result_type result(dont_care) const
type tag (line 88) | namespace tag
type mean (line 90) | struct mean
type immediate_mean (line 97) | struct immediate_mean
type mean_of_weights (line 104) | struct mean_of_weights
type immediate_mean_of_weights (line 112) | struct immediate_mean_of_weights
type mean_of_variates (line 121) | struct mean_of_variates
type immediate_mean_of_variates (line 129) | struct immediate_mean_of_variates
type as_feature<tag::mean(immediate)> (line 166) | struct as_feature<tag::mean(immediate)>
type as_feature<tag::mean_of_weights(lazy)> (line 173) | struct as_feature<tag::mean_of_weights(lazy)>
type as_feature<tag::mean_of_weights(immediate)> (line 180) | struct as_feature<tag::mean_of_weights(immediate)>
type feature_of<tag::immediate_mean> (line 202) | struct feature_of<tag::immediate_mean>
type feature_of<tag::immediate_mean_of_weights> (line 210) | struct feature_of<tag::immediate_mean_of_weights>
type as_weighted_feature<tag::mean> (line 226) | struct as_weighted_feature<tag::mean>
type feature_of<tag::weighted_mean> (line 232) | struct feature_of<tag::weighted_mean>
type as_weighted_feature<tag::immediate_mean> (line 239) | struct as_weighted_feature<tag::immediate_mean>
type feature_of<tag::immediate_weighted_mean> (line 245) | struct feature_of<tag::immediate_weighted_mean>
type feature_of<tag::weighted_mean_of_variates<VariateType, VariateTag> > (line 258) | struct feature_of<tag::weighted_mean_of_variates<VariateType, VariateTag> >
type feature_of<tag::immediate_weighted_mean_of_variates<VariateType, VariateTag> > (line 272) | struct feature_of<tag::immediate_weighted_mean_of_variates<VariateType, ...
FILE: external/common/include/boost/accumulators/statistics/median.hpp
type boost (line 24) | namespace boost { namespace accumulators
type accumulators (line 24) | namespace accumulators
type impl (line 27) | namespace impl
type median_impl (line 38) | struct median_impl
method median_impl (line 44) | median_impl(dont_care) {}
method result_type (line 47) | result_type result(Args const &args) const
type with_density_median_impl (line 63) | struct with_density_median_impl
method with_density_median_impl (line 73) | with_density_median_impl(Args const &args)
method result_type (line 86) | result_type result(Args const &args) const
type with_p_square_cumulative_distribution_median_impl (line 125) | struct with_p_square_cumulative_distribution_median_impl
method with_p_square_cumulative_distribution_median_impl (line 134) | with_p_square_cumulative_distribution_median_impl(dont_care)
method result_type (line 145) | result_type result(Args const &args) const
type tag (line 176) | namespace tag
type median (line 178) | struct median
type with_density_median (line 185) | struct with_density_median
type with_p_square_cumulative_distribution_median (line 192) | struct with_p_square_cumulative_distribution_median
type extract (line 206) | namespace extract
type as_feature<tag::median(with_p_square_quantile)> (line 223) | struct as_feature<tag::median(with_p_square_quantile)>
type as_feature<tag::median(with_density)> (line 230) | struct as_feature<tag::median(with_density)>
type as_feature<tag::median(with_p_square_cumulative_distribution)> (line 237) | struct as_feature<tag::median(with_p_square_cumulative_distribution)>
type feature_of<tag::with_density_median> (line 246) | struct feature_of<tag::with_density_median>
type feature_of<tag::with_p_square_cumulative_distribution_median> (line 252) | struct feature_of<tag::with_p_square_cumulative_distribution_median>
type as_weighted_feature<tag::median> (line 260) | struct as_weighted_feature<tag::median>
type feature_of<tag::weighted_median> (line 266) | struct feature_of<tag::weighted_median>
type as_weighted_feature<tag::with_density_median> (line 274) | struct as_weighted_feature<tag::with_density_median>
type feature_of<tag::with_density_weighted_median> (line 280) | struct feature_of<tag::with_density_weighted_median>
type as_weighted_feature<tag::with_p_square_cumulative_distribution_median> (line 288) | struct as_weighted_feature<tag::with_p_square_cumulative_distributio...
type feature_of<tag::with_p_square_cumulative_distribution_weighted_median> (line 294) | struct feature_of<tag::with_p_square_cumulative_distribution_weighte...
FILE: external/common/include/boost/accumulators/statistics/min.hpp
type boost (line 20) | namespace boost { namespace accumulators
type accumulators (line 20) | namespace accumulators
type impl (line 23) | namespace impl
type min_impl (line 28) | struct min_impl
method min_impl (line 35) | min_impl(Args const &args)
method result_type (line 46) | result_type result(dont_care) const
type tag (line 60) | namespace tag
type min (line 62) | struct min
type extract (line 74) | namespace extract
FILE: external/common/include/boost/accumulators/statistics/moment.hpp
type boost (line 23) | namespace boost { namespace numeric
type numeric (line 23) | namespace numeric
function T (line 28) | T const &pow(T const &x, mpl::int_<1>)
function T (line 36) | T pow(T const &x, mpl::int_<N>)
type accumulators (line 45) | namespace accumulators
type impl (line 48) | namespace impl
type moment_impl (line 53) | struct moment_impl
method moment_impl (line 61) | moment_impl(Args const &args)
method result_type (line 73) | result_type result(Args const &args) const
type tag (line 87) | namespace tag
type moment (line 90) | struct moment
type extract (line 102) | namespace extract
type as_weighted_feature<tag::moment<N> > (line 112) | struct as_weighted_feature<tag::moment<N> >
type feature_of<tag::weighted_moment<N> > (line 118) | struct feature_of<tag::weighted_moment<N> >
FILE: external/common/include/boost/accumulators/statistics/p_square_cumul_dist.hpp
type boost (line 24) | namespace boost { namespace accumulators
type accumulators (line 24) | namespace accumulators
type impl (line 33) | namespace impl
type p_square_cumulative_distribution_impl (line 54) | struct p_square_cumulative_distribution_impl
method p_square_cumulative_distribution_impl (line 64) | p_square_cumulative_distribution_impl(Args const &args)
method result_type (line 187) | result_type result(Args const &args) const
type tag (line 223) | namespace tag
type p_square_cumulative_distribution (line 225) | struct p_square_cumulative_distribution
type extract (line 238) | namespace extract
type as_weighted_feature<tag::p_square_cumulative_distribution> (line 250) | struct as_weighted_feature<tag::p_square_cumulative_distribution>
type feature_of<tag::weighted_p_square_cumulative_distribution> (line 256) | struct feature_of<tag::weighted_p_square_cumulative_distribution>
FILE: external/common/include/boost/accumulators/statistics/p_square_quantile.hpp
type boost (line 26) | namespace boost { namespace accumulators
type accumulators (line 26) | namespace accumulators
type impl (line 29) | namespace impl
type p_square_quantile_impl (line 54) | struct p_square_quantile_impl
method p_square_quantile_impl (line 63) | p_square_quantile_impl(Args const &args)
method result_type (line 189) | result_type result(dont_care) const
type tag (line 207) | namespace tag
type p_square_quantile (line 209) | struct p_square_quantile
type p_square_quantile_for_median (line 216) | struct p_square_quantile_for_median
type extract (line 229) | namespace extract
type as_weighted_feature<tag::p_square_quantile> (line 244) | struct as_weighted_feature<tag::p_square_quantile>
type feature_of<tag::weighted_p_square_quantile> (line 250) | struct feature_of<tag::weighted_p_square_quantile>
FILE: external/common/include/boost/accumulators/statistics/parameters/quantile_probability.hpp
type boost (line 14) | namespace boost { namespace accumulators
type accumulators (line 14) | namespace accumulators
FILE: external/common/include/boost/accumulators/statistics/peaks_over_threshold.hpp
type boost (line 41) | namespace boost { namespace accumulators
type accumulators (line 41) | namespace accumulators
type impl (line 53) | namespace impl
type peaks_over_threshold_impl (line 125) | struct peaks_over_threshold_impl
method peaks_over_threshold_impl (line 135) | peaks_over_threshold_impl(Args const &args)
method result_type (line 159) | result_type result(Args const &args) const
type peaks_over_threshold_prob_impl (line 205) | struct peaks_over_threshold_prob_impl
method peaks_over_threshold_prob_impl (line 215) | peaks_over_threshold_prob_impl(Args const &args)
method result_type (line 230) | result_type result(Args const &args) const
type tag (line 307) | namespace tag
type peaks_over_threshold (line 310) | struct peaks_over_threshold
type peaks_over_threshold_prob (line 320) | struct peaks_over_threshold_prob
type abstract_peaks_over_threshold (line 329) | struct abstract_peaks_over_threshold
type extract (line 338) | namespace extract
type as_feature<tag::peaks_over_threshold<LeftRight>(with_threshold_value)> (line 349) | struct as_feature<tag::peaks_over_threshold<LeftRight>(with_threshol...
type as_feature<tag::peaks_over_threshold<LeftRight>(with_threshold_probability)> (line 356) | struct as_feature<tag::peaks_over_threshold<LeftRight>(with_threshol...
type feature_of<tag::peaks_over_threshold<LeftRight> > (line 362) | struct feature_of<tag::peaks_over_threshold<LeftRight> >
type feature_of<tag::peaks_over_threshold_prob<LeftRight> > (line 368) | struct feature_of<tag::peaks_over_threshold_prob<LeftRight> >
type as_weighted_feature<tag::peaks_over_threshold<LeftRight> > (line 376) | struct as_weighted_feature<tag::peaks_over_threshold<LeftRight> >
type feature_of<tag::weighted_peaks_over_threshold<LeftRight> > (line 382) | struct feature_of<tag::weighted_peaks_over_threshold<LeftRight> >
type as_weighted_feature<tag::peaks_over_threshold_prob<LeftRight> > (line 389) | struct as_weighted_feature<tag::peaks_over_threshold_prob<LeftRight> >
type feature_of<tag::weighted_peaks_over_threshold_prob<LeftRight> > (line 395) | struct feature_of<tag::weighted_peaks_over_threshold_prob<LeftRight> >
FILE: external/common/include/boost/accumulators/statistics/pot_quantile.hpp
type boost (line 29) | namespace boost { namespace accumulators
type accumulators (line 29) | namespace accumulators
type impl (line 32) | namespace impl
type pot_quantile_impl (line 49) | struct pot_quantile_impl
method pot_quantile_impl (line 56) | pot_quantile_impl(dont_care)
method result_type (line 62) | result_type result(Args const &args) const
type tag (line 96) | namespace tag
type pot_quantile (line 99) | struct pot_quantile
type pot_quantile_prob (line 107) | struct pot_quantile_prob
type weighted_pot_quantile (line 115) | struct weighted_pot_quantile
type weighted_pot_quantile_prob (line 123) | struct weighted_pot_quantile_prob
type as_feature<tag::pot_quantile<LeftRight>(with_threshold_value)> (line 134) | struct as_feature<tag::pot_quantile<LeftRight>(with_threshold_value)>
type as_feature<tag::pot_quantile<LeftRight>(with_threshold_probability)> (line 141) | struct as_feature<tag::pot_quantile<LeftRight>(with_threshold_probab...
type as_feature<tag::weighted_pot_quantile<LeftRight>(with_threshold_value)> (line 148) | struct as_feature<tag::weighted_pot_quantile<LeftRight>(with_thresho...
type as_feature<tag::weighted_pot_quantile<LeftRight>(with_threshold_probability)> (line 155) | struct as_feature<tag::weighted_pot_quantile<LeftRight>(with_thresho...
type feature_of<tag::pot_quantile<LeftRight> > (line 164) | struct feature_of<tag::pot_quantile<LeftRight> >
type feature_of<tag::pot_quantile_prob<LeftRight> > (line 170) | struct feature_of<tag::pot_quantile_prob<LeftRight> >
type as_weighted_feature<tag::pot_quantile<LeftRight> > (line 178) | struct as_weighted_feature<tag::pot_quantile<LeftRight> >
type feature_of<tag::weighted_pot_quantile<LeftRight> > (line 184) | struct feature_of<tag::weighted_pot_quantile<LeftRight> >
type as_weighted_feature<tag::pot_quantile_prob<LeftRight> > (line 192) | struct as_weighted_feature<tag::pot_quantile_prob<LeftRight> >
type feature_of<tag::weighted_pot_quantile_prob<LeftRight> > (line 198) | struct feature_of<tag::weighted_pot_quantile_prob<LeftRight> >
FILE: external/common/include/boost/accumulators/statistics/pot_tail_mean.hpp
type boost (line 31) | namespace boost { namespace accumulators
type accumulators (line 31) | namespace accumulators
type impl (line 34) | namespace impl
type pot_tail_mean_impl (line 52) | struct pot_tail_mean_impl
method pot_tail_mean_impl (line 59) | pot_tail_mean_impl(dont_care)
method result_type (line 65) | result_type result(Args const &args) const
type tag (line 102) | namespace tag
type pot_tail_mean (line 105) | struct pot_tail_mean
type pot_tail_mean_prob (line 113) | struct pot_tail_mean_prob
type weighted_pot_tail_mean (line 121) | struct weighted_pot_tail_mean
type weighted_pot_tail_mean_prob (line 129) | struct weighted_pot_tail_mean_prob
type as_feature<tag::pot_tail_mean<LeftRight>(with_threshold_value)> (line 140) | struct as_feature<tag::pot_tail_mean<LeftRight>(with_threshold_value)>
type as_feature<tag::pot_tail_mean<LeftRight>(with_threshold_probability)> (line 147) | struct as_feature<tag::pot_tail_mean<LeftRight>(with_threshold_proba...
type as_feature<tag::weighted_pot_tail_mean<LeftRight>(with_threshold_value)> (line 154) | struct as_feature<tag::weighted_pot_tail_mean<LeftRight>(with_thresh...
type as_feature<tag::weighted_pot_tail_mean<LeftRight>(with_threshold_probability)> (line 161) | struct as_feature<tag::weighted_pot_tail_mean<LeftRight>(with_thresh...
type feature_of<tag::pot_tail_mean<LeftRight> > (line 170) | struct feature_of<tag::pot_tail_mean<LeftRight> >
type feature_of<tag::pot_tail_mean_prob<LeftRight> > (line 176) | struct feature_of<tag::pot_tail_mean_prob<LeftRight> >
type as_weighted_feature<tag::pot_tail_mean<LeftRight> > (line 184) | struct as_weighted_feature<tag::pot_tail_mean<LeftRight> >
type feature_of<tag::weighted_pot_tail_mean<LeftRight> > (line 190) | struct feature_of<tag::weighted_pot_tail_mean<LeftRight> >
type as_weighted_feature<tag::pot_tail_mean_prob<LeftRight> > (line 198) | struct as_weighted_feature<tag::pot_tail_mean_prob<LeftRight> >
type feature_of<tag::weighted_pot_tail_mean_prob<LeftRight> > (line 204) | struct feature_of<tag::weighted_pot_tail_mean_prob<LeftRight> >
FILE: external/common/include/boost/accumulators/statistics/rolling_count.hpp
type boost (line 20) | namespace boost { namespace accumulators
type accumulators (line 20) | namespace accumulators
type impl (line 23) | namespace impl
type rolling_count_impl (line 30) | struct rolling_count_impl
method rolling_count_impl (line 35) | rolling_count_impl(dont_care)
method result_type (line 39) | result_type result(Args const &args) const
type tag (line 50) | namespace tag
type rolling_count (line 52) | struct rolling_count
type extract (line 69) | namespace extract
FILE: external/common/include/boost/accumulators/statistics/rolling_mean.hpp
type boost (line 22) | namespace boost { namespace accumulators
type accumulators (line 22) | namespace accumulators
type impl (line 24) | namespace impl
type lazy_rolling_mean_impl (line 31) | struct lazy_rolling_mean_impl
method lazy_rolling_mean_impl (line 37) | lazy_rolling_mean_impl(dont_care)
method result_type (line 42) | result_type result(Args const &args) const
type immediate_rolling_mean_impl (line 53) | struct immediate_rolling_mean_impl
method immediate_rolling_mean_impl (line 60) | immediate_rolling_mean_impl(Args const &args)
method result_type (line 80) | result_type result(Args const &) const
type tag (line 96) | namespace tag
type lazy_rolling_mean (line 98) | struct lazy_rolling_mean
type immediate_rolling_mean (line 111) | struct immediate_rolling_mean
type rolling_mean (line 125) | struct rolling_mean : immediate_rolling_mean {}
type extract (line 133) | namespace extract
type as_feature<tag::rolling_mean(lazy)> (line 150) | struct as_feature<tag::rolling_mean(lazy)>
type as_feature<tag::rolling_mean(immediate)> (line 157) | struct as_feature<tag::rolling_mean(immediate)>
type feature_of<tag::immediate_rolling_mean> (line 165) | struct feature_of<tag::immediate_rolling_mean>
type feature_of<tag::lazy_rolling_mean> (line 173) | struct feature_of<tag::lazy_rolling_mean>
FILE: external/common/include/boost/accumulators/statistics/rolling_moment.hpp
type accumulators (line 25) | namespace accumulators
type impl (line 27) | namespace impl
type rolling_moment_impl (line 32) | struct rolling_moment_impl
method rolling_moment_impl (line 40) | rolling_moment_impl(Args const &args)
method result_type (line 56) | result_type result(Args const &args) const
type tag (line 69) | namespace tag
type rolling_moment (line 72) | struct rolling_moment
type extract (line 89) | namespace extract
FILE: external/common/include/boost/accumulators/statistics/rolling_sum.hpp
type boost (line 20) | namespace boost { namespace accumulators
type accumulators (line 20) | namespace accumulators
type impl (line 22) | namespace impl
type rolling_sum_impl (line 28) | struct rolling_sum_impl
method rolling_sum_impl (line 34) | rolling_sum_impl(Args const &args)
method result_type (line 49) | result_type result(Args const & /*args*/) const
type tag (line 62) | namespace tag
type rolling_sum (line 64) | struct rolling_sum
type extract (line 81) | namespace extract
FILE: external/common/include/boost/accumulators/statistics/rolling_variance.hpp
type boost (line 28) | namespace boost { namespace accumulators
type accumulators (line 28) | namespace accumulators
type impl (line 30) | namespace impl
type lazy_rolling_variance_impl (line 49) | struct lazy_rolling_variance_impl
method lazy_rolling_variance_impl (line 55) | lazy_rolling_variance_impl(dont_care) {}
method result_type (line 58) | result_type result(Args const &args) const
type immediate_rolling_variance_impl (line 104) | struct immediate_rolling_variance_impl
method immediate_rolling_variance_impl (line 111) | immediate_rolling_variance_impl(Args const &args)
method result_type (line 135) | result_type result(Args const &args) const
method prevent_underflow (line 148) | void prevent_underflow(T &non_negative_number,typename boost::en...
method prevent_underflow (line 153) | void prevent_underflow(T &non_arithmetic_quantity,typename boost...
type tag (line 164) | namespace tag
type lazy_rolling_variance (line 166) | struct lazy_rolling_variance
type immediate_rolling_variance (line 179) | struct immediate_rolling_variance
type rolling_variance (line 193) | struct rolling_variance : immediate_rolling_variance {}
type extract (line 201) | namespace extract
type as_feature<tag::rolling_variance(lazy)> (line 218) | struct as_feature<tag::rolling_variance(lazy)>
type as_feature<tag::rolling_variance(immediate)> (line 225) | struct as_feature<tag::rolling_variance(immediate)>
type feature_of<tag::lazy_rolling_variance> (line 233) | struct feature_of<tag::lazy_rolling_variance>
type feature_of<tag::immediate_rolling_variance> (line 241) | struct feature_of<tag::immediate_rolling_variance>
FILE: external/common/include/boost/accumulators/statistics/rolling_window.hpp
type boost (line 25) | namespace boost { namespace accumulators
type accumulators (line 25) | namespace accumulators
type impl (line 34) | namespace impl
type rolling_window_plus1_impl (line 41) | struct rolling_window_plus1_impl
method rolling_window_plus1_impl (line 48) | rolling_window_plus1_impl(Args const & args)
method rolling_window_plus1_impl (line 55) | rolling_window_plus1_impl(rolling_window_plus1_impl const &that)
method rolling_window_plus1_impl (line 61) | rolling_window_plus1_impl &operator =(rolling_window_plus1_impl ...
method full (line 74) | bool full() const
method result_type (line 81) | result_type result(dont_care) const
function is_rolling_window_plus1_full (line 91) | bool is_rolling_window_plus1_full(Args const &args)
type rolling_window_impl (line 101) | struct rolling_window_impl
method rolling_window_impl (line 107) | rolling_window_impl(dont_care)
method result_type (line 111) | result_type result(Args const &args) const
type tag (line 123) | namespace tag
type rolling_window_plus1 (line 125) | struct rolling_window_plus1
type rolling_window (line 139) | struct rolling_window
type extract (line 158) | namespace extract
FILE: external/common/include/boost/accumulators/statistics/skewness.hpp
type boost (line 23) | namespace boost { namespace accumulators
type accumulators (line 23) | namespace accumulators
type impl (line 26) | namespace impl
type skewness_impl (line 47) | struct skewness_impl
method skewness_impl (line 53) | skewness_impl(dont_care)
method result_type (line 58) | result_type result(Args const &args) const
type tag (line 75) | namespace tag
type skewness (line 77) | struct skewness
type extract (line 89) | namespace extract
type as_weighted_feature<tag::skewness> (line 101) | struct as_weighted_feature<tag::skewness>
type feature_of<tag::weighted_skewness> (line 107) | struct feature_of<tag::weighted_skewness>
FILE: external/common/include/boost/accumulators/statistics/stats.hpp
type boost (line 16) | namespace boost { namespace accumulators
type accumulators (line 16) | namespace accumulators
type stats (line 22) | struct stats
FILE: external/common/include/boost/accumulators/statistics/sum.hpp
type boost (line 22) | namespace boost { namespace accumulators
type accumulators (line 22) | namespace accumulators
type impl (line 25) | namespace impl
type sum_impl (line 30) | struct sum_impl
method sum_impl (line 37) | sum_impl(Args const &args)
method result_type (line 49) | result_type result(dont_care) const
type tag (line 66) | namespace tag
type sum (line 68) | struct sum
type sum_of_weights (line 76) | struct sum_of_weights
type sum_of_variates (line 86) | struct sum_of_variates
type abstract_sum_of_variates (line 94) | struct abstract_sum_of_variates
type extract (line 105) | namespace extract
type as_weighted_feature<tag::sum> (line 123) | struct as_weighted_feature<tag::sum>
type feature_of<tag::weighted_sum> (line 129) | struct feature_of<tag::weighted_sum>
type feature_of<tag::sum_of_variates<VariateType, VariateTag> > (line 134) | struct feature_of<tag::sum_of_variates<VariateType, VariateTag> >
FILE: external/common/include/boost/accumulators/statistics/sum_kahan.hpp
type boost (line 18) | namespace boost { namespace accumulators
type accumulators (line 18) | namespace accumulators
type impl (line 21) | namespace impl
type sum_kahan_impl (line 30) | struct sum_kahan_impl
method sum_kahan_impl (line 45) | sum_kahan_impl(Args const & args)
method result_type (line 64) | result_type result(dont_care) const
type tag (line 85) | namespace tag
type sum_kahan (line 88) | struct sum_kahan
type sum_of_weights_kahan (line 96) | struct sum_of_weights_kahan
type sum_of_variates_kahan (line 106) | struct sum_of_variates_kahan
type extract (line 121) | namespace extract
type as_feature<tag::sum(kahan)> (line 138) | struct as_feature<tag::sum(kahan)>
type as_feature<tag::sum_of_weights(kahan)> (line 145) | struct as_feature<tag::sum_of_weights(kahan)>
type as_weighted_feature<tag::sum_kahan> (line 153) | struct as_weighted_feature<tag::sum_kahan>
type feature_of<tag::weighted_sum_kahan> (line 159) | struct feature_of<tag::weighted_sum_kahan>
type feature_of<tag::sum_kahan> (line 166) | struct feature_of<tag::sum_kahan>
type feature_of<tag::sum_of_weights_kahan> (line 174) | struct feature_of<tag::sum_of_weights_kahan>
type feature_of<tag::sum_of_variates_kahan<VariateType, VariateTag> > (line 180) | struct feature_of<tag::sum_of_variates_kahan<VariateType, VariateTag> >
FILE: external/common/include/boost/accumulators/statistics/tail.hpp
type boost (line 29) | namespace boost { namespace accumulators
type accumulators (line 29) | namespace accumulators
type detail (line 39) | namespace detail
type tail_range (line 46) | struct tail_range
function make_tail_range (line 58) | typename tail_range<ElementIterator, IndexIterator>::type
type stat_assign_visitor (line 76) | struct stat_assign_visitor
method stat_assign_visitor (line 78) | stat_assign_visitor(Args const &a, std::size_t i)
function stat_assign (line 101) | inline stat_assign_visitor<Args> const stat_assign(Args const &arg...
type is_tail_variate_feature (line 111) | struct is_tail_variate_feature
type is_tail_variate_feature<tag::tail_variate<VariateType, VariateTag, LeftRight>, LeftRight> (line 119) | struct is_tail_variate_feature<tag::tail_variate<VariateType, Vari...
type is_tail_variate_feature<tag::tail_weights<LeftRight>, LeftRight> (line 127) | struct is_tail_variate_feature<tag::tail_weights<LeftRight>, LeftR...
type impl (line 134) | namespace impl
type tail_impl (line 139) | struct tail_impl
method tail_impl (line 162) | tail_impl(Args const &args)
method tail_impl (line 170) | tail_impl(tail_impl const &that)
method result_type (line 205) | result_type result(dont_care) const
type is_tail_variate (line 226) | struct is_tail_variate
type apply (line 229) | struct apply
method assign (line 238) | void assign(Args const &args, std::size_t index)
type indirect_cmp (line 250) | struct indirect_cmp
method indirect_cmp (line 253) | indirect_cmp(std::vector<Sample> const &s)
type tail_cache_size_named_arg (line 278) | struct tail_cache_size_named_arg
type tail_cache_size_named_arg<left> (line 282) | struct tail_cache_size_named_arg<left>
type tail_cache_size_named_arg<right> (line 287) | struct tail_cache_size_named_arg<right>
type tag (line 295) | namespace tag
type tail (line 298) | struct tail
type abstract_tail (line 312) | struct abstract_tail
type extract (line 321) | namespace extract
type feature_of<tag::tail<LeftRight> > (line 331) | struct feature_of<tag::tail<LeftRight> >
FILE: external/common/include/boost/accumulators/statistics/tail_mean.hpp
type boost (line 36) | namespace boost { namespace accumulators
type accumulators (line 36) | namespace accumulators
type impl (line 39) | namespace impl
type coherent_tail_mean_impl (line 62) | struct coherent_tail_mean_impl
method coherent_tail_mean_impl (line 69) | coherent_tail_mean_impl(dont_care) {}
method result_type (line 72) | result_type result(Args const &args) const
type non_coherent_tail_mean_impl (line 117) | struct non_coherent_tail_mean_impl
method non_coherent_tail_mean_impl (line 124) | non_coherent_tail_mean_impl(dont_care) {}
method result_type (line 127) | result_type result(Args const &args) const
type tag (line 171) | namespace tag
type coherent_tail_mean (line 174) | struct coherent_tail_mean
type non_coherent_tail_mean (line 181) | struct non_coherent_tail_mean
type abstract_non_coherent_tail_mean (line 187) | struct abstract_non_coherent_tail_mean
type extract (line 197) | namespace extract
type feature_of<tag::coherent_tail_mean<LeftRight> > (line 212) | struct feature_of<tag::coherent_tail_mean<LeftRight> >
type feature_of<tag::non_coherent_tail_mean<LeftRight> > (line 218) | struct feature_of<tag::non_coherent_tail_mean<LeftRight> >
type as_weighted_feature<tag::non_coherent_tail_mean<LeftRight> > (line 226) | struct as_weighted_feature<tag::non_coherent_tail_mean<LeftRight> >
type feature_of<tag::non_coherent_weighted_tail_mean<LeftRight> > (line 232) | struct feature_of<tag::non_coherent_weighted_tail_mean<LeftRight> >
FILE: external/common/include/boost/accumulators/statistics/tail_quantile.hpp
type boost (line 37) | namespace boost { namespace accumulators
type accumulators (line 37) | namespace accumulators
type impl (line 40) | namespace impl
type tail_quantile_impl (line 60) | struct tail_quantile_impl
method tail_quantile_impl (line 66) | tail_quantile_impl(dont_care) {}
method result_type (line 69) | result_type result(Args const &args) const
type tag (line 107) | namespace tag
type tail_quantile (line 110) | struct tail_quantile
type extract (line 122) | namespace extract
type feature_of<tag::tail_quantile<LeftRight> > (line 134) | struct feature_of<tag::tail_quantile<LeftRight> >
type as_weighted_feature<tag::tail_quantile<LeftRight> > (line 142) | struct as_weighted_feature<tag::tail_quantile<LeftRight> >
type feature_of<tag::weighted_tail_quantile<LeftRight> > (line 148) | struct feature_of<tag::weighted_tail_quantile<LeftRight> >
FILE: external/common/include/boost/accumulators/statistics/tail_variate.hpp
type boost (line 22) | namespace boost { namespace accumulators
type accumulators (line 22) | namespace accumulators
type impl (line 25) | namespace impl
type tail_variate_impl (line 30) | struct tail_variate_impl
method tail_variate_impl (line 42) | tail_variate_impl(Args const &args)
method assign (line 48) | void assign(Args const &args, std::size_t index)
method result_type (line 54) | result_type result(Args const &args) const
method result_type (line 63) | result_type do_result(TailRng const &rng) const
type tag (line 80) | namespace tag
type tail_variate (line 83) | struct tail_variate
type abstract_tail_variate (line 91) | struct abstract_tail_variate
type tail_weights (line 97) | struct tail_weights
type abstract_tail_weights (line 105) | struct abstract_tail_weights
type extract (line 115) | namespace extract
type feature_of<tag::tail_variate<VariateType, VariateTag, LeftRight> > (line 128) | struct feature_of<tag::tail_variate<VariateType, VariateTag, LeftRig...
type feature_of<tag::tail_weights<LeftRight> > (line 134) | struct feature_of<tag::tail_weights<LeftRight> >
FILE: external/common/include/boost/accumulators/statistics/tail_variate_means.hpp
type boost (line 36) | namespace boost { namespace accumulators
type accumulators (line 36) | namespace accumulators
type impl (line 39) | namespace impl
type tail_variate_means_impl (line 79) | struct tail_variate_means_impl
method tail_variate_means_impl (line 87) | tail_variate_means_impl(dont_care) {}
method result_type (line 90) | result_type result(Args const &args) const
type tag (line 156) | namespace tag
type absolute_tail_variate_means (line 159) | struct absolute_tail_variate_means
type relative_tail_variate_means (line 165) | struct relative_tail_variate_means
type abstract_absolute_tail_variate_means (line 170) | struct abstract_absolute_tail_variate_means
type abstract_relative_tail_variate_means (line 174) | struct abstract_relative_tail_variate_means
type extract (line 184) | namespace extract
type as_feature<tag::tail_variate_means<LeftRight, VariateType, VariateTag>(absolute)> (line 198) | struct as_feature<tag::tail_variate_means<LeftRight, VariateType, Va...
type as_feature<tag::tail_variate_means<LeftRight, VariateType, VariateTag>(relative)> (line 205) | struct as_feature<tag::tail_variate_means<LeftRight, VariateType, Va...
type feature_of<tag::absolute_tail_variate_means<LeftRight, VariateType, VariateTag> > (line 212) | struct feature_of<tag::absolute_tail_variate_means<LeftRight, Variat...
type feature_of<tag::relative_tail_variate_means<LeftRight, VariateType, VariateTag> > (line 219) | struct feature_of<tag::relative_tail_variate_means<LeftRight, Variat...
type as_weighted_feature<tag::absolute_tail_variate_means<LeftRight, VariateType, VariateTag> > (line 227) | struct as_weighted_feature<tag::absolute_tail_variate_means<LeftRigh...
type feature_of<tag::absolute_weighted_tail_variate_means<LeftRight, VariateType, VariateTag> > (line 233) | struct feature_of<tag::absolute_weighted_tail_variate_means<LeftRigh...
type as_weighted_feature<tag::relative_tail_variate_means<LeftRight, VariateType, VariateTag> > (line 241) | struct as_weighted_feature<tag::relative_tail_variate_means<LeftRigh...
type feature_of<tag::relative_weighted_tail_variate_means<LeftRight, VariateType, VariateTag> > (line 247) | struct feature_of<tag::relative_weighted_tail_variate_means<LeftRigh...
FILE: external/common/include/boost/accumulators/statistics/times2_iterator.hpp
type boost (line 20) | namespace boost { namespace accumulators
type accumulators (line 20) | namespace accumulators
type detail (line 23) | namespace detail
function times2_iterator (line 30) | inline times2_iterator make_times2_iterator(std::size_t i)
type lvalue_index_iterator (line 41) | struct lvalue_index_iterator
method lvalue_index_iterator (line 44) | lvalue_index_iterator()
method lvalue_index_iterator (line 48) | lvalue_index_iterator(Base base)
FILE: external/common/include/boost/accumulators/statistics/variance.hpp
type boost (line 23) | namespace boost { namespace accumulators
type accumulators (line 23) | namespace accumulators
type impl (line 26) | namespace impl
type lazy_variance_impl (line 41) | struct lazy_variance_impl
method lazy_variance_impl (line 47) | lazy_variance_impl(dont_care) {}
method result_type (line 50) | result_type result(Args const &args) const
type variance_impl (line 84) | struct variance_impl
method variance_impl (line 91) | variance_impl(Args const &args)
method result_type (line 111) | result_type result(dont_care) const
type tag (line 126) | namespace tag
type lazy_variance (line 128) | struct lazy_variance
type variance (line 136) | struct variance
type extract (line 149) | namespace extract
type as_feature<tag::variance(lazy)> (line 163) | struct as_feature<tag::variance(lazy)>
type as_feature<tag::variance(immediate)> (line 170) | struct as_feature<tag::variance(immediate)>
type feature_of<tag::lazy_variance> (line 178) | struct feature_of<tag::lazy_variance>
type as_weighted_feature<tag::variance> (line 186) | struct as_weighted_feature<tag::variance>
type feature_of<tag::weighted_variance> (line 194) | struct feature_of<tag::weighted_variance>
type as_weighted_feature<tag::lazy_variance> (line 202) | struct as_weighted_feature<tag::lazy_variance>
type feature_of<tag::lazy_weighted_variance> (line 210) | struct feature_of<tag::lazy_weighted_variance>
FILE: external/common/include/boost/accumulators/statistics/variates/covariate.hpp
type boost (line 14) | namespace boost { namespace accumulators
type accumulators (line 14) | namespace accumulators
FILE: external/common/include/boost/accumulators/statistics/weighted_covariance.hpp
type boost (line 34) | namespace boost { namespace accumulators
type accumulators (line 34) | namespace accumulators
type impl (line 37) | namespace impl
type weighted_covariance_impl (line 57) | struct weighted_covariance_impl
method weighted_covariance_impl (line 66) | weighted_covariance_impl(Args const &args)
method result_type (line 95) | result_type result(dont_care) const
type tag (line 109) | namespace tag
type weighted_covariance (line 112) | struct weighted_covariance
type extract (line 122) | namespace extract
FILE: external/common/include/boost/accumulators/statistics/weighted_density.hpp
type boost (line 27) | namespace boost { namespace accumulators
type accumulators (line 27) | namespace accumulators
type impl (line 30) | namespace impl
type weighted_density_impl (line 50) | struct weighted_density_impl
method weighted_density_impl (line 60) | weighted_density_impl(Args const &args)
method result_type (line 154) | result_type result(Args const &args) const
type tag (line 189) | namespace tag
type weighted_density (line 191) | struct weighted_density
type extract (line 210) | namespace extract
FILE: external/common/include/boost/accumulators/statistics/weighted_extended_p_square.hpp
type boost (line 32) | namespace boost { namespace accumulators
type accumulators (line 32) | namespace accumulators
type impl (line 35) | namespace impl
type weighted_extended_p_square_impl (line 66) | struct weighted_extended_p_square_impl
method weighted_extended_p_square_impl (line 83) | weighted_extended_p_square_impl(Args const &args)
method result_type (line 242) | result_type result(dont_care) const
type tag (line 266) | namespace tag
type weighted_extended_p_square (line 268) | struct weighted_extended_p_square
type extract (line 279) | namespace extract
FILE: external/common/include/boost/accumulators/statistics/weighted_kurtosis.hpp
type boost (line 22) | namespace boost { namespace accumulators
type accumulators (line 22) | namespace accumulators
type impl (line 25) | namespace impl
type weighted_kurtosis_impl (line 50) | struct weighted_kurtosis_impl
method weighted_kurtosis_impl (line 57) | weighted_kurtosis_impl(dont_care)
method result_type (line 62) | result_type result(Args const &args) const
type tag (line 80) | namespace tag
type weighted_kurtosis (line 82) | struct weighted_kurtosis
type extract (line 94) | namespace extract
FILE: external/common/include/boost/accumulators/statistics/weighted_mean.hpp
type impl (line 28) | namespace impl
type weighted_mean_impl (line 34) | struct weighted_mean_impl
method weighted_mean_impl (line 41) | weighted_mean_impl(dont_care) {}
method result_type (line 44) | result_type result(Args const &args) const
type immediate_weighted_mean_impl (line 64) | struct immediate_weighted_mean_impl
method immediate_weighted_mean_impl (line 72) | immediate_weighted_mean_impl(Args const &args)
method result_type (line 95) | result_type result(dont_care) const
type tag (line 110) | namespace tag
type weighted_mean (line 112) | struct weighted_mean
type immediate_weighted_mean (line 119) | struct immediate_weighted_mean
type weighted_mean_of_variates (line 127) | struct weighted_mean_of_variates
type immediate_weighted_mean_of_variates (line 135) | struct immediate_weighted_mean_of_variates
type as_feature<tag::weighted_mean(immediate)> (line 168) | struct as_feature<tag::weighted_mean(immediate)>
FILE: external/common/include/boost/accumulators/statistics/weighted_median.hpp
type boost (line 25) | namespace boost { namespace accumulators
type accumulators (line 25) | namespace accumulators
type impl (line 28) | namespace impl
type weighted_median_impl (line 39) | struct weighted_median_impl
method weighted_median_impl (line 45) | weighted_median_impl(dont_care) {}
method result_type (line 48) | result_type result(Args const &args) const
type with_density_weighted_median_impl (line 65) | struct with_density_weighted_median_impl
method with_density_weighted_median_impl (line 75) | with_density_weighted_median_impl(Args const &args)
method result_type (line 87) | result_type result(Args const &args) const
type with_p_square_cumulative_distribution_weighted_median_impl (line 126) | struct with_p_square_cumulative_distribution_weighted_median_impl
method with_p_square_cumulative_distribution_weighted_median_impl (line 136) | with_p_square_cumulative_distribution_weighted_median_impl(dont_...
method result_type (line 147) | result_type result(Args const &args) const
type tag (line 177) | namespace tag
type weighted_median (line 179) | struct weighted_median
type with_density_weighted_median (line 186) | struct with_density_weighted_median
type with_p_square_cumulative_distribution_weighted_median (line 193) | struct with_p_square_cumulative_distribution_weighted_median
type extract (line 206) | namespace extract
type as_feature<tag::weighted_median(with_p_square_quantile)> (line 216) | struct as_feature<tag::weighted_median(with_p_square_quantile)>
type as_feature<tag::weighted_median(with_density)> (line 223) | struct as_feature<tag::weighted_median(with_density)>
type as_feature<tag::weighted_median(with_p_square_cumulative_distribution)> (line 230) | struct as_feature<tag::weighted_median(with_p_square_cumulative_dist...
FILE: external/common/include/boost/accumulators/statistics/weighted_moment.hpp
type accumulators (line 29) | namespace accumulators
type impl (line 32) | namespace impl
type weighted_moment_impl (line 37) | struct weighted_moment_impl
method weighted_moment_impl (line 46) | weighted_moment_impl(Args const &args)
method result_type (line 58) | result_type result(Args const &args) const
type tag (line 72) | namespace tag
type weighted_moment (line 75) | struct weighted_moment
type extract (line 87) | namespace extract
FILE: external/common/include/boost/accumulators/statistics/weighted_p_square_cumul_dist.hpp
type boost (line 25) | namespace boost { namespace accumulators
type accumulators (line 25) | namespace accumulators
type impl (line 28) | namespace impl
type weighted_p_square_cumulative_distribution_impl (line 52) | struct weighted_p_square_cumulative_distribution_impl
method weighted_p_square_cumulative_distribution_impl (line 63) | weighted_p_square_cumulative_distribution_impl(Args const &args)
method result_type (line 205) | result_type result(Args const &args) const
type tag (line 238) | namespace tag
type weighted_p_square_cumulative_distribution (line 240) | struct weighted_p_square_cumulative_distribution
type extract (line 251) | namespace extract
FILE: external/common/include/boost/accumulators/statistics/weighted_p_square_quantile.hpp
type boost (line 26) | namespace boost { namespace accumulators
type accumulators (line 26) | namespace accumulators
type impl (line 29) | namespace impl {
type weighted_p_square_quantile_impl (line 54) | struct weighted_p_square_quantile_impl
method weighted_p_square_quantile_impl (line 64) | weighted_p_square_quantile_impl(Args const &args)
method result_type (line 206) | result_type result(dont_care) const
type tag (line 223) | namespace tag
type weighted_p_square_quantile (line 225) | struct weighted_p_square_quantile
type weighted_p_square_quantile_for_median (line 230) | struct weighted_p_square_quantile_for_median
type extract (line 241) | namespace extract
FILE: external/common/include/boost/accumulators/statistics/weighted_peaks_over_threshold.hpp
type boost (line 37) | namespace boost { namespace accumulators
type accumulators (line 37) | namespace accumulators
type impl (line 40) | namespace impl
type weighted_peaks_over_threshold_impl (line 55) | struct weighted_peaks_over_threshold_impl
method weighted_peaks_over_threshold_impl (line 64) | weighted_peaks_over_threshold_impl(Args const &args)
method result_type (line 89) | result_type result(Args const &args) const
type weighted_peaks_over_threshold_prob_impl (line 134) | struct weighted_peaks_over_threshold_prob_impl
method weighted_peaks_over_threshold_prob_impl (line 143) | weighted_peaks_over_threshold_prob_impl(Args const &args)
method result_type (line 159) | result_type result(Args const &args) const
type tag (line 236) | namespace tag
type weighted_peaks_over_threshold (line 239) | struct weighted_peaks_over_threshold
type weighted_peaks_over_threshold_prob (line 248) | struct weighted_peaks_over_threshold_prob
type extract (line 260) | namespace extract
type as_feature<tag::weighted_peaks_over_threshold<LeftRight>(with_threshold_value)> (line 271) | struct as_feature<tag::weighted_peaks_over_threshold<LeftRight>(with...
type as_feature<tag::weighted_peaks_over_threshold<LeftRight>(with_threshold_probability)> (line 278) | struct as_feature<tag::weighted_peaks_over_threshold<LeftRight>(with...
FILE: external/common/include/boost/accumulators/statistics/weighted_skewness.hpp
type boost (line 22) | namespace boost { namespace accumulators
type accumulators (line 22) | namespace accumulators
type impl (line 25) | namespace impl
type weighted_skewness_impl (line 49) | struct weighted_skewness_impl
method weighted_skewness_impl (line 56) | weighted_skewness_impl(dont_care) {}
method result_type (line 59) | result_type result(Args const &args) const
type tag (line 76) | namespace tag
type weighted_skewness (line 78) | struct weighted_skewness
type extract (line 90) | namespace extract
FILE: external/common/include/boost/accumulators/statistics/weighted_sum.hpp
type boost (line 21) | namespace boost { namespace accumulators
type accumulators (line 21) | namespace accumulators
type impl (line 24) | namespace impl
type weighted_sum_impl (line 29) | struct weighted_sum_impl
method weighted_sum_impl (line 38) | weighted_sum_impl(Args const &args)
method result_type (line 53) | result_type result(dont_care) const
type tag (line 68) | namespace tag
type weighted_sum (line 70) | struct weighted_sum
type weighted_sum_of_variates (line 79) | struct weighted_sum_of_variates
type abstract_weighted_sum_of_variates (line 87) | struct abstract_weighted_sum_of_variates
type extract (line 96) | namespace extract
type feature_of<tag::weighted_sum_of_variates<VariateType, VariateTag> > (line 109) | struct feature_of<tag::weighted_sum_of_variates<VariateType, Variate...
FILE: external/common/include/boost/accumulators/statistics/weighted_sum_kahan.hpp
type boost (line 23) | namespace boost { namespace accumulators
type accumulators (line 23) | namespace accumulators
type impl (line 26) | namespace impl
type weighted_sum_kahan_impl (line 36) | struct weighted_sum_kahan_impl
method weighted_sum_kahan_impl (line 45) | weighted_sum_kahan_impl(Args const &args)
method result_type (line 66) | result_type result(dont_care) const
type tag (line 86) | namespace tag
type weighted_sum_kahan (line 88) | struct weighted_sum_kahan
type weighted_sum_of_variates_kahan (line 97) | struct weighted_sum_of_variates_kahan
type extract (line 111) | namespace extract
type as_feature<tag::weighted_sum(kahan)> (line 125) | struct as_feature<tag::weighted_sum(kahan)>
type feature_of<tag::weighted_sum_of_variates_kahan<VariateType, VariateTag> > (line 131) | struct feature_of<tag::weighted_sum_of_variates_kahan<VariateType, V...
FILE: external/common/include/boost/accumulators/statistics/weighted_tail_mean.hpp
type boost (line 35) | namespace boost { namespace accumulators
type accumulators (line 35) | namespace accumulators
type impl (line 38) | namespace impl
type non_coherent_weighted_tail_mean_impl (line 81) | struct non_coherent_weighted_tail_mean_impl
method non_coherent_weighted_tail_mean_impl (line 89) | non_coherent_weighted_tail_mean_impl(dont_care) {}
method result_type (line 92) | result_type result(Args const &args) const
type tag (line 141) | namespace tag
type non_coherent_weighted_tail_mean (line 144) | struct non_coherent_weighted_tail_mean
type extract (line 154) | namespace extract
FILE: external/common/include/boost/accumulators/statistics/weighted_tail_quantile.hpp
type boost (line 36) | namespace boost { namespace accumulators
type accumulators (line 36) | namespace accumulators
type impl (line 39) | namespace impl
type weighted_tail_quantile_impl (line 66) | struct weighted_tail_quantile_impl
method weighted_tail_quantile_impl (line 73) | weighted_tail_quantile_impl(dont_care) {}
method result_type (line 76) | result_type result(Args const &args) const
type tag (line 117) | namespace tag
type weighted_tail_quantile (line 120) | struct weighted_tail_quantile
type extract (line 131) | namespace extract
FILE: external/common/include/boost/accumulators/statistics/weighted_tail_variate_means.hpp
type boost (line 37) | namespace boost
type numeric (line 41) | namespace numeric { namespace functional
type functional (line 41) | namespace functional
type multiply_and_promote_to_double (line 46) | struct multiply_and_promote_to_double
type accumulators (line 53) | namespace accumulators
type impl (line 56) | namespace impl
type weighted_tail_variate_means_impl (line 107) | struct weighted_tail_variate_means_impl
method weighted_tail_variate_means_impl (line 115) | weighted_tail_variate_means_impl(dont_care) {}
method result_type (line 118) | result_type result(Args const &args) const
type tag (line 190) | namespace tag
type absolute_weighted_tail_variate_means (line 193) | struct absolute_weighted_tail_variate_means
type relative_weighted_tail_variate_means (line 199) | struct relative_weighted_tail_variate_means
type extract (line 210) | namespace extract
type as_feature<tag::weighted_tail_variate_means<LeftRight, VariateType, VariateTag>(absolute)> (line 224) | struct as_feature<tag::weighted_tail_variate_means<LeftRight, Variat...
type as_feature<tag::weighted_tail_variate_means<LeftRight, VariateType, VariateTag>(relative)> (line 231) | struct as_feature<tag::weighted_tail_variate_means<LeftRight, Variat...
type boost (line 53) | namespace boost { namespace accumulators
type numeric (line 41) | namespace numeric { namespace functional
type functional (line 41) | namespace functional
type multiply_and_promote_to_double (line 46) | struct multiply_and_promote_to_double
type accumulators (line 53) | namespace accumulators
type impl (line 56) | namespace impl
type weighted_tail_variate_means_impl (line 107) | struct weighted_tail_variate_means_impl
method weighted_tail_variate_means_impl (line 115) | weighted_tail_variate_means_impl(dont_care) {}
method result_type (line 118) | result_type result(Args const &args) const
type tag (line 190) | namespace tag
type absolute_weighted_tail_variate_means (line 193) | struct absolute_weighted_tail_variate_means
type relative_weighted_tail_variate_means (line 199) | struct relative_weighted_tail_variate_means
type extract (line 210) | namespace extract
type as_feature<tag::weighted_tail_variate_means<LeftRight, VariateType, VariateTag>(absolute)> (line 224) | struct as_feature<tag::weighted_tail_variate_means<LeftRight, Variat...
type as_feature<tag::weighted_tail_variate_means<LeftRight, VariateType, VariateTag>(relative)> (line 231) | struct as_feature<tag::weighted_tail_variate_means<LeftRight, Variat...
FILE: external/common/include/boost/accumulators/statistics/weighted_variance.hpp
type boost (line 24) | namespace boost { namespace accumulators
type accumulators (line 24) | namespace accumulators
type impl (line 27) | namespace impl
type lazy_weighted_variance_impl (line 39) | struct lazy_weighted_variance_impl
method lazy_weighted_variance_impl (line 46) | lazy_weighted_variance_impl(dont_care) {}
method result_type (line 49) | result_type result(Args const &args) const
type weighted_variance_impl (line 71) | struct weighted_variance_impl
method weighted_variance_impl (line 79) | weighted_variance_impl(Args const &args)
method result_type (line 101) | result_type result(dont_care) const
type tag (line 116) | namespace tag
type lazy_weighted_variance (line 118) | struct lazy_weighted_variance
type weighted_variance (line 126) | struct weighted_variance
type extract (line 139) | namespace extract
type as_feature<tag::weighted_variance(lazy)> (line 153) | struct as_feature<tag::weighted_variance(lazy)>
type as_feature<tag::weighted_variance(immediate)> (line 160) | struct as_feature<tag::weighted_variance(immediate)>
FILE: external/common/include/boost/accumulators/statistics/with_error.hpp
type boost (line 18) | namespace boost { namespace accumulators
type accumulators (line 18) | namespace accumulators
type detail (line 21) | namespace detail
type error_of_tag (line 24) | struct error_of_tag
type with_error (line 34) | struct with_error
FILE: external/common/include/boost/accumulators/statistics_fwd.hpp
type boost (line 18) | namespace boost { namespace accumulators
type accumulators (line 18) | namespace accumulators
type tag (line 23) | namespace tag
type quantile (line 25) | struct quantile
class ____MISSING_SPECIFIC_QUANTILE_FEATURE_IN_ACCUMULATOR_SET____ (line 28) | class ____MISSING_SPECIFIC_QUANTILE_FEATURE_IN_ACCUMULATOR_SET____
type tail_mean (line 43) | struct tail_mean
class ____MISSING_SPECIFIC_TAIL_MEAN_FEATURE_IN_ACCUMULATOR_SET____ (line 46) | class ____MISSING_SPECIFIC_TAIL_MEAN_FEATURE_IN_ACCUMULATOR_SET____
type weights (line 61) | struct weights
type covariate1 (line 62) | struct covariate1
type covariate2 (line 63) | struct covariate2
type count (line 67) | struct count
type covariance (line 69) | struct covariance
type density (line 70) | struct density
type error_of (line 72) | struct error_of
type extended_p_square (line 73) | struct extended_p_square
type extended_p_square_quantile (line 74) | struct extended_p_square_quantile
type extended_p_square_quantile_quadratic (line 75) | struct extended_p_square_quantile_quadratic
type kurtosis (line 76) | struct kurtosis
type max (line 77) | struct max
type mean (line 78) | struct mean
type immediate_mean (line 79) | struct immediate_mean
type mean_of_weights (line 80) | struct mean_of_weights
type immediate_mean_of_weights (line 81) | struct immediate_mean_of_weights
type mean_of_variates (line 83) | struct mean_of_variates
type immediate_mean_of_variates (line 85) | struct immediate_mean_of_variates
type median (line 86) | struct median
type with_density_median (line 87) | struct with_density_median
type with_p_square_cumulative_distribution_median (line 88) | struct with_p_square_cumulative_distribution_median
type min (line 89) | struct min
type moment (line 91) | struct moment
type peaks_over_threshold (line 93) | struct peaks_over_threshold
type peaks_over_threshold_prob (line 95) | struct peaks_over_threshold_prob
type pot_tail_mean (line 97) | struct pot_tail_mean
type pot_tail_mean_prob (line 99) | struct pot_tail_mean_prob
type pot_quantile (line 101) | struct pot_quantile
type pot_quantile_prob (line 103) | struct pot_quantile_prob
type p_square_cumulative_distribution (line 104) | struct p_square_cumulative_distribution
type p_square_quantile (line 105) | struct p_square_quantile
type p_square_quantile_for_median (line 106) | struct p_square_quantile_for_median
type skewness (line 107) | struct skewness
type sum (line 108) | struct sum
type sum_of_weights (line 109) | struct sum_of_weights
type sum_of_variates (line 111) | struct sum_of_variates
type sum_kahan (line 112) | struct sum_kahan
type sum_of_weights_kahan (line 113) | struct sum_of_weights_kahan
type sum_of_variates_kahan (line 115) | struct sum_of_variates_kahan
type tail (line 117) | struct tail
type coherent_tail_mean (line 119) | struct coherent_tail_mean
type non_coherent_tail_mean (line 121) | struct non_coherent_tail_mean
type tail_quantile (line 123) | struct tail_quantile
type tail_variate (line 125) | struct tail_variate
type tail_weights (line 127) | struct tail_weights
type right_tail_variate (line 129) | struct right_tail_variate
type left_tail_variate (line 131) | struct left_tail_variate
type tail_variate_means (line 133) | struct tail_variate_means
type absolute_tail_variate_means (line 135) | struct absolute_tail_variate_means
type relative_tail_variate_means (line 137) | struct relative_tail_variate_means
type lazy_variance (line 138) | struct lazy_variance
type variance (line 139) | struct variance
type weighted_covariance (line 141) | struct weighted_covariance
type weighted_density (line 142) | struct weighted_density
type weighted_kurtosis (line 143) | struct weighted_kurtosis
type weighted_mean (line 144) | struct weighted_mean
type immediate_weighted_mean (line 145) | struct immediate_weighted_mean
type weighted_mean_of_variates (line 147) | struct weighted_mean_of_variates
type immediate_weighted_mean_of_variates (line 149) | struct immediate_weighted_mean_of_variates
type weighted_median (line 150) | struct weighted_median
type with_density_weighted_median (line 151) | struct with_density_weighted_median
type with_p_square_cumulative_distribution_weighted_median (line 152) | struct with_p_square_cumulative_distribution_weighted_median
type weighted_extended_p_square (line 153) | struct weighted_extended_p_square
type weighted_extended_p_square_quantile (line 154) | struct weighted_extended_p_square_quantile
type weighted_extended_p_square_quantile_quadratic (line 155) | struct weighted_extended_p_square_quantile_quadratic
type weighted_moment (line 157) | struct weighted_moment
type weighted_peaks_over_threshold (line 159) | struct weighted_peaks_over_threshold
type weighted_peaks_over_threshold_prob (line 161) | struct weighted_peaks_over_threshold_prob
type weighted_pot_quantile (line 163) | struct weighted_pot_quantile
type weighted_pot_quantile_prob (line 165) | struct weighted_pot_quantile_prob
type weighted_pot_tail_mean (line 167) | struct weighted_pot_tail_mean
type weighted_pot_tail_mean_prob (line 169) | struct weighted_pot_tail_mean_prob
type weighted_p_square_cumulative_distribution (line 170) | struct weighted_p_square_cumulative_distribution
type weighted_p_square_quantile (line 171) | struct weighted_p_square_quantile
type weighted_p_square_quantile_for_median (line 172) | struct weighted_p_square_quantile_for_median
type weighted_skewness (line 173) | struct weighted_skewness
type weighted_tail_quantile (line 175) | struct weighted_tail_quantile
type non_coherent_weighted_tail_mean (line 177) | struct non_coherent_weighted_tail_mean
type weighted_tail_quantile (line 179) | struct weighted_tail_quantile
type weighted_tail_variate_means (line 181) | struct weighted_tail_variate_means
type absolute_weighted_tail_variate_means (line 183) | struct absolute_weighted_tail_variate_means
type relative_weighted_tail_variate_means (line 185) | struct relative_weighted_tail_variate_means
type lazy_weighted_variance (line 186) | struct lazy_weighted_variance
type weighted_variance (line 187) | struct weighted_variance
type weighted_sum (line 188) | struct weighted_sum
type weighted_sum_of_variates (line 190) | struct weighted_sum_of_variates
type rolling_window_plus1 (line 191) | struct rolling_window_plus1
type rolling_window (line 192) | struct rolling_window
type rolling_sum (line 193) | struct rolling_sum
type rolling_count (line 194) | struct rolling_count
type rolling_mean (line 195) | struct rolling_mean
type extract (line 31) | namespace extract
type tag (line 41) | namespace tag
type quantile (line 25) | struct quantile
class ____MISSING_SPECIFIC_QUANTILE_FEATURE_IN_ACCUMULATOR_SET____ (line 28) | class ____MISSING_SPECIFIC_QUANTILE_FEATURE_IN_ACCUMULATOR_SET____
type tail_mean (line 43) | struct tail_mean
class ____MISSING_SPECIFIC_TAIL_MEAN_FEATURE_IN_ACCUMULATOR_SET____ (line 46) | class ____MISSING_SPECIFIC_TAIL_MEAN_FEATURE_IN_ACCUMULATOR_SET____
type weights (line 61) | struct weights
type covariate1 (line 62) | struct covariate1
type covariate2 (line 63) | struct covariate2
type count (line 67) | struct count
type covariance (line 69) | struct covariance
type density (line 70) | struct density
type error_of (line 72) | struct error_of
type extended_p_square (line 73) | struct extended_p_square
type extended_p_square_quantile (line 74) | struct extended_p_square_quantile
type extended_p_square_quantile_quadratic (line 75) | struct extended_p_square_quantile_quadratic
type kurtosis (line 76) | struct kurtosis
type max (line 77) | struct max
type mean (line 78) | struct mean
type immediate_mean (line 79) | struct immediate_mean
type mean_of_weights (line 80) | struct mean_of_weights
type immediate_mean_of_weights (line 81) | struct immediate_mean_of_weights
type mean_of_variates (line 83) | struct mean_of_variates
type immediate_mean_of_variates (line 85) | struct immediate_mean_of_variates
type median (line 86) | struct median
type with_density_median (line 87) | struct with_density_median
type with_p_square_cumulative_distribution_median (line 88) | struct with_p_square_cumulative_distribution_median
type min (line 89) | struct min
type moment (line 91) | struct moment
type peaks_over_threshold (line 93) | struct peaks_over_threshold
type peaks_over_threshold_prob (line 95) | struct peaks_over_threshold_prob
type pot_tail_mean (line 97) | struct pot_tail_mean
type pot_tail_mean_prob (line 99) | struct pot_tail_mean_prob
type pot_quantile (line 101) | struct pot_quantile
type pot_quantile_prob (line 103) | struct pot_quantile_prob
type p_square_cumulative_distribution (line 104) | struct p_square_cumulative_distribution
type p_square_quantile (line 105) | struct p_square_quantile
type p_square_quantile_for_median (line 106) | struct p_square_quantile_for_median
type skewness (line 107) | struct skewness
type sum (line 108) | struct sum
type sum_of_weights (line 109) | struct sum_of_weights
type sum_of_variates (line 111) | struct sum_of_variates
type sum_kahan (line 112) | struct sum_kahan
type sum_of_weights_kahan (line 113) | struct sum_of_weights_kahan
type sum_of_variates_kahan (line 115) | struct sum_of_variates_kahan
type tail (line 117) | struct tail
type coherent_tail_mean (line 119) | struct coherent_tail_mean
type non_coherent_tail_mean (line 121) | struct non_coherent_tail_mean
type tail_quantile (line 123) | struct tail_quantile
type tail_variate (line 125) | struct tail_variate
type tail_weights (line 127) | struct tail_weights
type right_tail_variate (line 129) | struct right_tail_variate
type left_tail_variate (line 131) | struct left_tail_variate
type tail_variate_means (line 133) | struct tail_variate_means
type absolute_tail_variate_means (line 135) | struct absolute_tail_variate_means
type relative_tail_variate_means (line 137) | struct relative_tail_variate_means
type lazy_variance (line 138) | struct lazy_variance
type variance (line 139) | struct variance
type weighted_covariance (line 141) | struct weighted_covariance
type weighted_density (line 142) | struct weighted_density
type weighted_kurtosis (line 143) | struct weighted_kurtosis
type weighted_mean (line 144) | struct weighted_mean
type immediate_weighted_mean (line 145) | struct immediate_weighted_mean
type weighted_mean_of_variates (line 147) | struct weighted_mean_of_variates
type immediate_weighted_mean_of_variates (line 149) | struct immediate_weighted_mean_of_variates
type weighted_median (line 150) | struct weighted_median
type with_density_weighted_median (line 151) | struct with_density_weighted_median
type with_p_square_cumulative_distribution_weighted_median (line 152) | struct with_p_square_cumulative_distribution_weighted_median
type weighted_extended_p_square (line 153) | struct weighted_extended_p_square
type weighted_extended_p_square_quantile (line 154) | struct weighted_extended_p_square_quantile
type weighted_extended_p_square_quantile_quadratic (line 155) | struct weighted_extended_p_square_quantile_quadratic
type weighted_moment (line 157) | struct weighted_moment
type weighted_peaks_over_threshold (line 159) | struct weighted_peaks_over_threshold
type weighted_peaks_over_threshold_prob (line 161) | struct weighted_peaks_over_threshold_prob
type weighted_pot_quantile (line 163) | struct weighted_pot_quantile
type weighted_pot_quantile_prob (line 165) | struct weighted_pot_quantile_prob
type weighted_pot_tail_mean (line 167) | struct weighted_pot_tail_mean
type weighted_pot_tail_mean_prob (line 169) | struct weighted_pot_tail_mean_prob
type weighted_p_square_cumulative_distribution (line 170) | struct weighted_p_square_cumulative_distribution
type weighted_p_square_quantile (line 171) | struct weighted_p_square_quantile
type weighted_p_square_quantile_for_median (line 172) | struct weighted_p_square_quantile_for_median
type weighted_skewness (line 173) | struct weighted_skewness
type weighted_tail_quantile (line 175) | struct weighted_tail_quantile
type non_coherent_weighted_tail_mean (line 177) | struct non_coherent_weighted_tail_mean
type weighted_tail_quantile (line 179) | struct weighted_tail_quantile
type weighted_tail_variate_means (line 181) | struct weighted_tail_variate_means
type absolute_weighted_tail_variate_means (line 183) | struct absolute_weighted_tail_variate_means
type relative_weighted_tail_variate_means (line 185) | struct relative_weighted_tail_variate_means
type lazy_weighted_variance (line 186) | struct lazy_weighted_variance
type weighted_variance (line 187) | struct weighted_variance
type weighted_sum (line 188) | struct weighted_sum
type weighted_sum_of_variates (line 190) | struct weighted_sum_of_variates
type rolling_window_plus1 (line 191) | struct rolling_window_plus1
type rolling_window (line 192) | struct rolling_window
type rolling_sum (line 193) | struct rolling_sum
type rolling_count (line 194) | struct rolling_count
type rolling_mean (line 195) | struct rolling_mean
type extract (line 49) | namespace extract
type tag (line 57) | namespace tag
type quantile (line 25) | struct quantile
class ____MISSING_SPECIFIC_QUANTILE_FEATURE_IN_ACCUMULATOR_SET____ (line 28) | class ____MISSING_SPECIFIC_QUANTILE_FEATURE_IN_ACCUMULATOR_SET____
type tail_mean (line 43) | struct tail_mean
class ____MISSING_SPECIFIC_TAIL_MEAN_FEATURE_IN_ACCUMULATOR_SET____ (line 46) | class ____MISSING_SPECIFIC_TAIL_MEAN_FEATURE_IN_ACCUMULATOR_SET____
type weights (line 61) | struct weights
type covariate1 (line 62) | struct covariate1
type covariate2 (line 63) | struct covariate2
type count (line 67) | struct count
type covariance (line 69) | struct covariance
type density (line 70) | struct density
type error_of (line 72) | struct error_of
type extended_p_square (line 73) | struct extended_p_square
type extended_p_square_quantile (line 74) | struct extended_p_square_quantile
type extended_p_square_quantile_quadratic (line 75) | struct extended_p_square_quantile_quadratic
type kurtosis (line 76) | struct kurtosis
type max (line 77) | struct max
type mean (line 78) | struct mean
type immediate_mean (line 79) | struct immediate_mean
type mean_of_weights (line 80) | struct mean_of_weights
type immediate_mean_of_weights (line 81) | struct immediate_mean_of_weights
type mean_of_variates (line 83) | struct mean_of_variates
type immediate_mean_of_variates (line 85) | struct immediate_mean_of_variates
type median (line 86) | struct median
type with_density_median (line 87) | struct with_density_median
type with_p_square_cumulative_distribution_median (line 88) | struct with_p_square_cumulative_distribution_median
type min (line 89) | struct min
type moment (line 91) | struct moment
type peaks_over_threshold (line 93) | struct peaks_over_threshold
type peaks_over_threshold_prob (line 95) | struct peaks_over_threshold_prob
type pot_tail_mean (line 97) | struct pot_tail_mean
type pot_tail_mean_prob (line 99) | struct pot_tail_mean_prob
type pot_quantile (line 101) | struct pot_quantile
type pot_quantile_prob (line 103) | struct pot_quantile_prob
type p_square_cumulative_distribution (line 104) | struct p_square_cumulative_distribution
type p_square_quantile (line 105) | struct p_square_quantile
type p_square_quantile_for_median (line 106) | struct p_square_quantile_for_median
type skewness (line 107) | struct skewness
type sum (line 108) | struct sum
type sum_of_weights (line 109) | struct sum_of_weights
type sum_of_variates (line 111) | struct sum_of_variates
type sum_kahan (line 112) | struct sum_kahan
type sum_of_weights_kahan (line 113) | struct sum_of_weights_kahan
type sum_of_variates_kahan (line 115) | struct sum_of_variates_kahan
type tail (line 117) | struct tail
type coherent_tail_mean (line 119) | struct coherent_tail_mean
type non_coherent_tail_mean (line 121) | struct non_coherent_tail_mean
type tail_quantile (line 123) | struct tail_quantile
type tail_variate (line 125) | struct tail_variate
type tail_weights (line 127) | struct tail_weights
type right_tail_variate (line 129) | struct right_tail_variate
type left_tail_variate (line 131) | struct left_tail_variate
type tail_variate_means (line 133) | struct tail_variate_means
type absolute_tail_variate_means (line 135) | struct absolute_tail_variate_means
type relative_tail_variate_means (line 137) | struct relative_tail_variate_means
type lazy_variance (line 138) | struct lazy_variance
type variance (line 139) | struct variance
type weighted_covariance (line 141) | struct weighted_covariance
type weighted_density (line 142) | struct weighted_density
type weighted_kurtosis (line 143) | struct weighted_kurtosis
type weighted_mean (line 144) | struct weighted_mean
type immediate_weighted_mean (line 145) | struct immediate_weighted_mean
type weighted_mean_of_variates (line 147) | struct weighted_mean_of_variates
type immediate_weighted_mean_of_variates (line 149) | struct immediate_weighted_mean_of_variates
type weighted_median (line 150) | struct weighted_median
type with_density_weighted_median (line 151) | struct with_density_weighted_median
type with_p_square_cumulative_distribution_weighted_median (line 152) | struct with_p_square_cumulative_distribution_weighted_median
type weighted_extended_p_square (line 153) | struct weighted_extended_p_square
type weighted_extended_p_square_quantile (line 154) | struct weighted_extended_p_square_quantile
type weighted_extended_p_square_quantile_quadratic (line 155) | struct weighted_extended_p_square_quantile_quadratic
type weighted_moment (line 157) | struct weighted_moment
type weighted_peaks_over_threshold (line 159) | struct weighted_peaks_over_threshold
type weighted_peaks_over_threshold_prob (line 161) | struct weighted_peaks_over_threshold_prob
type weighted_pot_quantile (line 163) | struct weighted_pot_quantile
type weighted_pot_quantile_prob (line 165) | struct weighted_pot_quantile_prob
type weighted_pot_tail_mean (line 167) | struct weighted_pot_tail_mean
type weighted_pot_tail_mean_prob (line 169) | struct weighted_pot_tail_mean_prob
type weighted_p_square_cumulative_distribution (line 170) | struct weighted_p_square_cumulative_distribution
type weighted_p_square_quantile (line 171) | struct weighted_p_square_quantile
type weighted_p_square_quantile_for_median (line 172) | struct weighted_p_square_quantile_for_median
type weighted_skewness (line 173) | struct weighted_skewness
type weighted_tail_quantile (line 175) | struct weighted_tail_quantile
type non_coherent_weighted_tail_mean (line 177) | struct non_coherent_weighted_tail_mean
type weighted_tail_quantile (line 179) | struct weighted_tail_quantile
type weighted_tail_variate_means (line 181) | struct weighted_tail_variate_means
type absolute_weighted_tail_variate_means (line 183) | struct absolute_weighted_tail_variate_means
type relative_weighted_tail_variate_means (line 185) | struct relative_weighted_tail_variate_means
type lazy_weighted_variance (line 186) | struct lazy_weighted_variance
type weighted_variance (line 187) | struct weighted_variance
type weighted_sum (line 188) | struct weighted_sum
type weighted_sum_of_variates (line 190) | struct weighted_sum_of_variates
type rolling_window_plus1 (line 191) | struct rolling_window_plus1
type rolling_window (line 192) | struct rolling_window
type rolling_sum (line 193) | struct rolling_sum
type rolling_count (line 194) | struct rolling_count
type rolling_mean (line 195) | struct rolling_mean
type impl (line 198) | namespace impl
type count_impl (line 202) | struct count_impl
type covariance_impl (line 205) | struct covariance_impl
type density_impl (line 208) | struct density_impl
type error_of_impl (line 211) | struct error_of_impl
type error_of_mean_impl (line 214) | struct error_of_mean_impl
type extended_p_square_impl (line 217) | struct extended_p_square_impl
type extended_p_square_quantile_impl (line 220) | struct extended_p_square_quantile_impl
type kurtosis_impl (line 223) | struct kurtosis_impl
type max_impl (line 226) | struct max_impl
type median_impl (line 229) | struct median_impl
type with_density_median_impl (line 232) | struct with_density_median_impl
type with_p_square_cumulative_distribution_median_impl (line 235) | struct with_p_square_cumulative_distribution_median_impl
type min_impl (line 238) | struct min_impl
type mean_impl (line 241) | struct mean_impl
type immediate_mean_impl (line 244) | struct immediate_mean_impl
type moment_impl (line 247) | struct moment_impl
type peaks_over_threshold_prob_impl (line 250) | struct peaks_over_threshold_prob_impl
type pot_quantile_impl (line 253) | struct pot_quantile_impl
type pot_tail_mean_impl (line 256) | struct pot_tail_mean_impl
type p_square_cumulative_distribution_impl (line 259) | struct p_square_cumulative_distribution_impl
type p_square_quantile_impl (line 262) | struct p_square_quantile_impl
type skewness_impl (line 265) | struct skewness_impl
type sum_impl (line 268) | struct sum_impl
type sum_kahan_impl (line 271) | struct sum_kahan_impl
type tail_impl (line 274) | struct tail_impl
type coherent_tail_mean_impl (line 277) | struct coherent_tail_mean_impl
type non_coherent_tail_mean_impl (line 280) | struct non_coherent_tail_mean_impl
type tail_quantile_impl (line 283) | struct tail_quantile_impl
type tail_variate_impl (line 286) | struct tail_variate_impl
type tail_variate_means_impl (line 289) | struct tail_variate_means_impl
type lazy_variance_impl (line 292) | struct lazy_variance_impl
type variance_impl (line 295) | struct variance_impl
type weighted_covariance_impl (line 298) | struct weighted_covariance_impl
type weighted_density_impl (line 301) | struct weighted_density_impl
type weighted_kurtosis_impl (line 304) | struct weighted_kurtosis_impl
type weighted_median_impl (line 307) | struct weighted_median_impl
type with_density_weighted_median_impl (line 310) | struct with_density_weighted_median_impl
type with_p_square_cumulative_distribution_weighted_median_impl (line 313) | struct with_p_square_cumulative_distribution_weighted_median_impl
type weighted_mean_impl (line 316) | struct weighted_mean_impl
type immediate_weighted_mean_impl (line 319) | struct immediate_weighted_mean_impl
type weighted_peaks_over_threshold_impl (line 322) | struct weighted_peaks_over_threshold_impl
type weighted_peaks_over_threshold_prob_impl (line 325) | struct weighted_peaks_over_threshold_prob_impl
type with_p_square_cumulative_distribution_weighted_median_impl (line 328) | struct with_p_square_cumulative_distribution_weighted_median_impl
type weighted_extended_p_square_impl (line 331) | struct weighted_extended_p_square_impl
type weighted_moment_impl (line 334) | struct weighted_moment_impl
type weighted_p_square_cumulative_distribution_impl (line 337) | struct weighted_p_square_cumulative_distribution_impl
type weighted_p_square_quantile_impl (line 340) | struct weighted_p_square_quantile_impl
type weighted_skewness_impl (line 343) | struct weighted_skewness_impl
type weighted_sum_impl (line 346) | struct weighted_sum_impl
type weighted_sum_kahan_impl (line 349) | struct weighted_sum_kahan_impl
type non_coherent_weighted_tail_mean_impl (line 352) | struct non_coherent_weighted_tail_mean_impl
type weighted_tail_quantile_impl (line 355) | struct weighted_tail_quantile_impl
type weighted_tail_variate_means_impl (line 358) | struct weighted_tail_variate_means_impl
type lazy_weighted_variance_impl (line 361) | struct lazy_weighted_variance_impl
type weighted_variance_impl (line 364) | struct weighted_variance_impl
type rolling_window_plus1_impl (line 367) | struct rolling_window_plus1_impl
type rolling_window_impl (line 370) | struct rolling_window_impl
type rolling_sum_impl (line 373) | struct rolling_sum_impl
type rolling_count_impl (line 376) | struct rolling_count_impl
type rolling_mean_impl (line 379) | struct rolling_mean_impl
type stats (line 386) | struct stats
type with_error (line 389) | struct with_error
type lazy (line 392) | struct lazy {}
type immediate (line 393) | struct immediate {}
type right (line 400) | struct right {}
type left (line 401) | struct left {}
type absolute (line 405) | struct absolute {}
type relative (line 406) | struct relative {}
type with_density (line 409) | struct with_density {}
type with_p_square_cumulative_distribution (line 410) | struct with_p_square_cumulative_distribution {}
type with_p_square_quantile (line 411) | struct with_p_square_quantile {}
type with_threshold_value (line 414) | struct with_threshold_value {}
type with_threshold_probability (line 415) | struct with_threshold_probability {}
type weighted (line 418) | struct weighted {}
type unweighted (line 419) | struct unweighted {}
type linear (line 420) | struct linear {}
type quadratic (line 421) | struct quadratic {}
type regular (line 424) | struct regular {}
type for_median (line 425) | struct for_median {}
type kahan (line 428) | struct kahan {}
FILE: external/common/include/boost/algorithm/algorithm.hpp
type boost (line 25) | namespace boost { namespace algorithm {
type algorithm (line 25) | namespace algorithm {
function T (line 28) | T identity_operation ( std::multiplies<T> ) { return T(1); }
function T (line 31) | T identity_operation ( std::plus<T> ) { return T(0); }
function power (line 43) | typename boost::enable_if<boost::is_integral<Integer>, T>::type
function power (line 70) | typename boost::enable_if<boost::is_integral<Integer>, T>::type
FILE: external/common/include/boost/algorithm/clamp.hpp
type boost (line 31) | namespace boost { namespace algorithm {
type algorithm (line 31) | namespace algorithm {
function T (line 49) | T const & clamp ( T const& val,
function T (line 71) | T const& clamp ( const T& val,
function OutputIterator (line 90) | OutputIterator clamp_range ( InputIterator first, InputIterator last...
function clamp_range (line 111) | typename boost::disable_if_c<boost::is_same<Range, OutputIterator>::...
function OutputIterator (line 136) | OutputIterator clamp_range ( InputIterator first, InputIterator last...
function clamp_range (line 163) | typename boost::disable_if_c<boost::is_same<Range, OutputIterator>::...
FILE: external/common/include/boost/algorithm/cxx11/all_of.hpp
type boost (line 18) | namespace boost { namespace algorithm {
type algorithm (line 18) | namespace algorithm {
function all_of (line 30) | bool all_of ( InputIterator first, InputIterator last, Predicate p )
function all_of (line 46) | bool all_of ( const Range &r, Predicate p )
function all_of_equal (line 60) | bool all_of_equal ( InputIterator first, InputIterator last, const T...
function all_of_equal (line 76) | bool all_of_equal ( const Range &r, const T &val )
FILE: external/common/include/boost/algorithm/cxx11/any_of.hpp
type boost (line 20) | namespace boost { namespace algorithm {
type algorithm (line 20) | namespace algorithm {
function any_of (line 31) | bool any_of ( InputIterator first, InputIterator last, Predicate p )
function any_of (line 47) | bool any_of ( const Range &r, Predicate p )
function any_of_equal (line 61) | bool any_of_equal ( InputIterator first, InputIterator last, const V...
function any_of_equal (line 77) | bool any_of_equal ( const Range &r, const V &val )
FILE: external/common/include/boost/algorithm/cxx11/copy_if.hpp
type boost (line 19) | namespace boost { namespace algorithm {
type algorithm (line 19) | namespace algorithm {
function OutputIterator (line 32) | OutputIterator copy_if ( InputIterator first, InputIterator last, Ou...
function OutputIterator (line 50) | OutputIterator copy_if ( const Range &r, OutputIterator result, Pred...
function copy_while (line 67) | std::pair<InputIterator, OutputIterator>
function copy_while (line 85) | std::pair<typename boost::range_iterator<const Range>::type, OutputI...
function copy_until (line 103) | std::pair<InputIterator, OutputIterator>
function copy_until (line 121) | std::pair<typename boost::range_iterator<const Range>::type, OutputI...
FILE: external/common/include/boost/algorithm/cxx11/copy_n.hpp
type boost (line 15) | namespace boost { namespace algorithm {
type algorithm (line 15) | namespace algorithm {
function OutputIterator (line 27) | OutputIterator copy_n ( InputIterator first, Size n, OutputIterator ...
FILE: external/common/include/boost/algorithm/cxx11/find_if_not.hpp
type boost (line 18) | namespace boost { namespace algorithm {
type algorithm (line 18) | namespace algorithm {
function InputIterator (line 29) | InputIterator find_if_not ( InputIterator first, InputIterator last,...
function find_if_not (line 45) | typename boost::range_iterator<const Range>::type find_if_not ( cons...
FILE: external/common/include/boost/algorithm/cxx11/iota.hpp
type boost (line 18) | namespace boost { namespace algorithm {
type algorithm (line 18) | namespace algorithm {
function iota (line 28) | void iota ( ForwardIterator first, ForwardIterator last, T value )
function iota (line 41) | void iota ( Range &r, T value )
function OutputIterator (line 55) | OutputIterator iota_n ( OutputIterator out, T value, std::size_t n )
FILE: external/common/include/boost/algorithm/cxx11/is_partitioned.hpp
type boost (line 18) | namespace boost { namespace algorithm {
type algorithm (line 18) | namespace algorithm {
function is_partitioned (line 28) | bool is_partitioned ( InputIterator first, InputIterator last, Unary...
function is_partitioned (line 48) | bool is_partitioned ( const Range &r, UnaryPredicate p )
FILE: external/common/include/boost/algorithm/cxx11/is_permutation.hpp
type boost (line 25) | namespace boost { namespace algorithm {
type algorithm (line 25) | namespace algorithm {
type detail (line 28) | namespace detail {
type value_predicate (line 30) | struct value_predicate {
method value_predicate (line 31) | value_predicate ( Predicate p, Iterator it ) : p_ ( p ), it_ ( i...
function is_permutation_inner (line 44) | bool is_permutation_inner ( ForwardIterator1 first1, ForwardIterat...
function is_permutation_tag (line 64) | bool is_permutation_tag ( ForwardIterator1 first1, ForwardIterator...
function is_permutation_tag (line 81) | bool is_permutation_tag ( RandomAccessIterator1 first1, RandomAcce...
function is_permutation (line 112) | bool is_permutation ( ForwardIterator1 first1, ForwardIterator1 last1,
function is_permutation (line 137) | bool is_permutation ( ForwardIterator1 first1, ForwardIterator1 last...
function is_permutation (line 162) | bool is_permutation ( const Range &r, ForwardIterator first2 )
function is_permutation (line 177) | typename boost::disable_if_c<boost::is_same<Range, ForwardIterator>:...
FILE: external/common/include/boost/algorithm/cxx11/is_sorted.hpp
type boost (line 26) | namespace boost { namespace algorithm {
type algorithm (line 26) | namespace algorithm {
function ForwardIterator (line 37) | ForwardIterator is_sorted_until ( ForwardIterator first, ForwardIter...
function ForwardIterator (line 57) | ForwardIterator is_sorted_until ( ForwardIterator first, ForwardIter...
function is_sorted (line 72) | bool is_sorted ( ForwardIterator first, ForwardIterator last, Pred p )
function is_sorted (line 84) | bool is_sorted ( ForwardIterator first, ForwardIterator last )
function is_sorted_until (line 101) | typename boost::lazy_disable_if_c<
function is_sorted_until (line 116) | typename boost::range_iterator<const R>::type is_sorted_until ( cons...
function is_sorted (line 129) | typename boost::lazy_disable_if_c< boost::is_same<R, Pred>::value, b...
function is_sorted (line 142) | bool is_sorted ( const R &range )
function is_increasing (line 162) | bool is_increasing ( ForwardIterator first, ForwardIterator last )
function is_increasing (line 178) | bool is_increasing ( const R &range )
function is_decreasing (line 195) | bool is_decreasing ( ForwardIterator first, ForwardIterator last )
function is_decreasing (line 210) | bool is_decreasing ( const R &range )
function is_strictly_increasing (line 227) | bool is_strictly_increasing ( ForwardIterator first, ForwardIterator...
function is_strictly_increasing (line 242) | bool is_strictly_increasing ( const R &range )
function is_strictly_decreasing (line 258) | bool is_strictly_decreasing ( ForwardIterator first, ForwardIterator...
function is_strictly_decreasing (line 273) | bool is_strictly_decreasing ( const R &range )
FILE: external/common/include/boost/algorithm/cxx11/none_of.hpp
type boost (line 18) | namespace boost { namespace algorithm {
type algorithm (line 18) | namespace algorithm {
function none_of (line 29) | bool none_of ( InputIterator first, InputIterator last, Predicate p )
function none_of (line 45) | bool none_of ( const Range &r, Predicate p )
function none_of_equal (line 59) | bool none_of_equal ( InputIterator first, InputIterator last, const ...
function none_of_equal (line 75) | bool none_of_equal ( const Range &r, const V & val )
FILE: external/common/include/boost/algorithm/cxx11/one_of.hpp
type boost (line 21) | namespace boost { namespace algorithm {
type algorithm (line 21) | namespace algorithm {
function one_of (line 31) | bool one_of ( InputIterator first, InputIterator last, Predicate p )
function one_of (line 46) | bool one_of ( const Range &r, Predicate p )
function one_of_equal (line 60) | bool one_of_equal ( InputIterator first, InputIterator last, const V...
function one_of_equal (line 75) | bool one_of_equal ( const Range &r, const V &val )
FILE: external/common/include/boost/algorithm/cxx11/partition_copy.hpp
type boost (line 20) | namespace boost { namespace algorithm {
type algorithm (line 20) | namespace algorithm {
function partition_copy (line 38) | std::pair<OutputIterator1, OutputIterator2>
function partition_copy (line 60) | std::pair<OutputIterator1, OutputIterator2>
FILE: external/common/include/boost/algorithm/cxx11/partition_point.hpp
type boost (line 20) | namespace boost { namespace algorithm {
type algorithm (line 20) | namespace algorithm {
function ForwardIterator (line 31) | ForwardIterator partition_point ( ForwardIterator first, ForwardIter...
function partition_point (line 57) | typename boost::range_iterator<Range>::type partition_point ( Range ...
FILE: external/common/include/boost/algorithm/cxx14/equal.hpp
type boost (line 19) | namespace boost { namespace algorithm {
type algorithm (line 19) | namespace algorithm {
type detail (line 21) | namespace detail {
type eq (line 24) | struct eq : public std::binary_function<T1, T2, bool> {
function equal (line 29) | bool equal ( RandomAccessIterator1 first1, RandomAccessIterator1 l...
function equal (line 41) | bool equal ( InputIterator1 first1, InputIterator1 last1,
function equal (line 64) | bool equal ( InputIterator1 first1, InputIterator1 last1,
function equal (line 82) | bool equal ( InputIterator1 first1, InputIterator1 last1,
FILE: external/common/include/boost/algorithm/cxx14/is_permutation.hpp
type boost (line 22) | namespace boost { namespace algorithm {
type algorithm (line 22) | namespace algorithm {
function is_permutation (line 34) | bool is_permutation ( ForwardIterator1 first1, ForwardIterator1 last1,
function is_permutation (line 63) | bool is_permutation ( ForwardIterator1 first1, ForwardIterator1 last1,
FILE: external/common/include/boost/algorithm/cxx14/mismatch.hpp
type boost (line 17) | namespace boost { namespace algorithm {
type algorithm (line 17) | namespace algorithm {
function mismatch (line 30) | std::pair<InputIterator1, InputIterator2> mismatch (
function mismatch (line 50) | std::pair<InputIterator1, InputIterator2> mismatch (
FILE: external/common/include/boost/algorithm/gather.hpp
type boost (line 73) | namespace boost { namespace algorithm {
type algorithm (line 73) | namespace algorithm {
function gather (line 85) | std::pair<BidirectionalIterator, BidirectionalIterator> gather
function gather (line 105) | std::pair<
FILE: external/common/include/boost/algorithm/hex.hpp
type boost (line 36) | namespace boost { namespace algorithm {
type algorithm (line 36) | namespace algorithm {
type hex_decode_error (line 50) | struct hex_decode_error : virtual boost::exception, virtual std::exc...
type not_enough_input (line 51) | struct not_enough_input : virtual hex_decode_error {}
type non_hex_input (line 52) | struct non_hex_input : virtual hex_decode_error {}
type bad_char_ (line 53) | struct bad_char_
type detail (line 55) | namespace detail {
function OutputIterator (line 59) | OutputIterator encode_one ( T val, OutputIterator out, const char ...
function hex_char_to_int (line 69) | unsigned char hex_char_to_int ( T val ) {
type hex_iterator_traits (line 83) | struct hex_iterator_traits {
type hex_iterator_traits< std::back_insert_iterator<Container> > (line 88) | struct hex_iterator_traits< std::back_insert_iterator<Container> > {
type hex_iterator_traits< std::front_insert_iterator<Container> > (line 93) | struct hex_iterator_traits< std::front_insert_iterator<Container> > {
type hex_iterator_traits< std::insert_iterator<Container> > (line 98) | struct hex_iterator_traits< std::insert_iterator<Container> > {
type hex_iterator_traits< std::ostream_iterator<T, charType, traits> > (line 107) | struct hex_iterator_traits< std::ostream_iterator<T, charType, tra...
function iter_end (line 112) | bool iter_end ( Iterator current, Iterator last ) { return current...
function ptr_end (line 115) | bool ptr_end ( const T* ptr, const T* /*end*/ ) { return *ptr == '...
function decode_one (line 122) | typename boost::enable_if<boost::is_integral<typename hex_iterator...
function hex (line 150) | typename boost::enable_if<boost::is_integral<typename detail::hex_it...
function hex_lower (line 167) | typename boost::enable_if<boost::is_integral<typename detail::hex_it...
function hex (line 183) | typename boost::enable_if<boost::is_integral<T>, OutputIterator>::type
function hex_lower (line 199) | typename boost::enable_if<boost::is_integral<T>, OutputIterator>::type
function hex (line 215) | typename boost::enable_if<boost::is_integral<typename detail::hex_it...
function hex_lower (line 229) | typename boost::enable_if<boost::is_integral<typename detail::hex_it...
function OutputIterator (line 244) | OutputIterator unhex ( InputIterator first, InputIterator last, Outp...
function OutputIterator (line 259) | OutputIterator unhex ( const T *ptr, OutputIterator out ) {
function OutputIterator (line 277) | OutputIterator unhex ( const Range &r, OutputIterator out ) {
function String (line 288) | String hex ( const String &input ) {
function String (line 302) | String hex_lower ( const String &input ) {
function String (line 316) | String unhex ( const String &input ) {
FILE: external/common/include/boost/algorithm/is_palindrome.hpp
type boost (line 25) | namespace boost { namespace algorithm {
type algorithm (line 25) | namespace algorithm {
function is_palindrome (line 38) | bool is_palindrome(BidirectionalIterator begin, BidirectionalIterato...
function is_palindrome (line 72) | bool is_palindrome(BidirectionalIterator begin, BidirectionalIterato...
function is_palindrome (line 105) | bool is_palindrome(const R& range)
function is_palindrome (line 120) | bool is_palindrome(const R& range, Predicate p)
function is_palindrome (line 134) | bool is_palindrome(const char* str)
function is_palindrome (line 152) | bool is_palindrome(const char* str, Predicate p)
FILE: external/common/include/boost/algorithm/minmax.hpp
type boost (line 31) | namespace boost {
function minmax (line 34) | tuple< T const&, T const& >
function minmax (line 40) | tuple< T const&, T const& >
FILE: external/common/include/boost/algorithm/minmax_element.hpp
type boost (line 31) | namespace boost {
type detail (line 33) | namespace detail { // for obtaining a uniform version of minmax_element
type less_over_iter (line 38) | struct less_over_iter {
type binary_pred_over_iter (line 44) | struct binary_pred_over_iter {
method binary_pred_over_iter (line 45) | explicit binary_pred_over_iter(BinaryPredicate const& p ) : m_p( p...
function basic_minmax_element (line 55) | std::pair<ForwardIter,ForwardIter>
function ForwardIter (line 211) | ForwardIter
function ForwardIter (line 224) | ForwardIter
function ForwardIter (line 237) | ForwardIter
function ForwardIter (line 250) | ForwardIter
function basic_first_min_last_max_element (line 334) | std::pair<ForwardIter,ForwardIter>
function basic_last_min_first_max_element (line 380) | std::pair<ForwardIter,ForwardIter>
function basic_last_min_last_max_element (line 425) | std::pair<ForwardIter,ForwardIter>
function minmax_element (line 122) | std::pair<ForwardIter,ForwardIter>
function minmax_element (line 130) | std::pair<ForwardIter,ForwardIter>
type detail (line 208) | namespace detail { // common base for the overloads
type less_over_iter (line 38) | struct less_over_iter {
type binary_pred_over_iter (line 44) | struct binary_pred_over_iter {
method binary_pred_over_iter (line 45) | explicit binary_pred_over_iter(BinaryPredicate const& p ) : m_p( p...
function basic_minmax_element (line 55) | std::pair<ForwardIter,ForwardIter>
function ForwardIter (line 211) | ForwardIter
function ForwardIter (line 224) | ForwardIter
function ForwardIter (line 237) | ForwardIter
function ForwardIter (line 250) | ForwardIter
function basic_first_min_last_max_element (line 334) | std::pair<ForwardIter,ForwardIter>
function basic_last_min_first_max_element (line 380) | std::pair<ForwardIter,ForwardIter>
function basic_last_min_last_max_element (line 425) | std::pair<ForwardIter,ForwardIter>
function ForwardIter (line 265) | ForwardIter
function ForwardIter (line 273) | ForwardIter
function ForwardIter (line 281) | ForwardIter
function ForwardIter (line 289) | ForwardIter
function ForwardIter (line 297) | ForwardIter
function ForwardIter (line 305) | ForwardIter
function ForwardIter (line 313) | ForwardIter
function ForwardIter (line 321) | ForwardIter
type detail (line 331) | namespace detail {
type less_over_iter (line 38) | struct less_over_iter {
type binary_pred_over_iter (line 44) | struct binary_pred_over_iter {
method binary_pred_over_iter (line 45) | explicit binary_pred_over_iter(BinaryPredicate const& p ) : m_p( p...
function basic_minmax_element (line 55) | std::pair<ForwardIter,ForwardIter>
function ForwardIter (line 211) | ForwardIter
function ForwardIter (line 224) | ForwardIter
function ForwardIter (line 237) | ForwardIter
function ForwardIter (line 250) | ForwardIter
function basic_first_min_last_max_element (line 334) | std::pair<ForwardIter,ForwardIter>
function basic_last_min_first_max_element (line 380) | std::pair<ForwardIter,ForwardIter>
function basic_last_min_last_max_element (line 425) | std::pair<ForwardIter,ForwardIter>
function first_min_first_max_element (line 486) | inline std::pair<ForwardIter,ForwardIter>
function first_min_first_max_element (line 493) | inline std::pair<ForwardIter,ForwardIter>
function first_min_last_max_element (line 501) | std::pair<ForwardIter,ForwardIter>
function first_min_last_max_element (line 509) | inline std::pair<ForwardIter,ForwardIter>
function last_min_first_max_element (line 518) | std::pair<ForwardIter,ForwardIter>
function last_min_first_max_element (line 526) | inline std::pair<ForwardIter,ForwardIter>
function last_min_last_max_element (line 535) | std::pair<ForwardIter,ForwardIter>
function last_min_last_max_element (line 543) | inline std::pair<ForwardIter,ForwardIter>
type boost (line 204) | namespace boost {
type detail (line 33) | namespace detail { // for obtaining a uniform version of minmax_element
type less_over_iter (line 38) | struct less_over_iter {
type binary_pred_over_iter (line 44) | struct binary_pred_over_iter {
method binary_pred_over_iter (line 45) | explicit binary_pred_over_iter(BinaryPredicate const& p ) : m_p( p...
function basic_minmax_element (line 55) | std::pair<ForwardIter,ForwardIter>
function ForwardIter (line 211) | ForwardIter
function ForwardIter (line 224) | ForwardIter
function ForwardIter (line 237) | ForwardIter
function ForwardIter (line 250) | ForwardIter
function basic_first_min_last_max_element (line 334) | std::pair<ForwardIter,ForwardIter>
function basic_last_min_first_max_element (line 380) | std::pair<ForwardIter,ForwardIter>
function basic_last_min_last_max_element (line 425) | std::pair<ForwardIter,ForwardIter>
function minmax_element (line 122) | std::pair<ForwardIter,ForwardIter>
function minmax_element (line 130) | std::pair<ForwardIter,ForwardIter>
type detail (line 208) | namespace detail { // common base for the overloads
type less_over_iter (line 38) | struct less_over_iter {
type binary_pred_over_iter (line 44) | struct binary_pred_over_iter {
method binary_pred_over_iter (line 45) | explicit binary_pred_over_iter(BinaryPredicate const& p ) : m_p( p...
function basic_minmax_element (line 55) | std::pair<ForwardIter,ForwardIter>
function ForwardIter (line 211) | ForwardIter
function ForwardIter (line 224) | ForwardIter
function ForwardIter (line 237) | ForwardIter
function ForwardIter (line 250) | ForwardIter
function basic_first_min_last_max_element (line 334) | std::pair<ForwardIter,ForwardIter>
function basic_last_min_first_max_element (line 380) | std::pair<ForwardIter,ForwardIter>
function basic_last_min_last_max_element (line 425) | std::pair<ForwardIter,ForwardIter>
function ForwardIter (line 265) | ForwardIter
function ForwardIter (line 273) | ForwardIter
function ForwardIter (line 281) | ForwardIter
function ForwardIter (line 289) | ForwardIter
function ForwardIter (line 297) | ForwardIter
function ForwardIter (line 305) | ForwardIter
function ForwardIter (line 313) | ForwardIter
function ForwardIter (line 321) | ForwardIter
type detail (line 331) | namespace detail {
type less_over_iter (line 38) | struct less_over_iter {
type binary_pred_over_iter (line 44) | struct binary_pred_over_iter {
method binary_pred_over_iter (line 45) | explicit binary_pred_over_iter(BinaryPredicate const& p ) : m_p( p...
function basic_minmax_element (line 55) | std::pair<ForwardIter,ForwardIter>
function ForwardIter (line 211) | ForwardIter
function ForwardIter (line 224) | ForwardIter
function ForwardIter (line 237) | ForwardIter
function ForwardIter (line 250) | ForwardIter
function basic_first_min_last_max_element (line 334) | std::pair<ForwardIter,ForwardIter>
function basic_last_min_first_max_element (line 380) | std::pair<ForwardIter,ForwardIter>
function basic_last_min_last_max_element (line 425) | std::pair<ForwardIter,ForwardIter>
function first_min_first_max_element (line 486) | inline std::pair<ForwardIter,ForwardIter>
function first_min_first_max_element (line 493) | inline std::pair<ForwardIter,ForwardIter>
function first_min_last_max_element (line 501) | std::pair<ForwardIter,ForwardIter>
function first_min_last_max_element (line 509) | inline std::pair<ForwardIter,ForwardIter>
function last_min_first_max_element (line 518) | std::pair<ForwardIter,ForwardIter>
function last_min_first_max_element (line 526) | inline std::pair<ForwardIter,ForwardIter>
function last_min_last_max_element (line 535) | std::pair<ForwardIter,ForwardIter>
function last_min_last_max_element (line 543) | inline std::pair<ForwardIter,ForwardIter>
FILE: external/common/include/boost/algorithm/searching/boyer_moore.hpp
type boost (line 27) | namespace boost { namespace algorithm {
type algorithm (line 27) | namespace algorithm {
class boyer_moore (line 56) | class boyer_moore {
method boyer_moore (line 59) | boyer_moore ( patIter first, patIter last )
method do_search (line 117) | std::pair<corpusIter, corpusIter>
method build_skip_table (line 148) | void build_skip_table ( patIter first, patIter last ) {
method compute_bm_prefix (line 155) | void compute_bm_prefix ( Iter pat_first, Iter pat_last, Container ...
method build_suffix_table (line 175) | void build_suffix_table ( patIter pat_first, patIter pat_last ) {
function boyer_moore_search (line 217) | std::pair<corpusIter, corpusIter> boyer_moore_search (
function boyer_moore_search (line 226) | std::pair<corpusIter, corpusIter> boyer_moore_search (
function boyer_moore_search (line 235) | typename boost::disable_if_c<
function boyer_moore_search (line 246) | std::pair<typename boost::range_iterator<CorpusRange>::type, typenam...
function make_boyer_moore (line 257) | boost::algorithm::boyer_moore<typename boost::range_iterator<const R...
function make_boyer_moore (line 264) | boost::algorithm::boyer_moore<typename boost::range_iterator<Range>:...
FILE: external/common/include/boost/algorithm/searching/boyer_moore_horspool.hpp
type boost (line 29) | namespace boost { namespace algorithm {
type algorithm (line 29) | namespace algorithm {
class boyer_moore_horspool (line 47) | class boyer_moore_horspool {
method boyer_moore_horspool (line 50) | boyer_moore_horspool ( patIter first, patIter last )
method do_search (line 112) | std::pair<corpusIter, corpusIter>
function boyer_moore_horspool_search (line 147) | std::pair<corpusIter, corpusIter> boyer_moore_horspool_search (
function boyer_moore_horspool_search (line 156) | std::pair<corpusIter, corpusIter> boyer_moore_horspool_search (
function boyer_moore_horspool_search (line 165) | typename boost::disable_if_c<
function boyer_moore_horspool_search (line 176) | std::pair<typename boost::range_iterator<CorpusRange>::type, typenam...
function make_boyer_moore_horspool (line 187) | boost::algorithm::boyer_moore_horspool<typename boost::range_iterato...
function make_boyer_moore_horspool (line 194) | boost::algorithm::boyer_moore_horspool<typename boost::range_iterato...
FILE: external/common/include/boost/algorithm/searching/detail/bm_traits.hpp
type boost (line 31) | namespace boost { namespace algorithm { namespace detail {
type algorithm (line 31) | namespace algorithm { namespace detail {
type detail (line 31) | namespace detail {
class skip_table (line 36) | class skip_table
class skip_table<key_type, value_type, false> (line 40) | class skip_table<key_type, value_type, false> {
method skip_table (line 51) | skip_table ( std::size_t patSize, value_type default_value )
method insert (line 54) | void insert ( key_type key, value_type val ) {
method value_type (line 58) | value_type operator [] ( key_type key ) const {
method PrintSkipTable (line 63) | void PrintSkipTable () const {
class skip_table<key_type, value_type, true> (line 75) | class skip_table<key_type, value_type, true> {
method skip_table (line 82) | skip_table ( std::size_t /*patSize*/, value_type default_value )...
method insert (line 86) | void insert ( key_type key, value_type val ) {
method value_type (line 90) | value_type operator [] ( key_type key ) const {
method PrintSkipTable (line 94) | void PrintSkipTable () const {
type BM_traits (line 104) | struct BM_traits {
FILE: external/common/include/boost/algorithm/searching/detail/debugging.hpp
type boost (line 16) | namespace boost { namespace algorithm { namespace detail {
type algorithm (line 16) | namespace algorithm { namespace detail {
type detail (line 16) | namespace detail {
function PrintTable (line 20) | void PrintTable ( Iter first, Iter last ) {
FILE: external/common/include/boost/algorithm/searching/knuth_morris_pratt.hpp
type boost (line 29) | namespace boost { namespace algorithm {
type algorithm (line 29) | namespace algorithm {
class knuth_morris_pratt (line 45) | class knuth_morris_pratt {
method knuth_morris_pratt (line 48) | knuth_morris_pratt ( patIter first, patIter last )
method do_search (line 109) | std::pair<corpusIter, corpusIter>
method preKmp (line 157) | void preKmp ( patIter first, patIter last ) {
method init_skip_table (line 177) | void init_skip_table ( patIter first, patIter last ) {
function knuth_morris_pratt_search (line 209) | std::pair<corpusIter, corpusIter> knuth_morris_pratt_search (
function knuth_morris_pratt_search (line 218) | std::pair<corpusIter, corpusIter> knuth_morris_pratt_search (
function knuth_morris_pratt_search (line 227) | typename boost::disable_if_c<
function knuth_morris_pratt_search (line 238) | std::pair<typename boost::range_iterator<CorpusRange>::type, typenam...
function make_knuth_morris_pratt (line 249) | boost::algorithm::knuth_morris_pratt<typename boost::range_iterator<...
function make_knuth_morris_pratt (line 256) | boost::algorithm::knuth_morris_pratt<typename boost::range_iterator<...
FILE: external/common/include/boost/algorithm/sort_subrange.hpp
type boost (line 28) | namespace boost { namespace algorithm {
type algorithm (line 28) | namespace algorithm {
function sort_subrange (line 45) | void sort_subrange (
function sort_subrange (line 62) | void sort_subrange (Iterator first, Iterator last, Iterator sub_firs...
function partition_subrange (line 86) | void partition_subrange (
function partition_subrange (line 101) | void partition_subrange (Iterator first, Iterator last, Iterator sub...
FILE: external/common/include/boost/algorithm/string/case_conv.hpp
type boost (line 32) | namespace boost {
type algorithm (line 33) | namespace algorithm {
function OutputIteratorT (line 54) | inline OutputIteratorT
function SequenceT (line 72) | inline SequenceT to_lower_copy(
function to_lower (line 91) | inline void to_lower(
function OutputIteratorT (line 119) | inline OutputIteratorT
function SequenceT (line 137) | inline SequenceT to_upper_copy(
function to_upper (line 156) | inline void to_upper(
FILE: external/common/include/boost/algorithm/string/classification.hpp
type boost (line 29) | namespace boost {
type algorithm (line 30) | namespace algorithm {
function is_classified (line 43) | inline detail::is_classifiedF
function is_space (line 56) | inline detail::is_classifiedF
function is_alnum (line 69) | inline detail::is_classifiedF
function is_alpha (line 82) | inline detail::is_classifiedF
function is_cntrl (line 95) | inline detail::is_classifiedF
function is_digit (line 108) | inline detail::is_classifiedF
function is_graph (line 121) | inline detail::is_classifiedF
function is_lower (line 134) | inline detail::is_classifiedF
function is_print (line 147) | inline detail::is_classifiedF
function is_punct (line 160) | inline detail::is_classifiedF
function is_upper (line 173) | inline detail::is_classifiedF
function is_xdigit (line 186) | inline detail::is_classifiedF
function is_any_of (line 201) | inline detail::is_any_ofF<
function is_from_range (line 219) | inline detail::is_from_rangeF<CharT> is_from_range(CharT From, CharT...
FILE: external/common/include/boost/algorithm/string/compare.hpp
type boost (line 24) | namespace boost {
type algorithm (line 25) | namespace algorithm {
type is_equal (line 34) | struct is_equal
type is_iequal (line 52) | struct is_iequal
method is_iequal (line 58) | is_iequal( const std::locale& Loc=std::locale() ) :
type is_less (line 86) | struct is_less
type is_iless (line 105) | struct is_iless
method is_iless (line 111) | is_iless( const std::locale& Loc=std::locale() ) :
type is_not_greater (line 139) | struct is_not_greater
type is_not_igreater (line 158) | struct is_not_igreater
method is_not_igreater (line 164) | is_not_igreater( const std::locale& Loc=std::locale() ) :
FILE: external/common/include/boost/algorithm/string/concept.hpp
type boost (line 23) | namespace boost {
type algorithm (line 24) | namespace algorithm {
type FinderConcept (line 35) | struct FinderConcept
method constraints (line 40) | void constraints()
type FormatterConcept (line 62) | struct FormatterConcept
method constraints (line 65) | void constraints()
FILE: external/common/include/boost/algorithm/string/constants.hpp
type boost (line 14) | namespace boost {
type algorithm (line 15) | namespace algorithm {
type token_compress_mode_type (line 21) | enum token_compress_mode_type
FILE: external/common/include/boost/algorithm/string/detail/case_conv.hpp
type boost (line 20) | namespace boost {
type algorithm (line 21) | namespace algorithm {
type detail (line 22) | namespace detail {
type to_lowerF (line 33) | struct to_lowerF : public std::unary_function<CharT, CharT>
method to_lowerF (line 36) | to_lowerF( const std::locale& Loc ) : m_Loc( &Loc ) {}
method CharT (line 39) | CharT operator ()( CharT Ch ) const
type to_upperF (line 53) | struct to_upperF : public std::unary_function<CharT, CharT>
method to_upperF (line 56) | to_upperF( const std::locale& Loc ) : m_Loc( &Loc ) {}
method CharT (line 59) | CharT operator ()( CharT Ch ) const
function OutputIteratorT (line 79) | OutputIteratorT transform_range_copy(
function transform_range (line 93) | void transform_range(
function SequenceT (line 105) | inline SequenceT transform_range_copy(
FILE: external/common/include/boost/algorithm/string/detail/classification.hpp
type boost (line 25) | namespace boost {
type algorithm (line 26) | namespace algorithm {
type detail (line 27) | namespace detail {
type is_classifiedF (line 32) | struct is_classifiedF :
method is_classifiedF (line 39) | is_classifiedF(std::ctype_base::mask Type, std::locale const & L...
type is_any_ofF (line 67) | struct is_any_ofF :
method is_any_ofF (line 80) | is_any_ofF( const RangeT& Range ) : m_Size(0)
method is_any_ofF (line 107) | is_any_ofF(const is_any_ofF& Other) : m_Size(Other.m_Size)
method is_any_ofF (line 142) | is_any_ofF& operator=(const is_any_ofF& Other)
method use_fixed_storage (line 227) | static bool use_fixed_storage(std::size_t size)
type is_from_rangeF (line 253) | struct is_from_rangeF :
method is_from_rangeF (line 260) | is_from_rangeF( CharT From, CharT To ) : m_From(From), m_To(To) {}
type pred_andF (line 276) | struct pred_andF :
method pred_andF (line 285) | pred_andF( Pred1T Pred1, Pred2T Pred2 ) :
type pred_orF (line 302) | struct pred_orF :
method pred_orF (line 310) | pred_orF( Pred1T Pred1, Pred2T Pred2 ) :
type pred_notF (line 327) | struct pred_notF :
method pred_notF (line 335) | pred_notF( PredT Pred ) : m_Pred(Pred) {}
FILE: external/common/include/boost/algorithm/string/detail/find_format.hpp
type boost (line 21) | namespace boost {
type algorithm (line 22) | namespace algorithm {
type detail (line 23) | namespace detail {
function OutputIteratorT (line 33) | inline OutputIteratorT find_format_copy_impl2(
function OutputIteratorT (line 72) | inline OutputIteratorT find_format_copy_impl(
function InputT (line 98) | inline InputT find_format_copy_impl2(
function InputT (line 134) | inline InputT find_format_copy_impl(
function find_format_impl2 (line 157) | inline void find_format_impl2(
function find_format_impl (line 186) | inline void find_format_impl(
FILE: external/common/include/boost/algorithm/string/detail/find_format_all.hpp
type boost (line 21) | namespace boost {
type algorithm (line 22) | namespace algorithm {
type detail (line 23) | namespace detail {
function OutputIteratorT (line 34) | inline OutputIteratorT find_format_all_copy_impl2(
function OutputIteratorT (line 81) | inline OutputIteratorT find_format_all_copy_impl(
function InputT (line 109) | inline InputT find_format_all_copy_impl2(
function InputT (line 157) | inline InputT find_format_all_copy_impl(
function find_format_all_impl2 (line 183) | inline void find_format_all_impl2(
function find_format_all_impl (line 253) | inline void find_format_all_impl(
FILE: external/common/include/boost/algorithm/string/detail/find_format_store.hpp
type boost (line 17) | namespace boost {
type algorithm (line 18) | namespace algorithm {
type detail (line 19) | namespace detail {
class find_format_store (line 31) | class find_format_store :
method find_format_store (line 42) | find_format_store(
method find_format_store (line 52) | find_format_store& operator=( FindResultT FindResult )
method format_result_type (line 63) | const format_result_type& format_result()
function check_find_result (line 74) | bool check_find_result(InputT&, FindResultT& FindResult)
FILE: external/common/include/boost/algorithm/string/detail/find_iterator.hpp
type boost (line 20) | namespace boost {
type algorithm (line 21) | namespace algorithm {
type detail (line 22) | namespace detail {
class find_iterator_base (line 28) | class find_iterator_base
method find_iterator_base (line 43) | find_iterator_base() {}
method find_iterator_base (line 45) | find_iterator_base( const find_iterator_base& Other ) :
method find_iterator_base (line 50) | find_iterator_base( FinderT Finder, int ) :
method match_type (line 57) | match_type do_find(
method is_null (line 72) | bool is_null() const
FILE: external/common/include/boost/algorithm/string/detail/finder.hpp
type boost (line 24) | namespace boost {
type algorithm (line 25) | namespace algorithm {
type detail (line 26) | namespace detail {
type first_finderF (line 37) | struct first_finderF
method first_finderF (line 43) | first_finderF( const SearchT& Search, PredicateT Comp ) :
method first_finderF (line 45) | first_finderF(
type last_finderF (line 101) | struct last_finderF
method last_finderF (line 110) | last_finderF( const SearchT& Search, PredicateT Comp ) :
method last_finderF (line 112) | last_finderF(
method findit (line 139) | iterator_range<ForwardIteratorT>
method findit (line 164) | iterator_range<ForwardIteratorT>
type nth_finderF (line 210) | struct nth_finderF
method nth_finderF (line 222) | nth_finderF(
method nth_finderF (line 229) | nth_finderF(
method find_forward (line 259) | iterator_range<ForwardIteratorT>
method find_backward (line 293) | iterator_range<ForwardIteratorT>
function find_head_impl (line 336) | iterator_range<ForwardIteratorT>
function find_head_impl (line 355) | iterator_range<ForwardIteratorT>
function find_head_impl (line 372) | iterator_range<ForwardIteratorT>
function find_tail_impl (line 385) | iterator_range<ForwardIteratorT>
function find_tail_impl (line 409) | iterator_range<ForwardIteratorT>
function find_tail_impl (line 428) | iterator_range<ForwardIteratorT>
function find_tail_impl (line 445) | iterator_range<ForwardIteratorT>
type head_finderF (line 468) | struct head_finderF
method head_finderF (line 471) | head_finderF( int N ) : m_N(N) {}
type tail_finderF (line 506) | struct tail_finderF
method tail_finderF (line 509) | tail_finderF( int N ) : m_N(N) {}
type token_finderF (line 548) | struct token_finderF
method token_finderF (line 551) | token_finderF(
type range_finderF (line 603) | struct range_finderF
method range_finderF (line 609) | range_finderF(
method range_finderF (line 613) | range_finderF(const iterator_range<input_iterator_type>& Range) :
FILE: external/common/include/boost/algorithm/string/detail/finder_regex.hpp
type boost (line 21) | namespace boost {
type algorithm (line 22) | namespace algorithm {
type detail (line 23) | namespace detail {
type regex_search_result (line 29) | struct regex_search_result :
method regex_search_result (line 43) | regex_search_result( const match_results_type& MatchResults ) :
method regex_search_result (line 48) | regex_search_result( IteratorT End ) :
method regex_search_result (line 51) | regex_search_result( const regex_search_result& Other ) :
method regex_search_result (line 56) | regex_search_result& operator=( const regex_search_result& Other )
method match_results_type (line 64) | const match_results_type& match_results() const
type find_regexF (line 79) | struct find_regexF
method find_regexF (line 85) | find_regexF( regex_reference_type Rx, match_flag_type MatchFlags...
FILE: external/common/include/boost/algorithm/string/detail/formatter.hpp
type boost (line 24) | namespace boost {
type algorithm (line 25) | namespace algorithm {
type detail (line 26) | namespace detail {
type const_formatF (line 32) | struct const_formatF
method const_formatF (line 41) | const_formatF(const RangeT& Format) :
method result_type (line 47) | result_type& operator()(const Range2T&)
method result_type (line 54) | const result_type& operator()(const Range2T&) const
type identity_formatF (line 67) | struct identity_formatF
method RangeT (line 71) | const RangeT& operator()(const Range2T& Replace) const
type empty_formatF (line 81) | struct empty_formatF
type dissect_formatF (line 94) | struct dissect_formatF
method dissect_formatF (line 98) | dissect_formatF(FinderT Finder) :
FILE: external/common/include/boost/algorithm/string/detail/formatter_regex.hpp
type boost (line 19) | namespace boost {
type algorithm (line 20) | namespace algorithm {
type detail (line 21) | namespace detail {
type regex_formatF (line 27) | struct regex_formatF
method regex_formatF (line 35) | regex_formatF( const StringT& Fmt, match_flag_type Flags=format_...
method result_type (line 39) | result_type operator()(
FILE: external/common/include/boost/algorithm/string/detail/predicate.hpp
type boost (line 17) | namespace boost {
type algorithm (line 18) | namespace algorithm {
type detail (line 19) | namespace detail {
function ends_with_iter_select (line 27) | inline bool ends_with_iter_select(
function ends_with_iter_select (line 50) | inline bool ends_with_iter_select(
FILE: external/common/include/boost/algorithm/string/detail/replace_storage.hpp
type boost (line 20) | namespace boost {
type algorithm (line 21) | namespace algorithm {
type detail (line 22) | namespace detail {
function OutputIteratorT (line 27) | inline OutputIteratorT move_from_storage(
function copy_to_storage (line 45) | inline void copy_to_storage(
type process_segment_helper (line 56) | struct process_segment_helper
method ForwardIteratorT (line 63) | ForwardIteratorT operator()(
type process_segment_helper< true > (line 112) | struct process_segment_helper< true >
method ForwardIteratorT (line 119) | ForwardIteratorT operator()(
function ForwardIteratorT (line 141) | inline ForwardIteratorT process_segment(
FILE: external/common/include/boost/algorithm/string/detail/sequence.hpp
type boost (line 22) | namespace boost {
type algorithm (line 23) | namespace algorithm {
type detail (line 24) | namespace detail {
function insert (line 29) | inline void insert(
function insert (line 39) | inline void insert(
function erase (line 54) | inline typename InputT::iterator erase(
type replace_const_time_helper (line 67) | struct replace_const_time_helper
type replace_const_time_helper< true > (line 102) | struct replace_const_time_helper< true >
type replace_native_helper (line 130) | struct replace_native_helper
type replace_native_helper< true > (line 150) | struct replace_native_helper< true >
function replace (line 167) | inline void replace(
function replace (line 179) | inline void replace(
FILE: external/common/include/boost/algorithm/string/detail/trim.hpp
type boost (line 17) | namespace boost {
type algorithm (line 18) | namespace algorithm {
type detail (line 19) | namespace detail {
function ForwardIteratorT (line 24) | inline ForwardIteratorT trim_end_iter_select(
function ForwardIteratorT (line 45) | inline ForwardIteratorT trim_end_iter_select(
function ForwardIteratorT (line 61) | inline ForwardIteratorT trim_begin(
function ForwardIteratorT (line 78) | inline ForwardIteratorT trim_end(
FILE: external/common/include/boost/algorithm/string/detail/util.hpp
type boost (line 18) | namespace boost {
type algorithm (line 19) | namespace algorithm {
type detail (line 20) | namespace detail {
type empty_container (line 32) | struct empty_container
method const_iterator (line 45) | const_iterator begin() const
method const_iterator (line 50) | const_iterator end() const
method empty (line 55) | bool empty() const
method size_type (line 60) | size_type size() const
function OutputIteratorT (line 70) | inline OutputIteratorT bounded_copy(
type copy_iterator_rangeF (line 92) | struct copy_iterator_rangeF :
method SeqT (line 95) | SeqT operator()( const iterator_range<IteratorT>& Range ) const
FILE: external/common/include/boost/algorithm/string/erase.hpp
type boost (line 31) | namespace boost {
type algorithm (line 32) | namespace algorithm {
function OutputIteratorT (line 50) | inline OutputIteratorT erase_range_copy(
function SequenceT (line 69) | inline SequenceT erase_range_copy(
function erase_range (line 90) | inline void erase_range(
function OutputIteratorT (line 122) | inline OutputIteratorT erase_first_copy(
function SequenceT (line 139) | inline SequenceT erase_first_copy(
function erase_first (line 158) | inline void erase_first(
function OutputIteratorT (line 190) | inline OutputIteratorT ierase_first_copy(
function SequenceT (line 208) | inline SequenceT ierase_first_copy(
function ierase_first (line 229) | inline void ierase_first(
function OutputIteratorT (line 260) | inline OutputIteratorT erase_last_copy(
function SequenceT (line 277) | inline SequenceT erase_last_copy(
function erase_last (line 296) | inline void erase_last(
function OutputIteratorT (line 328) | inline OutputIteratorT ierase_last_copy(
function SequenceT (line 346) | inline SequenceT ierase_last_copy(
function ierase_last (line 367) | inline void ierase_last(
function OutputIteratorT (line 401) | inline OutputIteratorT erase_nth_copy(
function SequenceT (line 419) | inline SequenceT erase_nth_copy(
function erase_nth (line 441) | inline void erase_nth(
function OutputIteratorT (line 476) | inline OutputIteratorT ierase_nth_copy(
function SequenceT (line 495) | inline SequenceT ierase_nth_copy(
function ierase_nth (line 519) | inline void ierase_nth(
function OutputIteratorT (line 553) | inline OutputIteratorT erase_all_copy(
function SequenceT (line 570) | inline SequenceT erase_all_copy(
function erase_all (line 589) | inline void erase_all(
function OutputIteratorT (line 621) | inline OutputIteratorT ierase_all_copy(
function SequenceT (line 639) | inline SequenceT ierase_all_copy(
function ierase_all (line 660) | inline void ierase_all(
function OutputIteratorT (line 694) | inline OutputIteratorT erase_head_copy(
function SequenceT (line 711) | inline SequenceT erase_head_copy(
function erase_head (line 733) | inline void erase_head(
function OutputIteratorT (line 766) | inline OutputIteratorT erase_tail_copy(
function SequenceT (line 783) | inline SequenceT erase_tail_copy(
function erase_tail (line 805) | inline void erase_tail(
FILE: external/common/include/boost/algorithm/string/find.hpp
type boost (line 32) | namespace boost {
type algorithm (line 33) | namespace algorithm {
function find (line 50) | inline iterator_range<
function find_first (line 78) | inline iterator_range<
function ifind_first (line 104) | inline iterator_range<
function find_last (line 131) | inline iterator_range<
function ifind_last (line 157) | inline iterator_range<
function find_nth (line 185) | inline iterator_range<
function ifind_nth (line 215) | inline iterator_range<
function find_head (line 247) | inline iterator_range<
function find_tail (line 278) | inline iterator_range<
function find_token (line 307) | inline iterator_range<
FILE: external/common/include/boost/algorithm/string/find_format.hpp
type boost (line 32) | namespace boost {
type algorithm (line 33) | namespace algorithm {
function OutputIteratorT (line 58) | inline OutputIteratorT find_format_copy(
function SequenceT (line 93) | inline SequenceT find_format_copy(
function find_format (line 129) | inline void find_format(
function OutputIteratorT (line 177) | inline OutputIteratorT find_format_all_copy(
function SequenceT (line 213) | inline SequenceT find_format_all_copy(
function find_format_all (line 251) | inline void find_format_all(
FILE: external/common/include/boost/algorithm/string/find_iterator.hpp
type boost (line 33) | namespace boost {
type algorithm (line 34) | namespace algorithm {
class find_iterator (line 50) | class find_iterator :
method find_iterator (line 77) | find_iterator() {}
method find_iterator (line 83) | find_iterator( const find_iterator& Other ) :
method find_iterator (line 94) | find_iterator(
method find_iterator (line 111) | find_iterator(
method match_type (line 127) | const match_type& dereference() const
method increment (line 133) | void increment()
method equal (line 139) | bool equal( const find_iterator& Other ) const
method eof (line 160) | bool eof() const
function make_find_iterator (line 181) | inline find_iterator<
class split_iterator (line 206) | class split_iterator :
method split_iterator (line 233) | split_iterator() :
method split_iterator (line 243) | split_iterator( const split_iterator& Other ) :
method split_iterator (line 257) | split_iterator(
method split_iterator (line 279) | split_iterator(
method match_type (line 302) | const match_type& dereference() const
method increment (line 308) | void increment()
method equal (line 326) | bool equal( const split_iterator& Other ) const
method eof (line 348) | bool eof() const
function make_split_iterator (line 366) | inline split_iterator<
FILE: external/common/include/boost/algorithm/string/finder.hpp
type boost (line 34) | namespace boost {
type algorithm (line 35) | namespace algorithm {
function first_finder (line 50) | inline detail::first_finderF<
function first_finder (line 67) | inline detail::first_finderF<
function last_finder (line 91) | inline detail::last_finderF<
function last_finder (line 107) | inline detail::last_finderF<
function nth_finder (line 131) | inline detail::nth_finderF<
function nth_finder (line 149) | inline detail::nth_finderF<
function head_finder (line 175) | inline detail::head_finderF
function tail_finder (line 192) | inline detail::tail_finderF
function token_finder (line 217) | inline detail::token_finderF<PredicateT>
function range_finder (line 237) | inline detail::range_finderF<ForwardIteratorT>
function range_finder (line 250) | inline detail::range_finderF<ForwardIteratorT>
FILE: external/common/include/boost/algorithm/string/formatter.hpp
type boost (line 32) | namespace boost {
type algorithm (line 33) | namespace algorithm {
function const_formatter (line 46) | inline detail::const_formatF<
function identity_formatter (line 64) | inline detail::identity_formatF<
function empty_formatter (line 84) | inline detail::empty_formatF<
function dissect_formatter (line 102) | inline detail::dissect_formatF< FinderT >
FILE: external/common/include/boost/algorithm/string/iter_find.hpp
type boost (line 41) | namespace boost {
type algorithm (line 42) | namespace algorithm {
function SequenceSequenceT (line 71) | inline SequenceSequenceT&
function SequenceSequenceT (line 142) | inline SequenceSequenceT&
FILE: external/common/include/boost/algorithm/string/join.hpp
type boost (line 28) | namespace boost {
type algorithm (line 29) | namespace algorithm {
function join (line 45) | inline typename range_value<SequenceSequenceT>::type
function join_if (line 95) | inline typename range_value<SequenceSequenceT>::type
FILE: external/common/include/boost/algorithm/string/predicate.hpp
type boost (line 37) | namespace boost {
type algorithm (line 38) | namespace algorithm {
function starts_with (line 57) | inline bool starts_with(
function starts_with (line 91) | inline bool starts_with(
function istarts_with (line 112) | inline bool istarts_with(
function ends_with (line 139) | inline bool ends_with(
function ends_with (line 168) | inline bool ends_with(
function iends_with (line 189) | inline bool iends_with(
function contains (line 213) | inline bool contains(
function contains (line 237) | inline bool contains(
function icontains (line 257) | inline bool icontains(
function equals (line 284) | inline bool equals(
function equals (line 318) | inline bool equals(
function iequals (line 341) | inline bool iequals(
function lexicographical_compare (line 370) | inline bool lexicographical_compare(
function lexicographical_compare (line 391) | inline bool lexicographical_compare(
function ilexicographical_compare (line 415) | inline bool ilexicographical_compare(
function all (line 438) | inline bool all(
FILE: external/common/include/boost/algorithm/string/predicate_facade.hpp
type boost (line 23) | namespace boost {
type algorithm (line 24) | namespace algorithm {
type predicate_facade (line 36) | struct predicate_facade {}
FILE: external/common/include/boost/algorithm/string/regex.hpp
type boost (line 32) | namespace boost {
type algorithm (line 33) | namespace algorithm {
function find_regex (line 56) | inline iterator_range<
function OutputIteratorT (line 94) | inline OutputIteratorT replace_regex_copy(
function SequenceT (line 117) | inline SequenceT replace_regex_copy(
function replace_regex (line 144) | inline void replace_regex(
function OutputIteratorT (line 180) | inline OutputIteratorT replace_all_regex_copy(
function SequenceT (line 203) | inline SequenceT replace_all_regex_copy(
function replace_all_regex (line 230) | inline void replace_all_regex(
function OutputIteratorT (line 264) | inline OutputIteratorT erase_regex_copy(
function SequenceT (line 285) | inline SequenceT erase_regex_copy(
function erase_regex (line 309) | inline void erase_regex(
function OutputIteratorT (line 343) | inline OutputIteratorT erase_all_regex_copy(
function SequenceT (line 364) | inline SequenceT erase_all_regex_copy(
function erase_all_regex (line 388) | inline void erase_all_regex(
function SequenceSequenceT (line 428) | inline SequenceSequenceT& find_all_regex(
function SequenceSequenceT (line 469) | inline SequenceSequenceT& split_regex(
Copy disabled (too large)
Download .json
Condensed preview — 12933 files, each showing path, character count, and a content snippet. Download the .json file for the full structured content (108,345K chars).
[
{
"path": ".circleci/config.yml",
"chars": 4428,
"preview": "version: 2\njobs:\n build-and-test:\n macos:\n xcode: '9.0.1'\n working_directory: ~/numenta/nupic.core\n paral"
},
{
"path": ".clang-format",
"chars": 62,
"preview": "---\nLanguage: Cpp\nBasedOnStyle: LLVM\nDisableFormat: false\n...\n"
},
{
"path": ".gitignore",
"chars": 444,
"preview": ".metadata\n.idea\n*.manifest\n*.cache\n*~\n*.DS_Store\n*.swp\n*.pyc\n*.pkl\n\n# Coverage files \n.coverage\nhtmlcov/\n\n# IDE project "
},
{
"path": ".travis.yml",
"chars": 4443,
"preview": "sudo: false\n\nlanguage: cpp\n\nosx_image: xcode6.4\n\nos:\n - osx\n\ncompiler:\n - clang\n\nenv:\n global:\n - NUPICCORE = ${TR"
},
{
"path": "CHANGELOG.md",
"chars": 24468,
"preview": "# Changelog\n\n## 1.0.6\n\n* This release was because of a deployment problem with 1.0.5 and issues with pypi.\n\n## 1.0.5\n\n* "
},
{
"path": "CMakeLists.txt",
"chars": 2516,
"preview": "# Copyright 2015-2017 Numenta Inc.\n#\n# Copyright may exist in Contributors' modifications\n# and/or contributions to the "
},
{
"path": "CONTRIBUTING.md",
"chars": 174,
"preview": "## We'd love your help!\n\nFor information about contributing to NuPIC, please read about our [Development Process](https:"
},
{
"path": "CommonCompilerConfig.cmake",
"chars": 16948,
"preview": "# Copyright 2013-2016 Numenta Inc.\n#\n# Copyright may exist in Contributors' modifications\n# and/or contributions to the "
},
{
"path": "DEPENDENCIES.md",
"chars": 1896,
"preview": "# Dependencies\n\nThis file declares all dependencies nupic.core has on third-party code, including their licenses.\n\n- Cap"
},
{
"path": "Dockerfile",
"chars": 994,
"preview": "FROM ubuntu:14.04\n\nRUN apt-get update && \\\n apt-get install -y \\\n curl \\\n wget \\\n git-core \\\n gcc \\\n g"
},
{
"path": "LICENSE.txt",
"chars": 1056,
"preview": "Copyright 2013-2024 Numenta Inc.\n\nPermission is hereby granted, free of charge, to any person obtaining a copy\nof this s"
},
{
"path": "README.md",
"chars": 8308,
"preview": "<img src=\"http://numenta.org/87b23beb8a4b7dea7d88099bfb28d182.svg\" alt=\"NuPIC Logo\" width=100/>\n\nAs of September 2023 th"
},
{
"path": "RELEASE.md",
"chars": 566,
"preview": "# Release Process\n\n1. Select a green build in Bamboo that has the changes that you want to release\n2. Ensure that this b"
},
{
"path": "VERSION",
"chars": 11,
"preview": "1.0.7.dev0\n"
},
{
"path": "appveyor.yml",
"chars": 7851,
"preview": "#---------------------------------#\n# general configuration #\n#---------------------------------#\n\nimage: Visu"
},
{
"path": "bindings/py/dummy.c",
"chars": 71,
"preview": "#include <stdio.h>\n\nint main()\n{\n return 0;\n}\n\nvoid initdummy() {}\n\n"
},
{
"path": "bindings/py/requirements.txt",
"chars": 156,
"preview": "#See http://www.pip-installer.org/en/latest/requirements.html for details\nnumpy==1.12.1\npytest==3.0.7\npytest-cov==2.5.0\n"
},
{
"path": "bindings/py/setup.py",
"chars": 6694,
"preview": "# Copyright 2015 Numenta Inc.\n#\n# Copyright may exist in Contributors' modifications\n# and/or contributions to the work"
},
{
"path": "bindings/py/src/nupic/__init__.py",
"chars": 339,
"preview": "# Copyright 2013 Numenta Inc.\n#\n# Copyright may exist in Contributors' modifications\n# and/or contributions to the work."
},
{
"path": "bindings/py/src/nupic/bindings/regions/PyRegion.py",
"chars": 15478,
"preview": "# Copyright 2013-2015 Numenta Inc.\n#\n# Copyright may exist in Contributors' modifications\n# and/or contributions to the "
},
{
"path": "bindings/py/src/nupic/bindings/regions/TestNode.py",
"chars": 9300,
"preview": "# Copyright 2015 Numenta Inc.\n#\n# Copyright may exist in Contributors' modifications\n# and/or contributions to the work."
},
{
"path": "bindings/py/src/nupic/bindings/regions/__init__.py",
"chars": 265,
"preview": "# Copyright 2015 Numenta Inc.\n#\n# Copyright may exist in Contributors' modifications\n# and/or contributions to the work."
},
{
"path": "bindings/py/src/nupic/bindings/tools/SerializationTestPyRegionProto.capnp",
"chars": 176,
"preview": "@0x8ae35855f4636f7b;\n\nusing import \"/nupic/proto/RandomProto.capnp\".RandomProto;\n\nstruct SerializationTestPyRegionProto "
},
{
"path": "bindings/py/src/nupic/bindings/tools/__init__.py",
"chars": 283,
"preview": "# Copyright 2017 Numenta Inc.\n#\n# Copyright may exist in Contributors' modifications\n# and/or contributions to the work."
},
{
"path": "bindings/py/src/nupic/bindings/tools/cyclical_serialization_perf.py",
"chars": 3549,
"preview": "#!/usr/bin/env python\n# Copyright 2017 Numenta Inc.\n#\n# Copyright may exist in Contributors' modifications\n# and/or cont"
},
{
"path": "bindings/py/src/nupic/bindings/tools/random_serialization_perf.py",
"chars": 2774,
"preview": "#!/usr/bin/env python\n# Copyright 2017 Numenta Inc.\n#\n# Copyright may exist in Contributors' modifications\n# and/or cont"
},
{
"path": "bindings/py/src/nupic/bindings/tools/serialization_test_py_region.py",
"chars": 3980,
"preview": "# Copyright 2017 Numenta Inc.\n#\n# Copyright may exist in Contributors' modifications\n# and/or contributions to the work."
},
{
"path": "bindings/py/src/nupic/proto/.gitignore",
"chars": 8,
"preview": "*.capnp\n"
},
{
"path": "bindings/py/src/nupic/proto/__init__.py",
"chars": 265,
"preview": "# Copyright 2015 Numenta Inc.\n#\n# Copyright may exist in Contributors' modifications\n# and/or contributions to the work."
},
{
"path": "bindings/py/tests/__init__.py",
"chars": 265,
"preview": "# Copyright 2015 Numenta Inc.\n#\n# Copyright may exist in Contributors' modifications\n# and/or contributions to the work."
},
{
"path": "bindings/py/tests/algorithms/cells4_test.py",
"chars": 8596,
"preview": "# Copyright 2013-2017 Numenta Inc.\n#\n# Copyright may exist in Contributors' modifications\n# and/or contributions to the "
},
{
"path": "bindings/py/tests/algorithms/svm_test.py",
"chars": 4058,
"preview": "# Copyright 2013-2017 Numenta Inc.\n#\n# Copyright may exist in Contributors' modifications\n# and/or contributions to the "
},
{
"path": "bindings/py/tests/array_algorithms_test.py",
"chars": 803,
"preview": "#!/usr/bin/env python\n# Copyright 2013 Numenta Inc.\n#\n# Copyright may exist in Contributors' modifications\n# and/or cont"
},
{
"path": "bindings/py/tests/cast_mode_test.py",
"chars": 1030,
"preview": "#!/usr/bin/env python\n# Copyright 2013 Numenta Inc.\n#\n# Copyright may exist in Contributors' modifications\n# and/or cont"
},
{
"path": "bindings/py/tests/check_test.py",
"chars": 649,
"preview": "# Copyright 2015 Numenta Inc.\n#\n# Copyright may exist in Contributors' modifications\n# and/or contributions to the work."
},
{
"path": "bindings/py/tests/connections_test.py",
"chars": 17944,
"preview": "#!/usr/bin/env python\n# Copyright 2017 Numenta Inc.\n#\n# Copyright may exist in Contributors' modifications\n# and/or cont"
},
{
"path": "bindings/py/tests/network_test.py",
"chars": 6555,
"preview": "# Copyright 2017 Numenta Inc.\n#\n# Copyright may exist in Contributors' modifications\n# and/or contributions to the work."
},
{
"path": "bindings/py/tests/nupic_random_test.py",
"chars": 6735,
"preview": "#!/usr/bin/env python\n# Copyright 2017 Numenta Inc.\n#\n# Copyright may exist in Contributors' modifications\n# and/or cont"
},
{
"path": "bindings/py/tests/pyregion_test.py",
"chars": 2681,
"preview": "# Copyright 2014-2015 Numenta Inc.\n#\n# Copyright may exist in Contributors' modifications\n# and/or contributions to the "
},
{
"path": "bindings/py/tests/segment_sparse_matrix_test.py",
"chars": 3331,
"preview": "# Copyright 2016 Numenta Inc.\n#\n# Copyright may exist in Contributors' modifications\n# and/or contributions to the work."
},
{
"path": "bindings/py/tests/sparse_binary_matrix_test.py",
"chars": 44213,
"preview": "#!/usr/bin/env python\n# Copyright 2013 Numenta Inc.\n#\n# Copyright may exist in Contributors' modifications\n# and/or cont"
},
{
"path": "bindings/py/tests/sparse_link_test.py",
"chars": 9355,
"preview": "# Copyright 2018 Numenta Inc.\n#\n# Copyright may exist in Contributors' modifications\n# and/or contributions to the work."
},
{
"path": "bindings/py/tests/sparse_matrix_test.py",
"chars": 100399,
"preview": "#!/usr/bin/env python\n# Copyright 2013-2017 Numenta Inc.\n#\n# Copyright may exist in Contributors' modifications\n# and/or"
},
{
"path": "bindings/py/tests/temporal_memory_test.py",
"chars": 635,
"preview": "# Copyright 2014-2015 Numenta Inc.\n#\n# Copyright may exist in Contributors' modifications\n# and/or contributions to the "
},
{
"path": "ci/appveyor/install_python_pip.ps1",
"chars": 3356,
"preview": "# Sample script to install Python and pip under Windows\n# Authors: Olivier Grisel and Kyle Kastner\n# License: CC0 1.0 Un"
},
{
"path": "ci/bamboo/build-linux-debug.sh",
"chars": 857,
"preview": "#!/bin/bash\n# Copyright 2016 Numenta Inc.\n#\n# Copyright may exist in Contributors' modifications\n# and/or contributions "
},
{
"path": "ci/bamboo/build-linux-release.sh",
"chars": 774,
"preview": "#!/bin/bash\n# Copyright 2016 Numenta Inc.\n#\n# Copyright may exist in Contributors' modifications\n# and/or contributions "
},
{
"path": "ci/bamboo/build-manylinux-debug.sh",
"chars": 1226,
"preview": "#!/bin/bash\n# Copyright 2016 Numenta Inc.\n#\n# Copyright may exist in Contributors' modifications\n# and/or contributions "
},
{
"path": "ci/bamboo/build-manylinux-release.sh",
"chars": 1151,
"preview": "#!/bin/bash\n# Copyright 2016 Numenta Inc.\n#\n# Copyright may exist in Contributors' modifications\n# and/or contributions "
},
{
"path": "ci/bamboo/build-osx.sh",
"chars": 706,
"preview": "#!/bin/bash\n# Copyright 2016 Numenta Inc.\n#\n# Copyright may exist in Contributors' modifications\n# and/or contributions "
},
{
"path": "ci/bamboo/build-windows.ps1",
"chars": 5591,
"preview": "# Copyright 2016 Numenta Inc.\n#\n# Copyright may exist in Contributors' modifications\n# and/or contributions to the work."
},
{
"path": "ci/bamboo/check-style.sh",
"chars": 682,
"preview": "#!/bin/bash\n# Copyright 2016 Numenta Inc.\n#\n# Copyright may exist in Contributors' modifications\n# and/or contributions "
},
{
"path": "ci/bamboo/fetch_remote.py",
"chars": 3446,
"preview": "# Copyright 2016 Numenta Inc.\n#\n# Copyright may exist in Contributors' modifications\n# and/or contributions to the work."
},
{
"path": "ci/bamboo/manylinux-build-env.rc",
"chars": 1154,
"preview": "#!/bin/bash\n# Copyright 2016 Numenta Inc.\n#\n# Copyright may exist in Contributors' modifications\n# and/or contributions "
},
{
"path": "ci/bamboo/setup-dependencies-linux.sh",
"chars": 181,
"preview": "#!/bin/bash\nset -o errexit\nset -o xtrace\n\nDIR=\"$( cd \"$( dirname \"${BASH_SOURCE[0]}\" )\" && pwd )\"\n\n# Environment default"
},
{
"path": "ci/build-and-test-nupic-bindings.sh",
"chars": 3954,
"preview": "#!/bin/bash\n# Copyright 2016 Numenta Inc.\n#\n# Copyright may exist in Contributors' modifications\n# and/or contributions "
},
{
"path": "ci/deploy-wheel-to-s3.py",
"chars": 1123,
"preview": "#!/usr/bin/env python\n# Copyright 2013-2015 Numenta Inc.\n#\n# Copyright may exist in Contributors' modifications\n# and/or"
},
{
"path": "ci/travis/README.md",
"chars": 395,
"preview": "## Travis-CI Scripts\n\nThe bash scripts in this directory are run only in Travis-CI, and are placed here to help simplify"
},
{
"path": "ci/travis/before_deploy.sh",
"chars": 1335,
"preview": "#!/bin/bash\n# Copyright 2013-2015 Numenta Inc.\n#\n# Copyright may exist in Contributors' modifications\n# and/or contribut"
},
{
"path": "ci/travis/before_install-osx.sh",
"chars": 972,
"preview": "#!/bin/bash\n# Copyright 2013-2015 Numenta Inc.\n#\n# Copyright may exist in Contributors' modifications\n# and/or contribut"
},
{
"path": "docs/.gitignore",
"chars": 12,
"preview": "xml/\nbuild/\n"
},
{
"path": "docs/Doxyfile",
"chars": 104254,
"preview": "# Doxyfile 1.8.7\n\n# This file describes the settings to be used by the documentation system\n# doxygen (www.doxygen.org) "
},
{
"path": "docs/Makefile",
"chars": 5585,
"preview": "# Makefile for Sphinx documentation\n#\n\n# You can set these variables from the command line.\nSPHINXOPTS =\nSPHINXBUILD "
},
{
"path": "docs/make.bat",
"chars": 5111,
"preview": "@ECHO OFF\n\nREM Command file for Sphinx documentation\n\nif \"%SPHINXBUILD%\" == \"\" (\n\tset SPHINXBUILD=sphinx-build\n)\nset BUI"
},
{
"path": "docs/source/algorithms.rst",
"chars": 143,
"preview": "Algorithms\n==========\n\n.. toctree::\n :maxdepth: 3\n :caption: Contents:\n\n spatial-pooler\n temporal-memory\n conn"
},
{
"path": "docs/source/classifiers.rst",
"chars": 253,
"preview": "Classifiers\n===========\n\nSDRClassifier\n^^^^^^^^^^^^^\n\n.. doxygenclass:: nupic::algorithms::sdr_classifier::SDRClassifier"
},
{
"path": "docs/source/conf.py",
"chars": 8385,
"preview": "# -*- coding: utf-8 -*-\n#\n# NuPIC Core documentation build configuration file, created by\n# sphinx-quickstart on Thu Mar"
},
{
"path": "docs/source/connections.rst",
"chars": 100,
"preview": "Connections\n===========\n\n.. doxygenclass:: nupic::algorithms::connections::Connections\n :members:\n"
},
{
"path": "docs/source/encoders.rst",
"chars": 231,
"preview": "Encoders\n========\n\nScalarEncoder\n^^^^^^^^^^^^^\n\n.. doxygenclass:: nupic::algorithms::spatial_pooler::SpatialPooler\n :m"
},
{
"path": "docs/source/engine.rst",
"chars": 287,
"preview": "Engine\n======\n\n.. doxygenclass:: nupic::NuPIC\n :members:\n\n.. doxygenclass:: nupic::Network\n :members:\n\n.. doxygencla"
},
{
"path": "docs/source/index.rst",
"chars": 476,
"preview": ".. NuPIC Core documentation master file, created by\n sphinx-quickstart on Thu Mar 2 09:07:39 2017.\n You can adapt t"
},
{
"path": "docs/source/math.rst",
"chars": 994,
"preview": "Math\n====\n\nDomain\n^^^^^^\n\n.. doxygenclass:: nupic::Domain\n :members:\n\nIndex\n^^^^^\n\n.. doxygenclass:: nupic::Index\n :"
},
{
"path": "docs/source/network-io.rst",
"chars": 149,
"preview": "Input / Output\n==============\n\nInput\n^^^^^\n\n.. doxygenclass:: nupic::Input\n :members:\n\nOutput\n^^^^^^\n\n.. doxygenclass:"
},
{
"path": "docs/source/network-links.rst",
"chars": 329,
"preview": "Links\n=====\n\nLink\n^^^^\n\n.. doxygenclass:: nupic::Link\n :members:\n\nLinkPolicy\n^^^^^^^^^^\n\n.. doxygenclass:: nupic::Link"
},
{
"path": "docs/source/network-network.rst",
"chars": 138,
"preview": "Network\n=======\n\nNuPIC\n^^^^^\n\n.. doxygenclass:: nupic::NuPIC\n :members:\n\nNetwork\n^^^^^^^\n\n.. doxygenclass:: nupic::Net"
},
{
"path": "docs/source/network-regions.rst",
"chars": 347,
"preview": "Regions\n=======\n\nRegion\n^^^^^^\n\n.. doxygenclass:: nupic::Region\n :members:\n\nRegionImpl\n^^^^^^^^^^\n\n.. doxygenclass:: n"
},
{
"path": "docs/source/network-sensors.rst",
"chars": 22,
"preview": "Sensors\n=======\n\nTODO\n"
},
{
"path": "docs/source/network.rst",
"chars": 144,
"preview": "Network API\n===========\n\n\n.. toctree::\n :maxdepth: 3\n\n network-network\n network-regions\n network-sensors\n netw"
},
{
"path": "docs/source/spatial-pooler.rst",
"chars": 111,
"preview": "Spatial Pooler\n==============\n\n.. doxygenclass:: nupic::algorithms::spatial_pooler::SpatialPooler\n :members:\n"
},
{
"path": "docs/source/temporal-memory.rst",
"chars": 115,
"preview": "Temporal Memory\n===============\n\n.. doxygenclass:: nupic::algorithms::temporal_memory::TemporalMemory\n :members:\n"
},
{
"path": "docs/source/types.rst",
"chars": 314,
"preview": "Types\n=====\n\nDimensions\n^^^^^^^^^^\n\n.. doxygenclass:: nupic::Dimensions\n :members:\n\nTypes\n^^^^^\n\nBasicType\n+++++++++\n\n"
},
{
"path": "docs/source/utils.rst",
"chars": 27,
"preview": "Utilities\n=========\n\n\nTODO\n"
},
{
"path": "docs/xunit.xslt",
"chars": 5810,
"preview": "<?xml version=\"1.0\" encoding=\"UTF-8\" ?>\n<xsl:stylesheet version=\"1.0\" xmlns:xsl=\"http://www.w3.org/1999/XSL/Transform\">\n"
},
{
"path": "external/Apr1Lib.cmake",
"chars": 4879,
"preview": "# Copyright 2016 Numenta Inc.\n#\n# Copyright may exist in Contributors' modifications\n# and/or contributions to the work."
},
{
"path": "external/AprUtil1Lib.cmake",
"chars": 4801,
"preview": "# Copyright 2016 Numenta Inc.\n#\n# Copyright may exist in Contributors' modifications\n# and/or contributions to the work."
},
{
"path": "external/CMakeLists.txt",
"chars": 2368,
"preview": "# Copyright 2015 Numenta Inc.\n#\n# Copyright may exist in Contributors' modifications\n# and/or contributions to the work."
},
{
"path": "external/CapnProto.cmake",
"chars": 5733,
"preview": "# Copyright 2015 Numenta Inc.\n#\n# Copyright may exist in Contributors' modifications\n# and/or contributions to the work."
},
{
"path": "external/MoveFilesToNewDir.cmake",
"chars": 844,
"preview": "# Copyright 2016 Numenta Inc.\n#\n# Copyright may exist in Contributors' modifications\n# and/or contributions to the work."
},
{
"path": "external/README.md",
"chars": 1788,
"preview": "NuPIC Core external libraries\n=============================\n\nNuPIC Core depends on a number of external libraries that a"
},
{
"path": "external/Swig.cmake",
"chars": 1680,
"preview": "# Copyright 2015 Numenta Inc.\n#\n# Copyright may exist in Contributors' modifications\n# and/or contributions to the work."
},
{
"path": "external/YamlCppLib.cmake",
"chars": 2215,
"preview": "# Copyright 2016 Numenta Inc.\n#\n# Copyright may exist in Contributors' modifications\n# and/or contributions to the work."
},
{
"path": "external/YamlLib.cmake",
"chars": 1760,
"preview": "# Copyright 2016 Numenta Inc.\n#\n# Copyright may exist in Contributors' modifications\n# and/or contributions to the work."
},
{
"path": "external/Zlib.cmake",
"chars": 2502,
"preview": "# Copyright 2016 Numenta Inc.\n#\n# Copyright may exist in Contributors' modifications\n# and/or contributions to the work."
},
{
"path": "external/common/include/CSV_README.md",
"chars": 16272,
"preview": "# Fast C++ CSV Parser\n\nThis is a small, easy-to-use and fast header-only library for reading comma separated value (CSV)"
},
{
"path": "external/common/include/boost/accumulators/accumulators.hpp",
"chars": 1383,
"preview": "///////////////////////////////////////////////////////////////////////////////\n/// \\file accumulators.hpp\n/// Includes "
},
{
"path": "external/common/include/boost/accumulators/accumulators_fwd.hpp",
"chars": 9150,
"preview": "///////////////////////////////////////////////////////////////////////////////\n// accumulators_fwd.hpp\n//\n// Copyright"
},
{
"path": "external/common/include/boost/accumulators/framework/accumulator_base.hpp",
"chars": 1462,
"preview": "///////////////////////////////////////////////////////////////////////////////\n// accumulator_base.hpp\n//\n// Copyright"
},
{
"path": "external/common/include/boost/accumulators/framework/accumulator_concept.hpp",
"chars": 725,
"preview": "///////////////////////////////////////////////////////////////////////////////\n// accumulator_concept.hpp\n//\n// Copyri"
},
{
"path": "external/common/include/boost/accumulators/framework/accumulator_set.hpp",
"chars": 15046,
"preview": "///////////////////////////////////////////////////////////////////////////////\n// accumulator_set.hpp\n//\n// Copyright "
},
{
"path": "external/common/include/boost/accumulators/framework/accumulators/droppable_accumulator.hpp",
"chars": 10136,
"preview": "///////////////////////////////////////////////////////////////////////////////\n// droppable_accumulator.hpp\n//\n// Copy"
},
{
"path": "external/common/include/boost/accumulators/framework/accumulators/external_accumulator.hpp",
"chars": 3603,
"preview": "///////////////////////////////////////////////////////////////////////////////\n// external_accumulator.hpp\n//\n// Copyr"
},
{
"path": "external/common/include/boost/accumulators/framework/accumulators/reference_accumulator.hpp",
"chars": 2534,
"preview": "///////////////////////////////////////////////////////////////////////////////\n// reference_accumulator.hpp\n//\n// Copy"
},
{
"path": "external/common/include/boost/accumulators/framework/accumulators/value_accumulator.hpp",
"chars": 2417,
"preview": "///////////////////////////////////////////////////////////////////////////////\n// value_accumulator.hpp\n//\n// Copyrigh"
},
{
"path": "external/common/include/boost/accumulators/framework/depends_on.hpp",
"chars": 14887,
"preview": "///////////////////////////////////////////////////////////////////////////////\n// depends_on.hpp\n//\n// Copyright 2005 "
},
{
"path": "external/common/include/boost/accumulators/framework/external.hpp",
"chars": 782,
"preview": "///////////////////////////////////////////////////////////////////////////////\n// external.hpp\n//\n// Copyright 2005 Er"
},
{
"path": "external/common/include/boost/accumulators/framework/extractor.hpp",
"chars": 10615,
"preview": "///////////////////////////////////////////////////////////////////////////////\n// extractor.hpp\n//\n// Copyright 2005 E"
},
{
"path": "external/common/include/boost/accumulators/framework/features.hpp",
"chars": 923,
"preview": "///////////////////////////////////////////////////////////////////////////////\n// features.hpp\n//\n// Copyright 2005 Er"
},
{
"path": "external/common/include/boost/accumulators/framework/parameters/accumulator.hpp",
"chars": 718,
"preview": "///////////////////////////////////////////////////////////////////////////////\n// accumulator.hpp\n//\n// Copyright 2005"
},
{
"path": "external/common/include/boost/accumulators/framework/parameters/sample.hpp",
"chars": 693,
"preview": "///////////////////////////////////////////////////////////////////////////////\n// sample.hpp\n//\n// Copyright 2005 Eric"
},
{
"path": "external/common/include/boost/accumulators/framework/parameters/weight.hpp",
"chars": 726,
"preview": "///////////////////////////////////////////////////////////////////////////////\n// weight.hpp\n//\n// Copyright 2005 Eric"
},
{
"path": "external/common/include/boost/accumulators/framework/parameters/weights.hpp",
"chars": 724,
"preview": "///////////////////////////////////////////////////////////////////////////////\n// weights.hpp\n//\n// Copyright 2005 Eri"
},
{
"path": "external/common/include/boost/accumulators/numeric/detail/function1.hpp",
"chars": 2681,
"preview": "// Copyright David Abrahams 2006. Distributed under the Boost\n// Software License, Version 1.0. (See accompanying\n// fil"
},
{
"path": "external/common/include/boost/accumulators/numeric/detail/function2.hpp",
"chars": 406,
"preview": "// Copyright David Abrahams 2006. Distributed under the Boost\n// Software License, Version 1.0. (See accompanying\n// fil"
},
{
"path": "external/common/include/boost/accumulators/numeric/detail/function3.hpp",
"chars": 409,
"preview": "// Copyright David Abrahams 2006. Distributed under the Boost\n// Software License, Version 1.0. (See accompanying\n// fil"
},
{
"path": "external/common/include/boost/accumulators/numeric/detail/function4.hpp",
"chars": 409,
"preview": "// Copyright David Abrahams 2006. Distributed under the Boost\n// Software License, Version 1.0. (See accompanying\n// fil"
},
{
"path": "external/common/include/boost/accumulators/numeric/detail/function_n.hpp",
"chars": 6725,
"preview": "// Copyright David Abrahams 2006. Distributed under the Boost\n// Software License, Version 1.0. (See accompanying\n// fil"
},
{
"path": "external/common/include/boost/accumulators/numeric/detail/pod_singleton.hpp",
"chars": 530,
"preview": "// Copyright David Abrahams 2006. Distributed under the Boost\n// Software License, Version 1.0. (See accompanying\n// fil"
},
{
"path": "external/common/include/boost/accumulators/numeric/functional/complex.hpp",
"chars": 2316,
"preview": "///////////////////////////////////////////////////////////////////////////////\n/// \\file complex.hpp\n///\n// Copyright "
},
{
"path": "external/common/include/boost/accumulators/numeric/functional/valarray.hpp",
"chars": 16827,
"preview": "///////////////////////////////////////////////////////////////////////////////\n/// \\file valarray.hpp\n///\n// Copyright"
},
{
"path": "external/common/include/boost/accumulators/numeric/functional/vector.hpp",
"chars": 12418,
"preview": "///////////////////////////////////////////////////////////////////////////////\n/// \\file vector.hpp\n///\n// Copyright 2"
},
{
"path": "external/common/include/boost/accumulators/numeric/functional.hpp",
"chars": 22698,
"preview": "///////////////////////////////////////////////////////////////////////////////\n/// \\file functional.hpp\n///\n// Copyrig"
},
{
"path": "external/common/include/boost/accumulators/numeric/functional_fwd.hpp",
"chars": 9458,
"preview": "///////////////////////////////////////////////////////////////////////////////\n/// \\file functional_fwd.hpp\n///\n// Cop"
},
{
"path": "external/common/include/boost/accumulators/statistics/count.hpp",
"chars": 1820,
"preview": "///////////////////////////////////////////////////////////////////////////////\n// count.hpp\n//\n// Copyright 2005 Eric "
},
{
"path": "external/common/include/boost/accumulators/statistics/covariance.hpp",
"chars": 7178,
"preview": "///////////////////////////////////////////////////////////////////////////////\n// covariance.hpp\n//\n// Copyright 2006 "
},
{
"path": "external/common/include/boost/accumulators/statistics/density.hpp",
"chars": 9475,
"preview": "\n///////////////////////////////////////////////////////////////////////////////\n// density.hpp\n//\n// Copyright 2006 Da"
},
{
"path": "external/common/include/boost/accumulators/statistics/error_of.hpp",
"chars": 2588,
"preview": "///////////////////////////////////////////////////////////////////////////////\n// error_of.hpp\n//\n// Copyright 2005 Er"
},
{
"path": "external/common/include/boost/accumulators/statistics/error_of_mean.hpp",
"chars": 2193,
"preview": "///////////////////////////////////////////////////////////////////////////////\n// error_of.hpp\n//\n// Copyright 2005 Er"
},
{
"path": "external/common/include/boost/accumulators/statistics/extended_p_square.hpp",
"chars": 11143,
"preview": "///////////////////////////////////////////////////////////////////////////////\n// extended_p_square.hpp\n//\n// Copyrigh"
},
{
"path": "external/common/include/boost/accumulators/statistics/extended_p_square_quantile.hpp",
"chars": 12179,
"preview": "///////////////////////////////////////////////////////////////////////////////\n// extended_p_square_quantile.hpp\n//\n// "
},
{
"path": "external/common/include/boost/accumulators/statistics/kurtosis.hpp",
"chars": 3687,
"preview": "///////////////////////////////////////////////////////////////////////////////\n// kurtosis.hpp\n//\n// Copyright 2006 Ol"
},
{
"path": "external/common/include/boost/accumulators/statistics/max.hpp",
"chars": 2100,
"preview": "///////////////////////////////////////////////////////////////////////////////\n// max.hpp\n//\n// Copyright 2005 Eric Ni"
},
{
"path": "external/common/include/boost/accumulators/statistics/mean.hpp",
"chars": 9018,
"preview": "///////////////////////////////////////////////////////////////////////////////\n// mean.hpp\n//\n// Copyright 2005 Eric N"
},
{
"path": "external/common/include/boost/accumulators/statistics/median.hpp",
"chars": 9587,
"preview": "///////////////////////////////////////////////////////////////////////////////\n// median.hpp\n//\n// Copyright 2006 Eric"
},
{
"path": "external/common/include/boost/accumulators/statistics/min.hpp",
"chars": 2100,
"preview": "///////////////////////////////////////////////////////////////////////////////\n// min.hpp\n//\n// Copyright 2005 Eric Ni"
},
{
"path": "external/common/include/boost/accumulators/statistics/moment.hpp",
"chars": 3243,
"preview": "///////////////////////////////////////////////////////////////////////////////\n// moment.hpp\n//\n// Copyright 2005 Eric"
},
{
"path": "external/common/include/boost/accumulators/statistics/p_square_cumul_dist.hpp",
"chars": 9810,
"preview": "///////////////////////////////////////////////////////////////////////////////\n// p_square_cumulative_distribution.hpp\n"
},
{
"path": "external/common/include/boost/accumulators/statistics/p_square_cumulative_distribution.hpp",
"chars": 955,
"preview": "///////////////////////////////////////////////////////////////////////////////\n// p_square_cumulative_distribution.hpp\n"
},
{
"path": "external/common/include/boost/accumulators/statistics/p_square_quantile.hpp",
"chars": 9363,
"preview": "///////////////////////////////////////////////////////////////////////////////\n// p_square_quantile.hpp\n//\n// Copyrigh"
},
{
"path": "external/common/include/boost/accumulators/statistics/parameters/quantile_probability.hpp",
"chars": 766,
"preview": "///////////////////////////////////////////////////////////////////////////////\n// quantile_probability.hpp\n//\n// Copyr"
},
{
"path": "external/common/include/boost/accumulators/statistics/peaks_over_threshold.hpp",
"chars": 16503,
"preview": "///////////////////////////////////////////////////////////////////////////////\n// peaks_over_threshold.hpp\n//\n// Copyr"
},
{
"path": "external/common/include/boost/accumulators/statistics/pot_quantile.hpp",
"chars": 7137,
"preview": "///////////////////////////////////////////////////////////////////////////////\n// pot_quantile.hpp\n//\n// Copyright 200"
},
{
"path": "external/common/include/boost/accumulators/statistics/pot_tail_mean.hpp",
"chars": 7602,
"preview": "///////////////////////////////////////////////////////////////////////////////\n// pot_tail_mean.hpp\n//\n// Copyright 20"
},
{
"path": "external/common/include/boost/accumulators/statistics/rolling_count.hpp",
"chars": 2397,
"preview": "///////////////////////////////////////////////////////////////////////////////\n// rolling_count.hpp\n//\n// Copyright 200"
},
{
"path": "external/common/include/boost/accumulators/statistics/rolling_mean.hpp",
"chars": 5919,
"preview": "///////////////////////////////////////////////////////////////////////////////\n// rolling_mean.hpp\n// Copyright (C) 200"
},
{
"path": "external/common/include/boost/accumulators/statistics/rolling_moment.hpp",
"chars": 3547,
"preview": "///////////////////////////////////////////////////////////////////////////////\n// rolling_moment.hpp\n// Copyright 2005 "
},
{
"path": "external/common/include/boost/accumulators/statistics/rolling_sum.hpp",
"chars": 2677,
"preview": "///////////////////////////////////////////////////////////////////////////////\n// rolling_sum.hpp\n//\n// Copyright 2008 "
},
{
"path": "external/common/include/boost/accumulators/statistics/rolling_variance.hpp",
"chars": 9063,
"preview": "///////////////////////////////////////////////////////////////////////////////\n// rolling_variance.hpp\n// Copyright (C)"
},
{
"path": "external/common/include/boost/accumulators/statistics/rolling_window.hpp",
"chars": 5615,
"preview": "///////////////////////////////////////////////////////////////////////////////\n// rolling_window.hpp\n//\n// Copyright 20"
},
{
"path": "external/common/include/boost/accumulators/statistics/skewness.hpp",
"chars": 3514,
"preview": "///////////////////////////////////////////////////////////////////////////////\n// skewness.hpp\n//\n// Copyright 2006 Ol"
},
{
"path": "external/common/include/boost/accumulators/statistics/stats.hpp",
"chars": 972,
"preview": "///////////////////////////////////////////////////////////////////////////////\n/// \\file stats.hpp\n/// Contains the sta"
},
{
"path": "external/common/include/boost/accumulators/statistics/sum.hpp",
"chars": 3739,
"preview": "///////////////////////////////////////////////////////////////////////////////\n// sum.hpp\n//\n// Copyright 2005 Eric Ni"
},
{
"path": "external/common/include/boost/accumulators/statistics/sum_kahan.hpp",
"chars": 4890,
"preview": "///////////////////////////////////////////////////////////////////////////////\n// sum_kahan.hpp\n//\n// Copyright 2010 G"
},
{
"path": "external/common/include/boost/accumulators/statistics/tail.hpp",
"chars": 10655,
"preview": "///////////////////////////////////////////////////////////////////////////////\n// tail.hpp\n//\n// Copyright 2005 Eric N"
},
{
"path": "external/common/include/boost/accumulators/statistics/tail_mean.hpp",
"chars": 8804,
"preview": "///////////////////////////////////////////////////////////////////////////////\n// tail_mean.hpp\n//\n// Copyright 2006 D"
},
{
"path": "external/common/include/boost/accumulators/statistics/tail_quantile.hpp",
"chars": 5358,
"preview": "///////////////////////////////////////////////////////////////////////////////\n// tail_quantile.hpp\n//\n// Copyright 20"
},
{
"path": "external/common/include/boost/accumulators/statistics/tail_variate.hpp",
"chars": 4251,
"preview": "///////////////////////////////////////////////////////////////////////////////\n// tail_variate.hpp\n//\n// Copyright 200"
},
{
"path": "external/common/include/boost/accumulators/statistics/tail_variate_means.hpp",
"chars": 10088,
"preview": "///////////////////////////////////////////////////////////////////////////////\n// tail_variate_means.hpp\n//\n// Copyrig"
},
{
"path": "external/common/include/boost/accumulators/statistics/times2_iterator.hpp",
"chars": 1713,
"preview": "///////////////////////////////////////////////////////////////////////////////\n// times2_iterator.hpp\n//\n// Copyright "
},
{
"path": "external/common/include/boost/accumulators/statistics/variance.hpp",
"chars": 7147,
"preview": "///////////////////////////////////////////////////////////////////////////////\n// variance.hpp\n//\n// Copyright 2005 Da"
},
{
"path": "external/common/include/boost/accumulators/statistics/variates/covariate.hpp",
"chars": 792,
"preview": "///////////////////////////////////////////////////////////////////////////////\n// weight.hpp\n//\n// Copyright 2005 Eric"
},
{
"path": "external/common/include/boost/accumulators/statistics/weighted_covariance.hpp",
"chars": 5050,
"preview": "///////////////////////////////////////////////////////////////////////////////\n// weighted_covariance.hpp\n//\n// Copyri"
},
{
"path": "external/common/include/boost/accumulators/statistics/weighted_density.hpp",
"chars": 8986,
"preview": "///////////////////////////////////////////////////////////////////////////////\n// weighted_density.hpp\n//\n// Copyright"
},
{
"path": "external/common/include/boost/accumulators/statistics/weighted_extended_p_square.hpp",
"chars": 12403,
"preview": "///////////////////////////////////////////////////////////////////////////////\n// weighted_extended_p_square.hpp\n//\n// "
},
{
"path": "external/common/include/boost/accumulators/statistics/weighted_kurtosis.hpp",
"chars": 4147,
"preview": "///////////////////////////////////////////////////////////////////////////////\n// weighted_kurtosis.hpp\n//\n// Copyrigh"
},
{
"path": "external/common/include/boost/accumulators/statistics/weighted_mean.hpp",
"chars": 6443,
"preview": "///////////////////////////////////////////////////////////////////////////////\n// weighted_mean.hpp\n//\n// Copyright 20"
},
{
"path": "external/common/include/boost/accumulators/statistics/weighted_median.hpp",
"chars": 8190,
"preview": "///////////////////////////////////////////////////////////////////////////////\n// weighted_median.hpp\n//\n// Copyright "
},
{
"path": "external/common/include/boost/accumulators/statistics/weighted_moment.hpp",
"chars": 3191,
"preview": "///////////////////////////////////////////////////////////////////////////////\n// weighted_moment.hpp\n//\n// Copyright "
},
{
"path": "external/common/include/boost/accumulators/statistics/weighted_p_square_cumul_dist.hpp",
"chars": 10631,
"preview": "///////////////////////////////////////////////////////////////////////////////\n// weighted_p_square_cumul_dist.hpp\n//\n/"
},
{
"path": "external/common/include/boost/accumulators/statistics/weighted_p_square_cumulative_distribution.hpp",
"chars": 1009,
"preview": "///////////////////////////////////////////////////////////////////////////////\n// weighted_p_square_cumulative_distribu"
},
{
"path": "external/common/include/boost/accumulators/statistics/weighted_p_square_quantile.hpp",
"chars": 10747,
"preview": "///////////////////////////////////////////////////////////////////////////////\n// weighted_p_square_quantile.hpp\n//\n// "
},
{
"path": "external/common/include/boost/accumulators/statistics/weighted_peaks_over_threshold.hpp",
"chars": 11927,
"preview": "///////////////////////////////////////////////////////////////////////////////\n// weighted_peaks_over_threshold.hpp\n//\n"
},
{
"path": "external/common/include/boost/accumulators/statistics/weighted_skewness.hpp",
"chars": 3844,
"preview": "///////////////////////////////////////////////////////////////////////////////\n// weighted_skewness.hpp\n//\n// Copyrigh"
},
{
"path": "external/common/include/boost/accumulators/statistics/weighted_sum.hpp",
"chars": 3437,
"preview": "///////////////////////////////////////////////////////////////////////////////\n// weighted_sum.hpp\n//\n// Copyright 200"
},
{
"path": "external/common/include/boost/accumulators/statistics/weighted_sum_kahan.hpp",
"chars": 4326,
"preview": "///////////////////////////////////////////////////////////////////////////////\n// weighted_sum_kahan.hpp\n//\n// Copyrig"
},
{
"path": "external/common/include/boost/accumulators/statistics/weighted_tail_mean.hpp",
"chars": 5788,
"preview": "///////////////////////////////////////////////////////////////////////////////\n// weighted_tail_mean.hpp\n//\n// Copyrig"
},
{
"path": "external/common/include/boost/accumulators/statistics/weighted_tail_quantile.hpp",
"chars": 5135,
"preview": "///////////////////////////////////////////////////////////////////////////////\n// weighted_tail_quantile.hpp\n//\n// Cop"
},
{
"path": "external/common/include/boost/accumulators/statistics/weighted_tail_variate_means.hpp",
"chars": 9663,
"preview": "///////////////////////////////////////////////////////////////////////////////\n// weighted_tail_variate_means.hpp\n//\n//"
},
{
"path": "external/common/include/boost/accumulators/statistics/weighted_variance.hpp",
"chars": 6568,
"preview": "///////////////////////////////////////////////////////////////////////////////\n// weighted_variance.hpp\n//\n// Copyrigh"
},
{
"path": "external/common/include/boost/accumulators/statistics/with_error.hpp",
"chars": 1277,
"preview": "///////////////////////////////////////////////////////////////////////////////\n// with_error.hpp\n//\n// Copyright 2005 "
},
{
"path": "external/common/include/boost/accumulators/statistics.hpp",
"chars": 3365,
"preview": "///////////////////////////////////////////////////////////////////////////////\n/// \\file statistics.hpp\n/// Includes al"
},
{
"path": "external/common/include/boost/accumulators/statistics_fwd.hpp",
"chars": 13621,
"preview": "///////////////////////////////////////////////////////////////////////////////\n// statistics_fwd.hpp\n//\n// Copyright 2"
},
{
"path": "external/common/include/boost/algorithm/algorithm.hpp",
"chars": 2305,
"preview": "/* \n Copyright (c) Marshall Clow 2014.\n\n Distributed under the Boost Software License, Version 1.0. (See accompanyin"
},
{
"path": "external/common/include/boost/algorithm/clamp.hpp",
"chars": 7669,
"preview": "/* \n Copyright (c) Marshall Clow 2008-2012.\n\n Distributed under the Boost Software License, Version 1.0. (See accomp"
},
{
"path": "external/common/include/boost/algorithm/cxx11/all_of.hpp",
"chars": 2705,
"preview": "/* \n Copyright (c) Marshall Clow 2008-2012.\n\n Distributed under the Boost Software License, Version 1.0. (See accomp"
},
{
"path": "external/common/include/boost/algorithm/cxx11/any_of.hpp",
"chars": 2696,
"preview": "/* \n Copyright (c) Marshall Clow 2008-2012.\n\n Distributed under the Boost Software License, Version 1.0. (See accomp"
},
{
"path": "external/common/include/boost/algorithm/cxx11/copy_if.hpp",
"chars": 5313,
"preview": "/* \n Copyright (c) Marshall Clow 2008-2012.\n\n Distributed under the Boost Software License, Version 1.0. (See accomp"
},
{
"path": "external/common/include/boost/algorithm/cxx11/copy_n.hpp",
"chars": 1223,
"preview": "/* \n Copyright (c) Marshall Clow 2011-2012.\n\n Distributed under the Boost Software License, Version 1.0. (See accomp"
},
{
"path": "external/common/include/boost/algorithm/cxx11/find_if_not.hpp",
"chars": 1848,
"preview": "/* \n Copyright (c) Marshall Clow 2011-2012.\n\n Distributed under the Boost Software License, Version 1.0. (See accomp"
},
{
"path": "external/common/include/boost/algorithm/cxx11/iota.hpp",
"chars": 2041,
"preview": "/* \n Copyright (c) Marshall Clow 2008-2012.\n\n Distributed under the Boost Software License, Version 1.0. (See accomp"
},
{
"path": "external/common/include/boost/algorithm/cxx11/is_partitioned.hpp",
"chars": 1848,
"preview": "/* \n Copyright (c) Marshall Clow 2011-2012.\n\n Distributed under the Boost Software License, Version 1.0. (See accomp"
},
{
"path": "external/common/include/boost/algorithm/cxx11/is_permutation.hpp",
"chars": 8068,
"preview": "/*\n Copyright (c) Marshall Clow 2011-2012.\n\n Distributed under the Boost Software License, Version 1.0. (See accompa"
},
{
"path": "external/common/include/boost/algorithm/cxx11/is_sorted.hpp",
"chars": 10692,
"preview": "// Copyright (c) 2010 Nuovation System Designs, LLC\n// Grant Erickson <gerickson@nuovations.com>\n//\n// Reworked som"
},
{
"path": "external/common/include/boost/algorithm/cxx11/none_of.hpp",
"chars": 2683,
"preview": "/* \n Copyright (c) Marshall Clow 2008-2012.\n\n Distributed under the Boost Software License, Version 1.0. (See accomp"
},
{
"path": "external/common/include/boost/algorithm/cxx11/one_of.hpp",
"chars": 2802,
"preview": "/* \n Copyright (c) Marshall Clow 2008-2012.\n\n Distributed under the Boost Software License, Version 1.0. (See accomp"
},
{
"path": "external/common/include/boost/algorithm/cxx11/partition_copy.hpp",
"chars": 2895,
"preview": "/* \n Copyright (c) Marshall Clow 2011-2012.\n\n Distributed under the Boost Software License, Version 1.0. (See accomp"
},
{
"path": "external/common/include/boost/algorithm/cxx11/partition_point.hpp",
"chars": 2067,
"preview": "/* \n Copyright (c) Marshall Clow 2011-2012.\n\n Distributed under the Boost Software License, Version 1.0. (See accomp"
},
{
"path": "external/common/include/boost/algorithm/cxx14/equal.hpp",
"chars": 4041,
"preview": "/* \n Copyright (c) Marshall Clow 2008-2012.\n\n Distributed under the Boost Software License, Version 1.0. (See accomp"
},
{
"path": "external/common/include/boost/algorithm/cxx14/is_permutation.hpp",
"chars": 3601,
"preview": "/*\n Copyright (c) Marshall Clow 2014.\n\n Distributed under the Boost Software License, Version 1.0. (See accompanying"
},
{
"path": "external/common/include/boost/algorithm/cxx14/mismatch.hpp",
"chars": 2555,
"preview": "/* \n Copyright (c) Marshall Clow 2008-2012.\n\n Distributed under the Boost Software License, Version 1.0. (See accomp"
},
{
"path": "external/common/include/boost/algorithm/gather.hpp",
"chars": 4047,
"preview": "/* \n Copyright 2008 Adobe Systems Incorporated\n\n Distributed under the Boost Software License, Version 1.0. (See ac"
}
]
// ... and 12733 more files (download for full content)
About this extraction
This page contains the full source code of the numenta/nupic.core GitHub repository, extracted and formatted as plain text for AI agents and large language models (LLMs). The extraction includes 12933 files (113.2 MB), approximately 27.0M tokens, and a symbol index with 167594 extracted functions, classes, methods, constants, and types. Use this with OpenClaw, Claude, ChatGPT, Cursor, Windsurf, or any other AI tool that accepts text input. You can copy the full output to your clipboard or download it as a .txt file.
Extracted by GitExtract — free GitHub repo to text converter for AI. Built by Nikandr Surkov.