[ { "path": ".appveyor.yml", "content": "build: false\n\nos: Visual Studio 2015\n\nplatform:\n - x64\n\nenvironment:\n matrix:\n - MINICONDA: C:\\xframe-conda\n\ninit:\n - \"ECHO %MINICONDA%\"\n - C:\\\"Program Files (x86)\"\\\"Microsoft Visual Studio 14.0\"\\VC\\vcvarsall.bat %PLATFORM%\n - ps: if($env:Platform -eq \"x64\"){Start-FileDownload 'http://repo.continuum.io/miniconda/Miniconda3-latest-Windows-x86_64.exe' C:\\Miniconda.exe; echo \"Done\"}\n - ps: if($env:Platform -eq \"x86\"){Start-FileDownload 'http://repo.continuum.io/miniconda/Miniconda3-latest-Windows-x86.exe' C:\\Miniconda.exe; echo \"Done\"}\n - cmd: C:\\Miniconda.exe /S /D=C:\\xframe-conda\n - \"set PATH=%MINICONDA%;%MINICONDA%\\\\Scripts;%MINICONDA%\\\\Library\\\\bin;%PATH%\"\n\ninstall:\n - conda config --set always_yes yes --set changeps1 no\n - conda update -q conda\n - conda info -a\n - conda env create --file environment-dev.yml\n - CALL conda.bat activate xframe\n - cmake -G \"NMake Makefiles\" -D CMAKE_INSTALL_PREFIX=%MINICONDA%\\\\LIBRARY -DDOWNLOAD_GTEST=ON .\n - nmake test_xframe\n - cd test\n\nbuild_script:\n - .\\test_xframe\n" }, { "path": ".azure-pipelines/azure-pipelines-linux-clang.yml", "content": "jobs:\n - job: 'Linux_0'\n strategy:\n matrix:\n clang_4:\n llvm_version: '4.0'\n clang_5:\n llvm_version: '5.0'\n clang_6:\n llvm_version: '6.0'\n clang_7:\n llvm_version: '7'\n clang_8:\n llvm_version: '8'\n clang_9:\n llvm_version: '9'\n clang_10:\n llvm_version: '10'\n pool:\n vmImage: ubuntu-16.04\n variables:\n CC: clang-$(llvm_version)\n CXX: clang++-$(llvm_version)\n timeoutInMinutes: 360\n steps:\n\n - script: |\n sudo add-apt-repository ppa:ubuntu-toolchain-r/test\n if [[ $(llvm_version) == '4.0' || $(llvm_version) == '5.0' ]]; then\n sudo apt-get update\n sudo apt-get --no-install-suggests --no-install-recommends install gcc-4.9 clang-$(llvm_version)\n else\n LLVM_VERSION=$(llvm_version)\n get -O - http://apt.llvm.org/llvm-snapshot.gpg.key | sudo apt-key add -\n sudo add-apt-repository \"deb http://apt.llvm.org/xenial/ llvm-toolchain-xenial-$LLVM_VERSION main\"\n sudo apt-get update\n sudo apt-get --no-install-suggests --no-install-recommends install clang-$(llvm_version)\n fi\n displayName: Install build toolchain\n\n - bash: echo \"##vso[task.prependpath]$CONDA/bin\"\n displayName: Add conda to PATH\n\n - template: unix-build.yml\n" }, { "path": ".azure-pipelines/azure-pipelines-linux-gcc.yml", "content": "jobs:\n - job: 'Linux_1'\n strategy:\n matrix:\n gcc_4:\n gcc_version: '4.9'\n gcc_5:\n gcc_version: '5'\n gcc_6:\n gcc_version: '6'\n gcc_7:\n gcc_version: '7'\n gcc_8:\n gcc_version: '8'\n gcc_9:\n gcc_version: '9'\n pool:\n vmImage: ubuntu-16.04\n variables:\n CC: gcc-$(gcc_version)\n CXX: g++-$(gcc_version)\n timeoutInMinutes: 360\n steps:\n\n - script: |\n if [[ $(gcc_version) == '4.9' || $(gcc_version) == '6' ]]; then\n sudo add-apt-repository ppa:ubuntu-toolchain-r/test\n sudo apt-get update\n sudo apt-get --no-install-suggests --no-install-recommends install g++-$(gcc_version)\n fi\n displayName: Install build toolchain\n \n - bash: echo \"##vso[task.prependpath]$CONDA/bin\"\n displayName: Add conda to PATH\n\n - template: unix-build.yml\n\n" }, { "path": ".azure-pipelines/azure-pipelines-osx.yml", "content": "jobs:\n - job: 'OSX'\n strategy:\n matrix:\n macOS_10_14:\n image_name: 'macOS-10.14'\n macOS_10_15:\n image_name: 'macOS-10.15'\n pool:\n vmImage: $(image_name)\n variables:\n CC: clang\n CXX: clang++\n timeoutInMinutes: 360\n steps:\n - script: |\n echo \"Removing homebrew for Azure to avoid conflicts with conda\"\n curl -fsSL https://raw.githubusercontent.com/Homebrew/install/master/uninstall > ~/uninstall_homebrew\n chmod +x ~/uninstall_homebrew\n ~/uninstall_homebrew -f -q\n displayName: Remove homebrew\n\n - bash: |\n echo \"##vso[task.prependpath]$CONDA/bin\"\n sudo chown -R $USER $CONDA\n displayName: Add conda to PATH\n\n - template: unix-build.yml\n" }, { "path": ".azure-pipelines/unix-build.yml", "content": "steps:\n - script: |\n conda config --set always_yes yes --set changeps1 no\n conda update -q conda\n conda env create --file environment-dev.yml\n source activate xframe\n\n - script: |\n source activate xframe\n mkdir build\n cd build\n cmake -DCMAKE_INSTALL_PREFIX=$CONDA_PREFIX -DDOWNLOAD_GTEST=ON $(Build.SourcesDirectory)\n displayName: Configure xframe\n workingDirectory: $(Build.BinariesDirectory)\n\n - script: |\n source activate xxframe\n make -j2 test_xframe\n displayName: Build xframe\n workingDirectory: $(Build.BinariesDirectory)/build\n\n - script: |\n source activate xframe\n cd test\n ./test_xframe\n displayName: Test xframe\n workingDirectory: $(Build.BinariesDirectory)/build/test\n \n" }, { "path": ".gitignore", "content": "# Prerequisites\n*.d\n\n# Compiled Object files\n*.slo\n*.lo\n*.o\n*.obj\n\n# Precompiled Headers\n*.gch\n*.pch\n\n# Compiled Dynamic libraries\n*.so\n*.dylib\n*.dll\n\n# Compiled Static libraries\n*.lai\n*.la\n*.a\n*.lib\n\n# Executables\n*.exe\n*.out\n*.app\n\n# Vim tmp files\n*.swp\n\n# Build directory\nbuild/\n\n# Test build artefacts\ntest/test_xtensor\ntest/CMakeCache.txt\ntest/Makefile\ntest/CMakeFiles/\ntest/cmake_install.cmake\n\n# Documentation build artefacts\ndocs/CMakeCache.txt\ndocs/xml/\ndocs/build/\n\n# Jupyter artefacts\n.ipynb_checkpoints/\n\n# Generated files\n*.pc\n" }, { "path": ".travis.yml", "content": "language: cpp\ndist: xenial\nmatrix:\n include:\n - os: linux\n addons:\n apt:\n sources:\n - ubuntu-toolchain-r-test\n packages:\n - g++-4.9\n env: COMPILER=gcc GCC=4.9\n - os: linux\n addons:\n apt:\n sources:\n - ubuntu-toolchain-r-test\n packages:\n - g++-5\n env: COMPILER=gcc GCC=5\n - os: linux\n addons:\n apt:\n sources:\n - ubuntu-toolchain-r-test\n packages:\n - g++-6\n env: COMPILER=gcc GCC=6\n - os: linux\n addons:\n apt:\n sources:\n - ubuntu-toolchain-r-test\n packages:\n - g++-7\n env: COMPILER=gcc GCC=7\n - os: linux\n addons:\n apt:\n sources:\n - ubuntu-toolchain-r-test\n - llvm-toolchain-xenial-4.0\n packages:\n - g++-4.9\n - clang-4.0\n env: COMPILER=clang CLANG=4.0\n - os: linux\n addons:\n apt:\n sources:\n - ubuntu-toolchain-r-test\n - llvm-toolchain-xenial-5.0\n packages:\n - g++-4.9\n - clang-5.0\n env: COMPILER=clang CLANG=5.0\n - os: linux\n addons:\n apt:\n sources:\n - ubuntu-toolchain-r-test\n - llvm-toolchain-xenial-6.0\n packages:\n - clang-6.0\n env: COMPILER=clang CLANG=6.0\n - os: osx\n osx_image: xcode8\n compiler: clang\nenv:\n global:\n - MINCONDA_VERSION=\"latest\"\n - MINCONDA_LINUX=\"Linux-x86_64\"\n - MINCONDA_OSX=\"MacOSX-x86_64\"\nbefore_install:\n - |\n # Configure build variables\n if [[ \"$TRAVIS_OS_NAME\" == \"linux\" ]]; then\n if [[ \"$COMPILER\" == \"gcc\" ]]; then\n export CXX=g++-$GCC CC=gcc-$GCC;\n fi\n if [[ \"$COMPILER\" == \"clang\" ]]; then\n export CXX=clang++-$CLANG CC=clang-$CLANG;\n fi\n elif [[ \"$TRAVIS_OS_NAME\" == \"osx\" ]]; then\n export CXX=clang++ CC=clang;\n fi\ninstall:\n # Define the version of miniconda to download\n - if [[ \"$TRAVIS_OS_NAME\" == \"linux\" ]]; then\n MINCONDA_OS=$MINCONDA_LINUX;\n elif [[ \"$TRAVIS_OS_NAME\" == \"osx\" ]]; then\n MINCONDA_OS=$MINCONDA_OSX;\n fi\n - wget \"http://repo.continuum.io/miniconda/Miniconda3-$MINCONDA_VERSION-$MINCONDA_OS.sh\" -O miniconda.sh;\n - bash miniconda.sh -b -p $HOME/miniconda\n - export PATH=\"$HOME/miniconda/bin:$PATH\"\n - hash -r\n - conda config --set always_yes yes --set changeps1 no\n # The 2 following lines are a workaround to https://github.com/conda/conda/issues/9337\n - pip uninstall -y setuptools\n - conda install setuptools\n - conda update -q conda\n - conda install cmake -c conda-forge\n - conda install xtensor=0.21.4 -c conda-forge\n # Testing\n - mkdir build\n - cd build\n - cmake -DDOWNLOAD_GTEST=ON ..;\n - make -j2 test_xframe\n - cd test\nscript:\n - ./test_xframe\n" }, { "path": "CMakeLists.txt", "content": "############################################################################\n# Copyright (c) Johan Mabille and Sylvain Corlay #\n# Copyright (c) QuantStack #\n# #\n# Distributed under the terms of the BSD 3-Clause License. #\n# #\n# The full license is in the file LICENSE, distributed with this software. #\n############################################################################\n\ncmake_minimum_required(VERSION 3.1)\nproject(xframe)\n\nset(XFRAME_INCLUDE_DIR ${CMAKE_CURRENT_SOURCE_DIR}/include)\n\n# Versionning\n# ===========\n\nfile(STRINGS \"${XFRAME_INCLUDE_DIR}/xframe/xframe_config.hpp\" xframe_version_defines\n REGEX \"#define XFRAME_VERSION_(MAJOR|MINOR|PATCH)\")\nforeach(ver ${xframe_version_defines})\n if(ver MATCHES \"#define XFRAME_VERSION_(MAJOR|MINOR|PATCH) +([^ ]+)$\")\n set(XFRAME_VERSION_${CMAKE_MATCH_1} \"${CMAKE_MATCH_2}\" CACHE INTERNAL \"\")\n endif()\nendforeach()\nset(${PROJECT_NAME}_VERSION\n ${XFRAME_VERSION_MAJOR}.${XFRAME_VERSION_MINOR}.${XFRAME_VERSION_PATCH})\nmessage(STATUS \"xframe v${${PROJECT_NAME}_VERSION}\")\n\n# Dependencies\n# ============\n\nfind_package(xtensor REQUIRED)\ninclude_directories(${xtensor_INCLUDE_DIRS})\n\nfind_package(xtl REQUIRED)\ninclude_directories(${xtl_INCLUDE_DIRS})\n\n# Build\n# =====\n\nset(XFRAME_HEADERS\n ${XFRAME_INCLUDE_DIR}/xframe/xaxis.hpp\n ${XFRAME_INCLUDE_DIR}/xframe/xaxis_base.hpp\n ${XFRAME_INCLUDE_DIR}/xframe/xaxis_default.hpp\n ${XFRAME_INCLUDE_DIR}/xframe/xaxis_expression_leaf.hpp\n ${XFRAME_INCLUDE_DIR}/xframe/xaxis_function.hpp\n ${XFRAME_INCLUDE_DIR}/xframe/xaxis_index_slice.hpp\n ${XFRAME_INCLUDE_DIR}/xframe/xaxis_label_slice.hpp\n ${XFRAME_INCLUDE_DIR}/xframe/xaxis_math.hpp\n ${XFRAME_INCLUDE_DIR}/xframe/xaxis_meta.hpp\n ${XFRAME_INCLUDE_DIR}/xframe/xaxis_scalar.hpp\n ${XFRAME_INCLUDE_DIR}/xframe/xaxis_variant.hpp\n ${XFRAME_INCLUDE_DIR}/xframe/xaxis_view.hpp\n ${XFRAME_INCLUDE_DIR}/xframe/xcoordinate.hpp\n ${XFRAME_INCLUDE_DIR}/xframe/xcoordinate_base.hpp\n ${XFRAME_INCLUDE_DIR}/xframe/xcoordinate_chain.hpp\n ${XFRAME_INCLUDE_DIR}/xframe/xcoordinate_expanded.hpp\n ${XFRAME_INCLUDE_DIR}/xframe/xcoordinate_system.hpp\n ${XFRAME_INCLUDE_DIR}/xframe/xcoordinate_view.hpp\n ${XFRAME_INCLUDE_DIR}/xframe/xdimension.hpp\n ${XFRAME_INCLUDE_DIR}/xframe/xdynamic_variable_impl.hpp\n ${XFRAME_INCLUDE_DIR}/xframe/xdynamic_variable.hpp\n ${XFRAME_INCLUDE_DIR}/xframe/xexpand_dims_view.hpp\n ${XFRAME_INCLUDE_DIR}/xframe/xframe_config.hpp\n ${XFRAME_INCLUDE_DIR}/xframe/xframe_expression.hpp\n ${XFRAME_INCLUDE_DIR}/xframe/xframe_trace.hpp\n ${XFRAME_INCLUDE_DIR}/xframe/xframe_utils.hpp\n ${XFRAME_INCLUDE_DIR}/xframe/xio.hpp\n ${XFRAME_INCLUDE_DIR}/xframe/xnamed_axis.hpp\n ${XFRAME_INCLUDE_DIR}/xframe/xreindex_view.hpp\n ${XFRAME_INCLUDE_DIR}/xframe/xreindex_data.hpp\n ${XFRAME_INCLUDE_DIR}/xframe/xselecting.hpp\n ${XFRAME_INCLUDE_DIR}/xframe/xsequence_view.hpp\n ${XFRAME_INCLUDE_DIR}/xframe/xvariable.hpp\n ${XFRAME_INCLUDE_DIR}/xframe/xvariable_assign.hpp\n ${XFRAME_INCLUDE_DIR}/xframe/xvariable_base.hpp\n ${XFRAME_INCLUDE_DIR}/xframe/xvariable_function.hpp\n ${XFRAME_INCLUDE_DIR}/xframe/xvariable_masked_view.hpp\n ${XFRAME_INCLUDE_DIR}/xframe/xvariable_math.hpp\n ${XFRAME_INCLUDE_DIR}/xframe/xvariable_meta.hpp\n ${XFRAME_INCLUDE_DIR}/xframe/xvariable_scalar.hpp\n ${XFRAME_INCLUDE_DIR}/xframe/xvariable_view.hpp\n ${XFRAME_INCLUDE_DIR}/xframe/xvector_variant.hpp\n)\n\nOPTION(BUILD_TESTS \"xframe test suite\" OFF)\nOPTION(DOWNLOAD_GTEST \"build gtest from downloaded sources\" OFF)\n\nif(DOWNLOAD_GTEST OR GTEST_SRC_DIR)\n set(BUILD_TESTS ON)\nendif()\n\nif(BUILD_TESTS)\n add_subdirectory(test)\nendif()\n\n# Installation\n# ============\n\ninclude(GNUInstallDirs)\ninclude(CMakePackageConfigHelpers)\n\ninstall(FILES ${XFRAME_HEADERS}\n DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}/xframe)\n\nset(XFRAME_CMAKECONFIG_INSTALL_DIR \"${CMAKE_INSTALL_LIBDIR}/cmake/${PROJECT_NAME}\" CACHE\n STRING \"install path for xframeConfig.cmake\")\n\nconfigure_package_config_file(${PROJECT_NAME}Config.cmake.in\n \"${CMAKE_CURRENT_BINARY_DIR}/${PROJECT_NAME}Config.cmake\"\n INSTALL_DESTINATION ${XFRAME_CMAKECONFIG_INSTALL_DIR})\n\n# xframe is header-only and does not depend on the architecture.\n# Remove CMAKE_SIZEOF_VOID_P from xframeConfigVersion.cmake so that an xframeConfig.cmake\n# generated for a 64 bit target can be used for 32 bit targets and vice versa.\nset(_XFRAME_CMAKE_SIZEOF_VOID_P ${CMAKE_SIZEOF_VOID_P})\nunset(CMAKE_SIZEOF_VOID_P)\nwrite_basic_package_version_file(${CMAKE_CURRENT_BINARY_DIR}/${PROJECT_NAME}ConfigVersion.cmake\n VERSION ${${PROJECT_NAME}_VERSION}\n COMPATIBILITY AnyNewerVersion)\nset(CMAKE_SIZEOF_VOID_P ${_XFRAME_CMAKE_SIZEOF_VOID_P})\ninstall(FILES ${CMAKE_CURRENT_BINARY_DIR}/${PROJECT_NAME}Config.cmake\n ${CMAKE_CURRENT_BINARY_DIR}/${PROJECT_NAME}ConfigVersion.cmake\n DESTINATION ${XFRAME_CMAKECONFIG_INSTALL_DIR})\n\n\nconfigure_file(${PROJECT_NAME}.pc.in\n \"${CMAKE_CURRENT_BINARY_DIR}/${PROJECT_NAME}.pc\"\n @ONLY)\ninstall(FILES \"${CMAKE_CURRENT_BINARY_DIR}/${PROJECT_NAME}.pc\"\n DESTINATION \"${CMAKE_INSTALL_LIBDIR}/pkgconfig/\")\n" }, { "path": "LICENSE", "content": "BSD 3-Clause License\n\nCopyright (c) 2017, Johan Mabille, Sylvain Corlay, Wolf Vollprecht and\n Martin Renou\nCopyright (c) 2017, QuantStack\nAll rights reserved.\n\nRedistribution and use in source and binary forms, with or without\nmodification, are permitted provided that the following conditions are met:\n\n* Redistributions of source code must retain the above copyright notice, this\n list of conditions and the following disclaimer.\n\n* Redistributions in binary form must reproduce the above copyright notice,\n this list of conditions and the following disclaimer in the documentation\n and/or other materials provided with the distribution.\n\n* Neither the name of the copyright holder nor the names of its\n contributors may be used to endorse or promote products derived from\n this software without specific prior written permission.\n\nTHIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\"\nAND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\nIMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE\nDISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE\nFOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL\nDAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR\nSERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER\nCAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,\nOR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE\nOF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.\n" }, { "path": "README.md", "content": "# ![xframe](docs/source/xframe.svg)\n\n[![Travis](https://travis-ci.org/xtensor-stack/xframe.svg?branch=master)](https://travis-ci.org/xtensor-stack/xframe)\n[![Appveyor](https://ci.appveyor.com/api/projects/status/nhjtyvkefhyo26v5?svg=true)](https://ci.appveyor.com/project/xtensor-stack/xframe)\n[![Documentation](http://readthedocs.org/projects/xframe/badge/?version=latest)](https://xframe.readthedocs.io/en/latest/?badge=latest)\n[![Binder](https://img.shields.io/badge/launch-binder-brightgreen.svg)](https://mybinder.org/v2/gh/xtensor-stack/xframe/stable?filepath=notebooks%2Fxframe.ipynb)\n[![Zulip](https://img.shields.io/badge/social_chat-zulip-blue.svg)](https://xtensor.zulipchat.com/#narrow/channel/539553-Ask-anything)\n\n## Introduction\n\n**xframe is an early developer preview, and is not suitable for general usage yet. Features and implementation are subject to change.**\n\n`xframe` is a dataframe for C++, based on [xtensor](https://github.com/xtensor-stack/xtensor) and [xtl](https://github.com/xtensor-stack/xtl).\n\nFor more information on using `xframe`, check out the reference documentation\n\nhttps://xframe.readthedocs.io/\n\n# Installation\n\n## Package managers\n\nWe provide a package for the mamba (or conda) package manager:\n\n```\nmamba install -c conda-forge xtensor\n```\n\n## Dependencies\n\n`xframe` depends on the [xtensor](https://github.com/xtensor-stack/xtensor) library:\n\n| xframe | xtensor |\n|----------|-----------|\n| master | ^0.21.4 |\n| 0.3.0 | ^0.21.4 |\n| 0.2.0 | ^0.20.0 |\n| 0.1.0 | ^0.19.1 |\n| 0.0.2 | ^0.19.1 |\n| 0.0.1 | ^0.19.1 |\n\n## License\n\nWe use a shared copyright model that enables all contributors to maintain the\ncopyright on their contributions.\n\nThis software is licensed under the BSD-3-Clause license. See the [LICENSE](LICENSE) file for details.\n" }, { "path": "azure-pipelines.yml", "content": "trigger:\n - master\n\njobs:\n - template: ./.azure-pipelines/azure-pipelines-linux-clang.yml\n - template: ./.azure-pipelines/azure-pipelines-linux-gcc.yml\n - template: ./.azure-pipelines/azure-pipelines-osx.yml\n\n" }, { "path": "docs/Doxyfile", "content": "PROJECT_NAME = \"xframe\"\nXML_OUTPUT = xml\nINPUT = ../include\nGENERATE_LATEX = NO\nGENERATE_MAN = NO\nGENERATE_RTF = NO\nCASE_SENSE_NAMES = NO\nGENERATE_HTML = NO\nGENERATE_XML = YES\nRECURSIVE = YES\nQUIET = YES\nJAVADOC_AUTOBRIEF = YES\nWARN_IF_UNDOCUMENTED = NO\nMACRO_EXPANSION = YES\n" }, { "path": "docs/Makefile", "content": "# You can set these variables from the command line.\nSPHINXOPTS =\nSPHINXBUILD = sphinx-build\nPAPER =\nBUILDDIR = build\n\n# User-friendly check for sphinx-build\nifeq ($(shell which $(SPHINXBUILD) >/dev/null 2>&1; echo $$?), 1)\n$(error The '$(SPHINXBUILD)' command was not found. Make sure you have Sphinx installed, then set the SPHINXBUILD environment variable to point to the full path of the '$(SPHINXBUILD)' executable. Alternatively you can add the directory with the executable to your PATH. If you don't have Sphinx installed, grab it from http://sphinx-doc.org/)\nendif\n\n# Internal variables.\nPAPEROPT_a4 = -D latex_paper_size=a4\nPAPEROPT_letter = -D latex_paper_size=letter\nALLSPHINXOPTS = -d $(BUILDDIR)/doctrees $(PAPEROPT_$(PAPER)) $(SPHINXOPTS) source\n# the i18n builder cannot share the environment and doctrees with the others\nI18NSPHINXOPTS = $(PAPEROPT_$(PAPER)) $(SPHINXOPTS) source\n\n.PHONY: help clean html dirhtml singlehtml pickle json htmlhelp qthelp devhelp epub latex latexpdf text man changes linkcheck doctest coverage gettext api\n\ndefault: html\n\nhelp:\n\t@echo \"Please use \\`make ' where is one of\"\n\t@echo \" html to make standalone HTML files\"\n\t@echo \" dirhtml to make HTML files named index.html in directories\"\n\t@echo \" singlehtml to make a single large HTML file\"\n\t@echo \" pickle to make pickle files\"\n\t@echo \" json to make JSON files\"\n\t@echo \" htmlhelp to make HTML files and a HTML help project\"\n\t@echo \" qthelp to make HTML files and a qthelp project\"\n\t@echo \" applehelp to make an Apple Help Book\"\n\t@echo \" devhelp to make HTML files and a Devhelp project\"\n\t@echo \" epub to make an epub\"\n\t@echo \" latex to make LaTeX files, you can set PAPER=a4 or PAPER=letter\"\n\t@echo \" latexpdf to make LaTeX files and run them through pdflatex\"\n\t@echo \" latexpdfja to make LaTeX files and run them through platex/dvipdfmx\"\n\t@echo \" text to make text files\"\n\t@echo \" man to make manual pages\"\n\t@echo \" texinfo to make Texinfo files\"\n\t@echo \" info to make Texinfo files and run them through makeinfo\"\n\t@echo \" gettext to make PO message catalogs\"\n\t@echo \" changes to make an overview of all changed/added/deprecated items\"\n\t@echo \" xml to make Docutils-native XML files\"\n\t@echo \" pseudoxml to make pseudoxml-XML files for display purposes\"\n\t@echo \" linkcheck to check all external links for integrity\"\n\t@echo \" doctest to run all doctests embedded in the documentation (if enabled)\"\n\t@echo \" coverage to run coverage check of the documentation (if enabled)\"\n\nclean:\n\trm -rf $(BUILDDIR)/*\n\trm -rf xml\n\nhtml:\n\tdoxygen\n\t$(SPHINXBUILD) -b html $(ALLSPHINXOPTS) $(BUILDDIR)/html\n\t@echo\n\t@echo \"Build finished. The HTML pages are in $(BUILDDIR)/html.\"\n\ndirhtml:\n\tdoxygen\n\t$(SPHINXBUILD) -b dirhtml $(ALLSPHINXOPTS) $(BUILDDIR)/dirhtml\n\t@echo\n\t@echo \"Build finished. The HTML pages are in $(BUILDDIR)/dirhtml.\"\n\nsinglehtml:\n\tdoxygen\n\t$(SPHINXBUILD) -b singlehtml $(ALLSPHINXOPTS) $(BUILDDIR)/singlehtml\n\t@echo\n\t@echo \"Build finished. The HTML page is in $(BUILDDIR)/singlehtml.\"\n\npickle:\n\tdoxygen\n\t$(SPHINXBUILD) -b pickle $(ALLSPHINXOPTS) $(BUILDDIR)/pickle\n\t@echo\n\t@echo \"Build finished; now you can process the pickle files.\"\n\njson:\n\tdoxygen\n\t$(SPHINXBUILD) -b json $(ALLSPHINXOPTS) $(BUILDDIR)/json\n\t@echo\n\t@echo \"Build finished; now you can process the JSON files.\"\n\nhtmlhelp:\n\tdoxygen\n\t$(SPHINXBUILD) -b htmlhelp $(ALLSPHINXOPTS) $(BUILDDIR)/htmlhelp\n\t@echo\n\t@echo \"Build finished; now you can run HTML Help Workshop with the\" \\\n\t \".hhp project file in $(BUILDDIR)/htmlhelp.\"\n\nepub:\n\tdoxygen\n\t$(SPHINXBUILD) -b epub $(ALLSPHINXOPTS) $(BUILDDIR)/epub\n\t@echo\n\t@echo \"Build finished. The epub file is in $(BUILDDIR)/epub.\"\n\nlatex:\n\tdoxygen\n\t$(SPHINXBUILD) -b latex $(ALLSPHINXOPTS) $(BUILDDIR)/latex\n\t@echo\n\t@echo \"Build finished; the LaTeX files are in $(BUILDDIR)/latex.\"\n\t@echo \"Run \\`make' in that directory to run these through (pdf)latex\" \\\n\t \"(use \\`make latexpdf' here to do that automatically).\"\n\nlatexpdf:\n\tdoxygen\n\t$(SPHINXBUILD) -b latex $(ALLSPHINXOPTS) $(BUILDDIR)/latex\n\t@echo \"Running LaTeX files through pdflatex...\"\n\t$(MAKE) -C $(BUILDDIR)/latex all-pdf\n\t@echo \"pdflatex finished; the PDF files are in $(BUILDDIR)/latex.\"\n\nlatexpdfja:\n\tdoxygen\n\t$(SPHINXBUILD) -b latex $(ALLSPHINXOPTS) $(BUILDDIR)/latex\n\t@echo \"Running LaTeX files through platex and dvipdfmx...\"\n\t$(MAKE) -C $(BUILDDIR)/latex all-pdf-ja\n\t@echo \"pdflatex finished; the PDF files are in $(BUILDDIR)/latex.\"\n\ntext:\n\tdoxygen\n\t$(SPHINXBUILD) -b text $(ALLSPHINXOPTS) $(BUILDDIR)/text\n\t@echo\n\t@echo \"Build finished. The text files are in $(BUILDDIR)/text.\"\n\nman:\n\tdoxygen\n\t$(SPHINXBUILD) -b man $(ALLSPHINXOPTS) $(BUILDDIR)/man\n\t@echo\n\t@echo \"Build finished. The manual pages are in $(BUILDDIR)/man.\"\n\ntexinfo:\n\tdoxygen\n\t$(SPHINXBUILD) -b texinfo $(ALLSPHINXOPTS) $(BUILDDIR)/texinfo\n\t@echo\n\t@echo \"Build finished. The Texinfo files are in $(BUILDDIR)/texinfo.\"\n\t@echo \"Run \\`make' in that directory to run these through makeinfo\" \\\n\t \"(use \\`make info' here to do that automatically).\"\n\ninfo:\n\tdoxygen\n\t$(SPHINXBUILD) -b texinfo $(ALLSPHINXOPTS) $(BUILDDIR)/texinfo\n\t@echo \"Running Texinfo files through makeinfo...\"\n\tmake -C $(BUILDDIR)/texinfo info\n\t@echo \"makeinfo finished; the Info files are in $(BUILDDIR)/texinfo.\"\n\ngettext:\n\tdoxygen\n\t$(SPHINXBUILD) -b gettext $(I18NSPHINXOPTS) $(BUILDDIR)/locale\n\t@echo\n\t@echo \"Build finished. The message catalogs are in $(BUILDDIR)/locale.\"\n\nchanges:\n\tdoxygen\n\t$(SPHINXBUILD) -b changes $(ALLSPHINXOPTS) $(BUILDDIR)/changes\n\t@echo\n\t@echo \"The overview file is in $(BUILDDIR)/changes.\"\n\nlinkcheck:\n\tdoxygen\n\t$(SPHINXBUILD) -b linkcheck $(ALLSPHINXOPTS) $(BUILDDIR)/linkcheck\n\t@echo\n\t@echo \"Link check complete; look for any errors in the above output \" \\\n\t \"or in $(BUILDDIR)/linkcheck/output.txt.\"\n\ndoctest:\n\tdoxygen\n\t$(SPHINXBUILD) -b doctest $(ALLSPHINXOPTS) $(BUILDDIR)/doctest\n\t@echo \"Testing of doctests in the sources finished, look at the \" \\\n\t \"results in $(BUILDDIR)/doctest/output.txt.\"\n\ncoverage:\n\tdoxygen\n\t$(SPHINXBUILD) -b coverage $(ALLSPHINXOPTS) $(BUILDDIR)/coverage\n\t@echo \"Testing of coverage in the sources finished, look at the \" \\\n\t \"results in $(BUILDDIR)/coverage/python.txt.\"\n\nxml:\n\tdoxygen\n\t$(SPHINXBUILD) -b xml $(ALLSPHINXOPTS) $(BUILDDIR)/xml\n\t@echo\n\t@echo \"Build finished. The XML files are in $(BUILDDIR)/xml.\"\n\npseudoxml:\n\tdoxygen\n\t$(SPHINXBUILD) -b pseudoxml $(ALLSPHINXOPTS) $(BUILDDIR)/pseudoxml\n\t@echo\n\t@echo \"Build finished. The pseudo-XML files are in $(BUILDDIR)/pseudoxml.\"\n" }, { "path": "docs/environment.yml", "content": "name: xframe-docs\n\nchannels:\n - QuantStack\n\ndependencies:\n - breathe\n" }, { "path": "docs/make.bat", "content": "@ECHO OFF\r\n\r\nREM Command file for Sphinx documentation\r\n\r\nif \"%SPHINXBUILD%\" == \"\" (\r\n\tset SPHINXBUILD=sphinx-build\r\n)\r\nset BUILDDIR=build\r\nset ALLSPHINXOPTS=-d %BUILDDIR%/doctrees %SPHINXOPTS% source\r\nset I18NSPHINXOPTS=%SPHINXOPTS% source\r\nif NOT \"%PAPER%\" == \"\" (\r\n\tset ALLSPHINXOPTS=-D latex_paper_size=%PAPER% %ALLSPHINXOPTS%\r\n\tset I18NSPHINXOPTS=-D latex_paper_size=%PAPER% %I18NSPHINXOPTS%\r\n)\r\n\r\nif \"%1\" == \"\" goto help\r\n\r\nif \"%1\" == \"help\" (\r\n\t:help\r\n\techo.Please use `make ^` where ^ is one of\r\n\techo. html to make standalone HTML files\r\n\techo. dirhtml to make HTML files named index.html in directories\r\n\techo. singlehtml to make a single large HTML file\r\n\techo. pickle to make pickle files\r\n\techo. json to make JSON files\r\n\techo. htmlhelp to make HTML files and a HTML help project\r\n\techo. qthelp to make HTML files and a qthelp project\r\n\techo. devhelp to make HTML files and a Devhelp project\r\n\techo. epub to make an epub\r\n\techo. latex to make LaTeX files, you can set PAPER=a4 or PAPER=letter\r\n\techo. text to make text files\r\n\techo. man to make manual pages\r\n\techo. texinfo to make Texinfo files\r\n\techo. gettext to make PO message catalogs\r\n\techo. changes to make an overview over all changed/added/deprecated items\r\n\techo. xml to make Docutils-native XML files\r\n\techo. pseudoxml to make pseudoxml-XML files for display purposes\r\n\techo. linkcheck to check all external links for integrity\r\n\techo. doctest to run all doctests embedded in the documentation if enabled\r\n\techo. coverage to run coverage check of the documentation if enabled\r\n\tgoto end\r\n)\r\n\r\nif \"%1\" == \"clean\" (\r\n\tfor /d %%i in (%BUILDDIR%\\*) do rmdir /q /s %%i\r\n\tdel /q /s %BUILDDIR%\\*\r\n\tgoto end\r\n)\r\n\r\n\r\nREM Check if sphinx-build is available and fallback to Python version if any\r\n%SPHINXBUILD% 1>NUL 2>NUL\r\nif errorlevel 9009 goto sphinx_python\r\ngoto sphinx_ok\r\n\r\n:sphinx_python\r\n\r\nset SPHINXBUILD=python -m sphinx.__init__\r\n%SPHINXBUILD% 2> nul\r\nif errorlevel 9009 (\r\n\techo.\r\n\techo.The 'sphinx-build' command was not found. Make sure you have Sphinx\r\n\techo.installed, then set the SPHINXBUILD environment variable to point\r\n\techo.to the full path of the 'sphinx-build' executable. Alternatively you\r\n\techo.may add the Sphinx directory to PATH.\r\n\techo.\r\n\techo.If you don't have Sphinx installed, grab it from\r\n\techo.http://sphinx-doc.org/\r\n\texit /b 1\r\n)\r\n\r\n:sphinx_ok\r\n\r\n\r\nif \"%1\" == \"html\" (\r\n doxygen\r\n\t%SPHINXBUILD% -b html %ALLSPHINXOPTS% %BUILDDIR%/html\r\n\tif errorlevel 1 exit /b 1\r\n\techo.\r\n\techo.Build finished. The HTML pages are in %BUILDDIR%/html.\r\n\tgoto end\r\n)\r\n\r\nif \"%1\" == \"dirhtml\" (\r\n\t%SPHINXBUILD% -b dirhtml %ALLSPHINXOPTS% %BUILDDIR%/dirhtml\r\n\tif errorlevel 1 exit /b 1\r\n\techo.\r\n\techo.Build finished. The HTML pages are in %BUILDDIR%/dirhtml.\r\n\tgoto end\r\n)\r\n\r\nif \"%1\" == \"singlehtml\" (\r\n\t%SPHINXBUILD% -b singlehtml %ALLSPHINXOPTS% %BUILDDIR%/singlehtml\r\n\tif errorlevel 1 exit /b 1\r\n\techo.\r\n\techo.Build finished. The HTML pages are in %BUILDDIR%/singlehtml.\r\n\tgoto end\r\n)\r\n\r\nif \"%1\" == \"pickle\" (\r\n\t%SPHINXBUILD% -b pickle %ALLSPHINXOPTS% %BUILDDIR%/pickle\r\n\tif errorlevel 1 exit /b 1\r\n\techo.\r\n\techo.Build finished; now you can process the pickle files.\r\n\tgoto end\r\n)\r\n\r\nif \"%1\" == \"json\" (\r\n\t%SPHINXBUILD% -b json %ALLSPHINXOPTS% %BUILDDIR%/json\r\n\tif errorlevel 1 exit /b 1\r\n\techo.\r\n\techo.Build finished; now you can process the JSON files.\r\n\tgoto end\r\n)\r\n\r\nif \"%1\" == \"htmlhelp\" (\r\n\t%SPHINXBUILD% -b htmlhelp %ALLSPHINXOPTS% %BUILDDIR%/htmlhelp\r\n\tif errorlevel 1 exit /b 1\r\n\techo.\r\n\techo.Build finished; now you can run HTML Help Workshop with the ^\r\n.hhp project file in %BUILDDIR%/htmlhelp.\r\n\tgoto end\r\n)\r\n\r\nif \"%1\" == \"qthelp\" (\r\n\t%SPHINXBUILD% -b qthelp %ALLSPHINXOPTS% %BUILDDIR%/qthelp\r\n\tif errorlevel 1 exit /b 1\r\n\techo.\r\n\techo.Build finished; now you can run \"qcollectiongenerator\" with the ^\r\n.qhcp project file in %BUILDDIR%/qthelp, like this:\r\n\techo.^> qcollectiongenerator %BUILDDIR%\\qthelp\\packagename.qhcp\r\n\techo.To view the help file:\r\n\techo.^> assistant -collectionFile %BUILDDIR%\\qthelp\\packagename.ghc\r\n\tgoto end\r\n)\r\n\r\nif \"%1\" == \"devhelp\" (\r\n\t%SPHINXBUILD% -b devhelp %ALLSPHINXOPTS% %BUILDDIR%/devhelp\r\n\tif errorlevel 1 exit /b 1\r\n\techo.\r\n\techo.Build finished.\r\n\tgoto end\r\n)\r\n\r\nif \"%1\" == \"epub\" (\r\n\t%SPHINXBUILD% -b epub %ALLSPHINXOPTS% %BUILDDIR%/epub\r\n\tif errorlevel 1 exit /b 1\r\n\techo.\r\n\techo.Build finished. The epub file is in %BUILDDIR%/epub.\r\n\tgoto end\r\n)\r\n\r\nif \"%1\" == \"latex\" (\r\n\t%SPHINXBUILD% -b latex %ALLSPHINXOPTS% %BUILDDIR%/latex\r\n\tif errorlevel 1 exit /b 1\r\n\techo.\r\n\techo.Build finished; the LaTeX files are in %BUILDDIR%/latex.\r\n\tgoto end\r\n)\r\n\r\nif \"%1\" == \"latexpdf\" (\r\n\t%SPHINXBUILD% -b latex %ALLSPHINXOPTS% %BUILDDIR%/latex\r\n\tcd %BUILDDIR%/latex\r\n\tmake all-pdf\r\n\tcd %~dp0\r\n\techo.\r\n\techo.Build finished; the PDF files are in %BUILDDIR%/latex.\r\n\tgoto end\r\n)\r\n\r\nif \"%1\" == \"latexpdfja\" (\r\n\t%SPHINXBUILD% -b latex %ALLSPHINXOPTS% %BUILDDIR%/latex\r\n\tcd %BUILDDIR%/latex\r\n\tmake all-pdf-ja\r\n\tcd %~dp0\r\n\techo.\r\n\techo.Build finished; the PDF files are in %BUILDDIR%/latex.\r\n\tgoto end\r\n)\r\n\r\nif \"%1\" == \"text\" (\r\n\t%SPHINXBUILD% -b text %ALLSPHINXOPTS% %BUILDDIR%/text\r\n\tif errorlevel 1 exit /b 1\r\n\techo.\r\n\techo.Build finished. The text files are in %BUILDDIR%/text.\r\n\tgoto end\r\n)\r\n\r\nif \"%1\" == \"man\" (\r\n\t%SPHINXBUILD% -b man %ALLSPHINXOPTS% %BUILDDIR%/man\r\n\tif errorlevel 1 exit /b 1\r\n\techo.\r\n\techo.Build finished. The manual pages are in %BUILDDIR%/man.\r\n\tgoto end\r\n)\r\n\r\nif \"%1\" == \"texinfo\" (\r\n\t%SPHINXBUILD% -b texinfo %ALLSPHINXOPTS% %BUILDDIR%/texinfo\r\n\tif errorlevel 1 exit /b 1\r\n\techo.\r\n\techo.Build finished. The Texinfo files are in %BUILDDIR%/texinfo.\r\n\tgoto end\r\n)\r\n\r\nif \"%1\" == \"gettext\" (\r\n\t%SPHINXBUILD% -b gettext %I18NSPHINXOPTS% %BUILDDIR%/locale\r\n\tif errorlevel 1 exit /b 1\r\n\techo.\r\n\techo.Build finished. The message catalogs are in %BUILDDIR%/locale.\r\n\tgoto end\r\n)\r\n\r\nif \"%1\" == \"changes\" (\r\n\t%SPHINXBUILD% -b changes %ALLSPHINXOPTS% %BUILDDIR%/changes\r\n\tif errorlevel 1 exit /b 1\r\n\techo.\r\n\techo.The overview file is in %BUILDDIR%/changes.\r\n\tgoto end\r\n)\r\n\r\nif \"%1\" == \"linkcheck\" (\r\n\t%SPHINXBUILD% -b linkcheck %ALLSPHINXOPTS% %BUILDDIR%/linkcheck\r\n\tif errorlevel 1 exit /b 1\r\n\techo.\r\n\techo.Link check complete; look for any errors in the above output ^\r\nor in %BUILDDIR%/linkcheck/output.txt.\r\n\tgoto end\r\n)\r\n\r\nif \"%1\" == \"doctest\" (\r\n\t%SPHINXBUILD% -b doctest %ALLSPHINXOPTS% %BUILDDIR%/doctest\r\n\tif errorlevel 1 exit /b 1\r\n\techo.\r\n\techo.Testing of doctests in the sources finished, look at the ^\r\nresults in %BUILDDIR%/doctest/output.txt.\r\n\tgoto end\r\n)\r\n\r\nif \"%1\" == \"coverage\" (\r\n\t%SPHINXBUILD% -b coverage %ALLSPHINXOPTS% %BUILDDIR%/coverage\r\n\tif errorlevel 1 exit /b 1\r\n\techo.\r\n\techo.Testing of coverage in the sources finished, look at the ^\r\nresults in %BUILDDIR%/coverage/python.txt.\r\n\tgoto end\r\n)\r\n\r\nif \"%1\" == \"xml\" (\r\n\t%SPHINXBUILD% -b xml %ALLSPHINXOPTS% %BUILDDIR%/xml\r\n\tif errorlevel 1 exit /b 1\r\n\techo.\r\n\techo.Build finished. The XML files are in %BUILDDIR%/xml.\r\n\tgoto end\r\n)\r\n\r\nif \"%1\" == \"pseudoxml\" (\r\n\t%SPHINXBUILD% -b pseudoxml %ALLSPHINXOPTS% %BUILDDIR%/pseudoxml\r\n\tif errorlevel 1 exit /b 1\r\n\techo.\r\n\techo.Build finished. The pseudo-XML files are in %BUILDDIR%/pseudoxml.\r\n\tgoto end\r\n)\r\n\r\n:end\r\n" }, { "path": "docs/source/_static/main_stylesheet.css", "content": ".wy-nav-content{\n max-width: 1000px;\n margin: auto;\n}\n" }, { "path": "docs/source/api/axis_index.rst", "content": ".. Copyright (c) 2018, Johan Mabille, Sylvain Corlay, Wolf Vollprecht\n and Martin Renou\n\n Distributed under the terms of the BSD 3-Clause License.\n\n The full license is in the file LICENSE, distributed with this software.\n\nAxes\n====\n\n.. toctree::\n\n xaxis_base\n xaxis\n xaxis_default\n xaxis_function\n xaxis_expression_leaf\n xaxis_view\n xaxis_variant\n xnamed_axis\n" }, { "path": "docs/source/api/coordinate_index.rst", "content": ".. Copyright (c) 2018, Johan Mabille, Sylvain Corlay, Wolf Vollprecht\n and Martin Renou\n\n Distributed under the terms of the BSD 3-Clause License.\n\n The full license is in the file LICENSE, distributed with this software.\n\nCoordinates and dimensions\n==========================\n\n.. toctree::\n\n xcoordinate_base\n xcoordinate\n xcoordinate_view\n xcoordinate_chain\n xcoordinate_expanded\n xdimension\n" }, { "path": "docs/source/api/variable_index.rst", "content": ".. Copyright (c) 2018, Johan Mabille, Sylvain Corlay, Wolf Vollprecht\n and Martin Renou\n\n Distributed under the terms of the BSD 3-Clause License.\n\n The full license is in the file LICENSE, distributed with this software.\n\nVariables\n=========\n\n.. toctree::\n\n xexpand_dims_view\n xvariable_masked_view\n" }, { "path": "docs/source/api/xaxis.rst", "content": ".. Copyright (c) 2018, Johan Mabille, Sylvain Corlay, Wolf Vollprecht\n and Martin Renou\n\n Distributed under the terms of the BSD 3-Clause License.\n\n The full license is in the file LICENSE, distributed with this software.\n\nxaxis\n=====\n\nDefined in ``xframe/xaxis.hpp``\n\n.. doxygenclass:: xf::xaxis\n :project: xframe\n :members:\n\n.. doxygenfunction:: xf::axis(L, L, L)\n :project: xframe\n\n.. doxygenfunction:: xf::axis(std::initializer_list)\n :project: xframe\n\n" }, { "path": "docs/source/api/xaxis_base.rst", "content": ".. Copyright (c) 2018, Johan Mabille, Sylvain Corlay, Wolf Vollprecht\n and Martin Renou\n\n Distributed under the terms of the BSD 3-Clause License.\n\n The full license is in the file LICENSE, distributed with this software.\n\nxaxis_base\n==========\n\nDefined in ``xframe/xaxis_base.hpp``\n\n.. doxygenclass:: xf::xaxis_base\n :project: xframe\n :members:\n\n.. doxygenfunction:: operator==(const xaxis_base&, const xaxis_base&)\n :project: xframe\n\n.. doxygenfunction:: operator!=(const xaxis_base&, const xaxis_base&)\n :project: xframe\n" }, { "path": "docs/source/api/xaxis_default.rst", "content": ".. Copyright (c) 2018, Johan Mabille, Sylvain Corlay, Wolf Vollprecht\n and Martin Renou\n\n Distributed under the terms of the BSD 3-Clause License.\n\n The full license is in the file LICENSE, distributed with this software.\n\nxaxis_default\n=============\n\nDefined in ``xframe/xaxis_default.hpp``\n\n.. doxygenclass:: xf::xaxis_default\n :project: xframe\n :members:\n\n.. doxygenfunction:: xf::axis(L)\n :project: xframe\n\n" }, { "path": "docs/source/api/xaxis_expression_leaf.rst", "content": ".. Copyright (c) 2018, Johan Mabille, Sylvain Corlay, Wolf Vollprecht\n and Martin Renou\n\n Distributed under the terms of the BSD 3-Clause License.\n\n The full license is in the file LICENSE, distributed with this software.\n\nxaxis_expression_leaf\n=====================\n\nDefined in ``xframe/xaxis_expression_leaf.hpp``\n\n.. doxygenclass:: xf::xaxis_expression_leaf\n :project: xframe\n :members:\n" }, { "path": "docs/source/api/xaxis_function.rst", "content": ".. Copyright (c) 2018, Johan Mabille, Sylvain Corlay, Wolf Vollprecht\n and Martin Renou\n\n Distributed under the terms of the BSD 3-Clause License.\n\n The full license is in the file LICENSE, distributed with this software.\n\nxaxis_function\n==============\n\nDefined in ``xframe/xaxis_function.hpp``\n\n.. doxygenclass:: xf::xaxis_function\n :project: xframe\n :members:\n" }, { "path": "docs/source/api/xaxis_variant.rst", "content": ".. Copyright (c) 2018, Johan Mabille, Sylvain Corlay, Wolf Vollprecht\n and Martin Renou\n\n Distributed under the terms of the BSD 3-Clause License.\n\n The full license is in the file LICENSE, distributed with this software.\n\nxaxis_variant\n=============\n\nDefined in ``xframe/xaxis_variant.hpp``\n\n.. doxygenclass:: xf::xaxis_variant\n :project: xframe\n :members:\n\n" }, { "path": "docs/source/api/xaxis_view.rst", "content": ".. Copyright (c) 2018, Johan Mabille, Sylvain Corlay, Wolf Vollprecht\n and Martin Renou\n\n Distributed under the terms of the BSD 3-Clause License.\n\n The full license is in the file LICENSE, distributed with this software.\n\nxaxis_view\n==========\n\nDefined in ``xframe/xaxis_view.hpp``\n\n.. doxygenclass:: xf::xaxis_view\n :project: xframe\n :members:\n\n.. doxygenfunction:: operator==(const xaxis_view&, const xaxis_view&)\n :project: xframe\n\n.. doxygenfunction:: operator!=(const xaxis_view&, const xaxis_view&)\n :project: xframe\n\n.. doxygenfunction:: operator==(const xaxis_view&, const xaxis_variant&)\n :project: xframe\n\n.. doxygenfunction:: operator!=(const xaxis_view&, const xaxis_variant&)\n :project: xframe\n\n.. doxygenfunction:: operator==(const xaxis_variant&, const xaxis_view&)\n :project: xframe\n\n.. doxygenfunction:: operator!=(const xaxis_variant&, const xaxis_view&)\n :project: xframe\n" }, { "path": "docs/source/api/xcoordinate.rst", "content": ".. Copyright (c) 2018, Johan Mabille, Sylvain Corlay, Wolf Vollprecht\n and Martin Renou\n\n Distributed under the terms of the BSD 3-Clause License.\n\n The full license is in the file LICENSE, distributed with this software.\n\nxcoordinate\n===========\n\nDefined in ``xframe/xcoordinate.hpp``\n\n.. doxygenclass:: xf::xcoordinate\n :project: xframe\n :members:\n\n.. doxygenfunction:: coordinate(const std::map>&)\n :project: xframe\n\n.. doxygenfunction:: coordinate(std::map>&&)\n :project: xframe\n\n.. doxygenfunction:: coordinate(xnamed_axis, xnamed_axis...)\n :project: xframe\n\n.. doxygenfunction:: broadcast_coordinates(xcoordinate&, const Args&...)\n :project: xframe\n" }, { "path": "docs/source/api/xcoordinate_base.rst", "content": ".. Copyright (c) 2018, Johan Mabille, Sylvain Corlay, Wolf Vollprecht\n and Martin Renou\n\n Distributed under the terms of the BSD 3-Clause License.\n\n The full license is in the file LICENSE, distributed with this software.\n\nxcoordinate_base\n================\n\nDefined in ``xframe/xcoordinate_base.hpp``\n\n.. doxygenclass:: xf::xcoordinate_base\n :project: xframe\n :members:\n\n.. doxygenfunction:: operator==(const xcoordinate_base&, const xcoordinate_base&)\n :project: xframe\n\n.. doxygenfunction:: operator!=(const xcoordinate_base&, const xcoordinate_base&)\n :project: xframe\n" }, { "path": "docs/source/api/xcoordinate_chain.rst", "content": ".. Copyright (c) 2018, Johan Mabille, Sylvain Corlay, Wolf Vollprecht\n and Martin Renou\n\n Distributed under the terms of the BSD 3-Clause License.\n\n The full license is in the file LICENSE, distributed with this software.\n\nxcoordinate_chain\n=================\n\nDefined in ``xframe/xcoordinate_chain.hpp``\n\n.. doxygenclass:: xf::xcoordinate_chain\n :project: xframe\n :members:\n\n.. doxygenfunction:: reindex(const C&, const typename C::map_type&)\n :project: xframe\n\n.. doxygenfunction:: reindex(const C&, typename C::map_type&&)\n :project: xframe\n" }, { "path": "docs/source/api/xcoordinate_expanded.rst", "content": ".. Copyright (c) 2018, Johan Mabille, Sylvain Corlay, Wolf Vollprecht\n and Martin Renou\n\n Distributed under the terms of the BSD 3-Clause License.\n\n The full license is in the file LICENSE, distributed with this software.\n\nxcoordinate_expanded\n====================\n\nDefined in ``xframe/xcoordinate_expanded.hpp``\n\n.. doxygenclass:: xf::xcoordinate_expanded\n :project: xframe\n :members:\n\n.. doxygenfunction:: expand_dims(const C&, const typename C::map_type&)\n :project: xframe\n\n.. doxygenfunction:: expand_dims(const C&, typename C::map_type&&)\n :project: xframe\n" }, { "path": "docs/source/api/xcoordinate_view.rst", "content": ".. Copyright (c) 2018, Johan Mabille, Sylvain Corlay, Wolf Vollprecht\n and Martin Renou\n\n Distributed under the terms of the BSD 3-Clause License.\n\n The full license is in the file LICENSE, distributed with this software.\n\nxcoordinate_view\n================\n\nDefined in ``xframe/xcoordinate_view.hpp``\n\n.. doxygenclass:: xf::xcoordinate_view\n :project: xframe\n :members:\n\n.. doxygenfunction:: coordinate_view(const std::map>&)\n :project: xframe\n\n.. doxygenfunction:: coordinate_view(std::map>&&)\n :project: xframe\n" }, { "path": "docs/source/api/xdimension.rst", "content": ".. Copyright (c) 2018, Johan Mabille, Sylvain Corlay, Wolf Vollprecht\n and Martin Renou\n\n Distributed under the terms of the BSD 3-Clause License.\n\n The full license is in the file LICENSE, distributed with this software.\n\nxdimension\n==========\n\nDefined in ``xframe/xdimension.hpp``\n\n.. doxygenclass:: xf::xdimension\n :project: xframe\n :members:\n\n.. doxygenfunction:: operator==(const xdimension&, const xdimension&)\n :project: xframe\n\n.. doxygenfunction:: operator!=(const xdimension&, const xdimension&)\n :project: xframe\n" }, { "path": "docs/source/api/xexpand_dims_view.rst", "content": ".. Copyright (c) 2018, Johan Mabille, Sylvain Corlay, Wolf Vollprecht\n and Martin Renou\n\n Distributed under the terms of the BSD 3-Clause License.\n\n The full license is in the file LICENSE, distributed with this software.\n\nxexpand_dims_view\n=================\n\nDefined in ``xframe/xexpand_dims_view.hpp``\n\n.. doxygenclass:: xf::xexpand_dims_view\n :project: xframe\n :members:\n\n.. doxygenfunction:: expand_dims(E&&, std::initializer_list)\n :project: xframe\n\n.. doxygenfunction:: expand_dims(E&&, std::initializer_list::key_type, std::size_t>>)\n :project: xframe\n" }, { "path": "docs/source/api/xnamed_axis.rst", "content": ".. Copyright (c) 2018, Johan Mabille, Sylvain Corlay, Wolf Vollprecht\n and Martin Renou\n\n Distributed under the terms of the BSD 3-Clause License.\n\n The full license is in the file LICENSE, distributed with this software.\n\nxnamed_axis\n===========\n\nDefined in ``xframe/xnamed_axis.hpp``\n\n.. doxygenclass:: xf::xnamed_axis\n :project: xframe\n :members:\n\n.. doxygenfunction:: xf::named_axis(const K&, A&&)\n :project: xframe\n" }, { "path": "docs/source/api/xvariable_masked_view.rst", "content": ".. Copyright (c) 2018, Johan Mabille, Sylvain Corlay, Wolf Vollprecht\n and Martin Renou\n\n Distributed under the terms of the BSD 3-Clause License.\n\n The full license is in the file LICENSE, distributed with this software.\n\nxvariable_masked_view\n=====================\n\nDefined in ``xframe/xvariable_masked_view.hpp``\n\n.. doxygenclass:: xf::xvariable_masked_view\n :project: xframe\n :members:\n\n.. doxygenfunction:: where(EV&&, EAX&&)\n :project: xframe\n" }, { "path": "docs/source/computation.rst", "content": ".. Copyright (c) 2018, Johan Mabille, Sylvain Corlay, Wolf Vollprecht\n and Martin Renou\n\n Distributed under the terms of the BSD 3-Clause License.\n\n The full license is in the file LICENSE, distributed with this software.\n\nComputation\n===========\n\n`xframe` is actually more than a multi-dimensional data frame library; like `xtensor`_,\nit is an expression engine that allows numerical computation on any object implementing\nthe variable or the frame interfaces.\n\nExpressions\n-----------\n\nAssume ``x``, ``y`` and ``z`` are variables with *compatible coordinates* (we'll come back\nto that later), the return type of an expression such as ``x + exp(y) * sin(z)`` is \n**not a variable**. The result is a variable expression which offers the same interface\nas ``xvariable`` but does not hold any value. Such expressions can be plugged into others\nto build more cmoplex expressions:\n\n.. code::\n\n auto f = x + exp(y) * sin(z);\n auto f2 = x + exp(w) * cos(f);\n\nThe expression engines avoids the evaluation of intermediate results and their storage in\ntemporary variables, so you can achieve the same performance as if you had written a loop.\nSuch a loop is quite more complicated than an array loop since labels and dimension names\nare involved in the assignment mechanism.\n\nSince a variable expression provides the same API as ``xvariable``, all the indexing and\nselection operations are available:\n\n.. code::\n\n auto v = (x + exp(y) * sin(z)).select({{\"city\", \"Paris\"}, {\"group\", \"a\"}});\n auto view = select(x + exp(y) * sin(z), {{\"city\", xf::keep(\"Paris\")}, {\"group\", xf::drop({\"b\", \"d\", \"h\"})}});\n\nLazy evaluation\n---------------\n\nAn expression such as ``x + exp(y) * sin(z)`` does not hold the result. **Values are only computed\nupon access or when the expression is assigned to a variable**. this allows to operate symbolically\non very large data sets and only compute the result for the indices of interest:\n\n.. code::\n\n // Assuming x and y are variables each holding ~1M values\n auto f = cos(x) + sin(y);\n \n double first_res = f.locate(\"a\", \"London\");\n double second_res = f.locate(\"b\", \"Pekin\");\n // Only two values have been computed\n\nThat means if you use the same expression in two assign statements, the computation of the expression\nwill be done twice. Depending on the complexity of the cmoputation and the size of the data, it might\nbe convenient to store the result of the expression in a temporary variable:\n\n.. code::\n\n variable_type tmp = cos(x) + sin(y);\n variable_type res1 = tmp + 2 * exp(z);\n variable_type res2 = tmp - 3 * exp(w);\n\nBroadcasting by dimension names\n-------------------------------\n\nLike `xarray`_, broadcasting in *xframe* is done according to the dimension names rather than\ntheir positions. This way, you do not need to transpose variable or insert dimensions of length\n1 to to get array operations to work, as commonly done in `xtensor`_ with ``xt::reshape`` or\n``xt::newaxis``.\n\nThis can be illustrated with the following examples. First, consider two one-dimensional variable\naligned along different dimensions:\n\n.. code::\n\n auto v1 = variable_type(data_type({1., 2.}), {{\"x\", xf::axis(1, 3)}});\n auto v2 = variable_type(data_type({3., 7.}), {{\"y\", xf::axis(2, 5)}});\n\nWe can apply mathematical operations to these variables, their dimension are expanded automatically:\n\n.. code::\n\n variable_type res = v1 + v2;\n std::cout << res << std::endl;\n // Output:\n // {{ 4. 8.}\n // { 5. 9.}}\n // Coordinates:\n // x: (1, 3, )\n // y: (2, 5, )\n \nContrary to `xarray`_ , dimensions are not reordered to the order in which they first appeared:\n\n.. code::\n\n auto v3 = variable_type(data_type({{1., 2.}, {3., 4.}}),\n {{\"y\", xf::axis({2, 5})}, {\"x\", xf::axis({1, 4})}});\n variable_type res2 = v1 + v3;\n std::cout << res2 << std::endl;\n // Output:\n // {{ 2. 4. }\n // { 4. 6. }}\n // Coordinates:\n // y: (2, 5, )\n // x: (1, 3, )\n\nThis allows many optimizations in the assignment mechanism.\n\nAutomatic alignment\n-------------------\n\n`xframe` enforces alignment between coordinate labels on objects involved in operations.\nThe default result of an operation is by the *intersection* of the coordinate labels:\n\n.. code::\n\n auto v4 = variable_type(data_type({1., 2., 3.}), {{\"x\", xf::axis({1, 3, 5})}});\n auto v5 = variable_type(data_type({4., 7., 12.}), {{\"x\", xf::axis({1, 5, 7})}});\n\n variable_type res3 = v4 + v5;\n std::cout << res3 << std::endl;\n // Output:\n // { 5. 10. }\n // Coordinates:\n // x: (1, 5,)\n\nOperations are slower when variables are not aligned, so it might be useful to\nexplicitly align variables involved in loops of performance critical code.\n\nOperators and functions\n-----------------------\n\n`xframe` provides all the basic operators and mathematical functions:\n\n- arithmetic operators: ``+``, ``-``, ``*``, ``/``\n- logical operators: ``&&``, ``||``, ``!``\n- comparison operators: ``==``, ``!=``, ``<``, ``<=``, ``>``, ``>=``\n- basic functions: ``abs``, ``remainder``, ``fma``, ...\n- exponential functions: ``exp``, ``expm1``, ``log``, ``log1p``, ...\n- power functions: ``pow``, ``sqrt``, ``cbrt``, ...\n- trigonometric functions: ``sin``, ``cos``, ``tan``, ...\n- hyperbolic functions: ``sinh``, ``cosh``, ``tanh``, ...\n- error and gamma functions: ``erf``, ``erfc``, ``tgamma``, ``lgamma``, ...\n\nActually, any function operating on ``xtensor`` expressions can work with\n``xvariable`` expressions without any additional work; the only constraint\nis to accept and return expressions:\n\n.. code::\n\n template \n inline auto distance(const xexpression& e1, const xexpression& e2)\n {\n const E1& de1 = e1.derived_cast();\n const E2& de2 = e2.derived_cast();\n // \n return sqrt(de1 * de1 + de2 * de2);\n }\n\nThis function can work with both tnesor and variable expressions, performing\nbroadcasting according to the rules of `xtensor` or `xframe` depending on\nits argument type:\n\n.. code::\n\n xt::xarray a1 = {1., 2. };\n xt::xarray a2 = {{1., 3.}, {4., 7.}};\n\n // Broadcasting is applied according to xtensor rules,\n // that is by dimension order\n xt::xarray ares = distance(a1, a2);\n\n // Broadcasting is applied according to xframe rules,\n // that is by dimension name\n variable_type vres = distance(v1, v3);\n\nMissing values\n--------------\n\nContrary to `pandas`_ or `xarray`_, `xframe` does not use particular values\nfor representing missing values. Instead, it makes use of the dedicated type\n``xtl::xoptional`` which gathers the value and a flag to specify whether the\nvalue is missing or not:\n\n.. code::\n\n data_type d = {1., 2., 3. };\n d(1).has_value() = false;\n\n auto v = variable_type(d, {{\"x\", xf::axis({1, 3, 4})}});\n std::cout << v << std::endl;\n // Output:\n // { 1. N/A 3. }\n // Coordinates:\n // x: (1, 3, 4,)\n\n.. _pandas: https://pandas.pydata.org\n.. _xarray: https://xarray.pydata.org\n.. _xtensor: https://github.com/xtensor-stack/xtensor\n\n" }, { "path": "docs/source/conf.py", "content": "#!/usr/bin/env python3\n# -*- coding: utf-8 -*-\n\nimport os\nimport subprocess\n\non_rtd = os.environ.get('READTHEDOCS', None) == 'True'\n\nif on_rtd:\n subprocess.call('cd ..; doxygen', shell=True)\n\nimport sphinx_rtd_theme\n\nhtml_theme = \"sphinx_rtd_theme\"\n\nhtml_theme_path = [sphinx_rtd_theme.get_html_theme_path()]\n\ndef setup(app):\n app.add_stylesheet(\"main_stylesheet.css\")\n\nextensions = ['breathe']\nbreathe_projects = { 'xframe': '../xml' }\ntemplates_path = ['_templates']\nhtml_static_path = ['_static']\nsource_suffix = '.rst'\nmaster_doc = 'index'\nproject = 'xframe'\ncopyright = '2018, Johan Mabille, Sylvain Corlay, Wolf Vollprecht and Martin Renou'\nauthor = 'Johan Mabille, Sylvain Corlay, Wolf Vollprecht and Martin Renou'\n\nhtml_logo = 'quantstack-white.svg'\n\nexclude_patterns = []\nhighlight_language = 'c++'\npygments_style = 'sphinx'\ntodo_include_todos = False\nhtmlhelp_basename = 'xframedoc'\n\n" }, { "path": "docs/source/data_structure.rst", "content": ".. Copyright (c) 2018, Johan Mabille, Sylvain Corlay, Wolf Vollprecht\n and Martin Renou\n\n Distributed under the terms of the BSD 3-Clause License.\n\n The full license is in the file LICENSE, distributed with this software.\n\nData structures\n===============\n\nAxes\n----\n\nAn axis is a mapping of labels to positions in a given dimension. It is the equivalent of\nthe ``index`` object from `pandas`_. `xframe` supports many types of labels, the most common\nare strings, char, integers and dates. An axis is created from a list of labels, a builder\nfunction is provided so the type of the axis can be inferred. The following example illustrates\nthe two main ways of creating an axis:\n\n.. code::\n\n using saxis_type = xf::xaxis;\n\n saxis_type s1({ \"a\", \"b\", \"d\", \"e\" });\n auto s2 = xf::axis({ \"a\", \"b\", \"d\", \"e\" });\n // s1 and s2 are similar axes\n\nIt is also possible to create an axis given the size of the axis or the start, stop and step:\n\n.. code::\n\n auto s3 = xf::axis(5); // == xf::axis({ 0, 1, 2, 3, 4 });\n auto s4 = xf::axis(2, 7); // == xf::axis({ 2, 3, 4, 5, 6 });\n auto s5 = xf::axis(0, 10, 2); // == xf::axis({ 0, 2, 4, 6, 8 });\n auto s6 = xf::axis(\"a\", \"d\"); // == xf::axis({ \"a\", \"b\", \"c\" });\n\nThe axis API is similar to the one of a constant ``std::map`` that throws an exception when\nasked a missing key:\n\n.. code::\n\n std::size_t i0 = s1[\"a\"];\n try\n {\n std::size_t i1 = s1[\"c\"];\n }\n catch(std::exception& e)\n {\n // The exception will be catch since \"c\" is not a label of s1\n std::cout << e.what() << std::endl;\n }\n\n``xaxis`` also provides iterators and methods to compute the union and the intersection of\naxes. However a user rarely needs to manipulate the axes directly, the most common operation\nis to create them and then store them in a coordinate system.\n\nCoordinates\n-----------\n\nCoordinates are mappings of dimension names to axes. `xframe` provides different methods\nto easily create them:\n\n.. code::\n\n using coordinate_type = xf::xcoordinate;\n\n coordinate_type c1({{\"group\", xf::axis({\"a\", \"b\", \"d\", \"e\"})},\n {\"city\", xf::axis({\"London\", \"Paris\", \"Brussels\"})}});\n auto c2 = xf::coordinate({{\"group\", xf::axis({\"a\", \"b\", \"d\", \"e\"})},\n {\"city\", xf::axis({\"London\", \"Paris\", \"Brussels\"})}});\n // c1 and c2 are similar coordinates\n\n.. note::\n\n The builder function ``xf::coordinate`` converts the ``const char*``\n arguments to ``fstring`` and returns a ``xcoordinate`` object. You can modify\n this behavior by specifying the key type of the coordinate as the first template parameter\n of the ``coordinate`` function:\n ``auto c2 = xf::coordinate({{\"group\", xf::axis({\"a\", \"b\", \"d\", \"e\"})}, ...});``\n\n``xnamed_axis`` allows to store a dimension name - axis pair that you can reuse in different\ncoordinates objects; if you want to create a coordinate object from a named axis, all the\narguments must be named axes; fortunately, a ``xnamed_axis`` can be created in place, as\nshown below:\n\n.. code::\n\n // This object will be used in different coordinates objects\n auto a1 = xf::named_axis(\"igroup\", xf::axis({1, 2, 4, 5})});\n\n auto c1 = xf::coordinate(a1, xf::named_axis(\"city\", xf::axis({\"London\", \"Parid\", \"Brussels\"})));\n auto c2 = xf::coordinate(a1, xf::named_axis(\"country\", xf::axis({\"USA\", \"Japan\"})));\n\nAs you can notice, coordinates objects can store axes with different label types. By default,\nthese types are ``int``, ``std::size_t``, ``char`` and ``xf::fstring``, you can\nspecify a different type list:\n\n.. code::\n\n using coordinate_type = xf::xcoordinate>;\n\n coordinate_type c({{\"group\", xf::axis({\"a\", \"b\", \"d\", \"e\"})},\n {\"city\", xf::axis({\"London\", \"Paris\", \"Brussels\"})}});\n\nDimension\n---------\n\nA dimension object is the mapping of the dimension names to the dimension positions in the\ndata tensor. Creating a ``xdimension`` is as simple as creating an ``xcoordinate`` or an\n``xaxis``:\n\n.. code::\n\n using dimension_type = xf::xdimension;\n\n dimension_type dim1({\"city\", \"group\"});\n auto dim2 = xf::dimension({\"city\", \"group\"});\n // dim1 and dim2 are similar dimensions\n\n``xdimension`` provides an API similar to ``xaxis`` and therefore can be considered as a\nspecial axis. Together a dimension object and a coordinate object form a coordinate system\nwhich maps labels and dimension names to indexes in the data tensor.\n\n.. note::\n\n Like ``xf::coordinate``, the builder function ``xf::dimension`` converts the ``const char*``\n arguments to ``fstring`` and returns a ``xdimension`` object. You can modify\n this behavior by specifying the label type of the dimension as the first template parameter\n of the ``dimension`` function:\n ``auto d = xf::dimension({\"city\", \"group\"});``\n\nVariables\n---------\n\nA variable is a data tensor with a coordinate system, that is an ``xcoordinate`` object and\nan ``xdimension`` object. It is the C++ equivalent of the ``xarray.DataArray`` Python class.\n``xvariable`` provides many constructors:\n\n.. code::\n\n using coordinate_type = xf::xcoordinate;\n using dimension_type = xf::xdimension;\n using variable_type = xvariable;\n\n data_type d = xt::eval(xt::random::rand({3, 4}));\n auto c = xf::coordinate({{\"group\", xf::axis({\"a\", \"b\", \"d\", \"e\"})},\n {\"city\", xf::axis({\"London\", \"Paris\", \"Brussels\"})}});\n auto dim = xf::dimension({\"city\", \"group\"});\n\n variable_type v1(d, c, dim);\n\n // Coordinates and dimension can be built in place\n variable_type v2(d, xf::coordinate({{\"group\", xf::axis({\"a\", \"b\", \"d\", \"e\"})},\n {\"city\", xf::axis({\"London\", \"Paris\", \"Brussels\"})}}),\n xf::dimension({\"city\", \"group\"}));\n\nThe data parameter can be omitted, in that case the variable creates an uninitialized data tensor:\n\n.. code::\n\n variable_type v3(c, dim);\n\n variable_type v4(xf::coordinate({{\"group\", xf::axis({\"a\", \"b\", \"d\", \"e\"})},\n {\"city\", xf::axis({\"London\", \"Paris\", \"Brussels\"})}}),\n xf::dimension({\"city\", \"group\"}));\n\nA variable can also be created from a map of axes and a list of dimension names:\n\n.. code::\n\n variable_type::coordinate_map coord_map;\n coord_map[\"group\"] = xf::axis({\"a\", \"b\", \"d\", \"e\"});\n coord_map[\"city\"] = xf::axis({\"London\", \"Paris\", \"Brussels\"});\n dimension_type::label_list dim_list = {\"group\", \"city\"};\n\n variable_type v5(d, coord_map, dim_list);\n variable_type v6(coord_map, dim_list);\n\nIf the dimension object is omitted, the dimension mapping is inferred from the coordinate\nobject. In the code below, the mapping is different from the previous defined variables,\n``group`` is the name of the first dimension and ``city`` is the name of the second one:\n\n.. code::\n\n variable_type v7(d, {{\"group\", xf::axis({\"a\", \"b\", \"d\", \"e\"})},\n {\"city\", xf::axis({\"london\", \"Paris\", \"Brussels\"})}});\n\n // variable with same coordinate system but uninitialized data\n variable_type v8({{\"group\", xf::axis({\"a\", \"b\", \"d\", \"e\"})},\n {\"city\", xf::axis({\"london\", \"Paris\", \"Brussels\"})}});\n\n`xframe` also provides builder functions, so that the type of the variable can be inferred:\n\n.. code::\n\n auto v10 = variable(d, c, dim);\n auto v11 = variable(d, xf::coordinate({{\"group\", xf::axis({\"a\", \"b\", \"d\", \"e\"})},\n {\"city\", xf::axis({\"London\", \"Paris\", \"Brussels\"})}}),\n xf::dimension({\"city\", \"group\"}));\n\n auto v12 = variable(c, dim);\n auto v13 = variable(xf::coordinate({{\"group\", xf::axis({\"a\", \"b\", \"d\", \"e\"})},\n {\"city\", xf::axis({\"London\", \"Paris\", \"Brussels\"})}}),\n xf::dimension({\"city\", \"group\"}));\n\nSummary\n-------\n\n.. image:: xframe_summary.png\n :alt: xframe summay\n\n.. _pandas: https://pandas.pydata.org\n" }, { "path": "docs/source/getting_started.rst", "content": ".. Copyright (c) 2018, Johan Mabille, Sylvain Corlay, Wolf Vollprecht\n and Martin Renou\n\n Distributed under the terms of the BSD 3-Clause License.\n\n The full license is in the file LICENSE, distributed with this software.\n\nGetting started\n===============\n\nThis short guide explains how to get started with `xframe` once you have installed it with one of\nthe methods described in the installation section.\n\nFirst example\n-------------\n\n.. code::\n\n #include \n #include \"xtensor/xrandom.hpp\"\n #include \"xframe/xio.hpp\"\n #include \"xframe/xvariable.hpp\"\n\n int main(int argc, char* argv[])\n {\n using coordinate_type = xf::xcoordinate;\n using variable_type = xf::xvariable;\n using data_type = variable_type::data_type;\n\n // Creation of the data\n data_type data = xt::eval(xt::random::rand({6, 3}, 15., 25.));\n data(0, 0).has_value() = false;\n data(2, 1).has_value() = false;\n\n // Creation of coordinates and dimensions\n auto time_axis = xf::axis({\"2018-01-01\", \"2018-01-02\", \"2018-01-03\", \"2018-01-04\", \"2018-01-05\", \"2018-01-06\"});\n auto city_axis = xf::axis({\"London\", \"Paris\", \"Brussels\"});\n auto coord = xf::coordinate({{\"date\", time_axis}, {\"city\", city_axis}});\n auto dim = xf::dimension({\"date\", \"city\"});\n\n // Creation of the variable\n auto var = variable_type(data, coord, dim);\n std::cout << var << std::endl;\n\n return 0;\n }\n\nThis example creates a variable, that is, a tensor data (here random) with labels and dimension names.\n\nCompiling the first example\n---------------------------\n\n`xframe` is a header-only library, so there is no library to link with. The only constraint\nis that the compiler must be able to find the headers of `xframe` and those of its dependencies,\nthat is, `xtensor` and `xtl`; this is usually done by having the directory containing the headers\nin the include path. With GCC, use the ``-I`` option to achieve this. Assuming the first example\ncode is located in ``example.cpp``, the compilation command is:\n\n.. code:: bash\n\n gcc -I /path/to/headers/ example.cpp -o example\n\nWhen you run the program, it produces the following output (data should be different\nsince it is randomly generated):\n\n.. code::\n\n {{ N/A, 23.3501, 24.6887},\n {17.2103, 18.0817, 20.4722},\n {16.8838, N/A, 24.9646},\n {24.6769, 22.2584, 24.8111},\n {16.0986, 22.9811, 17.9703},\n {15.0478, 16.1246, 21.3976}}\n Coordinates:\n date: (2018-01-01, 2018-01-02, 2018-01-03, 2018-01-04, 2018-01-05, 2018-01-06, )\n city: (London, Paris, Brussels)\n\nBuilding with cmake\n-------------------\n\nA better alternative for building programs using `xframe` is to use `cmake`, especially if you are\ndeveloping for several platforms. Assuming the following folder structure:\n\n.. code:: bash\n\n first_example\n |- src\n | |- example.cpp\n |- CMakeLists.txt\n\nThe following minimal ``CMakeLists.txt`` is enough to build the first example:\n\n.. code:: cmake\n\n cmake_minimum_required(VERSION 3.1)\n project(first_example)\n\n find_package(xtl REQUIRED)\n find_package(xframeREQUIRED)\n\n add_executable(first_example src/example.cpp)\n target_link_libraries(first_example xtensor)\n\n`cmake` has to know where to find the headers, this is done through the ``CMAKE_INSTALL_PREFIX``\nvariable. Note that ``CMAKE_INSTALL_PREFIX`` is usually the path to a folder containing the following\nsubfolders: ``include``, ``lib`` and ``bin``, so you don't have to pass any additional option for linking.\nExamples of valid values for ``CMAKE_INSTALL_PREFIX`` on Unix platforms are ``/usr/local``, ``/opt``.\n\nThe following commands create a directory for building (avoid building in the source folder), builds\nthe first example with cmake and then runs the program:\n\n.. code:: bash\n\n mkdir build\n cd build\n cmake -DCMAKE_INSTALL_PREFIX=your_prefix ..\n make\n ./first_program\n\nSecond example: simplified variable creation\n--------------------------------------------\n\n`xframe` provides many shortcuts so coordinates and variables can be created with a concise syntax.\nThe following example creates the same variable as the previous one:\n\n.. code::\n\n #include \n #include \"xtensor/xrandom.hpp\"\n #include \"xframe/xio.hpp\"\n #include \"xframe/xvariable.hpp\"\n\n int main(int argc, char* argv[])\n {\n using coordinate_type = xf::xcoordinate;\n using variable_type = xf::xvariable;\n using data_type = variable_type::data_type;\n\n // Creation of the data\n data_type data = xt::eval(xt::random::rand({6, 3}, 15., 25.));\n data(0, 0).has_value() = false;\n data(2, 1).has_value() = false;\n\n // Creation of the variable\n auto var = variable_type(\n data,\n {\n {\"date\", xf::axis({\"2018-01-01\", \"2018-01-02\", \"2018-01-03\", \"2018-01-04\", \"2018-01-05\", \"2018-01-06\"})},\n {\"city\", xf::axis({\"London\", \"Paris\", \"Brussels\"})}\n }\n );\n std::cout << var << std::endl;\n\n return 0;\n }\n\nWhen compiled and run, this produces output similar to the one of the previous example (same coordinate system\nbut different data due to random generation).\n\nThird example: data access\n--------------------------\n\n`xframe` provides different ways to access data in a variable.\n\n.. code::\n\n #include \n #include \"xtensor/xrandom.hpp\"\n #include \"xframe/xio.hpp\"\n #include \"xframe/xvariable.hpp\"\n\n int main(int argc, char* argv[])\n {\n\n using coordinate_type = xf::xcoordinate;\n using variable_type = xf::xvariable;\n using data_type = variable_type::data_type;\n\n // Creation of the data\n data_type data = xt::eval(xt::random::rand({6, 3}, 15., 25.));\n data(0, 0).has_value() = false;\n data(2, 1).has_value() = false;\n\n // Creation of the variable\n auto var = variable_type(\n data,\n {\n {\"date\", xf::axis({\"2018-01-01\", \"2018-01-02\", \"2018-01-03\", \"2018-01-04\", \"2018-01-05\", \"2018-01-06\"})},\n {\"city\", xf::axis({\"London\", \"Paris\", \"Brussels\"})}\n }\n );\n\n // Data access\n std::cout << \"operator() - \" << var(3, 0) << std::endl;\n std::cout << \"locate - \" << var.locate(\"2018-01-04\", \"London\") << std::endl;\n std::cout << \"iselect - \" << var.iselect({{\"date\", 3}, {\"city\", 0}}) << std::endl;\n std::cout << \"select - \" << var.select({{\"date\", \"2018-01-04\"}, {\"city\", \"London\"}}) << std::endl;\n\n return 0;\n }\n\nOutputs:\n\n.. code::\n\n operator() - 24.6769\n locate - 24.6769\n iselect - 24.6769\n select - 24.6769\n\n" }, { "path": "docs/source/index.rst", "content": ".. Copyright (c) 2018, Johan Mabille, Sylvain Corlay, Wolf Vollprecht\n and Martin Renou\n\n Distributed under the terms of the BSD 3-Clause License.\n\n The full license is in the file LICENSE, distributed with this software.\n\n.. image:: xframe.svg\n :alt: xframe\n\nMulti-dimensional labeled arrays and data frame based on `xtensor`_.\n\nIntroduction\n------------\n\n`xframe` is a C++ library meant for numerical analysis with multi-dimensional\nlabeled array expressions (also referred as variable expressions) and data frame\nexpressions. It is built upon `xtensor`_ and provides similar features:\n\n- an extensible expression system enabling **lazy broadcasting** based on dimension\n names.\n- an API following the idioms of the C++ standard library.\n- tools to manipulate variable expressions and build upon *xframe*.\n\nThe API of `xframe` is inspired by the ones of `pandas`_ and `xarray`_.\n\n`xframe` requires a modern C++ compiler supporting C++14. The following C++\ncompilers are supported:\n\n- On Windows platforms, Visual C++ 2015 Update 2, or more recent\n- On Unix platforms, gcc 4.9 or a recent version of Clang\n\nLicensing\n---------\n\nWe use a shared copyright model that enables all contributors to maintain the\ncopyright on their contributions.\n\nThis software is licensed under the BSD-3-Clause license. See the LICENSE file\nfor details.\n\n\n.. toctree::\n :caption: INSTALLATION\n :maxdepth: 1\n\n installation\n\n.. toctree::\n :caption: USAGE\n :maxdepth: 2\n\n getting_started\n data_structure\n indexing\n computation\n\n.. toctree::\n :caption: API REFERENCE\n :maxdepth: 2\n\n api/axis_index\n api/coordinate_index\n api/variable_index\n\n.. toctree::\n :caption: MISCELLANEOUS\n\n xarray\n\n.. _xtensor: https://github.com/xtensor-stack/xtensor\n.. _pandas: https://pandas.pydata.org\n.. _xarray: https://xarray.pydata.org\n" }, { "path": "docs/source/indexing.rst", "content": ".. Copyright (c) 2018, Johan Mabille, Sylvain Corlay, Wolf Vollprecht\n and Martin Renou\n\n Distributed under the terms of the BSD 3-Clause License.\n\n The full license is in the file LICENSE, distributed with this software.\n\nIndexing and selecting data\n===========================\n\nIn this section, we consider the following variable:\n\n.. code::\n\n using coordinate_type = xf::xcoordinate;\n using dimension_type = xf::xdimension;\n using variable_type = xf::xvariable;\n\n data_type d = xt::eval(xt::random::rand({6, 3}, 15., 25.));\n variable_type v(std::move(d),\n {\n {\"group\", xf::axis({\"a\", \"b\", \"d\", \"e\", \"g\", \"h\"})},\n {\"city\", xf::axis({\"London\", \"Paris\", \"Brussels\"})}\n });\n\nPrinting this variable in a Jupyter Notebook gives:\n\n+-------+---------+---------+----------+\n| | London | Paris | Brussels |\n+=======+=========+=========+==========+\n| **a** | 16.3548 | 23.3501 | 24.6887 |\n+-------+---------+---------+----------+\n| **b** | 17.2103 | 18.0817 | 20.4722 |\n+-------+---------+---------+----------+\n| **d** | 16.8838 | 24.9288 | 24.9646 |\n+-------+---------+---------+----------+\n| **e** | 24.6769 | 22.2584 | 24.8111 |\n+-------+---------+---------+----------+\n| **g** | 16.0986 | 22.9811 | 17.9703 |\n+-------+---------+---------+----------+\n| **h** | 15.0478 | 16.1246 | 21.3976 |\n+-------+---------+---------+----------+\n\n`xframe` provides flexible indexing methods for data selection, similar to the\nones of `xarray`_. These methods are summarized in the following table:\n\n+------------------+--------------+---------------------------------------------------+\n| Dimension lookup | Index lookup | ``xvariable`` syntax |\n+==================+==============+===================================================+\n| Positional | By integer | ``v(2, 1)`` |\n+------------------+--------------+---------------------------------------------------+\n| Positional | By label | ``v.locate(\"d\", \"Paris\")`` |\n+------------------+--------------+---------------------------------------------------+\n| By name | By integer | ``v.iselect({{\"group\", 2}, {\"city\", 1}})`` |\n+------------------+--------------+---------------------------------------------------+\n| By name | By label | ``v.select({{\"group\", \"d\"}, {\"city\", \"Paris\"}})`` |\n+------------------+--------------+---------------------------------------------------+\n\nPositional indexing\n-------------------\n\nThe most basic way to access elements of an ``xvariable`` is to use ``operator()``, like\nyou would do with an ``xtensor``:\n\n.. code::\n\n std::cout << v(2, 1) << std::endl;\n\nContrary to Python, it is not possible to have different return types for a same method\nin C++. Multi selection is done with free functions that return views on the variable:,\n\n.. code::\n\n #include \"xvariable_view.hpp\"\n\n auto view1 = xf::ilocate(v, xf::irange(0, 5, 2), xf::irange(1, 3));\n std::cout << view1 << std::endl;\n\n+-------+---------+----------+\n| | Paris | Brussels |\n+=======+=========+==========+\n| **a** | 23.3501 | 24.6887 |\n+-------+---------+----------+\n| **d** | 24.9288 | 24.9646 |\n+-------+---------+----------+\n| **g** | 22.9811 | 17.9703 |\n+-------+---------+----------+\n\nTherefore a change in the view will reflect in the underlying variable:\n\n.. code::\n\n view1(0, 1) = 0.;\n std::cout << v(2, 2) << std::endl;\n // Outputs 0.\n\nIn the code creating the view, ``irange`` returns a range slice from `xtensor`, so any multi\nselection in `xtensor` is also supported in `xframe`.\n\n``xvariable`` also supports label-based indexing, with the ``locate`` method for single\npoint selection, and ``locate`` free function for multi selection:\n\n.. code::\n\n std::cout << v.locate(\"d\", \"Paris\") << std::endl;\n auto view2 = xf::locate(v, xf::range(\"a\", \"h\", 2), xf::range(\"Paris\", \"Brussels\"));\n std::cout << view2 << std::endl;\n // Same output as previous code\n\nBe aware of the difference between ``range`` and ``irange`` parameters: for the former one,\naccepting labels, the last value is *included* while for the latter one, accepting integral\nindices, the las value is *excluded*.\n\n`xframe` provides label-based slices similar to those of `xtensor`, so label-based\nmulti selection is really similar to positional multi selection.\n\nIndxing with dimension names\n----------------------------\n\nWith the dimension names, we do not have to rely on the dimension order. We can use them\nexplicitely to select data; Like positional indexing, `xframe` provides methods and\nfree functions depending on the kind of selection you want to do:\n\n.. code::\n\n // Dimension by name, index by position\n std::cout << v.iselect({{\"city\", 1}, {\"group\", 2}}) << std::endl;\n auto view3 = xf::iselect(v, {{\"city\", xf::irange(1, 3)}, {\"group\", xf::irange(0, 5, 2)}});\n \n // Dimension by name, index by label\n std::cout << v.select({{\"city\", \"Paris\"}, {\"group\", \"d\"}}) << std::endl;\n auto view4 = xf::select(v, {{\"city\", xf::range(\"Paris\", \"Brussels\")}, {\"group\", xf::range(\"a\", \"h\", 2)}});\n // view3 and view4 gives the same output as view2 and view1\n\nContrary to `xarray`_, `xframe` does not provide a selection operator accepting a map\nargument.\n\nKeeping and dropping labels\n---------------------------\n\n``drop`` and ``keep`` functions return slices that can be used to create a view with\nthe listed labels along the specified dimensions dropped or kept:\n\n.. code::\n\n auto view5 = xf::select(v, {{\"city\", xf::drop(\"London\")}, {\"group\", xf::keep(\"a\", \"d\", \"g\")}});\n // view5 is equivalent to view4\n\nThis is different form `xarray`_ where the ``xarray.DataArray.drop`` method returns a new object.\nTo achieve the same with `xframe`, simply assign the view to a new ``xvariable`` object:\n\n.. code::\n\n variable_type v2 = view5;\n\nMasking views\n-------------\n\nMasking views allow to select data points based on conditions expresses on labels. These conditions\ncan be arbitrary complicated boolean expressions. Contrary to other views which are generally a\nsubset of the original data, a masking view has the same shape as its underlying ``xvariable``.\n\nMasking views are created with the ``where`` function:\n\n.. code::\n\n data_type d2 = {{ 1., 2., 3. },\n { 4., 5., 6. },\n { 7., 8., 9. }};\n\n auto v3 = variable_type(\n d2,\n {\n {\"x\", xf::axis(3)},\n {\"y\", xf::axis(3)},\n }\n );\n\n auto view6 = xf::where(\n v3,\n not_equal(v3.axis(\"x\"), 2) && v3.axis(\"y\") < 2\n );\n std::cout << view6 << std::endl;\n\nIn a Jupyter Notebookn, this outputs the following:\n\n+-------+--------+--------+--------+\n| | 0 | 1 | 2 |\n+=======+========+========+========+\n| **0** | 1 | 2 | masked |\n+-------+--------+--------+--------+\n| **1** | 4 | 5 | masked |\n+-------+--------+--------+--------+\n| **2** | masked | masked | masked |\n+-------+--------+--------+--------+\n\nWhen assigning to a masked view, masked values are not changed. Like other views,\na masking view is a proxy on its underlying variable, no copy is made, so changing\nan unmasked value actually changes the corresponding value in the undnerlying variable.\n\nAssigning values with indexing\n------------------------------\n\nData selection in variables return either references or views; therefore, contrary to\n`xarray`_, it is *possible* to assign values to a subset of a variable with any of the\nindexing method:\n\n.. code::\n\n // The next four lines are equivalent, they change a single value of v:\n v(2, 1) = 2.5;\n v.locate(\"d\", \"Paris\") = 2.5;\n v.iselect({{\"city\", 1}, {\"group\", 2}}) = 2.5;\n v.select({{\"city\", \"Paris\"}, {\"group\", \"d\"}}) = 2.5;\n\n data_type d3 = {{0., 1.},\n {2., 3.},\n {4., 5.}};\n\n auto v4 = variable_type(\n d3,\n {\n {\"group\", xf::axis({\"a\", \"d\", \"g\"})},\n {\"city\", xf::axis({\"Paris\", \"Brussels\"})}\n }\n );\n\n // The next four lines are equivalent, they change a subset of v\n xf::ilocate(v, xf::irange(0, 5, 2), xf::irange(1, 3)) = v4;\n xf::locate(v, xf::range(\"a\", \"h\", 2), xf::range(\"Paris\", \"Brussels\")) = v4;\n xf::iselect(v, {{\"city\", xf::irange(1, 3)}, {\"group\", xf::irange(0, 5, 2)}}) = v4;\n xf::select(v, {{\"city\", xr::range(\"Paris\", \"Brussels\")}, {\"group\", xf::range(\"a\", \"h\", 2)}}) = v4;\n\nPrinting ``v`` after the assign gives\n\n+-------+---------+---------+----------+\n| | London | Paris | Brussels |\n+=======+=========+=========+==========+\n| **a** | 16.3548 | 0 | 1 |\n+-------+---------+---------+----------+\n| **b** | 17.2103 | 18.0817 | 20.4722 |\n+-------+---------+---------+----------+\n| **d** | 16.8838 | 2 | 3 |\n+-------+---------+---------+----------+\n| **e** | 24.6769 | 22.2584 | 24.8111 |\n+-------+---------+---------+----------+\n| **g** | 16.0986 | 4 | 5 |\n+-------+---------+---------+----------+\n| **h** | 15.0478 | 16.1246 | 21.3976 |\n+-------+---------+---------+----------+\n\nReindexing views\n----------------\n\nReindexing views give variables new set of coordinates to corresponding dimensions. Like other views,\nno copy is involved. Asking for values corresponding to new labels not found in the original set of\ncoordinates returns missing values. In the next example, we reindex the ``city`` dimension:\n\n.. code::\n\n auto view7 = xf::reindex(v, {{\"city\", xf::axis({\"London\", \"New York\", \"Brussels\"})}});\n\n+-------+---------+----------+----------+\n| | London | New York | Brussels |\n+=======+=========+==========+==========+\n| **a** | 16.3548 | N/A | 24.6887 |\n+-------+---------+----------+----------+\n| **b** | 17.2103 | N/A | 20.4722 |\n+-------+---------+----------+----------+\n| **d** | 16.8838 | N/A | 24.9646 |\n+-------+---------+----------+----------+\n| **e** | 24.6769 | N/A | 24.8111 |\n+-------+---------+----------+----------+\n| **g** | 16.0986 | N/A | 17.9703 |\n+-------+---------+----------+----------+\n| **h** | 15.0478 | N/A | 21.3976 |\n+-------+---------+----------+----------+\n\nLike `xarray`_, `xframe` provides the useful ``reindex_like`` shortcut which allows to reindex a\nvariable given the set of coordinates of another variable:\n\n.. code::\n\n auto v5 = variable_type(\n d,\n {\n {\"group\", xf::axis({\"a\", \"b\", \"d\", \"e\", \"g\", \"h\"})},\n {\"city\", xf::axis({\"London\", \"New York\", \"Brussels\"})}\n }\n );\n\n auto view8 = xf::reindex_like(v, v5);\n // view8 is equivalent to view7\n\nA reindexing view is a read-only view, it is not possible to change its value with indexing.\nThis allows memory optimizations, the view does not have to store the missing values, it can\nreturn a proxy to a static-allocated missing value.\n\nThe ``align`` function allows to reindex many variables with more flexible options:\n\n.. code::\n\n auto t1 = xf::align(v, v5);\n std::cout << std::get<0>(t1) << std::endl;\n std::cout << std::get<1>(t1) << std::endl;\n\nThe last lines print the same output:\n\n+-------+---------+----------+\n| | London | Brussels |\n+=======+=========+==========+\n| **a** | 16.3548 | 24.6887 |\n+-------+---------+----------+\n| **b** | 17.2103 | 20.4722 |\n+-------+---------+----------+\n| **d** | 16.8838 | 24.9646 |\n+-------+---------+----------+\n| **e** | 24.6769 | 24.8111 |\n+-------+---------+----------+\n| **g** | 16.0986 | 17.9703 |\n+-------+---------+----------+\n| **h** | 15.0478 | 21.3976 |\n+-------+---------+----------+\n\nIn the following, the variables are aligned w.r.t the union of the coordinates instead\nof their intersection:\n\n.. code::\n\n auto t2 = xf::align(v, v5);\n std::cout << std::get<0>(t2) << std::endl;\n std::cout << std::get<1>(t2) << std::endl;\n\nThe first outuput is\n\n+-------+---------+---------+----------+----------+\n| | London | Paris | Brussels | New York |\n+=======+=========+=========+==========+==========+\n| **a** | 16.3548 | 23.3501 | 24.6887 | N/A |\n+-------+---------+---------+----------+----------+\n| **b** | 17.2103 | 18.0817 | 20.4722 | N/A |\n+-------+---------+---------+----------+----------+\n| **d** | 16.8838 | 24.9288 | 24.9646 | N/A |\n+-------+---------+---------+----------+----------+\n| **e** | 24.6769 | 22.2584 | 24.8111 | N/A |\n+-------+---------+---------+----------+----------+\n| **g** | 16.0986 | 22.9811 | 17.9703 | N/A |\n+-------+---------+---------+----------+----------+\n| **h** | 15.0478 | 16.1246 | 21.3976 | N/A |\n+-------+---------+---------+----------+----------+\n\nWhile the second have ``N/A`` in the ``Paris`` column.\n\n.. _xarray: https://xarray.pydata.org\n" }, { "path": "docs/source/installation.rst", "content": ".. Copyright (c) 2018, Johan Mabille, Sylvain Corlay and Wolf Vollprecht\n and Martin Renou\n\n Distributed under the terms of the BSD 3-Clause License.\n\n The full license is in the file LICENSE, distributed with this software.\n\n\n.. raw:: html\n\n \n\nInstallation\n============\n\nAlthough ``xframe`` is a header-only library, we provide standardized means to\ninstall it, with package managers or with cmake.\n\nBesides the xframe headers, all these methods place the ``cmake`` project\nconfiguration file in the right location so that third-party projects can use\ncmake's ``find_package`` to locate xframe headers.\n\n.. image:: conda.svg\n\nUsing the conda-forge package\n-----------------------------\n\nA package for xframe is available for the mamba (or conda) package manager.\n\n.. code::\n\n mamba install -c conda-forge xframe\n\n.. image:: cmake.svg\n\nFrom source with cmake\n----------------------\n\nYou can also install ``xframe`` from source with cmake. This requires that you\nhave the xtensor_ library installed on your system. On Unix platforms,\nfrom the source directory:\n\n.. code::\n\n mkdir build\n cd build\n cmake -DCMAKE_INSTALL_PREFIX=path_to_prefix ..\n make install\n\nOn Windows platforms, from the source directory:\n\n.. code::\n\n mkdir build\n cd build\n cmake -G \"NMake Makefiles\" -DCMAKE_INSTALL_PREFIX=path_to_prefix ..\n nmake\n nmake install\n\n``path_to_prefix`` is the absolute path to the folder where cmake searches for\ndependencies and installs libraries. ``xframe`` installation from cmake assumes\nthis folder contains ``include`` and ``lib`` subfolders.\n\nIncluding xframe in your project\n--------------------------------\n\nThe different packages of ``xframe`` are built with cmake, so whatever the\ninstallation mode you choose, you can add ``xframe`` to your project using cmake:\n\n.. code::\n\n find_package(xframe REQUIRED)\n target_include_directories(your_target PUBLIC ${xframe_INCLUDE_DIRS})\n target_link_libraries(your_target PUBLIC xframe)\n\n.. _xtensor: https://github.com/xtensor-stack/xtensor\n" }, { "path": "docs/source/xarray.rst", "content": ".. Copyright (c) 2018, Johan Mabille, Sylvain Corlay, Wolf Vollprecht\n and Martin Renou\n\n Distributed under the terms of the BSD 3-Clause License.\n\n The full license is in the file LICENSE, distributed with this software.\n\nFrom xarray to xframe\n=====================\n\n.. raw:: html\n\n \n\n.. |_| unicode:: 0xA0\n\nContainers\n----------\n\n+------------------------------------------------+--------------------------------------------------+\n| Python 3 - xarray | C++ 14 - xframe |\n+================================================+==================================================+\n| | ``xr.DataArray([[1, 2], [3, 4]],`` | | ``xf::variable({{1, 2}, {3, 4}},`` |\n| | |_| |_| |_| ``[('x', ['a', 'b']),`` | | |_| |_| |_| ``{{\"x\", xf::axis({\"a\", \"b\"})},`` |\n| | |_| |_| |_| |_| ``('y', [1, 4])])`` | | |_| |_| |_| |_| ``{\"y\", xf::axis({1, 4})}})`` |\n+------------------------------------------------+--------------------------------------------------+\n\nIndexing\n--------\n\n`xframe` returns views for multi-selection, no copy is made.\n\n+-----------------------------------------------+-------------------------------------------------------------+\n| Python 3 - xarray | C++ 14 - xframe |\n+===============================================+=============================================================+\n| ``da[0, 1]`` | ``v(0, 1)`` |\n+-----------------------------------------------+-------------------------------------------------------------+\n| ``da.loc['a', 'Paris']`` | ``v.locate(\"a\", \"Paris\")`` |\n+-----------------------------------------------+-------------------------------------------------------------+\n| ``da.isel(city=1, group=0)`` | ``v.iselect({{\"city\", 1}, {\"group\", 0}})`` |\n+-----------------------------------------------+-------------------------------------------------------------+\n| ``da.sel(city='Paris', group='a')`` | ``v.select({{\"city\", \"Paris\"}, {\"group\", \"a\"}})`` |\n+-----------------------------------------------+-------------------------------------------------------------+\n| ``da[:, 1]`` | ``xf::ilocate(v, xf::iall(), 1)`` |\n+-----------------------------------------------+-------------------------------------------------------------+\n| ``da.loc[:, 'Paris']`` | ``xf::locate(v, xf::all(), \"Paris\")`` |\n+-----------------------------------------------+-------------------------------------------------------------+\n| ``da.isel(city=1)`` | ``xf::iselect(v, {{\"city\", 1}})`` |\n+-----------------------------------------------+-------------------------------------------------------------+\n| ``da.sel(city='Paris')`` | ``xf::select(v, {{\"city\", \"Paris\"}})`` |\n+-----------------------------------------------+-------------------------------------------------------------+\n| ``da.reindex(city=['NYC', 'Paris'])`` | ``xf::reindex(v, {{\"city\", xf::axis({\"NYC\", \"Paris\"})}})`` |\n+-----------------------------------------------+-------------------------------------------------------------+\n| ``da.reindex_like(df)`` | ``xf::reindex_like(v, v2)`` |\n+-----------------------------------------------+-------------------------------------------------------------+\n\nLogical\n-------\n\nLogical universal functions are truly lazy. ``xf::where(condition, a, b)`` does not evaluate ``a``\nwhere ``condition`` is falsy, and it does not evaluate ``b`` where ``condition`` is truthy.\n`xarray` relies on `numpy` functions, that can also operate on ``xarray.DataArray``.\n\n+-----------------------------------------------+-----------------------------------------------+\n| Python 3 - xarray | C++ 14 - xframe |\n+===============================================+===============================================+\n| ``xr.where(a > 5, a, b)`` | ``xf::where(a > 5, a, b)`` |\n| ``xr.where(a > 5, 100, a)`` | ``xf::where(a > 5, 100, a)`` |\n+-----------------------------------------------+-----------------------------------------------+\n| ``np.any(a)`` | ``xf::any(a)`` |\n+-----------------------------------------------+-----------------------------------------------+\n| ``np.all(a)`` | ``xf::all(a)`` |\n+-----------------------------------------------+-----------------------------------------------+\n| ``np.logical_and(a, b)`` | ``a && b`` |\n+-----------------------------------------------+-----------------------------------------------+\n| ``np.logical_or(a, b)`` | ``a || b`` |\n+-----------------------------------------------+-----------------------------------------------+\n| ``np.isclose(a, b)`` | ``xf::isclose(a, b)`` |\n+-----------------------------------------------+-----------------------------------------------+\n| ``np.allclose(a, b)`` | ``xf::allclose(a, b)`` |\n+-----------------------------------------------+-----------------------------------------------+\n\nComparisons\n-----------\n\n`xarray` relies on `numpy` functions, that can also operate on ``xarray.DataArray``.\n\n+-----------------------------------------------+-----------------------------------------------+\n| Python 3 - xarray | C++ 14 - xframe |\n+===============================================+===============================================+\n| ``np.equal(a, b)`` | ``xf::equal(a, b)`` |\n+-----------------------------------------------+-----------------------------------------------+\n| ``np.not_equal(a, b)`` | ``xf::not_equal(a, b)`` |\n+-----------------------------------------------+-----------------------------------------------+\n| ``np.less(a, b)`` || ``xf::less(a, b)`` |\n| || ``a < b`` |\n+-----------------------------------------------+-----------------------------------------------+\n| ``np.less_equal(a, b)`` || ``xf::less_equal(a, b)`` |\n| || ``a <= b`` |\n+-----------------------------------------------+-----------------------------------------------+\n| ``np.greater(a, b)`` || ``xf::greater(a, b)`` |\n| || ``a > b`` |\n+-----------------------------------------------+-----------------------------------------------+\n| ``np.greater_equal(a, b)`` || ``xf::greater_equal(a, b)`` |\n| || ``a >= b`` |\n+-----------------------------------------------+-----------------------------------------------+\n\nMathematical functions\n----------------------\n\nxframe universal functions are provided for a large set number of mathematical functions.\n`xarray` relies on `numpy` functions, that can also operate on ``xarray.DataArray``.\n\n**Basic functions:**\n\n+-----------------------------------------------+-----------------------------------------------+\n| Python 3 - xarray | C++ 14 - xframe |\n+===============================================+===============================================+\n| ``np.absolute(a)`` | ``xf::abs(a)`` |\n+-----------------------------------------------+-----------------------------------------------+\n| ``np.sign(a)`` | ``xf::sign(a)`` |\n+-----------------------------------------------+-----------------------------------------------+\n| ``np.remainder(a, b)`` | ``xf::remainder(a, b)`` |\n+-----------------------------------------------+-----------------------------------------------+\n| ``np.clip(a, min, max)`` | ``xf::clip(a, min, max)`` |\n+-----------------------------------------------+-----------------------------------------------+\n| | ``xf::fma(a, b, c)`` |\n+-----------------------------------------------+-----------------------------------------------+\n\n**Exponential functions:**\n\n+-----------------------------------------------+-----------------------------------------------+\n| Python 3 - xarray | C++ 14 - xframe |\n+===============================================+===============================================+\n| ``np.exp(a)`` | ``xf::exp(a)`` |\n+-----------------------------------------------+-----------------------------------------------+\n| ``np.expm1(a)`` | ``xf::expm1(a)`` |\n+-----------------------------------------------+-----------------------------------------------+\n| ``np.log(a)`` | ``xf::log(a)`` |\n+-----------------------------------------------+-----------------------------------------------+\n| ``np.log1p(a)`` | ``xf::log1p(a)`` |\n+-----------------------------------------------+-----------------------------------------------+\n\n**Power functions:**\n\n+-----------------------------------------------+-----------------------------------------------+\n| Python 3 - xarray | C++ 14 - xframe |\n+===============================================+===============================================+\n| ``np.power(a, p)`` | ``xf::pow(a, b)`` |\n+-----------------------------------------------+-----------------------------------------------+\n| ``np.sqrt(a)`` | ``xf::sqrt(a)`` |\n+-----------------------------------------------+-----------------------------------------------+\n| ``np.square(a)`` | ``xf::square(a)`` |\n| | ``xf::cube(a)`` |\n+-----------------------------------------------+-----------------------------------------------+\n| ``np.cbrt(a)`` | ``xf::cbrt(a)`` |\n+-----------------------------------------------+-----------------------------------------------+\n\n**Trigonometric functions:**\n\n+-----------------------------------------------+-----------------------------------------------+\n| Python 3 - xarray | C++ 14 - xframe |\n+===============================================+===============================================+\n| ``np.sin(a)`` | ``xf::sin(a)`` |\n+-----------------------------------------------+-----------------------------------------------+\n| ``np.cos(a)`` | ``xf::cos(a)`` |\n+-----------------------------------------------+-----------------------------------------------+\n| ``np.tan(a)`` | ``xf::tan(a)`` |\n+-----------------------------------------------+-----------------------------------------------+\n\n**Hyperbolic functions:**\n\n+-----------------------------------------------+-----------------------------------------------+\n| Python 3 - xarray | C++ 14 - xframe |\n+===============================================+===============================================+\n| ``np.sinh(a)`` | ``xf::sinh(a)`` |\n+-----------------------------------------------+-----------------------------------------------+\n| ``np.cosh(a)`` | ``xf::cosh(a)`` |\n+-----------------------------------------------+-----------------------------------------------+\n| ``np.tanh(a)`` | ``xf::tanh(a)`` |\n+-----------------------------------------------+-----------------------------------------------+\n\n**Error and gamma functions:**\n\n+-----------------------------------------------+-----------------------------------------------+\n| Python 3 - xarray | C++ 14 - xframe |\n+===============================================+===============================================+\n| ``scipy.special.erf(a)`` | ``xf::erf(a)`` |\n+-----------------------------------------------+-----------------------------------------------+\n| ``scipy.special.gamma(a)`` | ``xf::tgamma(a)`` |\n+-----------------------------------------------+-----------------------------------------------+\n| ``scipy.special.gammaln(a)`` | ``xf::lgamma(a)`` |\n+-----------------------------------------------+-----------------------------------------------+\n" }, { "path": "docs/source/xframe_summary_drawio.xml", "content": "\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" }, { "path": "environment-dev.yml", "content": "name: xframe\nchannels:\n - conda-forge\ndependencies:\n - cmake\n - xtensor=0.21.4\n\n" }, { "path": "environment.yml", "content": "name: xframe\nchannels:\n - QuantStack\n - conda-forge\ndependencies:\n - xframe=0.3.0\n - xeus-cling=0.8.1\n - notebook\n" }, { "path": "include/xframe/xaxis.hpp", "content": "/***************************************************************************\n* Copyright (c) Johan Mabille, Sylvain Corlay, Wolf Vollprecht and *\n* Martin Renou *\n* Copyright (c) QuantStack *\n* *\n* Distributed under the terms of the BSD 3-Clause License. *\n* *\n* The full license is in the file LICENSE, distributed with this software. *\n****************************************************************************/\n\n#ifndef XFRAME_XAXIS_HPP\n#define XFRAME_XAXIS_HPP\n\n#include \n#include \n#include \n#include \n#include \n#include \n#include \n\n#include \"xtl/xiterator_base.hpp\"\n\n#include \"xtensor/xbuilder.hpp\"\n\n#include \"xaxis_base.hpp\"\n#include \"xframe_utils.hpp\"\n\nnamespace xf\n{\n template \n class xaxis_iterator;\n\n template \n class xaxis_default;\n\n /*********************\n * map container tag *\n *********************/\n\n struct map_tag {};\n struct hash_map_tag {};\n\n template \n struct map_container;\n\n template \n struct map_container\n {\n using type = std::map;\n };\n\n template \n struct map_container\n {\n using type = std::unordered_map;\n };\n\n template \n using map_container_t = typename map_container::type;\n\n /*********\n * xaxis *\n *********/\n\n /**\n * @class xaxis\n * @brief Class modeling an axis in a coordinate system.\n *\n * The xaxis class is used for modeling general axes; an axis is a mapping\n * of labels to positions in a given dimension. It is the equivalent of\n * the \\c Index object from pandas.\n *\n * @tparam L the type of labels.\n * @tparam T the integer type used to represent positions. Default value is\n * \\c std::size_t.\n * @tparam MT the tag used for choosing the map type which holds the label-\n * position pairs. Possible values are \\c map_tag and \\c hash_map_tag.\n * Default value is \\c hash_map_tag.\n */\n template \n class xaxis : public xaxis_base>\n {\n public:\n\n using base_type = xaxis_base;\n using self_type = xaxis;\n using key_type = typename base_type::key_type;\n using label_list = typename base_type::label_list;\n using mapped_type = typename base_type::mapped_type;\n using map_type = map_container_t;\n using value_type = typename map_type::value_type;\n using reference = typename map_type::const_reference;\n using const_reference = typename map_type::const_reference;\n using pointer = typename map_type::const_pointer;\n using const_pointer = typename map_type::const_pointer;\n using size_type = typename base_type::size_type;\n using difference_type = typename base_type::difference_type;\n using iterator = typename base_type::iterator;\n using const_iterator = typename base_type::const_iterator;\n using reverse_iterator = typename base_type::reverse_iterator;\n using const_reverse_iterator = typename base_type::const_reverse_iterator;\n\n explicit xaxis();\n explicit xaxis(const label_list& labels);\n explicit xaxis(label_list&& labels);\n xaxis(std::initializer_list init);\n\n template \n explicit xaxis(xaxis_default axis);\n\n template \n xaxis(InputIt first, InputIt last);\n\n bool is_sorted() const noexcept;\n\n bool contains(const key_type& key) const;\n mapped_type operator[](const key_type& key) const;\n\n template \n self_type filter(const F& f) const noexcept;\n\n template \n self_type filter(const F& f, size_type size) const noexcept;\n\n const_iterator find(const key_type& key) const;\n\n const_iterator cbegin() const noexcept;\n const_iterator cend() const noexcept;\n\n template \n bool merge(const Args&... axes);\n\n template \n bool intersect(const Args&... axes);\n\n protected:\n\n void populate_index();\n void set_labels(const label_list& labels);\n\n template \n bool merge_unsorted(bool broadcasting, const Arg& a, const Args&... axes);\n bool merge_unsorted(bool broadcasting);\n\n template \n bool intersect_unsorted(const Arg& al, const Args&... axes_labels);\n bool intersect_unsorted();\n\n private:\n\n xaxis(const label_list& labels, bool is_sorted);\n xaxis(label_list&& labels, bool is_sorted);\n\n typename map_type::const_iterator find_index(const key_type& key) const;\n\n template \n bool merge_impl(const Args&... axes);\n\n template \n bool merge_empty(const Arg1& a, const Args&... axes);\n bool merge_empty();\n\n bool init_is_sorted() const noexcept;\n\n template \n bool all_sorted(const Arg& a, const Args&... axes) const noexcept;\n\n template \n bool all_sorted(const Arg& a) const noexcept;\n\n map_type m_index;\n bool m_is_sorted;\n\n friend class xaxis_iterator;\n friend class xaxis_default;\n };\n\n template \n bool merge_axes(xaxis& output, const Args&... axes);\n\n template \n bool intersect_axes(xaxis& output, const Args&... axes);\n\n /******************\n * xaxis builders *\n ******************/\n\n template \n xaxis axis(L start, L stop, L step = 1) noexcept;\n\n template \n xaxis axis(std::initializer_list init) noexcept;\n\n template \n xaxis axis(std::initializer_list init) noexcept;\n\n /********************\n * xaxis_inner_types *\n *********************/\n\n template \n struct xaxis_inner_types>\n {\n using key_type = L;\n using mapped_type = T;\n using iterator = xaxis_iterator;\n };\n\n /******************\n * xaxis_iterator *\n ******************/\n\n template \n class xaxis_iterator : public xtl::xrandom_access_iterator_base,\n typename xaxis::value_type,\n typename xaxis::difference_type,\n typename xaxis::const_pointer,\n typename xaxis::const_reference>\n {\n\n public:\n\n using self_type = xaxis_iterator;\n using container_type = xaxis;\n using label_list = typename container_type::label_list;\n using label_iterator = typename label_list::const_iterator;\n using value_type = typename container_type::value_type;\n using reference = typename container_type::const_reference;\n using pointer = typename container_type::const_pointer;\n using difference_type = typename container_type::difference_type;\n using iterator_category = std::random_access_iterator_tag;\n\n xaxis_iterator() = default;\n xaxis_iterator(const container_type* c, label_iterator it);\n\n self_type& operator++();\n self_type& operator--();\n\n self_type& operator+=(difference_type n);\n self_type& operator-=(difference_type n);\n\n difference_type operator-(const self_type& rhs) const;\n\n reference operator*() const;\n pointer operator->() const;\n\n bool equal(const self_type& rhs) const noexcept;\n bool less_than(const self_type& rhs) const noexcept;\n\n private:\n\n const container_type* p_c;\n label_iterator m_it;\n };\n\n template \n typename xaxis_iterator::difference_type operator-(const xaxis_iterator& lhs, const xaxis_iterator& rhs);\n\n template \n bool operator==(const xaxis_iterator& lhs, const xaxis_iterator& rhs) noexcept;\n\n template \n bool operator<(const xaxis_iterator& lhs, const xaxis_iterator& rhs) noexcept;\n\n /************************\n * xaxis implementation *\n ************************/\n\n /**\n * @name Constructors\n */\n //@{\n /**\n * Constructs an empty axis.\n */\n template \n inline xaxis::xaxis()\n : base_type(), m_index(), m_is_sorted(true)\n {\n }\n\n /**\n * Constructs an axis with the given list of labels. This list\n * is copied and the constructor internally checks whether it\n * is sorted.\n * @param labels the list of labels.\n */\n template \n inline xaxis::xaxis(const label_list& labels)\n : base_type(labels), m_index(), m_is_sorted()\n {\n m_is_sorted = init_is_sorted();\n populate_index();\n }\n\n /**\n * Constructs an axis with the given list of labels. The list is\n * moved and therefore it is invalid after the axis has been\n * constructed. The constructor internally checks whether the list\n * is sorted.\n * @param labels the list of labels.\n */\n template \n inline xaxis::xaxis(label_list&& labels)\n : base_type(std::move(labels)), m_index(), m_is_sorted()\n {\n m_is_sorted = init_is_sorted();\n populate_index();\n }\n\n /**\n * Constructs an axis with the given list of labels, and a boolean\n * specifying if the labels list is sorted. This is an optimization\n * that prevents the constructor to check if the labels list is sorted.\n * The list is copied.\n * @param labels th list of labels.\n * @param is_sorted a boolean parameter indicating if the labels list\n * is sorted.\n */\n template \n inline xaxis::xaxis(const label_list& labels, bool is_sorted)\n : base_type(labels), m_index(), m_is_sorted(is_sorted)\n {\n populate_index();\n }\n /**\n * Constructs an axis with the given list of labels, and a boolean\n * specifying if the labels list is sorted. This is an optimization\n * that prevents the constructor to check if the labels list is sorted.\n * The list is moved and therefore invalid after the axis has been\n * constructed.\n * @param labels th list of labels.\n * @param is_sorted a boolean parameter indicating if the labels list\n * is sorted.\n */\n\n template \n inline xaxis::xaxis(label_list&& labels, bool is_sorted)\n : base_type(labels), m_index(), m_is_sorted(is_sorted)\n {\n populate_index();\n }\n\n /**\n * Constructs an axis from the given initializer list of labels. The\n * constructor internally checks whether the list is sorted.\n */\n template \n inline xaxis::xaxis(std::initializer_list init)\n : base_type(init), m_index(), m_is_sorted()\n {\n m_is_sorted = init_is_sorted();\n populate_index();\n }\n\n /**\n * Constructs an axis from a \\c default_axis.\n * @sa default_axis\n */\n template \n template \n inline xaxis::xaxis(xaxis_default axis)\n : base_type(axis.labels()), m_index(), m_is_sorted(true)\n {\n static_assert(std::is_same::value, \"key_type L and key_type L1 must be the same\");\n\n populate_index();\n }\n\n /**\n * Constructs an axis from the content of the range [first, last)\n * @param first An iterator to the first label.\n * @param last An iterator the the element following the last label.\n */\n template \n template \n inline xaxis::xaxis(InputIt first, InputIt last)\n : base_type(first, last), m_index(), m_is_sorted()\n {\n m_is_sorted = init_is_sorted();\n populate_index();\n }\n //@}\n\n /**\n * Returns true if the labels list is sorted.\n */\n template \n inline bool xaxis::is_sorted() const noexcept\n {\n return m_is_sorted;\n }\n\n /**\n * @name Data\n */\n //@{\n /**\n * Returns true if the axis contains the speficied label.\n * @param key the label to search for.\n */\n template \n inline bool xaxis::contains(const key_type& key) const\n {\n return m_index.count(key) != typename map_type::size_type(0);\n }\n\n /**\n * Returns the position of the specified label. If this last one is\n * not found, an exception is thrown.\n * @param key the label to search for.\n */\n template \n inline auto xaxis::operator[](const key_type& key) const -> mapped_type\n {\n return m_index.at(key);\n }\n //@}\n\n /**\n * @name Filters\n */\n //@{\n /**\n * Builds an return a new axis by applying the given filter to the axis.\n * @param f the filter used to select the labels to keep in the new axis.\n */\n template \n template \n inline auto xaxis::filter(const F& f) const noexcept -> self_type\n {\n return self_type(base_type::filter_labels(f), m_is_sorted);\n }\n\n /**\n * Builds an return a new axis by applying the given filter to the axis. When\n * the size of the new list of labels is known, this method allows some\n * optimizations compared to the previous one.\n * @param f the filter used to select the labels to keep in the new axis.\n * @param size the size of the new label list.\n */\n template \n template \n inline auto xaxis::filter(const F& f, size_type size) const noexcept -> self_type\n {\n return self_type(base_type::filter_labels(f, size), m_is_sorted);\n }\n //@}\n\n /**\n * @name Iterator\n */\n //@{\n /**\n * Returns a constant iterator to the element with label equivalent to \\c key. If\n * no such element is found, past-the-end iterator is returned.\n * @param key the label to search for.\n */\n template \n inline auto xaxis::find(const key_type& key) const -> const_iterator\n {\n auto map_iter = m_index.find(key);\n return map_iter != m_index.end() ? cbegin() + map_iter->second : cend();\n }\n\n /**\n * Returns a constant iterator to the first element of the axis.\n * This element is a pair label - position.\n */\n template \n inline auto xaxis::cbegin() const noexcept -> const_iterator\n {\n return const_iterator(this, this->labels().begin());\n }\n\n /**\n * Returns a constant iterator to the element following the last element\n * of the axis.\n */\n template \n inline auto xaxis::cend() const noexcept -> const_iterator\n {\n return const_iterator(this, this->labels().end());\n }\n //@}\n\n /**\n * @name Set operations\n */\n //@{\n /**\n * Merges all the axes arguments into this ones. After this function call,\n * the axis contains all the labels from all the arguments.\n * @param axes the axes to merge.\n * @return true is the axis already contained all the labels.\n */\n template \n template \n inline bool xaxis::merge(const Args&... axes)\n {\n return this->empty() ? merge_empty(axes...) : merge_impl(axes...);\n }\n\n /**\n * Replaces the labels with the intersection of the labels of\n * the axes arguments and the labels of this axis.\n * @param axes the axes to intersect.\n * @return true if the intersection is equivalent to this axis.\n */\n template \n template \n inline bool xaxis::intersect(const Args&... axes)\n {\n bool res = true;\n if (all_sorted(*this, axes...))\n {\n res = intersect_to(this->mutable_labels(), axes.labels()...);\n populate_index();\n }\n else\n {\n res = intersect_unsorted(axes.labels()...);\n }\n return res;\n }\n //@}\n\n template \n inline void xaxis::populate_index()\n {\n for(size_type i = 0; i < this->labels().size(); ++i)\n {\n m_index[this->labels()[i]] = T(i);\n }\n }\n\n template \n void xaxis::set_labels(const label_list& labels)\n {\n this->mutable_labels() = labels;\n populate_index();\n }\n\n template \n inline auto xaxis::find_index(const key_type& key) const -> typename map_type::const_iterator\n {\n return m_index.find(key);\n }\n\n template \n template \n inline bool xaxis::merge_impl(const Args&... axes)\n {\n bool res = true;\n if(all_sorted(*this, axes...))\n {\n res = merge_to(this->mutable_labels(), axes.labels()...);\n populate_index();\n }\n else\n {\n m_is_sorted = false;\n if (m_index.empty())\n {\n populate_index();\n }\n res = merge_unsorted(false, axes.labels()...);\n }\n return res;\n }\n\n template \n template \n inline bool xaxis::merge_empty(const Arg1& a, const Args&... axes)\n {\n this->mutable_labels() = a.labels();\n return merge_impl(axes...);\n }\n\n template \n inline bool xaxis::merge_empty()\n {\n return true;\n }\n\n template \n inline bool xaxis::init_is_sorted() const noexcept\n {\n return std::is_sorted(this->labels().begin(), this->labels().end());\n }\n\n template \n template \n inline bool xaxis::all_sorted(const Arg& a, const Args&... axes) const noexcept\n {\n return a.is_sorted() && all_sorted(axes...);\n }\n\n template \n template \n inline bool xaxis::all_sorted(const Arg& a) const noexcept\n {\n return a.is_sorted();\n }\n\n template \n template \n inline bool xaxis::merge_unsorted(bool broadcasting, const Arg& a, const Args&... axes_labels)\n {\n bool res = merge_unsorted(broadcasting, axes_labels...);\n auto& labels = this->mutable_labels();\n auto output_iter = labels.rbegin();\n auto output_end = labels.rend();\n auto input_iter = a.rbegin();\n auto input_end = a.rend();\n while ((output_iter != output_end) && (input_iter != input_end) && (*output_iter == *input_iter))\n {\n ++output_iter;\n ++input_iter;\n }\n if(input_iter == input_end)\n {\n if(output_iter != output_end)\n {\n res &= broadcasting;\n }\n }\n else if(output_iter == output_end)\n {\n std::copy(a.begin(), a.begin() + std::distance(input_iter, input_end),\n std::inserter(labels, labels.begin()));\n populate_index();\n res &= broadcasting;\n }\n else\n {\n while(input_iter != input_end)\n {\n if(!contains(*input_iter))\n {\n if(output_iter != labels.rbegin())\n {\n labels.insert(labels.begin(), *input_iter);\n }\n else\n {\n labels.push_back(*input_iter);\n }\n }\n ++input_iter;\n }\n populate_index();\n res = false;\n }\n return res;\n }\n\n template \n inline bool xaxis::merge_unsorted(bool /*broadcasting*/)\n {\n return true;\n }\n\n template \n template \n inline bool xaxis::intersect_unsorted(const Arg& al, const Args&... axes_labels)\n {\n bool res = intersect_unsorted(axes_labels...);\n auto& labels = this->mutable_labels();\n auto iter = labels.begin();\n auto iter_end = labels.end();\n bool must_populate = false;\n while (iter != iter_end)\n {\n auto it = std::find(al.begin(), al.end(), *iter);\n if (it == al.end())\n {\n iter = labels.erase(iter, iter + 1);\n iter_end = labels.end();\n res = false;\n must_populate = true;\n }\n else\n {\n if (it - al.begin() != iter - labels.begin())\n {\n res = false;\n }\n ++iter;\n }\n }\n if (must_populate)\n {\n populate_index();\n }\n return res;\n }\n\n template \n inline bool xaxis::intersect_unsorted()\n {\n return true;\n }\n\n template \n inline bool merge_axes(xaxis& output, const Args&... axes)\n {\n return output.merge(axes...);\n }\n\n template \n inline bool intersect_axes(xaxis& output, const Args&... axes)\n {\n return output.intersect(axes...);\n }\n\n /*********************************\n * xaxis_iterator implementation *\n *********************************/\n\n template \n inline xaxis_iterator::xaxis_iterator(const container_type* c, label_iterator it)\n : p_c(c), m_it(it)\n {\n }\n\n template \n inline auto xaxis_iterator::operator++() -> self_type&\n {\n ++m_it;\n return *this;\n }\n\n template \n inline auto xaxis_iterator::operator--() -> self_type&\n {\n --m_it;\n return *this;\n }\n\n template \n inline auto xaxis_iterator::operator+=(difference_type n) -> self_type&\n {\n m_it += n;\n return *this;\n }\n\n template \n inline auto xaxis_iterator::operator-=(difference_type n) -> self_type&\n {\n m_it -= n;\n return *this;\n }\n\n template \n inline auto xaxis_iterator::operator-(const self_type& rhs) const -> difference_type\n {\n return m_it - rhs.m_it;\n }\n\n template \n inline auto xaxis_iterator::operator*() const -> reference\n {\n return *(p_c->find_index(*m_it));\n }\n\n template \n inline auto xaxis_iterator::operator->() const -> pointer\n {\n return &(*(p_c->find_index(*m_it)));\n }\n\n template \n inline bool xaxis_iterator::equal(const self_type& rhs) const noexcept\n {\n return m_it == rhs.m_it;\n }\n\n template \n inline bool xaxis_iterator::less_than(const self_type& rhs) const noexcept\n {\n return m_it < rhs.m_it;\n }\n\n template \n inline typename xaxis_iterator::difference_type operator-(const xaxis_iterator& lhs, const xaxis_iterator& rhs)\n {\n return lhs.operator-(rhs);\n }\n\n template \n inline bool operator==(const xaxis_iterator& lhs, const xaxis_iterator& rhs) noexcept\n {\n return lhs.equal(rhs);\n }\n\n template \n inline bool operator<(const xaxis_iterator& lhs, const xaxis_iterator& rhs) noexcept\n {\n return lhs.less_than(rhs);\n }\n\n /********************************\n * axis builders implementation *\n ********************************/\n\n /**\n * Returns an axis containing a range of integral labels.\n * @param start the first value of the range.\n * @param stop the end of the range. The range doe snot contain\n * this value.\n * @param step Spacing between values. Default step is \\c 1.\n * @tparam T the integral type used for positions. Default value\n * @tparam L the type of the labels.\n */\n template \n inline xaxis axis(L start, L stop, L step) noexcept\n {\n auto range = xt::arange(start, stop, step);\n return xaxis(range.begin(), range.end());\n }\n\n /**\n * Builds an returns an axis from the specified list of labels.\n * @param init the list of labels.\n * @tparam T the integral type used for positions. Default value\n * is \\c std::size_t.\n * @tparam L the type of the labels.\n */\n template \n inline xaxis axis(std::initializer_list init) noexcept\n {\n return xaxis(init);\n }\n\n template \n inline xaxis axis(std::initializer_list init) noexcept\n {\n return xaxis(init.begin(), init.end());\n }\n}\n\n#endif\n" }, { "path": "include/xframe/xaxis_base.hpp", "content": "/***************************************************************************\n* Copyright (c) Johan Mabille, Sylvain Corlay, Wolf Vollprecht and *\n* Martin Renou *\n* Copyright (c) QuantStack *\n* *\n* Distributed under the terms of the BSD 3-Clause License. *\n* *\n* The full license is in the file LICENSE, distributed with this software. *\n****************************************************************************/\n\n#ifndef XFRAME_XAXIS_BASE_HPP\n#define XFRAME_XAXIS_BASE_HPP\n\n#include \n#include \n#include \n\nnamespace xf\n{\n\n template \n struct xaxis_inner_types;\n\n /**************\n * xaxis_base *\n **************/\n\n /**\n * @class xaxis_base\n * @brief Base class for axes.\n *\n * The xaxis_base class defines the common interface for axes, which define the\n * mapping of labels to positions in a given dimension. The axis_base class\n * embeds the list of labels only, the mapping is hold by the inheriting classes.\n *\n * @tparam D The derived type, i.e. the inheriting class for which xaxis_base\n * provides the interface.\n */\n template \n class xaxis_base\n {\n public:\n\n using derived_type = D;\n using inner_types = xaxis_inner_types;\n\n using key_type = typename inner_types::key_type;\n using mapped_type = typename inner_types::mapped_type;\n using label_list = std::vector;\n using size_type = typename label_list::size_type;\n using difference_type = typename label_list::difference_type;\n using iterator = typename inner_types::iterator;\n using const_iterator = iterator;\n using reverse_iterator = std::reverse_iterator;\n using const_reverse_iterator = reverse_iterator;\n\n static_assert(std::is_integral::value, \"mapped_type T must be an integral type\");\n\n derived_type& derived_cast() & noexcept;\n const derived_type& derived_cast() const & noexcept;\n derived_type derived_cast() && noexcept;\n\n const label_list& labels() const noexcept;\n key_type label(size_type i) const;\n\n bool empty() const noexcept;\n size_type size() const noexcept;\n\n const_iterator begin() const noexcept;\n const_iterator end() const noexcept;\n\n const_reverse_iterator rbegin() const noexcept;\n const_reverse_iterator rend() const noexcept;\n\n const_reverse_iterator crbegin() const noexcept;\n const_reverse_iterator crend() const noexcept;\n\n protected:\n\n xaxis_base();\n xaxis_base(const label_list& labels);\n xaxis_base(label_list&& labels);\n xaxis_base(std::initializer_list init);\n\n template \n xaxis_base(InputIt first, InputIt last);\n\n ~xaxis_base() = default;\n\n xaxis_base(const xaxis_base&) = default;\n xaxis_base& operator=(const xaxis_base&) = default;\n\n xaxis_base(xaxis_base&&) = default;\n xaxis_base& operator=(xaxis_base&&) = default;\n\n label_list& mutable_labels() noexcept;\n\n template \n label_list filter_labels(const F& f) const noexcept;\n\n template \n label_list filter_labels(const F& f, size_type size) const noexcept;\n\n label_list m_labels;\n };\n\n template \n bool operator==(const xaxis_base& lhs, const xaxis_base& rhs) noexcept;\n\n template \n bool operator!=(const xaxis_base& lhs, const xaxis_base& rhs) noexcept;\n\n template \n OS& operator<<(OS& out, const xaxis_base& axis);\n\n /************************\n * is_axis metafunction *\n ************************/\n\n template \n struct is_axis : std::is_base_of, T>\n {\n };\n\n /*****************************\n * xaxis_base implementation *\n *****************************/\n\n template \n inline xaxis_base::xaxis_base()\n : m_labels()\n {\n }\n\n template \n inline xaxis_base::xaxis_base(const label_list& labels)\n : m_labels(labels)\n {\n }\n\n template \n inline xaxis_base::xaxis_base(label_list&& labels)\n : m_labels(std::move(labels))\n {\n }\n\n template \n inline xaxis_base::xaxis_base(std::initializer_list init)\n : m_labels(init)\n {\n }\n\n template \n template \n inline xaxis_base::xaxis_base(InputIt first, InputIt last)\n : m_labels(first, last)\n {\n }\n\n /**\n * @name Downcast\n */\n //@{\n /**\n * Casts the object to its inheriting type (i.e. D); this method\n * is called when the object is an lvalue.\n */\n template \n inline auto xaxis_base::derived_cast() & noexcept -> derived_type&\n {\n return *static_cast(this);\n }\n\n /**\n * Casts the object to its inheriting type (i.e. D); this method\n * is called when the object is a constant lvalue.\n */\n template \n inline auto xaxis_base::derived_cast() const & noexcept -> const derived_type&\n {\n return *static_cast(this);\n }\n\n /**\n * Casts the object to its inheriting type (i.e. D); this method\n * is called when the object is an rvalue.\n */\n template \n inline auto xaxis_base::derived_cast() && noexcept -> derived_type\n {\n return *static_cast(this);\n }\n //@}\n\n /**\n * @name Labels\n */\n //@{\n /**\n * Returns the list of labels contained in the axis.\n */\n template \n inline auto xaxis_base::labels() const noexcept -> const label_list&\n {\n return m_labels;\n }\n\n /**\n * Return the i-th label of the axis.\n * @param i the position of the label.\n */\n template \n inline auto xaxis_base::label(size_type i) const -> key_type\n {\n return m_labels[i];\n }\n\n /**\n * Checks if the axis has no labels.\n */\n template \n inline bool xaxis_base::empty() const noexcept\n {\n return m_labels.empty();\n }\n\n /**\n * Returns the number of labels in the axis.\n */\n template \n inline auto xaxis_base::size() const noexcept -> size_type\n {\n return m_labels.size();\n }\n //@}\n\n /**\n * @name Iterators\n */\n //@{\n /**\n * Returns a constant iterator to the first element of the axis.\n * This element is a pair label - position.\n */\n template \n inline auto xaxis_base::begin() const noexcept -> const_iterator\n {\n return derived_cast().cbegin();\n }\n\n /**\n * Returns a constant iterator to the element following the last element\n * of the axis.\n */\n template \n inline auto xaxis_base::end() const noexcept -> const_iterator\n {\n return derived_cast().cend();\n }\n\n /**\n * Returns a constant iterator to the first element of the reverse axis.\n * This element is a pair labal - position.\n */\n template \n inline auto xaxis_base::rbegin() const noexcept -> const_reverse_iterator\n {\n return crbegin();\n }\n\n /**\n * Returns a constant iterator to the element following the last element\n * of the reversed axis.\n */\n template \n inline auto xaxis_base::rend() const noexcept -> const_reverse_iterator\n {\n return crend();\n }\n\n /**\n * Returns a constant iterator to the first element of the reverse axis.\n * This element is a pair labal - position.\n */\n template \n inline auto xaxis_base::crbegin() const noexcept -> const_reverse_iterator\n {\n return const_reverse_iterator(derived_cast().cend());\n }\n\n /**\n * Returns a constant iterator to the element following the last element\n * of the reversed axis.\n */\n template \n inline auto xaxis_base::crend() const noexcept -> const_reverse_iterator\n {\n return const_reverse_iterator(derived_cast().cbegin());\n }\n //@}\n\n template \n inline auto xaxis_base::mutable_labels() noexcept -> label_list&\n {\n return m_labels;\n }\n\n template \n template \n inline auto xaxis_base::filter_labels(const F& f) const noexcept -> label_list\n {\n label_list l;\n std::copy_if(m_labels.cbegin(), m_labels.cend(), std::back_inserter(l), f);\n return l;\n }\n\n template \n template \n inline auto xaxis_base::filter_labels(const F& f, size_type size) const noexcept -> label_list\n {\n label_list l(size);\n std::copy_if(m_labels.cbegin(), m_labels.cend(), l.begin(), f);\n return l;\n }\n\n /**\n * Returns true is \\c lhs and \\c rhs are equivalent axes, i.e. they contain the same\n * label - position pairs.\n * @param lhs an axis.\n * @param rhs an axis.\n */\n template \n inline bool operator==(const xaxis_base& lhs, const xaxis_base& rhs) noexcept\n {\n return lhs.labels() == rhs.labels();\n }\n\n /**\n * Returns true is \\c lhs and \\c rhs are not equivalent axes, i.e. they contain different\n * label - position pairs.\n * @param lhs an axis.\n * @param rhs an axis.\n */\n template \n inline bool operator!=(const xaxis_base& lhs, const xaxis_base& rhs) noexcept\n {\n return !(lhs == rhs);\n }\n\n template \n inline OS& operator<<(OS& out, const xaxis_base& axis)\n {\n using iterator = std::ostream_iterator::key_type, typename OS::char_type, typename OS::traits_type>;\n out << '(';\n std::copy(axis.labels().begin(), axis.labels().end(), iterator(out, \", \"));\n out << ')';\n return out;\n }\n}\n\n#endif\n" }, { "path": "include/xframe/xaxis_default.hpp", "content": "/***************************************************************************\n* Copyright (c) Johan Mabille, Sylvain Corlay, Wolf Vollprecht and *\n* Martin Renou *\n* Copyright (c) QuantStack *\n* *\n* Distributed under the terms of the BSD 3-Clause License. *\n* *\n* The full license is in the file LICENSE, distributed with this software. *\n****************************************************************************/\n\n#ifndef XFRAME_XAXIS_DEFAULT_HPP\n#define XFRAME_XAXIS_DEFAULT_HPP\n\n#include \n#include \n#include \n#include \n\n#include \"xtl/xiterator_base.hpp\"\n\n#include \"xaxis_base.hpp\"\n#include \"xaxis.hpp\"\n\nnamespace xf\n{\n template \n class xaxis_default_iterator;\n\n template \n class xaxis_variant;\n\n /*****************\n * xaxis_default *\n *****************/\n\n /**\n * @class xaxis_default\n * @brief Default axis with integral labels.\n *\n * The xaxis_default class is used for modeling a default axis\n * that holds a contiguous sequence of integral labels starting at 0.\n *\n * @tparam L the type of labels. This must be an integral type.\n * @tparam T the integer type used to represent positions. Default value is\n * \\c std::size_t.\n */\n template \n class xaxis_default : public xaxis_base>\n {\n public:\n\n using base_type = xaxis_base;\n using self_type = xaxis_default;\n using axis_type = xaxis;\n using key_type = typename base_type::key_type;\n using label_list = typename base_type::label_list;\n using mapped_type = typename base_type::mapped_type;\n using value_type = std::pair;\n using reference = value_type&;\n using const_reference = const value_type&;\n using pointer = value_type*;\n using const_pointer = const value_type*;\n using size_type = typename base_type::size_type;\n using difference_type = typename base_type::difference_type;\n using iterator = typename base_type::iterator;\n using const_iterator = typename base_type::const_iterator;\n using reverse_iterator = typename base_type::reverse_iterator;\n using const_reverse_iterator = typename base_type::const_reverse_iterator;\n\n static_assert(std::is_integral::value, \"key_type L must be an integral type\");\n\n explicit xaxis_default(size_type size = 0);\n\n bool is_sorted() const noexcept;\n\n bool contains(const key_type& key) const;\n mapped_type operator[](const key_type& key) const;\n\n template \n axis_type filter(const F& f) const noexcept;\n\n template \n axis_type filter(const F& f, size_type size) const noexcept;\n\n const_iterator find(const key_type& key) const;\n\n const_iterator cbegin() const noexcept;\n const_iterator cend() const noexcept;\n\n protected:\n\n void populate_labels(const size_type& size = 0);\n\n private:\n\n template \n bool merge(const Args&... /*axes*/);\n\n template \n bool intersect(const Args&... /*axes*/);\n\n template \n friend class xaxis_variant;\n };\n\n /*************************\n * xaxis_default builder *\n *************************/\n\n template \n xaxis_default axis(L size) noexcept;\n\n /********************\n * xaxis_inner_types *\n *********************/\n\n template \n struct xaxis_inner_types>\n {\n using key_type = L;\n using mapped_type = T;\n using iterator = xaxis_default_iterator;\n };\n\n /**************************\n * xaxis_default_iterator *\n **************************/\n\n template \n class xaxis_default_iterator : public xtl::xrandom_access_iterator_base,\n typename xaxis_default::value_type,\n typename xaxis_default::difference_type,\n typename xaxis_default::const_pointer,\n typename xaxis_default::const_reference>\n {\n\n public:\n\n using self_type = xaxis_default_iterator;\n using container_type = xaxis_default;\n using label_list = typename container_type::label_list;\n using key_type = typename container_type::key_type;\n using mapped_type = typename container_type::mapped_type;\n using value_type = typename container_type::value_type;\n using reference = typename container_type::const_reference;\n using pointer = typename container_type::const_pointer;\n using difference_type = typename label_list::difference_type;\n using iterator_category = std::random_access_iterator_tag;\n\n xaxis_default_iterator() = default;\n xaxis_default_iterator(mapped_type value);\n\n self_type& operator++();\n self_type& operator--();\n\n self_type& operator+=(difference_type n);\n self_type& operator-=(difference_type n);\n\n difference_type operator-(const self_type& rhs) const;\n\n reference operator*() const;\n pointer operator->() const;\n\n bool equal(const self_type& rhs) const noexcept;\n bool less_than(const self_type& rhs) const noexcept;\n\n private:\n\n value_type m_value;\n };\n\n template \n typename xaxis_default_iterator::difference_type operator-(const xaxis_default_iterator& lhs, const xaxis_default_iterator& rhs);\n\n template \n bool operator==(const xaxis_default_iterator& lhs, const xaxis_default_iterator& rhs) noexcept;\n\n template \n bool operator<(const xaxis_default_iterator& lhs, const xaxis_default_iterator& rhs) noexcept;\n\n /********************************\n * xaxis_default implementation *\n ********************************/\n\n /**\n * Constructs a default axis holding \\c size integral elements.\n * The labels sequence is [0, 1, ..... size - 1)\n */\n template \n inline xaxis_default::xaxis_default(size_type size)\n : base_type()\n {\n populate_labels(size);\n }\n\n /**\n * Returns true if the labels list is sorted.\n */\n template \n inline bool xaxis_default::is_sorted() const noexcept\n {\n return true;\n }\n\n /**\n * Returns true if the axis contains the speficied label.\n * @param key the label to search for.\n */\n template \n inline bool xaxis_default::contains(const key_type& key) const\n {\n return key_type(0) <= key && key < key_type(this->size());\n }\n\n /**\n * Returns the position of the specified label. If this last one is\n * not found, an exception is thrown.\n * @param key the label to search for.\n */\n template \n inline auto xaxis_default::operator[](const key_type& key) const -> mapped_type\n {\n return mapped_type(this->labels().at(key));\n }\n\n /**\n * Builds an return a new axis by applying the given filter to the axis.\n * @param f the filter used to select the labels to keep in the new axis.\n */\n template \n template \n inline auto xaxis_default::filter(const F& f) const noexcept -> axis_type\n {\n return axis_type(base_type::filter_labels(f), true);\n }\n\n /**\n * Builds an return a new axis by applying the given filter to the axis. When\n * the size of the new list of labels is known, this method allows some\n * optimizations compared to the previous one.\n * @param f the filter used to select the labels to keep in the new axis.\n * @param size the size of the new label list.\n */\n template \n template \n inline auto xaxis_default::filter(const F& f, size_type size) const noexcept -> axis_type\n {\n return axis_type(base_type::filter_labels(f, size), true);\n }\n\n /**\n * Returns a constant iterator to the element with label equivalent to \\c key. If\n * no such element is found, past-the-end iterator is returned.\n * @param key the label to search for.\n */\n template \n inline auto xaxis_default::find(const key_type& key) const -> const_iterator\n {\n return contains(key) ? const_iterator(mapped_type(key)) : cend();\n }\n\n /**\n * Returns a constant iterator to the first element of the axis.\n * This element is a pair label - position.\n */\n template \n inline auto xaxis_default::cbegin() const noexcept -> const_iterator\n {\n return const_iterator(mapped_type(0));\n }\n\n /**\n * Returns a constant iterator to the element following the last element\n * of the axis.\n */\n template \n inline auto xaxis_default::cend() const noexcept -> const_iterator\n {\n return const_iterator(mapped_type(this->size()));\n }\n\n template \n inline void xaxis_default::populate_labels(const size_type& size)\n {\n auto& labels = this->mutable_labels();\n for(size_type i = 0; i < size; ++i)\n {\n labels.push_back(key_type(i));\n }\n }\n\n template \n template \n inline bool xaxis_default::merge(const Args&... /*axes*/)\n {\n throw std::runtime_error(\"merge forbidden for xaxis_default\");\n }\n\n template \n template \n inline bool xaxis_default::intersect(const Args&... /*axes*/)\n {\n throw std::runtime_error(\"intersect forbidden for xaxis_default\");\n }\n\n /****************************************\n * xaxis_default builder implementation *\n ****************************************/\n\n /**\n * Returns a default axis that holds \\c size integral\n * labels.\n * @param size the number of labels.\n * @tparam T the integral type used for positions. Default value\n * is \\c std::size_t.\n * @tparam L the type of the labels. This must be an integral type.\n */\n template \n inline xaxis_default axis(L size) noexcept\n {\n return xaxis_default(size);\n }\n\n /*****************************************\n * xaxis_default_iterator implementation *\n *****************************************/\n\n template \n inline xaxis_default_iterator::xaxis_default_iterator(mapped_type value)\n : m_value(std::make_pair(static_cast(value), value))\n {\n }\n\n template \n inline auto xaxis_default_iterator::operator++() -> self_type&\n {\n ++m_value.first;\n ++m_value.second;\n return *this;\n }\n\n template \n inline auto xaxis_default_iterator::operator--() -> self_type&\n {\n --m_value.first;\n --m_value.second;\n return *this;\n }\n\n template \n inline auto xaxis_default_iterator::operator+=(difference_type n) -> self_type&\n {\n m_value.first = static_cast(m_value.first + n);\n m_value.second += static_cast(n);\n return *this;\n }\n\n template \n inline auto xaxis_default_iterator::operator-=(difference_type n) -> self_type&\n {\n m_value.first = static_cast(m_value.first - n);\n m_value.second -= static_cast(n);\n return *this;\n }\n\n template \n inline auto xaxis_default_iterator::operator-(const self_type& rhs) const -> difference_type\n {\n return m_value.first - rhs.m_value.first;\n return m_value.second - rhs.m_value.second;\n }\n\n template \n inline auto xaxis_default_iterator::operator*() const -> reference\n {\n return m_value;\n }\n\n template \n inline auto xaxis_default_iterator::operator->() const -> pointer\n {\n return &m_value;\n }\n\n template \n inline bool xaxis_default_iterator::equal(const self_type& rhs) const noexcept\n {\n return m_value.first == rhs.m_value.first;\n }\n\n template \n inline bool xaxis_default_iterator::less_than(const self_type& rhs) const noexcept\n {\n return m_value.first < rhs.m_value.first;\n }\n\n template \n inline typename xaxis_default_iterator::difference_type operator-(const xaxis_default_iterator& lhs, const xaxis_default_iterator& rhs)\n {\n return lhs.operator-(rhs);\n }\n\n template \n inline bool operator==(const xaxis_default_iterator& lhs, const xaxis_default_iterator& rhs) noexcept\n {\n return lhs.equal(rhs);\n }\n\n template \n inline bool operator<(const xaxis_default_iterator& lhs, const xaxis_default_iterator& rhs) noexcept\n {\n return lhs.less_than(rhs);\n }\n}\n\n#endif\n" }, { "path": "include/xframe/xaxis_expression_leaf.hpp", "content": "/***************************************************************************\n* Copyright (c) Johan Mabille, Sylvain Corlay, Wolf Vollprecht and *\n* Martin Renou *\n* Copyright (c) QuantStack *\n* *\n* Distributed under the terms of the BSD 3-Clause License. *\n* *\n* The full license is in the file LICENSE, distributed with this software. *\n****************************************************************************/\n\n#ifndef XFRAME_XAXIS_EXPRESSION_LEAF_HPP\n#define XFRAME_XAXIS_EXPRESSION_LEAF_HPP\n\n#include \"xtl/xvariant.hpp\"\n#include \"xtl/xmeta_utils.hpp\"\n\n#include \"xtensor/xoptional.hpp\"\n\n#include \"xframe_config.hpp\"\n#include \"xframe_utils.hpp\"\n#include \"xframe_expression.hpp\"\n\nnamespace xf\n{\n /*************************\n * xaxis_expression_leaf *\n *************************/\n\n /**\n * @class xaxis_expression_leaf\n * @brief An subset of an expression on axis\n *\n * The xaxis_expression_leaf class is used with xaxis_function for creating\n * an expression on xnamed_axis, e.g. `auto expr = not_equal(axis1, 2) && axis2 < 3`.\n * In the example above, `axis1`, `axis2` are xnamed_axis which will be converted to\n * xaxis expression leaves before stored in the xaxis_function object.\n *\n * @tparam CTA the named axis type.\n * @sa xaxis_function\n */\n template \n class xaxis_expression_leaf : public xt::xexpression>\n {\n public:\n\n using named_axis_type = std::decay_t;\n using name_type = typename named_axis_type::name_type;\n using size_type = typename named_axis_type::size_type;\n\n using value_type = typename named_axis_type::value_type;\n using reference = typename named_axis_type::reference;\n using const_reference = typename named_axis_type::const_reference;\n using pointer = typename named_axis_type::pointer;\n using const_pointer = typename named_axis_type::const_pointer;\n\n template \n using selector_sequence_type = detail::xselector_sequence_t, N>;\n\n using expression_tag = xaxis_expression_tag;\n\n template \n xaxis_expression_leaf(AX&& n_axis) noexcept;\n\n template ::max()>\n const_reference operator()(const selector_sequence_type& selector) const;\n\n private:\n\n xaxis_closure_t m_named_axis;\n };\n\n /****************************************\n * xaxis_expression_leaf implementation *\n ****************************************/\n\n /**\n * Builds an xaxis_expression_leaf.\n * @param n_axis the xnamed_axis.\n */\n template \n template \n inline xaxis_expression_leaf::xaxis_expression_leaf(AX&& n_axis) noexcept\n : m_named_axis(std::forward(n_axis))\n {\n }\n\n /**\n * Returns the label from the xnamed_axis, given a selector.\n * @param selector a selector_sequence_type.\n */\n template \n template \n auto xaxis_expression_leaf::operator()(const selector_sequence_type& selector) const -> const_reference\n {\n for (const auto& sel: selector)\n {\n if (m_named_axis.name() == sel.first)\n {\n return m_named_axis.label(sel.second);\n }\n }\n throw std::runtime_error(std::string(\"Missing label for axis \") + std::string(m_named_axis.name()));\n }\n}\n\n#endif\n" }, { "path": "include/xframe/xaxis_function.hpp", "content": "/***************************************************************************\n* Copyright (c) Johan Mabille, Sylvain Corlay, Wolf Vollprecht and *\n* Martin Renou *\n* Copyright (c) QuantStack *\n* *\n* Distributed under the terms of the BSD 3-Clause License. *\n* *\n* The full license is in the file LICENSE, distributed with this software. *\n****************************************************************************/\n\n#ifndef XFRAME_XAXIS_FUNCTION_HPP\n#define XFRAME_XAXIS_FUNCTION_HPP\n\n#include \"xtensor/xoptional.hpp\"\n#include \"xtensor/xgenerator.hpp\"\n\n#include \"xframe_expression.hpp\"\n#include \"xframe_utils.hpp\"\n#include \"xaxis_meta.hpp\"\n#include \"xaxis_expression_leaf.hpp\"\n\nnamespace xf\n{\n /******************\n * xaxis_function *\n ******************/\n\n /**\n * @class xaxis_function\n * @brief An expression of xaxis\n *\n * The xaxis_function class is used for creating an expression on named axis, e.g.\n * `auto expr = not_equal(axis1, 2) && axis2 < 2`.\n *\n * @tparam F the function type.\n * @tparam R the result type.\n * @tparam CT the function argument types.\n * @sa xaxis_expression_leaf\n * @sa xnamed_axis\n */\n template \n class xaxis_function : public xt::xexpression>\n {\n public:\n\n using self_type = xaxis_function;\n using functor_type = std::remove_reference_t;\n\n using value_type = R;\n using reference = value_type;\n using const_reference = value_type;\n using pointer = value_type*;\n using const_pointer = const value_type*;\n using name_type = detail::common_name_type_t>...>;\n using size_type = xt::common_size_type_t>...>;\n\n template \n using selector_sequence_type = detail::xselector_sequence_t, N>;\n\n using expression_tag = xaxis_expression_tag;\n\n template ::value>>\n xaxis_function(Func&& f, CT... e) noexcept;\n\n template \n const_reference operator()(const selector_sequence_type& selector) const;\n\n private:\n\n template \n const_reference evaluate(std::index_sequence, const selector_sequence_type& selector) const;\n\n std::tuple...> m_e;\n functor_type m_f;\n };\n\n /*********************************\n * xaxis_function implementation *\n *********************************/\n\n /**\n * Builds an axis function.\n * @param f the function to apply.\n * @param e the function arguments.\n */\n template \n template \n inline xaxis_function::xaxis_function(Func&& f, CT... e) noexcept\n : m_e(detail::get_axis_closure(std::forward(e))...),\n m_f(std::forward(f))\n {\n }\n\n /**\n * Returns an evaluation of the xaxis_function.\n * Example:\n * \\code{.cpp}\n * auto axis1 = named_axis(\"abs\", axis(16));\n * auto axis2 = named_axis(\"ord\", axis({'a', 'c', 'i'}));\n *\n * auto func1 = axis1 < 5 && not_equal(axis2, 'i');\n *\n * // This will evaluate the xaxis_function for `axis1.label(10) == 9` and `axis2.label(1) == 'c'``\n * func1({{\"abs\", 10}, {\"ord\", 1}});\n * \\endcode\n *\n * @param selector a selector_sequence_type for selecting the position\n * where you want to evaluate the function.\n * @return the evaluation of the xaxis_function\n */\n template \n template \n inline auto xaxis_function::operator()(const selector_sequence_type& selector) const -> const_reference\n {\n return evaluate(std::make_index_sequence(), selector);\n }\n\n template \n template \n inline auto xaxis_function::evaluate(std::index_sequence, const selector_sequence_type& selector) const -> const_reference\n {\n#ifdef _MSC_VER\n return m_f(std::get(m_e).operator()(selector)...);\n#else\n return m_f(std::get(m_e).template operator()(selector)...);\n#endif\n }\n\n /**********************\n * axis_function_mask *\n **********************/\n\n namespace detail\n {\n template \n class axis_function_mask_impl\n {\n public:\n\n using axis_function_type = std::remove_reference_t;\n\n using value_type = typename axis_function_type::value_type;\n using name_type = typename axis_function_type::name_type;\n using size_type = typename axis_function_type::size_type;\n\n template \n using selector_sequence_type = detail::xselector_sequence_t, N>;\n\n axis_function_mask_impl(AF&& axis_function, DM&& dim_mapping)\n : m_axis_function(std::forward(axis_function)),\n m_dimension_mapping(std::forward(dim_mapping))\n {\n }\n\n template \n inline value_type operator()(Args... args) const\n {\n auto selector = make_selector(std::make_index_sequence(), args...);\n#ifdef _MSC_VER\n return m_axis_function.operator()(selector);\n#else\n return m_axis_function.template operator()(selector);\n#endif\n }\n\n template \n inline value_type element(It first, It last) const\n {\n // TODO avoid dynamic allocation\n auto selector = selector_sequence_type();\n std::size_t i = 0;\n for (It it = first; it != last; ++it)\n {\n selector.push_back(std::make_pair(m_dimension_mapping.label(i++), static_cast(*it)));\n }\n#ifdef _MSC_VER\n return m_axis_function.operator()(selector);\n#else\n return m_axis_function.template operator()(selector);\n#endif\n }\n\n private:\n\n AF m_axis_function;\n DM m_dimension_mapping;\n\n template \n inline selector_sequence_type make_selector(std::index_sequence, Args&&... args) const\n {\n return {std::make_pair(m_dimension_mapping.label(I), static_cast(args))...};\n }\n };\n }\n\n template \n inline auto axis_function_mask(AF&& axis_function, DM&& dim_mapping, const S& shape) noexcept\n {\n return xt::detail::make_xgenerator(\n detail::axis_function_mask_impl(std::forward(axis_function), std::forward(dim_mapping)),\n shape\n );\n }\n}\n\n#endif\n" }, { "path": "include/xframe/xaxis_index_slice.hpp", "content": "/***************************************************************************\n* Copyright (c) Johan Mabille, Sylvain Corlay, Wolf Vollprecht and *\n* Martin Renou *\n* Copyright (c) QuantStack *\n* *\n* Distributed under the terms of the BSD 3-Clause License. *\n* *\n* The full license is in the file LICENSE, distributed with this software. *\n****************************************************************************/\n\n#ifndef XFRAME_XAXIS_INDEX_SLICE_HPP\n#define XFRAME_XAXIS_INDEX_SLICE_HPP\n\n#include \n#include \n#include \"xtl/xvariant.hpp\"\n#include \"xtensor/xstorage.hpp\"\n#include \"xtensor/xslice.hpp\"\n\nnamespace xf\n{\n\n /*********************\n * xaxis_index_slice *\n *********************/\n\n template \n class xaxis_index_slice;\n\n namespace detail\n {\n template \n struct is_xaxis_index_slice : std::false_type\n {\n };\n\n template \n struct is_xaxis_index_slice> : std::true_type\n {\n };\n\n template \n using disable_xaxis_index_slice_t = std::enable_if_t>::value, void>;\n }\n\n template \n class xaxis_index_slice\n {\n public:\n\n using self_type = xaxis_index_slice;\n using size_type = T;\n using storage_type = xtl::variant,\n xt::xstepped_range,\n xt::xkeep_slice,\n xt::xdrop_slice,\n xt::xall>;\n\n xaxis_index_slice() = default;\n template >\n xaxis_index_slice(S&& slice) noexcept;\n\n size_type size() const noexcept;\n bool contains(size_type i) const noexcept;\n\n size_type operator()(size_type i) const noexcept;\n size_type step_size(size_type i, size_type n = 1) const noexcept;\n\n size_type revert_index(size_type i) const noexcept;\n\n template \n V convert_storage() const;\n\n bool operator==(const self_type& rhs) const noexcept;\n bool operator!=(const self_type& rhs) const noexcept;\n\n private:\n\n storage_type m_slice;\n };\n\n /*********************\n * Builder functions *\n *********************/\n\n template \n auto irange(A start_val);\n\n template \n auto irange(A start_val, B stop_val);\n\n template \n auto irange(A start_val, B stop_val, C step);\n\n template \n auto ikeep(T&&... t);\n\n template \n auto idrop(T&&... t);\n\n auto iall() noexcept;\n\n /************************************\n * xaxis_index_slice implementation *\n ************************************/\n\n template \n template \n inline xaxis_index_slice::xaxis_index_slice(S&& slice) noexcept\n : m_slice(std::forward(slice))\n {\n }\n\n template \n inline auto xaxis_index_slice::size() const noexcept -> size_type\n {\n return xtl::visit([](auto&& arg) { return arg.size(); }, m_slice);\n }\n\n template \n inline bool xaxis_index_slice::contains(size_type i) const noexcept\n {\n return xtl::visit([i](auto&& arg) { return arg.contains(i); }, m_slice);\n }\n\n template \n inline auto xaxis_index_slice::operator()(size_type i) const noexcept -> size_type\n {\n return xtl::visit([i](auto&& arg) { return arg(i); }, m_slice);\n }\n\n template \n inline auto xaxis_index_slice::step_size(size_type i, size_type n) const noexcept -> size_type\n {\n return xtl::visit([i, n](auto&& arg) { return arg.step_size(i, n); }, m_slice);\n }\n\n template \n inline auto xaxis_index_slice::revert_index(size_type i) const noexcept -> size_type\n {\n return xtl::visit([i](auto&& arg) { return arg.revert_index(i); }, m_slice);\n }\n\n // TODO: remove this when xrange and xstepped_range has been added\n // to xdynamic_slice in xtensor\n namespace detail\n {\n template \n inline xt::xrange_adaptor convert_range(const xt::xrange& r)\n {\n T start = r(T(0));\n T stop = start + r.size();\n return xt::xrange_adaptor(start, stop, T(1));\n }\n\n template \n inline xt::xrange_adaptor convert_range(const xt::xstepped_range& r)\n {\n T start = r(T(0));\n T stop = start + r.size();\n T step = r.step_size(T(0));\n return xt::xrange_adaptor(start, stop, step);\n }\n }\n\n template \n template \n inline V xaxis_index_slice::convert_storage() const\n {\n return xtl::visit(\n xtl::make_overload(\n /*[](const xt::xrange& s) -> V { return detail::convert_range(s); },\n [](const xt::xstepped_range& s) -> V { return detail::convert_range(s); },*/\n [](const xt::xrange& s) -> V { return xt::xrange(s); },\n [](const xt::xstepped_range& s) -> V { return xt::xstepped_range(s); },\n [](const xt::xkeep_slice& s) -> V { return xt::xkeep_slice(s); },\n [](const xt::xdrop_slice& s) -> V { return xt::xdrop_slice(s); },\n [](const xt::xall&) -> V { return xt::xall_tag(); }),\n m_slice);\n }\n\n template \n inline bool xaxis_index_slice::operator==(const self_type& rhs) const noexcept\n {\n return m_slice == rhs.m_slice;\n }\n\n template \n inline bool xaxis_index_slice::operator!=(const self_type& rhs) const noexcept\n {\n return !(*this == rhs);\n }\n\n /************************************\n * Builder functions implementation *\n ************************************/\n template \n inline auto irange(A start_val)\n {\n return xt::range(start_val);\n }\n\n template \n inline auto irange(A start_val, B stop_val)\n {\n return xt::range(start_val, stop_val);\n }\n\n template \n inline auto irange(A start_val, B stop_val, C step)\n {\n return xt::range(start_val, stop_val, step);\n }\n\n template \n inline auto ikeep(T&&... t)\n {\n return xt::keep(std::forward(t)...);\n }\n\n template \n inline auto idrop(T&&... t)\n {\n return xt::drop(std::forward(t)...);\n }\n\n inline auto iall() noexcept\n {\n return xt::all();\n }\n}\n\n#endif\n" }, { "path": "include/xframe/xaxis_label_slice.hpp", "content": "/***************************************************************************\n* Copyright (c) Johan Mabille, Sylvain Corlay, Wolf Vollprecht and *\n* Martin Renou *\n* Copyright (c) QuantStack *\n* *\n* Distributed under the terms of the BSD 3-Clause License. *\n* *\n* The full license is in the file LICENSE, distributed with this software. *\n****************************************************************************/\n\n#ifndef XFRAME_XAXIS_LABEL_SLICE_HPP\n#define XFRAME_XAXIS_LABEL_SLICE_HPP\n\n#include \n#include \n#include \"xaxis_index_slice.hpp\"\n#include \"xframe_config.hpp\"\n\nnamespace xf\n{\n /**************************\n * xlabel_slice_variant_t *\n **************************/\n\n template \n using xlabel_variant_t = xtl::mpl::cast_t;\n\n /***************\n * xaxis_range *\n ***************/\n\n template \n class xaxis_range\n {\n public:\n\n using value_type = xlabel_variant_t;\n\n xaxis_range(const value_type& first, const value_type& last) noexcept;\n xaxis_range(value_type&& first, value_type&& last) noexcept;\n\n template \n using index_slice_type = xt::xrange;\n\n template \n index_slice_type build_index_slice(const A& axis) const;\n\n private:\n\n value_type m_first;\n value_type m_last;\n };\n\n /***********************\n * xaxis_stepped_range *\n ***********************/\n\n template \n class xaxis_stepped_range\n {\n public:\n\n using value_type = xlabel_variant_t;\n using size_type = std::size_t;\n\n xaxis_stepped_range(const value_type& first, const value_type& last, size_type step) noexcept;\n xaxis_stepped_range(value_type&& first, value_type&& last, size_type step) noexcept;\n\n template \n using index_slice_type = xt::xstepped_range;\n\n template \n index_slice_type build_index_slice(const A& axis) const;\n\n private:\n\n value_type m_first;\n value_type m_last;\n size_type m_step;\n };\n\n /*************\n * xaxis_all *\n *************/\n\n class xaxis_all\n {\n public:\n\n template \n using index_slice_type = xt::xall;\n\n template \n index_slice_type build_index_slice(const A& axis) const;\n };\n\n /********************\n * xaxis_keep_slice *\n *******************/\n\n template \n class xaxis_keep_slice;\n\n namespace detail\n {\n template \n struct is_xaxis_keep_slice : std::false_type\n {\n };\n\n template \n struct is_xaxis_keep_slice>\n : std::true_type\n {\n };\n\n template \n using disable_xaxis_keep_slice_t = std::enable_if_t>::value, void>;\n\n template \n using enable_xaxis_keep_slice_t = std::enable_if_t>::value, void>;\n }\n\n template \n class xaxis_keep_slice\n {\n public:\n\n using value_type = xlabel_variant_t;\n using container_type = xt::svector;\n\n template >\n explicit xaxis_keep_slice(C& cont);\n explicit xaxis_keep_slice(container_type&& cont);\n\n template \n using index_slice_type = xt::xkeep_slice;\n\n template \n index_slice_type build_index_slice(const A& axis) const;\n\n private:\n\n container_type m_labels;\n };\n\n /********************\n * xaxis_drop_slice *\n ********************/\n\n template \n class xaxis_drop_slice;\n\n namespace detail\n {\n template \n struct is_axis_drop_slice : std::false_type\n {\n };\n\n template \n struct is_axis_drop_slice>\n : std::true_type\n {\n };\n\n template \n using disable_xaxis_drop_slice_t = std::enable_if_t>::value, void>;\n\n template \n using enable_xaxis_drop_slice_t = std::enable_if_t>::value, void>;\n }\n\n template \n class xaxis_drop_slice\n {\n public:\n\n using value_type = xlabel_variant_t;\n using container_type = xt::svector;\n\n template >\n explicit xaxis_drop_slice(C& cont);\n explicit xaxis_drop_slice(container_type&& cont);\n\n template \n using index_slice_type = xt::xdrop_slice;\n\n template \n index_slice_type build_index_slice(const A& axis) const;\n\n private:\n\n container_type m_labels;\n };\n\n /***************\n * xaxis_slice *\n ***************/\n\n template \n class xaxis_slice\n {\n public:\n\n using squeeze_type = xlabel_variant_t;\n using storage_type = xtl::variant,\n xaxis_stepped_range,\n xaxis_keep_slice,\n xaxis_drop_slice,\n xaxis_all,\n squeeze_type>;\n\n xaxis_slice() = default;\n template \n xaxis_slice(const V& slice);\n template \n xaxis_slice(V&& slice);\n\n template \n using index_slice_type = xaxis_index_slice;\n\n template \n index_slice_type build_index_slice(const A& axis) const;\n\n const squeeze_type* get_squeeze() const noexcept;\n\n private:\n\n storage_type m_data;\n };\n\n template \n xaxis_slice range(const xlabel_variant_t& first, const xlabel_variant_t& last);\n\n template \n xaxis_slice range(xlabel_variant_t&& first, xlabel_variant_t&& last);\n\n template \n xaxis_slice range(const xlabel_variant_t& first, const xlabel_variant_t& last, S step);\n\n template \n xaxis_slice range(xlabel_variant_t&& first, xlabel_variant_t&& last, S step);\n\n xaxis_all all() noexcept;\n\n namespace detail\n {\n template >\n struct has_size : std::false_type\n {\n };\n\n template \n struct has_size().size())>>\n : std::true_type\n {\n };\n\n template \n using enable_container_t = std::enable_if_t::value, R>;\n\n template \n using disable_container_t = std::enable_if_t::value, R>;\n }\n\n template \n detail::enable_container_t> keep(T&& indices);\n\n template \n detail::disable_container_t> keep(T index);\n\n template \n xaxis_slice keep(T0 t0, T1 t1, Args... args);\n\n template \n detail::enable_container_t> drop(T&& indices);\n\n template \n detail::disable_container_t> drop(T index);\n\n template \n xaxis_slice drop(T0 t0, T1 t1, Args... args);\n\n /******************************\n * xaxis_range implementation *\n ******************************/\n\n template \n inline xaxis_range::xaxis_range(const value_type& first, const value_type& last) noexcept\n : m_first(first), m_last(last)\n {\n }\n\n template \n inline xaxis_range::xaxis_range(value_type&& first, value_type&& last) noexcept\n : m_first(std::move(first)), m_last(std::move(last))\n {\n }\n\n template \n template \n inline auto xaxis_range::build_index_slice(const A& axis) const -> index_slice_type\n {\n return index_slice_type(axis[m_first], axis[m_last] + 1);\n }\n\n /**************************************\n * xaxis_stepped_range implementation *\n **************************************/\n\n template \n inline xaxis_stepped_range::xaxis_stepped_range(const value_type& first, const value_type& last, size_type step) noexcept\n : m_first(first), m_last(last), m_step(step)\n {\n }\n\n template \n inline xaxis_stepped_range::xaxis_stepped_range(value_type&& first, value_type&& last, size_type step) noexcept\n : m_first(std::move(first)), m_last(std::move(last)), m_step(step)\n {\n }\n\n template \n template \n inline auto xaxis_stepped_range::build_index_slice(const A& axis) const -> index_slice_type\n {\n return index_slice_type(axis[m_first], axis[m_last] + 1, m_step);\n }\n\n /****************************\n * xaxis_all implementation *\n ****************************/\n\n template \n inline auto xaxis_all::build_index_slice(const A& axis) const -> index_slice_type\n {\n return index_slice_type(axis.size());\n }\n\n /*****************************\n * xaxis_keep_implementation *\n *****************************/\n\n template \n template \n inline xaxis_keep_slice::xaxis_keep_slice(C& cont)\n : m_labels(cont.begin(), cont.end())\n {\n }\n\n template \n inline xaxis_keep_slice::xaxis_keep_slice(container_type&& cont)\n : m_labels(std::move(cont))\n {\n }\n\n template \n template \n inline auto xaxis_keep_slice::build_index_slice(const A& axis) const -> index_slice_type\n {\n using index_container_type = typename index_slice_type::container_type;\n index_container_type c(m_labels.size());\n std::transform(m_labels.cbegin(), m_labels.cend(), c.begin(), [&axis](const auto& arg) { return axis[arg]; });\n index_slice_type res(std::move(c));\n res.normalize(axis.size());\n return res;\n }\n\n /****************************\n * xaxis_drop_implemenation *\n ****************************/\n\n template \n template \n inline xaxis_drop_slice::xaxis_drop_slice(C& cont)\n : m_labels(cont.begin(), cont.end())\n {\n }\n\n template \n inline xaxis_drop_slice::xaxis_drop_slice(container_type&& cont)\n : m_labels(std::move(cont))\n {\n }\n\n template \n template \n inline auto xaxis_drop_slice::build_index_slice(const A& axis) const -> index_slice_type\n {\n using index_container_type = typename index_slice_type::container_type;\n index_container_type c(m_labels.size());\n std::transform(m_labels.cbegin(), m_labels.cend(), c.begin(), [&axis](const auto& arg) { return axis[arg]; });\n index_slice_type res(std::move(c));\n res.normalize(axis.size());\n return res;\n }\n\n /******************************\n * xaxis_slice implementation *\n ******************************/\n\n template \n template \n inline xaxis_slice::xaxis_slice(const V& slice)\n : m_data(slice)\n {\n }\n\n template \n template \n inline xaxis_slice::xaxis_slice(V&& slice)\n : m_data(std::move(slice))\n {\n }\n\n template \n template \n inline auto xaxis_slice::build_index_slice(const A& axis) const -> index_slice_type\n {\n return xtl::visit(\n xtl::make_overload(\n [&axis](const auto& arg) { return index_slice_type(arg.build_index_slice(axis)); },\n [&axis](const squeeze_type&) -> index_slice_type { throw std::runtime_error(\"build_islice forbidden for squeeze\"); }\n ),\n m_data);\n }\n\n template \n inline auto xaxis_slice::get_squeeze() const noexcept -> const squeeze_type*\n {\n return xtl::get_if(&m_data);\n }\n\n /***********************************\n * helper functions implementation *\n ***********************************/\n\n template \n inline xaxis_slice range(const xlabel_variant_t& first, const xlabel_variant_t& last)\n {\n return xaxis_slice(xaxis_range(first, last));\n }\n\n template \n inline xaxis_slice range(xlabel_variant_t&& first, xlabel_variant_t&& last)\n {\n return xaxis_slice(xaxis_range(std::move(first), std::move(last)));\n }\n\n template \n inline xaxis_slice range(const xlabel_variant_t& first, const xlabel_variant_t& last, S step)\n {\n return xaxis_slice(xaxis_stepped_range(first, last, step));\n }\n\n template \n inline xaxis_slice range(xlabel_variant_t&& first, xlabel_variant_t&& last, S step)\n {\n return xaxis_slice(xaxis_stepped_range(std::move(first), std::move(last), step));\n }\n\n namespace detail\n {\n template